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

Diff of /branches/doubleplusgood/dudley/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 122  namespace dudley { Line 122  namespace dudley {
122      char *name = attr->as_string(0);      char *name = attr->as_string(0);
123      delete attr;      delete attr;
124    
125      TMPMEMFREE(fName);      delete[] fName;
126    
127      /* allocate mesh */      /* allocate mesh */
128      mesh_p = Dudley_Mesh_alloc(name,numDim,mpi_info);      mesh_p = Dudley_Mesh_alloc(name,numDim,mpi_info);
# Line 198  namespace dudley { Line 198  namespace dudley {
198                     if (! nc_var_temp->get(&mesh_p->Elements->Color[0], num_Elements) )                     if (! nc_var_temp->get(&mesh_p->Elements->Color[0], num_Elements) )
199                         cleanupAndThrow(mesh_p, mpi_info, "get(Elements_Color)");                         cleanupAndThrow(mesh_p, mpi_info, "get(Elements_Color)");
200                     // Elements_Nodes                     // Elements_Nodes
201                     int *Elements_Nodes = TMPMEMALLOC(num_Elements*num_Elements_numNodes,int);                     int *Elements_Nodes = new int[num_Elements*num_Elements_numNodes];
202                     if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {
203                         TMPMEMFREE(Elements_Nodes);                         delete[] Elements_Nodes;
204                         cleanupAndThrow(mesh_p, mpi_info, "get_var(Elements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get_var(Elements_Nodes)");
205                     }                     }
206                     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) ) {
207                         TMPMEMFREE(Elements_Nodes);                         delete[] Elements_Nodes;
208                         cleanupAndThrow(mesh_p, mpi_info, "get(Elements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get(Elements_Nodes)");
209                     }                     }
210    
# Line 215  namespace dudley { Line 215  namespace dudley {
215                                  = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];                                  = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];
216                         }                         }
217                     }                     }
218                     TMPMEMFREE(Elements_Nodes);                     delete[] Elements_Nodes;
219                     Dudley_ElementFile_setTagsInUse(mesh_p->Elements);                     Dudley_ElementFile_setTagsInUse(mesh_p->Elements);
220                  } /* num_Elements>0 */                  } /* num_Elements>0 */
221              }              }
# Line 251  namespace dudley { Line 251  namespace dudley {
251                     if (! nc_var_temp->get(&mesh_p->FaceElements->Color[0], num_FaceElements) )                     if (! nc_var_temp->get(&mesh_p->FaceElements->Color[0], num_FaceElements) )
252                         cleanupAndThrow(mesh_p, mpi_info, "get(FaceElements_Color)");                         cleanupAndThrow(mesh_p, mpi_info, "get(FaceElements_Color)");
253                     // FaceElements_Nodes                     // FaceElements_Nodes
254                     int *FaceElements_Nodes = TMPMEMALLOC(num_FaceElements*num_FaceElements_numNodes,int);                     int *FaceElements_Nodes = new int[num_FaceElements*num_FaceElements_numNodes];
255                     if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {
256                         TMPMEMFREE(FaceElements_Nodes);                         delete[] FaceElements_Nodes;
257                         cleanupAndThrow(mesh_p, mpi_info, "get_var(FaceElements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get_var(FaceElements_Nodes)");
258                     }                     }
259                     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) ) {
260                         TMPMEMFREE(FaceElements_Nodes);                         delete[] FaceElements_Nodes;
261                         cleanupAndThrow(mesh_p, mpi_info, "get(FaceElements_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get(FaceElements_Nodes)");
262                     }                     }
263                     // Copy temp array into mesh_p->FaceElements->Nodes                     // Copy temp array into mesh_p->FaceElements->Nodes
# Line 266  namespace dudley { Line 266  namespace dudley {
266                             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)];
267                         }                         }
268                     }                     }
269                     TMPMEMFREE(FaceElements_Nodes);                     delete[] FaceElements_Nodes;
270                     Dudley_ElementFile_setTagsInUse(mesh_p->FaceElements);                     Dudley_ElementFile_setTagsInUse(mesh_p->FaceElements);
271                  } /* num_FaceElements>0 */                  } /* num_FaceElements>0 */
272              }              }
# Line 302  namespace dudley { Line 302  namespace dudley {
302                     if (!nc_var_temp->get(&mesh_p->Points->Color[0], num_Points))                     if (!nc_var_temp->get(&mesh_p->Points->Color[0], num_Points))
303                         cleanupAndThrow(mesh_p, mpi_info, "get(Points_Color)");                         cleanupAndThrow(mesh_p, mpi_info, "get(Points_Color)");
304                     // Points_Nodes                     // Points_Nodes
305                     int *Points_Nodes = TMPMEMALLOC(num_Points,int);                     int *Points_Nodes = new int[num_Points];
306                     if (!(nc_var_temp = dataFile.get_var("Points_Nodes"))) {                     if (!(nc_var_temp = dataFile.get_var("Points_Nodes"))) {
307                         TMPMEMFREE(Points_Nodes);                         delete[] Points_Nodes;
308                         cleanupAndThrow(mesh_p, mpi_info, "get_var(Points_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get_var(Points_Nodes)");
309                     }                     }
310                     if (! nc_var_temp->get(&(Points_Nodes[0]), num_Points) ) {                     if (! nc_var_temp->get(&(Points_Nodes[0]), num_Points) ) {
311                         TMPMEMFREE(Points_Nodes);                         delete[] Points_Nodes;
312                         cleanupAndThrow(mesh_p, mpi_info, "get(Points_Nodes)");                         cleanupAndThrow(mesh_p, mpi_info, "get(Points_Nodes)");
313                     }                     }
314                     // Copy temp array into mesh_p->Points->Nodes                     // Copy temp array into mesh_p->Points->Nodes
315                     for (int i=0; i<num_Points; i++) {                     for (int i=0; i<num_Points; i++) {
316                         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];
317                     }                     }
318                     TMPMEMFREE(Points_Nodes);                     delete[] Points_Nodes;
319                     Dudley_ElementFile_setTagsInUse(mesh_p->Points);                     Dudley_ElementFile_setTagsInUse(mesh_p->Points);
320                  } /* num_Points>0 */                  } /* num_Points>0 */
321              }              }
# Line 325  namespace dudley { Line 325  namespace dudley {
325          if (Dudley_noError()) {          if (Dudley_noError()) {
326            if (num_Tags>0) {            if (num_Tags>0) {
327              // Temp storage to gather node IDs              // Temp storage to gather node IDs
328              int *Tags_keys = TMPMEMALLOC(num_Tags, int);              int *Tags_keys = new  int[num_Tags];
329              char name_temp[4096];              char name_temp[4096];
330              int i;              int i;
331    
332              // Tags_keys              // Tags_keys
333              if (! ( nc_var_temp = dataFile.get_var("Tags_keys")) ) {              if (! ( nc_var_temp = dataFile.get_var("Tags_keys")) ) {
334                  TMPMEMFREE(Tags_keys);                  delete[] Tags_keys;
335                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Tags_keys)");                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Tags_keys)");
336              }              }
337              if (! nc_var_temp->get(&Tags_keys[0], num_Tags) ) {              if (! nc_var_temp->get(&Tags_keys[0], num_Tags) ) {
338                  TMPMEMFREE(Tags_keys);                  delete[] Tags_keys;
339                  cleanupAndThrow(mesh_p, mpi_info, "get(Tags_keys)");                  cleanupAndThrow(mesh_p, mpi_info, "get(Tags_keys)");
340              }              }
341              for (i=0; i<num_Tags; i++) {              for (i=0; i<num_Tags; i++) {
342                // Retrieve tag name                // Retrieve tag name
343                sprintf(name_temp, "Tags_name_%d", i);                sprintf(name_temp, "Tags_name_%d", i);
344                if (! (attr=dataFile.get_att(name_temp)) ) {                if (! (attr=dataFile.get_att(name_temp)) ) {
345                    TMPMEMFREE(Tags_keys);                    delete[] Tags_keys;
346                    sprintf(error_msg,"get_att(%s)", name_temp);                    sprintf(error_msg,"get_att(%s)", name_temp);
347                    cleanupAndThrow(mesh_p, mpi_info, error_msg);                    cleanupAndThrow(mesh_p, mpi_info, error_msg);
348                }                }
# Line 350  namespace dudley { Line 350  namespace dudley {
350                delete attr;                delete attr;
351                Dudley_Mesh_addTagMap(mesh_p, name, Tags_keys[i]);                Dudley_Mesh_addTagMap(mesh_p, name, Tags_keys[i]);
352              }              }
353              TMPMEMFREE(Tags_keys);              delete[] Tags_keys;
354            }            }
355          }          }
356        
357          if (Dudley_noError()) {          if (Dudley_noError()) {
358              // Nodes_DofDistribution              // Nodes_DofDistribution
359              first_DofComponent = TMPMEMALLOC(mpi_size+1,index_t);              first_DofComponent = new index_t[mpi_size+1];
360              if (! ( nc_var_temp = dataFile.get_var("Nodes_DofDistribution")) ) {              if (! ( nc_var_temp = dataFile.get_var("Nodes_DofDistribution")) ) {
361                  TMPMEMFREE(first_DofComponent);                  delete[] first_DofComponent;
362                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Nodes_DofDistribution)");                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Nodes_DofDistribution)");
363              }              }
364              if (! nc_var_temp->get(&first_DofComponent[0], mpi_size+1) ) {              if (! nc_var_temp->get(&first_DofComponent[0], mpi_size+1) ) {
365                  TMPMEMFREE(first_DofComponent);                  delete[] first_DofComponent;
366                  cleanupAndThrow(mesh_p, mpi_info, "get(Nodes_DofDistribution)");                  cleanupAndThrow(mesh_p, mpi_info, "get(Nodes_DofDistribution)");
367              }              }
368    
369              // Nodes_NodeDistribution              // Nodes_NodeDistribution
370              first_NodeComponent = TMPMEMALLOC(mpi_size+1,index_t);              first_NodeComponent = new index_t[mpi_size+1];
371              if (! ( nc_var_temp = dataFile.get_var("Nodes_NodeDistribution")) ) {              if (! ( nc_var_temp = dataFile.get_var("Nodes_NodeDistribution")) ) {
372                  TMPMEMFREE(first_DofComponent);                  delete[] first_DofComponent;
373                  TMPMEMFREE(first_NodeComponent);                  delete[] first_NodeComponent;
374                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Nodes_NodeDistribution)");                  cleanupAndThrow(mesh_p, mpi_info, "get_var(Nodes_NodeDistribution)");
375              }              }
376              if (! nc_var_temp->get(&first_NodeComponent[0], mpi_size+1) ) {              if (! nc_var_temp->get(&first_NodeComponent[0], mpi_size+1) ) {
377                  TMPMEMFREE(first_DofComponent);                  delete[] first_DofComponent;
378                  TMPMEMFREE(first_NodeComponent);                  delete[] first_NodeComponent;
379                  cleanupAndThrow(mesh_p, mpi_info, "get(Nodes_NodeDistribution)");                  cleanupAndThrow(mesh_p, mpi_info, "get(Nodes_NodeDistribution)");
380              }              }
381              Dudley_Mesh_createMappings(mesh_p, first_DofComponent, first_NodeComponent);              Dudley_Mesh_createMappings(mesh_p, first_DofComponent, first_NodeComponent);
382              TMPMEMFREE(first_DofComponent);              delete[] first_DofComponent;
383              TMPMEMFREE(first_NodeComponent);              delete[] first_NodeComponent;
384          }          }
385    
386      } /* Dudley_noError() after Dudley_Mesh_alloc() */      } /* Dudley_noError() after Dudley_Mesh_alloc() */
# Line 414  namespace dudley { Line 414  namespace dudley {
414         throw DataException("Null file name!");         throw DataException("Null file name!");
415      }      }
416    
417      char *fName = TMPMEMALLOC(fileName.size()+1,char);      char *fName = new char[fileName.size()+1];
418                    
419      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
420      double blocktimer_start = blocktimer_time();      double blocktimer_start = blocktimer_time();
# Line 424  namespace dudley { Line 424  namespace dudley {
424      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
425            
426      /* win32 refactor */      /* win32 refactor */
427      TMPMEMFREE(fName);      delete[] fName;
428            
429      blocktimer_increment("ReadMesh()", blocktimer_start);      blocktimer_increment("ReadMesh()", blocktimer_start);
430      return temp->getPtr();      return temp->getPtr();
# Line 447  namespace dudley { Line 447  namespace dudley {
447         throw DataException("Null file name!");         throw DataException("Null file name!");
448      }      }
449    
450      char *fName = TMPMEMALLOC(fileName.size()+1,char);      char *fName = new char[fileName.size()+1];
451                    
452      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
453      double blocktimer_start = blocktimer_time();      double blocktimer_start = blocktimer_time();
# Line 457  namespace dudley { Line 457  namespace dudley {
457      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
458            
459      /* win32 refactor */      /* win32 refactor */
460      TMPMEMFREE(fName);      delete[] fName;
461            
462      blocktimer_increment("ReadGmsh()", blocktimer_start);      blocktimer_increment("ReadGmsh()", blocktimer_start);
463      return temp->getPtr();      return temp->getPtr();

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

  ViewVC Help
Powered by ViewVC 1.1.26