Changeset 13874

Timestamp:

11/05/12 13:00:00 (12 years ago)

Author:

Mathieu Morlighem

Message:

CHG: moved some modules to FemModel.cpp

Location:

issm/trunk-jpl/src/c

Files:

• Makefile.am (modified) (1 diff)
• classes/FemModel.cpp (modified) (2 diffs)
• classes/FemModel.h (modified) (1 diff)
• modules/MinVelx (deleted)
• modules/MinVxx (deleted)
• modules/MinVyx (deleted)
• modules/MinVzx (deleted)
• modules/modules.h (modified) (1 diff)

issm/trunk-jpl/src/c/Makefile.am

@@ -482 +482 @@
 #}}}
 #Responses sources  {{{
-responses_sources = ./modules/MinVelx/MinVelx.h\
-                                             ./modules/MinVelx/MinVelx.cpp\
-                                             ./modules/MinVxx/MinVxx.h\
-                                             ./modules/MinVxx/MinVxx.cpp\
-                                             ./modules/MinVyx/MinVyx.h\
-                                             ./modules/MinVyx/MinVyx.cpp\
-                                             ./modules/MinVzx/MinVzx.h\
-                                             ./modules/MinVzx/MinVzx.cpp\
-                                             ./modules/TotalSmbx/TotalSmbx.h\
+responses_sources = ./modules/TotalSmbx/TotalSmbx.h\
                                              ./modules/TotalSmbx/TotalSmbx.cpp\
                                              ./modules/IceVolumex/IceVolumex.h\

issm/trunk-jpl/src/c/classes/FemModel.cpp

@@ -405 +405 @@
                 #ifdef _HAVE_RESPONSES_
                 case IceVolumeEnum:              IceVolumex(               responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
-                case MinVelEnum:                 MinVelx(                  responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
+                case MinVelEnum:                 this->MinVelx(responses,process_units); break;
                 case MaxVelEnum:                 this->MaxVelx(                  responses,process_units); break;
-                case MinVxEnum:                  MinVxx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
+                case MinVxEnum:                  this->MinVxx(responses,process_units); break;
                 case MaxVxEnum:                  this->MaxVxx(                   responses,process_units); break;
                 case MaxAbsVxEnum:               this->MaxAbsVxx(                responses,process_units); break;
-                case MinVyEnum:                  MinVyx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
+                case MinVyEnum:                  this->MinVyx(responses,process_units); break;
                 case MaxVyEnum:                  this->MaxVyx(                   responses,process_units); break;
                 case MaxAbsVyEnum:               this->MaxAbsVyx(                responses,process_units); break;
-                case MinVzEnum:                  MinVzx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
+                case MinVzEnum:                  this->MinVzx(responses,process_units); break;
                 case MaxVzEnum:                  this->MaxVzx(                   responses,process_units); break;
                 case MaxAbsVzEnum:               this->MaxAbsVzx(                responses,process_units); break;
@@ -793 +793 @@
 
 }/*}}}*/
+void FemModel::MinVelx(IssmDouble* pminvel,bool process_units){/*{{{*/
+
+        int i;
+        IssmDouble minvel;
+        IssmDouble node_minvel;
+        IssmDouble element_minvel;
+
+        /*Go through elements, and request velocity: */
+        minvel=INFINITY;
+        for(i=0;i<this->elements->Size();i++){
+                Element* element=(Element*)this->elements->GetObjectByOffset(i);
+                element->MinVel(&element_minvel,process_units);
+                if(element_minvel<minvel) minvel=element_minvel;
+        }
+
+        /*Figure out minimum across the cluster: */
+#ifdef _HAVE_MPI_
+        MPI_Reduce(&minvel,&node_minvel,1,MPI_DOUBLE,MPI_MAX,0,IssmComm::GetComm() );
+        MPI_Bcast(&node_minvel,1,MPI_DOUBLE,0,IssmComm::GetComm());   
+        minvel=node_minvel;
+#endif
+
+        /*Assign output pointers:*/
+        *pminvel=minvel;
+
+}/*}}}*/
+void FemModel::MinVxx(IssmDouble* pminvx,bool process_units){/*{{{*/
+
+        int i;
+        IssmDouble minvx;
+        IssmDouble node_minvx;
+        IssmDouble element_minvx;
+
+        /*Go through elements, and request velocity: */
+        minvx=INFINITY;
+        for(i=0;i<this->elements->Size();i++){
+                Element* element=(Element*)this->elements->GetObjectByOffset(i);
+                element->MinVx(&element_minvx,process_units);
+                if(element_minvx<minvx) minvx=element_minvx;
+        }
+
+        /*Figure out minimum across the cluster: */
+#ifdef _HAVE_MPI_
+        MPI_Reduce(&minvx,&node_minvx,1,MPI_DOUBLE,MPI_MAX,0,IssmComm::GetComm() );
+        MPI_Bcast(&node_minvx,1,MPI_DOUBLE,0,IssmComm::GetComm());   
+        minvx=node_minvx;
+#endif
+
+        /*Assign output pointers:*/
+        *pminvx=minvx;
+
+}/*}}}*/
+void FemModel::MinVyx(IssmDouble* pminvy,bool process_units){/*{{{*/
+
+        int i;
+        IssmDouble minvy;
+        IssmDouble node_minvy;
+        IssmDouble element_minvy;
+
+        /*Go through elements, and request velocity: */
+        minvy=INFINITY;
+        for(i=0;i<this->elements->Size();i++){
+                Element* element=(Element*)this->elements->GetObjectByOffset(i);
+                element->MinVy(&element_minvy,process_units);
+                if(element_minvy<minvy) minvy=element_minvy;
+        }
+
+        /*Figure out minimum across the cluster: */
+#ifdef _HAVE_MPI_
+        MPI_Reduce(&minvy,&node_minvy,1,MPI_DOUBLE,MPI_MAX,0,IssmComm::GetComm() );
+        MPI_Bcast(&node_minvy,1,MPI_DOUBLE,0,IssmComm::GetComm());   
+        minvy=node_minvy;
+#endif
+
+        /*Assign output pointers:*/
+        *pminvy=minvy;
+
+}/*}}}*/
+void FemModel::MinVzx(IssmDouble* pminvz,bool process_units){/*{{{*/
+
+        int i;
+        IssmDouble minvz;
+        IssmDouble node_minvz;
+        IssmDouble element_minvz;
+
+        /*Go through elements, and request velocity: */
+        minvz=INFINITY;
+        for(i=0;i<this->elements->Size();i++){
+                Element* element=(Element*)this->elements->GetObjectByOffset(i);
+                element->MinVz(&element_minvz,process_units);
+                if(element_minvz<minvz) minvz=element_minvz;
+        }
+
+        /*Figure out minimum across the cluster: */
+#ifdef _HAVE_MPI_
+        MPI_Reduce(&minvz,&node_minvz,1,MPI_DOUBLE,MPI_MAX,0,IssmComm::GetComm() );
+        MPI_Bcast(&node_minvz,1,MPI_DOUBLE,0,IssmComm::GetComm());   
+        minvz=node_minvz;
+#endif
+
+        /*Assign output pointers:*/
+        *pminvz=minvz;
+
+}/*}}}*/
 #endif
 #ifdef _HAVE_CONTROL_

issm/trunk-jpl/src/c/classes/FemModel.h

@@ -70 +70 @@
                 void MaxVyx(IssmDouble* presponse,bool process_units);
                 void MaxVzx(IssmDouble* presponse,bool process_units);
+                void MinVelx(IssmDouble* presponse,bool process_units);
+                void MinVxx(IssmDouble* presponse,bool process_units);
+                void MinVyx(IssmDouble* presponse,bool process_units);
+                void MinVzx(IssmDouble* presponse,bool process_units);
                 #endif
                 #ifdef  _HAVE_DAKOTA_

issm/trunk-jpl/src/c/modules/modules.h

@@ -67 +67 @@
 #include "./MeshPartitionx/MeshPartitionx.h"
 #include "./MeshProfileIntersectionx/MeshProfileIntersectionx.h"
-#include "./MinVelx/MinVelx.h"
-#include "./MinVxx/MinVxx.h"
-#include "./MinVyx/MinVyx.h"
-#include "./MinVzx/MinVzx.h"
 #include "./SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.h"
 #include "./SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.h"