Changeset 4229

Timestamp:

06/25/10 09:23:11 (15 years ago)

Author:

Mathieu Morlighem

Message:

fixed dof allocation for nodes (must be done for each analysis type

Location:

issm/trunk/src/c

Files:

• DataSet/DataSet.h (modified) (1 diff)
• DataSet/Nodes.cpp (modified) (12 diffs)
• modules/BuildNodeSetsx/BuildNodeSetsx.cpp (modified) (1 diff)
• modules/NodesDofx/NodesDofx.cpp (modified) (2 diffs)
• modules/NodesDofx/NodesDofx.h (modified) (1 diff)
• objects/FemModel.cpp (modified) (1 diff)

issm/trunk/src/c/DataSet/DataSet.h

@@ -130 +130 @@
                 /*}}}*/
                 /*numerics: {{{1*/
-                void  DistributeDofs(int numberofnodes,int numdofspernode);
-                void  FlagClones(int numberofnodes);
+                void  DistributeDofs(int numberofnodes,int numdofspernode,int analysis_type);
+                void  FlagClones(int numberofnodes,int analysis_type);
                 void  FlagNodeSets(Vec pv_g, Vec pv_m, Vec pv_n, Vec pv_f, Vec pv_s,int analysis_type);
                 int   NumberOfDofs(int analysis_type);
+                int   NumberOfNodes(int analysis_type);
                 int   NumberOfNodes(void);
-                void  Ranks(int* ranks);
+                void  Ranks(int* ranks,int analysis_type);
                 /*}}}*/
 

issm/trunk/src/c/DataSet/Nodes.cpp

@@ -44 +44 @@
 /*Numerics*/
 /*FUNCTION Nodes::DistributeDofs{{{1*/
-void  Nodes::DistributeDofs(int numberofobjects,int numberofdofsperobject){
+void  Nodes::DistributeDofs(int numberofobjects,int numberofdofsperobject,int analysis_type){
 
         extern int num_procs;
@@ -59 +59 @@
         for (i=0;i<this->Size();i++){
                 Node* node=(Node*)this->GetObjectByOffset(i);
-                node->DistributeDofs(&dofcount);
+
+                /*Check that this node corresponds to our analysis currently being carried out: */
+                if (node->InAnalysis(analysis_type)){
+                        node->DistributeDofs(&dofcount);
+                }
         }
 
@@ -85 +89 @@
         /*Ok, now every cpu knows where his dofs should start. Update the dof count: */
         for (i=0;i<this->Size();i++){
-                Node* node=(Node*)this->GetObjectByOffset(i);
-                node->OffsetDofs(dofcount);
+
+                /*Check that this node corresponds to our analysis currently being carried out: */
+                Node* node=(Node*)this->GetObjectByOffset(i);
+                if (node->InAnalysis(analysis_type)){
+                        node->OffsetDofs(dofcount);
+                }
+
         }
 
@@ -96 +105 @@
 
         for (i=0;i<this->Size();i++){
-                Node* node=(Node*)this->GetObjectByOffset(i);
-                node->ShowTrueDofs(truedofs);
+                /*Check that this node corresponds to our analysis currently being carried out: */
+                Node* node=(Node*)this->GetObjectByOffset(i);
+                if (node->InAnalysis(analysis_type)){
+                        node->ShowTrueDofs(truedofs);
+                }
         }
         
@@ -104 +116 @@
         /*Ok, now every cpu knows the true dofs of everyone else that is not a clone. Let the clones recover those true dofs: */
         for (i=0;i<this->Size();i++){
-                Node* node=(Node*)this->GetObjectByOffset(i);
-                node->UpdateCloneDofs(alltruedofs);
+                /*Check that this node corresponds to our analysis currently being carried out: */
+                Node* node=(Node*)this->GetObjectByOffset(i);
+                if (node->InAnalysis(analysis_type)){
+                        node->UpdateCloneDofs(alltruedofs);
+                }
         }
 
@@ -116 +131 @@
 /*}}}*/
 /*FUNCTION Nodes::FlagClones{{{1*/
-void  Nodes::FlagClones(int numberofobjects){
+void  Nodes::FlagClones(int numberofobjects,int analysis_type){
 
         int i;
@@ -131 +146 @@
 
         /*Now go through all our objects and ask them to report to who they belong (which rank): */
-        Ranks(ranks);
+        Ranks(ranks,analysis_type);
 
         /*We need to take the minimum rank for each vertex, and every cpu needs to get that result. That way, 
@@ -141 +156 @@
         /*Now go through all objects, and use minranks to flag which objects are cloned: */
         for(i=0;i<this->Size();i++){
-                /*For this object, decide whether it is a clone: */
-                Node* node=(Node*)this->GetObjectByOffset(i);
-                node->SetClone(minranks);
+
+                Node* node=(Node*)this->GetObjectByOffset(i);
+
+                /*Check that this node corresponds to our analysis currently being carried out: */
+                if (node->InAnalysis(analysis_type)){
+
+                        /*For this object, decide whether it is a clone: */
+                        node->SetClone(minranks);
+                }
         }
 
@@ -158 +179 @@
 
         for(i=0;i<this->Size();i++){
+
                 Node* node=(Node*)this->GetObjectByOffset(i);
                         
-                if (node->InAnalysis(analysis_type)){
+                /*Check that this node corresponds to our analysis currently being carried out: */
+                if (node->InAnalysis(analysis_type)){
+
                         /*Plug set values intp our 4 set vectors: */
                         node->CreateVecSets(pv_g,pv_m,pv_n,pv_f,pv_s);
@@ -215 +239 @@
 }
 /*}}}*/
-/*FUNCTION Nodes::NumberOfNodes{{{1*/
+/*FUNCTION Nodes::NumberOfNodes(){{{1*/
 int Nodes::NumberOfNodes(void){
 
@@ -244 +268 @@
 }
 /*}}}*/
+/*FUNCTION Nodes::NumberOfNodes{{{1*/
+int Nodes::NumberOfNodes(int analysis_type){
+
+        int i;
+
+        int max_sid=0;
+        int sid;
+        int node_max_sid;
+
+        for(i=0;i<this->Size();i++){
+
+                Node* node=(Node*)this->GetObjectByOffset(i);
+
+                /*Check that this node corresponds to our analysis currently being carried out: */
+                if (node->InAnalysis(analysis_type)){
+
+                        sid=node->Sid();
+                        if (sid>max_sid)max_sid=sid;
+                }
+        }
+
+#ifdef _PARALLEL_
+        MPI_Reduce (&max_sid,&node_max_sid,1,MPI_INT,MPI_MAX,0,MPI_COMM_WORLD );
+        MPI_Bcast(&node_max_sid,1,MPI_INT,0,MPI_COMM_WORLD);
+        max_sid=node_max_sid;
+#endif 
+
+        /*sid starts at 0*/
+        max_sid++;
+
+        /*return*/
+        return max_sid;
+}
+/*}}}*/
 /*FUNCTION Nodes::Ranks{{{1*/
-void   Nodes::Ranks(int* ranks){
+void   Nodes::Ranks(int* ranks,int analysis_type){
 
         /*Go through nodes, and for each object, report it cpu: */
@@ -254 +312 @@
         
         for(i=0;i<this->Size();i++){
-                Node* node=(Node*)this->GetObjectByOffset(i);
-                rank=node->MyRank();
-                sid=node->Sid();
-                
-                /*Plug rank into ranks, according to id: */
-                ranks[sid]=rank; 
+
+                Node* node=(Node*)this->GetObjectByOffset(i);
+
+                /*Check that this node corresponds to our analysis currently being carried out: */
+                if (node->InAnalysis(analysis_type)){
+
+                        rank=node->MyRank();
+                        sid=node->Sid();
+
+                        /*Plug rank into ranks, according to id: */
+                        ranks[sid]=rank; 
+                }
         }
         return;

issm/trunk/src/c/modules/BuildNodeSetsx/BuildNodeSetsx.cpp

@@ -77 +77 @@
                 VecFree(&vec_pv_s);
 
-
                 /*Create NodeSets* object: */
                 nodesets=new NodeSets(pv_m,pv_n,pv_f,pv_s,gsize,msize,nsize,fsize,ssize);

issm/trunk/src/c/modules/NodesDofx/NodesDofx.cpp

@@ -10 +10 @@
 #include "../../EnumDefinitions/EnumDefinitions.h"
 
-void NodesDofx(Nodes* nodes, Parameters* parameters){
+void NodesDofx(Nodes* nodes, Parameters* parameters,int analysis_type){
 
         int noerr=1;
@@ -20 +20 @@
         int  numberofdofspernode;
 
-        /*First, recover number of vertices and nodes: */
-        numberofnodes=nodes->NumberOfNodes();
+        /*First, recover number nodes associated th this analysis: */
+        numberofnodes=nodes->NumberOfNodes(analysis_type);
 
         /*Recover number of dofs per node: */
         found=parameters->FindParam(&numberofdofspernode,NumberOfDofsPerNodeEnum);
-        if(!found)ISSMERROR(" could not find numberofdofspernode in parameters");
+        if(!found)ISSMERROR("could not find numberofdofspernode in parameters");
 
         /*Ensure that only for each cpu, the partition border nodes only will be taken into account once 
          * across the cluster. To do so, we flag all the clone nodes: */
-        nodes->FlagClones(numberofnodes);
+        nodes->FlagClones(numberofnodes,analysis_type);
 
         /*Go through all nodes, and build degree of freedom lists. Each node gets a fixed number of dofs. When 
          *a  node has already been distributed dofs on one cpu, all other cpus with the same node cannot distribute it 
          *anymore. Use clone field to be sure of that: */
-        nodes->DistributeDofs(numberofnodes,numberofdofspernode);
+        nodes->DistributeDofs(numberofnodes,numberofdofspernode,analysis_type);
 
 }

issm/trunk/src/c/modules/NodesDofx/NodesDofx.h

@@ -10 +10 @@
 
 /* local prototypes: */
-void NodesDofx(Nodes* nodes, Parameters* parameters);
+void NodesDofx(Nodes* nodes, Parameters* parameters,int analysis_type);
 
 #endif  /* _NODESDOFX_H */

issm/trunk/src/c/objects/FemModel.cpp

@@ -63 +63 @@
                 _printf_("      create degrees of freedom\n");
                 VerticesDofx(&partition,&tpartition,vertices,parameters);
-                NodesDofx(nodes,parameters);
+                NodesDofx(nodes,parameters,analysis_type);
 
                 _printf_("      create single point constraints\n");