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

Diff of /branches/doubleplusgood/finley/src/CPPAdapter/MeshAdapterFactory.cpp

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

revision 4331 by jfenwick, Wed Feb 27 06:09:33 2013 UTC revision 4332 by jfenwick, Thu Mar 21 04:21:14 2013 UTC
# Line 125  namespace finley { Line 125  namespace finley {
125      char *name = attr->as_string(0);      char *name = attr->as_string(0);
126      delete attr;      delete attr;
127    
128      TMPMEMFREE(fName);      delete[] fName;
129    
130      /* allocate mesh */      /* allocate mesh */
131      mesh_p = Finley_Mesh_alloc(name,numDim,mpi_info);      mesh_p = Finley_Mesh_alloc(name,numDim,mpi_info);
# Line 212  namespace finley { Line 212  namespace finley {
212                     }                     }
213                     mesh_p->Elements->maxColor=mc;                     mesh_p->Elements->maxColor=mc;
214                     // Elements_Nodes                     // Elements_Nodes
215                     int *Elements_Nodes = TMPMEMALLOC(num_Elements*num_Elements_numNodes,int);                     int *Elements_Nodes = new int[num_Elements*num_Elements_numNodes];
216                     if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {
217                         TMPMEMFREE(Elements_Nodes);                         delete[] Elements_Nodes;
218                         cleanupAndThrow(mesh_p, mpi_info, "get_var(Elements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get_var(Elements_Nodes)");
219                     }                     }
220                     if (! nc_var_temp->get(&(Elements_Nodes[0]), num_Elements, num_Elements_numNodes) ) {                     if (! nc_var_temp->get(&(Elements_Nodes[0]), num_Elements, num_Elements_numNodes) ) {
221                         TMPMEMFREE(Elements_Nodes);                         delete[] Elements_Nodes;
222                         cleanupAndThrow(mesh_p, mpi_info, "get(Elements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get(Elements_Nodes)");
223                     }                     }
224    
# Line 229  namespace finley { Line 229  namespace finley {
229                                  = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];                                  = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];
230                         }                         }
231                     }                     }
232                     TMPMEMFREE(Elements_Nodes);                     delete[] Elements_Nodes;
233                     Finley_ElementFile_setTagsInUse(mesh_p->Elements);                     Finley_ElementFile_setTagsInUse(mesh_p->Elements);
234                  } /* num_Elements>0 */                  } /* num_Elements>0 */
235              }              }
# Line 278  namespace finley { Line 278  namespace finley {
278                     }                     }
279                     mesh_p->FaceElements->maxColor=mc;                     mesh_p->FaceElements->maxColor=mc;
280                     // FaceElements_Nodes                     // FaceElements_Nodes
281                     int *FaceElements_Nodes = TMPMEMALLOC(num_FaceElements*num_FaceElements_numNodes,int);                     int *FaceElements_Nodes = new int[num_FaceElements*num_FaceElements_numNodes];
282                     if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {
283                         TMPMEMFREE(FaceElements_Nodes);                         delete[] FaceElements_Nodes;
284                         cleanupAndThrow(mesh_p, mpi_info, "get_var(FaceElements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get_var(FaceElements_Nodes)");
285                     }                     }
286                     if (! nc_var_temp->get(&(FaceElements_Nodes[0]), num_FaceElements, num_FaceElements_numNodes) ) {                     if (! nc_var_temp->get(&(FaceElements_Nodes[0]), num_FaceElements, num_FaceElements_numNodes) ) {
287                         TMPMEMFREE(FaceElements_Nodes);                         delete[] FaceElements_Nodes;
288                         cleanupAndThrow(mesh_p, mpi_info, "get(FaceElements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get(FaceElements_Nodes)");
289                     }                     }
290                     // Copy temp array into mesh_p->FaceElements->Nodes                     // Copy temp array into mesh_p->FaceElements->Nodes
# Line 293  namespace finley { Line 293  namespace finley {
293                             mesh_p->FaceElements->Nodes[INDEX2(j,i,num_FaceElements_numNodes)] = 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)];
294                         }                         }
295                     }                     }
296                     TMPMEMFREE(FaceElements_Nodes);                     delete[] FaceElements_Nodes;
297                     Finley_ElementFile_setTagsInUse(mesh_p->FaceElements);                     Finley_ElementFile_setTagsInUse(mesh_p->FaceElements);
298                  } /* num_FaceElements>0 */                  } /* num_FaceElements>0 */
299              }              }
# Line 342  namespace finley { Line 342  namespace finley {
342                     }                     }
343                     mesh_p->ContactElements->maxColor=mc;                     mesh_p->ContactElements->maxColor=mc;
344                     // ContactElements_Nodes                     // ContactElements_Nodes
345                     int *ContactElements_Nodes = TMPMEMALLOC(num_ContactElements*num_ContactElements_numNodes,int);                     int *ContactElements_Nodes = new int[num_ContactElements*num_ContactElements_numNodes];
346                     if (!(nc_var_temp = dataFile.get_var("ContactElements_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("ContactElements_Nodes"))) {
347                         TMPMEMFREE(ContactElements_Nodes);                         delete[] ContactElements_Nodes;
348                         cleanupAndThrow(mesh_p, mpi_info, "get_var(ContactElements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get_var(ContactElements_Nodes)");
349                     }                     }
350                     if (! nc_var_temp->get(&(ContactElements_Nodes[0]), num_ContactElements, num_ContactElements_numNodes) ) {                     if (! nc_var_temp->get(&(ContactElements_Nodes[0]), num_ContactElements, num_ContactElements_numNodes) ) {
351                         TMPMEMFREE(ContactElements_Nodes);                         delete[] ContactElements_Nodes;
352                         cleanupAndThrow(mesh_p, mpi_info, "get(ContactElements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get(ContactElements_Nodes)");
353                     }                     }
354                     // Copy temp array into mesh_p->ContactElements->Nodes                     // Copy temp array into mesh_p->ContactElements->Nodes
# Line 357  namespace finley { Line 357  namespace finley {
357                             mesh_p->ContactElements->Nodes[INDEX2(j,i,num_ContactElements_numNodes)]= 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)];
358                         }                         }
359                     }                     }
360                     TMPMEMFREE(ContactElements_Nodes);                     delete[] ContactElements_Nodes;
361                     Finley_ElementFile_setTagsInUse(mesh_p->ContactElements);                     Finley_ElementFile_setTagsInUse(mesh_p->ContactElements);
362                 } /* num_ContactElements>0 */                 } /* num_ContactElements>0 */
363             }             }
# Line 406  namespace finley { Line 406  namespace finley {
406                     }                     }
407                     mesh_p->Points->maxColor=mc;                     mesh_p->Points->maxColor=mc;
408                     // Points_Nodes                     // Points_Nodes
409                     int *Points_Nodes = TMPMEMALLOC(num_Points,int);                     int *Points_Nodes = new int[num_Points];
410                     if (!(nc_var_temp = dataFile.get_var("Points_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("Points_Nodes"))) {
411                         TMPMEMFREE(Points_Nodes);                         delete[] Points_Nodes;
412                         cleanupAndThrow(mesh_p, mpi_info, "get_var(Points_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get_var(Points_Nodes)");
413                     }                     }
414                     if (! nc_var_temp->get(&(Points_Nodes[0]), num_Points) ) {                     if (! nc_var_temp->get(&(Points_Nodes[0]), num_Points) ) {
415                         TMPMEMFREE(Points_Nodes);                         delete[] Points_Nodes;
416                         cleanupAndThrow(mesh_p, mpi_info, "get(Points_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get(Points_Nodes)");
417                     }                     }
418                     // Copy temp array into mesh_p->Points->Nodes                     // Copy temp array into mesh_p->Points->Nodes
419                     for (int i=0; i<num_Points; i++) {                     for (int i=0; i<num_Points; i++) {
420                         mesh_p->Points->Id[mesh_p->Points->Nodes[INDEX2(0,i,1)]] = Points_Nodes[i];                         mesh_p->Points->Id[mesh_p->Points->Nodes[INDEX2(0,i,1)]] = Points_Nodes[i];
421                     }                     }
422                     TMPMEMFREE(Points_Nodes);                     delete[] Points_Nodes;
423                     Finley_ElementFile_setTagsInUse(mesh_p->Points);                     Finley_ElementFile_setTagsInUse(mesh_p->Points);
424                  } /* num_Points>0 */                  } /* num_Points>0 */
425              }              }
# Line 429  namespace finley { Line 429  namespace finley {
429          if (Finley_noError()) {          if (Finley_noError()) {
430            if (num_Tags>0) {            if (num_Tags>0) {
431              // Temp storage to gather node IDs              // Temp storage to gather node IDs
432              int *Tags_keys = TMPMEMALLOC(num_Tags, int);              int *Tags_keys = new  int[num_Tags];
433              char name_temp[4096];              char name_temp[4096];
434              int i;              int i;
435    
436              // Tags_keys              // Tags_keys
437              if (! ( nc_var_temp = dataFile.get_var("Tags_keys")) ) {              if (! ( nc_var_temp = dataFile.get_var("Tags_keys")) ) {
438                  TMPMEMFREE(Tags_keys);                  delete[] Tags_keys;
439                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Tags_keys)");                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Tags_keys)");
440              }              }
441              if (! nc_var_temp->get(&Tags_keys[0], num_Tags) ) {              if (! nc_var_temp->get(&Tags_keys[0], num_Tags) ) {
442                  TMPMEMFREE(Tags_keys);                  delete[] Tags_keys;
443                  cleanupAndThrow(mesh_p, mpi_info, "get(Tags_keys)");                  cleanupAndThrow(mesh_p, mpi_info, "get(Tags_keys)");
444              }              }
445              for (i=0; i<num_Tags; i++) {              for (i=0; i<num_Tags; i++) {
446                // Retrieve tag name                // Retrieve tag name
447                sprintf(name_temp, "Tags_name_%d", i);                sprintf(name_temp, "Tags_name_%d", i);
448                if (! (attr=dataFile.get_att(name_temp)) ) {                if (! (attr=dataFile.get_att(name_temp)) ) {
449                    TMPMEMFREE(Tags_keys);                    delete[] Tags_keys;
450                    sprintf(error_msg,"get_att(%s)", name_temp);                    sprintf(error_msg,"get_att(%s)", name_temp);
451                    cleanupAndThrow(mesh_p, mpi_info, error_msg);                    cleanupAndThrow(mesh_p, mpi_info, error_msg);
452                }                }
# Line 454  namespace finley { Line 454  namespace finley {
454                delete attr;                delete attr;
455                Finley_Mesh_addTagMap(mesh_p, name, Tags_keys[i]);                Finley_Mesh_addTagMap(mesh_p, name, Tags_keys[i]);
456              }              }
457              TMPMEMFREE(Tags_keys);              delete[] Tags_keys;
458            }            }
459          }          }
460        
461          if (Finley_noError()) {          if (Finley_noError()) {
462              // Nodes_DofDistribution              // Nodes_DofDistribution
463              first_DofComponent = TMPMEMALLOC(mpi_size+1,index_t);              first_DofComponent = new index_t[mpi_size+1];
464              if (! ( nc_var_temp = dataFile.get_var("Nodes_DofDistribution")) ) {              if (! ( nc_var_temp = dataFile.get_var("Nodes_DofDistribution")) ) {
465                  TMPMEMFREE(first_DofComponent);                  delete[] first_DofComponent;
466                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Nodes_DofDistribution)");                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Nodes_DofDistribution)");
467              }              }
468              if (! nc_var_temp->get(&first_DofComponent[0], mpi_size+1) ) {              if (! nc_var_temp->get(&first_DofComponent[0], mpi_size+1) ) {
469                  TMPMEMFREE(first_DofComponent);                  delete[] first_DofComponent;
470                  cleanupAndThrow(mesh_p, mpi_info, "get(Nodes_DofDistribution)");                  cleanupAndThrow(mesh_p, mpi_info, "get(Nodes_DofDistribution)");
471              }              }
472    
473              // Nodes_NodeDistribution              // Nodes_NodeDistribution
474              first_NodeComponent = TMPMEMALLOC(mpi_size+1,index_t);              first_NodeComponent = new index_t[mpi_size+1];
475              if (! ( nc_var_temp = dataFile.get_var("Nodes_NodeDistribution")) ) {              if (! ( nc_var_temp = dataFile.get_var("Nodes_NodeDistribution")) ) {
476                  TMPMEMFREE(first_DofComponent);                  delete[] first_DofComponent;
477                  TMPMEMFREE(first_NodeComponent);                  delete[] first_NodeComponent;
478                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Nodes_NodeDistribution)");                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Nodes_NodeDistribution)");
479              }              }
480              if (! nc_var_temp->get(&first_NodeComponent[0], mpi_size+1) ) {              if (! nc_var_temp->get(&first_NodeComponent[0], mpi_size+1) ) {
481                  TMPMEMFREE(first_DofComponent);                  delete[] first_DofComponent;
482                  TMPMEMFREE(first_NodeComponent);                  delete[] first_NodeComponent;
483                  cleanupAndThrow(mesh_p, mpi_info, "get(Nodes_NodeDistribution)");                  cleanupAndThrow(mesh_p, mpi_info, "get(Nodes_NodeDistribution)");
484              }              }
485              Finley_Mesh_createMappings(mesh_p, first_DofComponent, first_NodeComponent);              Finley_Mesh_createMappings(mesh_p, first_DofComponent, first_NodeComponent);
486              TMPMEMFREE(first_DofComponent);              delete[] first_DofComponent;
487              TMPMEMFREE(first_NodeComponent);              delete[] first_NodeComponent;
488          }          }
489    
490      } /* Finley_noError() after Finley_Mesh_alloc() */      } /* Finley_noError() after Finley_Mesh_alloc() */
# Line 518  namespace finley { Line 518  namespace finley {
518         throw DataException("Null file name!");         throw DataException("Null file name!");
519      }      }
520    
521      char *fName = TMPMEMALLOC(fileName.size()+1,char);      char *fName = new char[fileName.size()+1];
522                    
523      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
524      double blocktimer_start = blocktimer_time();      double blocktimer_start = blocktimer_time();
# Line 528  namespace finley { Line 528  namespace finley {
528      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
529            
530      /* win32 refactor */      /* win32 refactor */
531      TMPMEMFREE(fName);      delete[] fName;
532            
533      blocktimer_increment("ReadMesh()", blocktimer_start);      blocktimer_increment("ReadMesh()", blocktimer_start);
534      return temp->getPtr();      return temp->getPtr();
# Line 551  namespace finley { Line 551  namespace finley {
551         throw DataException("Null file name!");         throw DataException("Null file name!");
552      }      }
553    
554      char *fName = TMPMEMALLOC(fileName.size()+1,char);      char *fName = new char[fileName.size()+1];
555                    
556      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
557      double blocktimer_start = blocktimer_time();      double blocktimer_start = blocktimer_time();
# Line 561  namespace finley { Line 561  namespace finley {
561      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
562            
563      /* win32 refactor */      /* win32 refactor */
564      TMPMEMFREE(fName);      delete[] fName;
565            
566      blocktimer_increment("ReadGmsh()", blocktimer_start);      blocktimer_increment("ReadGmsh()", blocktimer_start);
567      return temp->getPtr();      return temp->getPtr();
# Line 725  namespace finley { Line 725  namespace finley {
725      //      //
726      // extract the meshes from meshList      // extract the meshes from meshList
727      int numMsh=boost::python::extract<int>(meshList.attr("__len__")());      int numMsh=boost::python::extract<int>(meshList.attr("__len__")());
728      Finley_Mesh **mshes = (numMsh) ? TMPMEMALLOC(numMsh,Finley_Mesh*) : (Finley_Mesh**)NULL;      Finley_Mesh **mshes = (numMsh) ? new Finley_Mesh*[numMsh] : (Finley_Mesh**)NULL;
729      for (int i=0;i<numMsh;++i) {      for (int i=0;i<numMsh;++i) {
730           AbstractContinuousDomain& meshListMember=boost::python::extract<AbstractContinuousDomain&>(meshList[i]);           AbstractContinuousDomain& meshListMember=boost::python::extract<AbstractContinuousDomain&>(meshList[i]);
731           const MeshAdapter* finley_meshListMember=static_cast<const MeshAdapter*>(&meshListMember);           const MeshAdapter* finley_meshListMember=static_cast<const MeshAdapter*>(&meshListMember);
# Line 734  namespace finley { Line 734  namespace finley {
734      //      //
735      // merge the meshes:      // merge the meshes:
736      fMesh=Finley_Mesh_merge(numMsh,mshes);      fMesh=Finley_Mesh_merge(numMsh,mshes);
737            TMPMEMFREE(mshes);            delete[] mshes;
738      //      //
739      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
740      checkFinleyError();      checkFinleyError();

Legend:
Removed from v.4331  
changed lines
  Added in v.4332

  ViewVC Help
Powered by ViewVC 1.1.26