Changeset 13918

Timestamp:

11/08/12 16:02:41 (12 years ago)

Author:

Mathieu Morlighem

Message:

NEW: final touches to matrix preallocation

File:

• issm/trunk-jpl/src/c/classes/FemModel.cpp (modified) (6 diffs)

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

@@ -409 +409 @@
         int      configuration_type;
         int      d_nz,o_nz;
-        Element *element      = NULL;
-        int     *head         = NULL;
-        int     *next         = NULL;
-        int     *count2offset = NULL;
-        int     * sidlist     = NULL;
+        Element *element            = NULL;
+        Load    *load               = NULL;
+        int     *head_e             = NULL;
+        int     *next_e             = NULL;
+        int     *count2offset_e     = NULL;
+        int     *head_l             = NULL;
+        int     *next_l             = NULL;
+        int     *count2offset_l     = NULL;
+        int     *sidlist            = NULL;
 
         /*output*/
@@ -429 +433 @@
         int m                   = nodes->NumberOfDofsLocal(configuration_type,set1enum);
         int n                   = nodes->NumberOfDofsLocal(configuration_type,set2enum);
-        int numnodesperobject   = elements->MaxNumNodes();
+        int numnodesperelement  = elements->MaxNumNodes();
+        int numnodesperload     = loads->MaxNumNodes(configuration_type);
 
         /*First, we are building chaining vectors so that we know what nodes are
@@ -436 +441 @@
          * will loop over all the elements that are connected to the node number
          * id*/
-        head         = xNew<int>(numnodes); for(i=0;i<numnodes;i++) head[i]=-1;
-        next         = xNew<int>(elements->Size()*numnodesperobject);
-        count2offset = xNew<int>(elements->Size()*numnodesperobject);
+        head_e         = xNew<int>(numnodes); for(i=0;i<numnodes;i++) head_e[i]=-1;
+        next_e         = xNew<int>(elements->Size()*numnodesperelement);
+        count2offset_e = xNew<int>(elements->Size()*numnodesperelement);
 
         k=0;
@@ -450 +455 @@
                         _assert_(index>=0 && index<numnodes);
 
-                        count2offset[k]=i;
-                        next[k]=head[index];
-                        head[index]=k++;
+                        count2offset_e[k]=i;
+                        next_e[k]=head_e[index];
+                        head_e[index]=k++;
                 }
-                for(j=0;j<numnodesperobject-element->GetNumberOfNodes();j++) k++;
+                for(j=0;j<numnodesperelement-element->GetNumberOfNodes();j++) k++;
+
+                xDelete<int>(sidlist);
+        }
+
+        /*Chain for loads*/
+        head_l         = xNew<int>(numnodes); for(i=0;i<numnodes;i++) head_l[i]=-1;
+        next_l         = xNew<int>(loads->Size(configuration_type)*numnodesperload);
+        count2offset_l = xNew<int>(loads->Size(configuration_type)*numnodesperload);
+        k=0;
+        for(i=0;i<loads->Size();i++){
+                load = dynamic_cast<Load*>(loads->GetObjectByOffset(i));
+                if(!load->InAnalysis(configuration_type)) continue;
+                sidlist = xNew<int>(load->GetNumberOfNodes());
+                load->GetNodesSidList(sidlist);
+
+                for(j=0;j<load->GetNumberOfNodes();j++){
+                        index = sidlist[j];
+                        _assert_(index>=0 && index<numnodes);
+
+                        count2offset_l[k]=i;
+                        next_l[k]=head_l[index];
+                        head_l[index]=k++;
+                }
+                for(j=0;j<numnodesperload-load->GetNumberOfNodes();j++) k++;
 
                 xDelete<int>(sidlist);
@@ -475 +504 @@
 
                         /*Loop over elements that hold node number i*/
-                        _assert_(head[node->Sid()]!=-1);
-                        for(j=head[node->Sid()];j!=-1;j=next[j]){
-                                offset=count2offset[j];
+                        _assert_(head_e[node->Sid()]!=-1 || head_l[node->Sid()]!=-1);
+                        for(j=head_e[node->Sid()];j!=-1;j=next_e[j]){
+                                offset=count2offset_e[j];
                                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(offset));
                                 element->SetwiseNodeConnectivity(&d_nz,&o_nz,node,flags,set1enum,set2enum);
@@ -488 +517 @@
                                 }
                         }
+                        for(j=head_l[node->Sid()];j!=-1;j=next_l[j]){
+                                offset=count2offset_l[j];
+                                load=dynamic_cast<Load*>(loads->GetObjectByOffset(offset));
+                                load->SetwiseNodeConnectivity(&d_nz,&o_nz,node,flags,set1enum,set2enum);
+                                if(node->IsClone()){
+                                        connectivity_clone[node->Sid()]+=d_nz+o_nz;
+                                }
+                                else{
+                                        d_connectivity[node->Sid()]+=d_nz;
+                                        o_connectivity[node->Sid()]+=o_nz;
+                                }
+                        }
                 }
         }
         xDelete<bool>(flags);
-        xDelete<int>(count2offset);
-        xDelete<int>(head);
-        xDelete<int>(next);
+        xDelete<int>(count2offset_e);
+        xDelete<int>(head_e);
+        xDelete<int>(next_e);
+        xDelete<int>(count2offset_l);
+        xDelete<int>(head_l);
+        xDelete<int>(next_l);
 
         /*sum over all cpus*/