/[escript]/trunk/finley/src/CPPAdapter/MeshAdapterFactory.cpp
ViewVC logotype

Diff of /trunk/finley/src/CPPAdapter/MeshAdapterFactory.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2722 by gross, Fri Oct 16 06:45:01 2009 UTC revision 2748 by gross, Tue Nov 17 07:32:59 2009 UTC
# Line 192  namespace finley { Line 192  namespace finley {
192    
193          /* read elements */          /* read elements */
194          if (Finley_noError()) {          if (Finley_noError()) {
195            mesh_p->Elements=Finley_ElementFile_alloc((ElementTypeId)Elements_TypeId,mesh_p->order, mesh_p->reduced_order, mpi_info);            Finley_ReferenceElementSet  *refElements= Finley_ReferenceElementSet_alloc((ElementTypeId)Elements_TypeId,mesh_p->order, mesh_p->reduced_order);
196              if (Finley_noError())  {
197                  mesh_p->Elements=Finley_ElementFile_alloc(refElements, mpi_info);
198              }
199              Finley_ReferenceElementSet_dealloc(refElements);
200            if (Finley_noError()) Finley_ElementFile_allocTable(mesh_p->Elements, num_Elements);            if (Finley_noError()) Finley_ElementFile_allocTable(mesh_p->Elements, num_Elements);
201            mesh_p->Elements->minColor=0;            if (Finley_noError()) {
202            mesh_p->Elements->maxColor=num_Elements-1;                mesh_p->Elements->minColor=0;
203            if (num_Elements>0) {                mesh_p->Elements->maxColor=num_Elements-1;
204                   if (Finley_noError()) {                if (num_Elements>0) {
205                 // Elements_Id                 // Elements_Id
206                     if (! ( nc_var_temp = dataFile.get_var("Elements_Id")) )                     if (! ( nc_var_temp = dataFile.get_var("Elements_Id")) )
207                       throw DataException("Error - loadMesh:: unable to read Elements_Id from netCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to read Elements_Id from netCDF file: " + *fName);
# Line 227  namespace finley { Line 231  namespace finley {
231                       throw DataException("Error - loadMesh:: unable to recover Elements_Color from NetCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to recover Elements_Color from NetCDF file: " + *fName);
232                     }                     }
233                 // Elements_Nodes                 // Elements_Nodes
234             int *Elements_Nodes = TMPMEMALLOC(num_Elements*num_Elements_numNodes,int);                      int *Elements_Nodes = TMPMEMALLOC(num_Elements*num_Elements_numNodes,int);
235                     if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {
236                       TMPMEMFREE(mesh_p->Elements->Nodes);                       TMPMEMFREE(mesh_p->Elements->Nodes);
237                       throw DataException("Error - loadMesh:: unable to read Elements_Nodes from netCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to read Elements_Nodes from netCDF file: " + *fName);
# Line 236  namespace finley { Line 240  namespace finley {
240                       TMPMEMFREE(Elements_Nodes);                       TMPMEMFREE(Elements_Nodes);
241                       throw DataException("Error - load:: unable to recover Elements_Nodes from netCDF file: " + *fName);                       throw DataException("Error - load:: unable to recover Elements_Nodes from netCDF file: " + *fName);
242                     }                     }
243             // Copy temp array into mesh_p->Elements->Nodes                     // Copy temp array into mesh_p->Elements->Nodes
244             for (int i=0; i<num_Elements; i++) {                     for (int i=0; i<num_Elements; i++) {
245               for (int j=0; j<num_Elements_numNodes; j++) {                         for (int j=0; j<num_Elements_numNodes; j++) {
246                 mesh_p->Elements->Nodes[INDEX2(j,i,num_Elements_numNodes)]                             mesh_p->Elements->Nodes[INDEX2(j,i,num_Elements_numNodes)]
247                   = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];                             = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];
248               }                         }
249             }                     }
250             TMPMEMFREE(Elements_Nodes);                     TMPMEMFREE(Elements_Nodes);
251           }                  
252        } /* num_Elements>0 */                } /* num_Elements>0 */
253              }
254      }      }
255    
256          /* get the face elements */          /* get the face elements */
257          if (Finley_noError()) {          if (Finley_noError()) {
258            mesh_p->FaceElements=Finley_ElementFile_alloc((ElementTypeId)FaceElements_TypeId,mesh_p->order, mesh_p->reduced_order, mpi_info);            Finley_ReferenceElementSet *refFaceElements=  Finley_ReferenceElementSet_alloc((ElementTypeId)FaceElements_TypeId ,mesh_p->order, mesh_p->reduced_order);
259              if (Finley_noError())  {
260                  mesh_p->FaceElements=Finley_ElementFile_alloc(refFaceElements, mpi_info);
261              }
262              Finley_ReferenceElementSet_dealloc(refFaceElements);  
263            if (Finley_noError()) Finley_ElementFile_allocTable(mesh_p->FaceElements, num_FaceElements);            if (Finley_noError()) Finley_ElementFile_allocTable(mesh_p->FaceElements, num_FaceElements);
264            mesh_p->FaceElements->minColor=0;            if (Finley_noError()) {
265            mesh_p->FaceElements->maxColor=num_FaceElements-1;                mesh_p->FaceElements->minColor=0;
266            if (num_FaceElements>0) {                mesh_p->FaceElements->maxColor=num_FaceElements-1;
267                   if (Finley_noError()) {                if (num_FaceElements>0) {
268                 // FaceElements_Id                 // FaceElements_Id
269                     if (! ( nc_var_temp = dataFile.get_var("FaceElements_Id")) )                     if (! ( nc_var_temp = dataFile.get_var("FaceElements_Id")) )
270                       throw DataException("Error - loadMesh:: unable to read FaceElements_Id from netCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to read FaceElements_Id from netCDF file: " + *fName);
# Line 285  namespace finley { Line 294  namespace finley {
294                       throw DataException("Error - loadMesh:: unable to recover FaceElements_Color from NetCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to recover FaceElements_Color from NetCDF file: " + *fName);
295                     }                     }
296                 // FaceElements_Nodes                 // FaceElements_Nodes
297             int *FaceElements_Nodes = TMPMEMALLOC(num_FaceElements*num_FaceElements_numNodes,int);                      int *FaceElements_Nodes = TMPMEMALLOC(num_FaceElements*num_FaceElements_numNodes,int);
298                     if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {
299                       TMPMEMFREE(mesh_p->FaceElements->Nodes);                       TMPMEMFREE(mesh_p->FaceElements->Nodes);
300                       throw DataException("Error - loadMesh:: unable to read FaceElements_Nodes from netCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to read FaceElements_Nodes from netCDF file: " + *fName);
# Line 294  namespace finley { Line 303  namespace finley {
303                       TMPMEMFREE(FaceElements_Nodes);                       TMPMEMFREE(FaceElements_Nodes);
304                       throw DataException("Error - load:: unable to recover FaceElements_Nodes from netCDF file: " + *fName);                       throw DataException("Error - load:: unable to recover FaceElements_Nodes from netCDF file: " + *fName);
305                     }                     }
306             // Copy temp array into mesh_p->FaceElements->Nodes                   // Copy temp array into mesh_p->FaceElements->Nodes
307             for (int i=0; i<num_FaceElements; i++) {                      for (int i=0; i<num_FaceElements; i++) {
308               for (int j=0; j<num_FaceElements_numNodes; j++) {                          for (int j=0; j<num_FaceElements_numNodes; j++) {
309                 mesh_p->FaceElements->Nodes[INDEX2(j,i,num_FaceElements_numNodes)]                              mesh_p->FaceElements->Nodes[INDEX2(j,i,num_FaceElements_numNodes)] = FaceElements_Nodes[INDEX2(j,i,num_FaceElements_numNodes)];
310                   = FaceElements_Nodes[INDEX2(j,i,num_FaceElements_numNodes)];                          }
311               }                      }
312             }                      TMPMEMFREE(FaceElements_Nodes);
313             TMPMEMFREE(FaceElements_Nodes);                } /* num_FaceElements>0 */
314           }            }
       } /* num_FaceElements>0 */  
315      }      }
316    
317          /* get the Contact elements */          /* get the Contact elements */
318          if (Finley_noError()) {          if (Finley_noError()) {
319            mesh_p->ContactElements=Finley_ElementFile_alloc((ElementTypeId)ContactElements_TypeId,mesh_p->order, mesh_p->reduced_order, mpi_info);            Finley_ReferenceElementSet *refContactElements=   Finley_ReferenceElementSet_alloc((ElementTypeId)ContactElements_TypeId,mesh_p->order, mesh_p->reduced_order);
320              if (Finley_noError())  {
321                  mesh_p->ContactElements=Finley_ElementFile_alloc(refContactElements, mpi_info);
322              }
323              Finley_ReferenceElementSet_dealloc(refContactElements);  
324            if (Finley_noError()) Finley_ElementFile_allocTable(mesh_p->ContactElements, num_ContactElements);            if (Finley_noError()) Finley_ElementFile_allocTable(mesh_p->ContactElements, num_ContactElements);
325            mesh_p->ContactElements->minColor=0;            if (Finley_noError()) {
326            mesh_p->ContactElements->maxColor=num_ContactElements-1;                mesh_p->ContactElements->minColor=0;
327            if (num_ContactElements>0) {                mesh_p->ContactElements->maxColor=num_ContactElements-1;
328                   if (Finley_noError()) {                if (num_ContactElements>0) {
329                 // ContactElements_Id                 // ContactElements_Id
330                     if (! ( nc_var_temp = dataFile.get_var("ContactElements_Id")) )                     if (! ( nc_var_temp = dataFile.get_var("ContactElements_Id")) )
331                       throw DataException("Error - loadMesh:: unable to read ContactElements_Id from netCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to read ContactElements_Id from netCDF file: " + *fName);
# Line 343  namespace finley { Line 355  namespace finley {
355                       throw DataException("Error - loadMesh:: unable to recover ContactElements_Color from NetCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to recover ContactElements_Color from NetCDF file: " + *fName);
356                     }                     }
357                 // ContactElements_Nodes                 // ContactElements_Nodes
358             int *ContactElements_Nodes = TMPMEMALLOC(num_ContactElements*num_ContactElements_numNodes,int);                      int *ContactElements_Nodes = TMPMEMALLOC(num_ContactElements*num_ContactElements_numNodes,int);
359                     if (!(nc_var_temp = dataFile.get_var("ContactElements_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("ContactElements_Nodes"))) {
360                       TMPMEMFREE(mesh_p->ContactElements->Nodes);                       TMPMEMFREE(mesh_p->ContactElements->Nodes);
361                       throw DataException("Error - loadMesh:: unable to read ContactElements_Nodes from netCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to read ContactElements_Nodes from netCDF file: " + *fName);
# Line 352  namespace finley { Line 364  namespace finley {
364                       TMPMEMFREE(ContactElements_Nodes);                       TMPMEMFREE(ContactElements_Nodes);
365                       throw DataException("Error - load:: unable to recover ContactElements_Nodes from netCDF file: " + *fName);                       throw DataException("Error - load:: unable to recover ContactElements_Nodes from netCDF file: " + *fName);
366                     }                     }
367             // Copy temp array into mesh_p->ContactElements->Nodes                     // Copy temp array into mesh_p->ContactElements->Nodes
368             for (int i=0; i<num_ContactElements; i++) {                      for (int i=0; i<num_ContactElements; i++) {
369               for (int j=0; j<num_ContactElements_numNodes; j++) {                          for (int j=0; j<num_ContactElements_numNodes; j++) {
370                 mesh_p->ContactElements->Nodes[INDEX2(j,i,num_ContactElements_numNodes)]                              mesh_p->ContactElements->Nodes[INDEX2(j,i,num_ContactElements_numNodes)]= ContactElements_Nodes[INDEX2(j,i,num_ContactElements_numNodes)];
371                   = ContactElements_Nodes[INDEX2(j,i,num_ContactElements_numNodes)];                          }
372               }                      }
373             }                      TMPMEMFREE(ContactElements_Nodes);
374             TMPMEMFREE(ContactElements_Nodes);                   } /* num_ContactElements>0 */
375           }                }
376        } /* num_ContactElements>0 */            
377      }      }
378    
379          /* get the Points (nodal elements) */          /* get the Points (nodal elements) */
380          if (Finley_noError()) {          if (Finley_noError()) {
381            mesh_p->Points=Finley_ElementFile_alloc((ElementTypeId)Points_TypeId,mesh_p->order, mesh_p->reduced_order, mpi_info);            Finley_ReferenceElementSet *refPoints=    Finley_ReferenceElementSet_alloc((ElementTypeId)Points_TypeId,mesh_p->order, mesh_p->reduced_order);
382              if (Finley_noError())  {
383                  mesh_p->Points=Finley_ElementFile_alloc(refPoints, mpi_info);
384              }
385              Finley_ReferenceElementSet_dealloc(refPoints);
386            if (Finley_noError()) Finley_ElementFile_allocTable(mesh_p->Points, num_Points);            if (Finley_noError()) Finley_ElementFile_allocTable(mesh_p->Points, num_Points);
387            mesh_p->Points->minColor=0;            if (Finley_noError()) {
388            mesh_p->Points->maxColor=num_Points-1;                mesh_p->Points->minColor=0;
389            if (num_Points>0) {                mesh_p->Points->maxColor=num_Points-1;
390               if (Finley_noError()) {                if (num_Points>0) {
391                 // Points_Id                 // Points_Id
392                     if (! ( nc_var_temp = dataFile.get_var("Points_Id")) )                     if (! ( nc_var_temp = dataFile.get_var("Points_Id")) )
393                       throw DataException("Error - loadMesh:: unable to read Points_Id from netCDF file: " + *fName);                       throw DataException("Error - loadMesh:: unable to read Points_Id from netCDF file: " + *fName);
# Line 415  namespace finley { Line 431  namespace finley {
431               mesh_p->Nodes->Id[mesh_p->Points->Nodes[INDEX2(0,i,1)]] = Points_Nodes[i];               mesh_p->Nodes->Id[mesh_p->Points->Nodes[INDEX2(0,i,1)]] = Points_Nodes[i];
432             }             }
433             TMPMEMFREE(Points_Nodes);             TMPMEMFREE(Points_Nodes);
434           }          
435        } /* num_Points>0 */                } /* num_Points>0 */
436      }            }
437            }
438    
439          /* get the tags */          /* get the tags */
440          if (Finley_noError()) {          if (Finley_noError()) {
# Line 491  namespace finley { Line 508  namespace finley {
508      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
509      double blocktimer_start = blocktimer_time();      double blocktimer_start = blocktimer_time();
510    
511      fMesh=Finley_Mesh_read_MPI(fName,integrationOrder, reducedIntegrationOrder, (optimize ? TRUE : FALSE));      fMesh=Finley_Mesh_read(fName,integrationOrder, reducedIntegrationOrder, (optimize ? TRUE : FALSE));
512      checkFinleyError();      checkFinleyError();
513      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
514            

Legend:
Removed from v.2722  
changed lines
  Added in v.2748

  ViewVC Help
Powered by ViewVC 1.1.26