/[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 1345 by ksteube, Wed Nov 14 07:53:34 2007 UTC revision 1346 by ksteube, Wed Nov 14 22:48:12 2007 UTC
# Line 52  namespace finley { Line 52  namespace finley {
52    AbstractContinuousDomain* loadMesh(const std::string& fileName)    AbstractContinuousDomain* loadMesh(const std::string& fileName)
53    {    {
54  #ifdef USE_NETCDF  #ifdef USE_NETCDF
55        bool optimize=FALSE; // ksteube should this be an argument to LoadMesh?
56      Paso_MPIInfo *mpi_info = Paso_MPIInfo_alloc( MPI_COMM_WORLD );      Paso_MPIInfo *mpi_info = Paso_MPIInfo_alloc( MPI_COMM_WORLD );
57      AbstractContinuousDomain* temp;      AbstractContinuousDomain* temp;
58      Finley_Mesh *mesh_p=NULL;      Finley_Mesh *mesh_p=NULL;
# Line 114  namespace finley { Line 115  namespace finley {
115            free(&mesh_p->Nodes->Id);            free(&mesh_p->Nodes->Id);
116            throw DataException("Error - loadMesh:: unable to recover Nodes_Id from NetCDF file: " + *fName);            throw DataException("Error - loadMesh:: unable to recover Nodes_Id from NetCDF file: " + *fName);
117          }          }
 // printf("ksteube Nodes_Id: "); for (int i=0; i<numNodes; i++) { printf(" %d", mesh_p->Nodes->Id[i]); } printf("\n");  
118      // Nodes_Tag      // Nodes_Tag
119          if (! ( nc_var_temp = dataFile.get_var("Nodes_Tag")) )          if (! ( nc_var_temp = dataFile.get_var("Nodes_Tag")) )
120            throw DataException("Error - loadMesh:: unable to read Nodes_Tag from netCDF file: " + *fName);            throw DataException("Error - loadMesh:: unable to read Nodes_Tag from netCDF file: " + *fName);
# Line 160  namespace finley { Line 160  namespace finley {
160            throw DataException("Error - load:: unable to recover Nodes_Coordinates from netCDF file: " + *fName);            throw DataException("Error - load:: unable to recover Nodes_Coordinates from netCDF file: " + *fName);
161          }          }
162    
 #if 0 /* Not yet...finish the above first */  
163          /* read elements */          /* read elements */
164          if (Finley_noError()) {          if (Finley_noError()) {
165               mesh_p->Elements=Finley_ElementFile_alloc(typeID,mesh_p->order, mesh_p->reduced_order, mpi_info);            if (num_Elements>0) {
166             int num_Elements_numNodes = NetCDF_Get_Int_Attribute(&dataFile, fName, "num_Elements_numNodes");
167             int Elements_TypeId = NetCDF_Get_Int_Attribute(&dataFile, fName, "Elements_TypeId");
168                 mesh_p->Elements=Finley_ElementFile_alloc((ElementTypeId)Elements_TypeId,mesh_p->order, mesh_p->reduced_order, mpi_info);
169               if (Finley_noError()) {               if (Finley_noError()) {
170                   Finley_ElementFile_allocTable(mesh_p->Elements, numEle);                   Finley_ElementFile_allocTable(mesh_p->Elements, num_Elements);
171                   mesh_p->Elements->minColor=0;                   mesh_p->Elements->minColor=0;
172                   mesh_p->Elements->maxColor=numEle-1;                   mesh_p->Elements->maxColor=num_Elements-1;
173                   if (Finley_noError()) {                   if (Finley_noError()) {
174                   // Elements_Id
175                       if (! ( nc_var_temp = dataFile.get_var("Elements_Id")) )
176                         throw DataException("Error - loadMesh:: unable to read Elements_Id from netCDF file: " + *fName);
177                       if (! nc_var_temp->get(&mesh_p->Elements->Id[0], num_Elements) ) {
178                         free(&mesh_p->Elements->Id);
179                         throw DataException("Error - loadMesh:: unable to recover Elements_Id from NetCDF file: " + *fName);
180                       }
181                   // Elements_Tag
182                       if (! ( nc_var_temp = dataFile.get_var("Elements_Tag")) )
183                         throw DataException("Error - loadMesh:: unable to read Elements_Tag from netCDF file: " + *fName);
184                       if (! nc_var_temp->get(&mesh_p->Elements->Tag[0], num_Elements) ) {
185                         free(&mesh_p->Elements->Tag);
186                         throw DataException("Error - loadMesh:: unable to recover Elements_Tag from NetCDF file: " + *fName);
187                       }
188                   // Elements_Owner
189                       if (! ( nc_var_temp = dataFile.get_var("Elements_Owner")) )
190                         throw DataException("Error - loadMesh:: unable to read Elements_Owner from netCDF file: " + *fName);
191                       if (! nc_var_temp->get(&mesh_p->Elements->Owner[0], num_Elements) ) {
192                         free(&mesh_p->Elements->Owner);
193                         throw DataException("Error - loadMesh:: unable to recover Elements_Owner from NetCDF file: " + *fName);
194                       }
195                   // Elements_Color
196                       if (! ( nc_var_temp = dataFile.get_var("Elements_Color")) )
197                         throw DataException("Error - loadMesh:: unable to read Elements_Color from netCDF file: " + *fName);
198                       if (! nc_var_temp->get(&mesh_p->Elements->Color[0], num_Elements) ) {
199                         free(&mesh_p->Elements->Color);
200                         throw DataException("Error - loadMesh:: unable to recover Elements_Color from NetCDF file: " + *fName);
201                       }
202                   // Elements_Nodes
203               int *Elements_Nodes = TMPMEMALLOC(num_Elements*num_Elements_numNodes,int);
204                       if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {
205                         free(&mesh_p->Elements->Nodes);
206                         throw DataException("Error - loadMesh:: unable to read Elements_Nodes from netCDF file: " + *fName);
207                       }
208                       if (! nc_var_temp->get(&(Elements_Nodes[0]), num_Elements, num_Elements_numNodes) ) {
209                         free(&Elements_Nodes);
210                         throw DataException("Error - load:: unable to recover Elements_Nodes from netCDF file: " + *fName);
211                       }
212               // Copy temp array into mesh_p->Elements->Nodes
213               for (int i=0; i<num_Elements; i++) {
214                 for (int j=0; j<num_Elements_numNodes; j++) {
215                   mesh_p->Elements->Nodes[INDEX2(j,i,num_Elements_numNodes)]
216                     = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];
217                 }
218               }
219               TMPMEMFREE(Elements_Nodes);
220           }           }
221           }           }
222          } /* num_Elements>0 */
223      }      }
 #endif  
224    
225          /* get the face elements */          /* get the face elements */
226            if (Finley_noError()) {
227              if (num_FaceElements>0) {
228             int num_FaceElements_numNodes = NetCDF_Get_Int_Attribute(&dataFile, fName, "num_FaceElements_numNodes");
229             int FaceElements_TypeId = NetCDF_Get_Int_Attribute(&dataFile, fName, "FaceElements_TypeId");
230                 mesh_p->FaceElements=Finley_ElementFile_alloc((ElementTypeId)FaceElements_TypeId,mesh_p->order, mesh_p->reduced_order, mpi_info);
231                 if (Finley_noError()) {
232                     Finley_ElementFile_allocTable(mesh_p->FaceElements, num_FaceElements);
233                     mesh_p->FaceElements->minColor=0;
234                     mesh_p->FaceElements->maxColor=num_FaceElements-1;
235                     if (Finley_noError()) {
236                   // FaceElements_Id
237                       if (! ( nc_var_temp = dataFile.get_var("FaceElements_Id")) )
238                         throw DataException("Error - loadMesh:: unable to read FaceElements_Id from netCDF file: " + *fName);
239                       if (! nc_var_temp->get(&mesh_p->FaceElements->Id[0], num_FaceElements) ) {
240                         free(&mesh_p->FaceElements->Id);
241                         throw DataException("Error - loadMesh:: unable to recover FaceElements_Id from NetCDF file: " + *fName);
242                       }
243                   // FaceElements_Tag
244                       if (! ( nc_var_temp = dataFile.get_var("FaceElements_Tag")) )
245                         throw DataException("Error - loadMesh:: unable to read FaceElements_Tag from netCDF file: " + *fName);
246                       if (! nc_var_temp->get(&mesh_p->FaceElements->Tag[0], num_FaceElements) ) {
247                         free(&mesh_p->FaceElements->Tag);
248                         throw DataException("Error - loadMesh:: unable to recover FaceElements_Tag from NetCDF file: " + *fName);
249                       }
250                   // FaceElements_Owner
251                       if (! ( nc_var_temp = dataFile.get_var("FaceElements_Owner")) )
252                         throw DataException("Error - loadMesh:: unable to read FaceElements_Owner from netCDF file: " + *fName);
253                       if (! nc_var_temp->get(&mesh_p->FaceElements->Owner[0], num_FaceElements) ) {
254                         free(&mesh_p->FaceElements->Owner);
255                         throw DataException("Error - loadMesh:: unable to recover FaceElements_Owner from NetCDF file: " + *fName);
256                       }
257                   // FaceElements_Color
258                       if (! ( nc_var_temp = dataFile.get_var("FaceElements_Color")) )
259                         throw DataException("Error - loadMesh:: unable to read FaceElements_Color from netCDF file: " + *fName);
260                       if (! nc_var_temp->get(&mesh_p->FaceElements->Color[0], num_FaceElements) ) {
261                         free(&mesh_p->FaceElements->Color);
262                         throw DataException("Error - loadMesh:: unable to recover FaceElements_Color from NetCDF file: " + *fName);
263                       }
264                   // FaceElements_Nodes
265               int *FaceElements_Nodes = TMPMEMALLOC(num_FaceElements*num_FaceElements_numNodes,int);
266                       if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {
267                         free(&mesh_p->FaceElements->Nodes);
268                         throw DataException("Error - loadMesh:: unable to read FaceElements_Nodes from netCDF file: " + *fName);
269                       }
270                       if (! nc_var_temp->get(&(FaceElements_Nodes[0]), num_FaceElements, num_FaceElements_numNodes) ) {
271                         free(&FaceElements_Nodes);
272                         throw DataException("Error - load:: unable to recover FaceElements_Nodes from netCDF file: " + *fName);
273                       }
274               // Copy temp array into mesh_p->FaceElements->Nodes
275               for (int i=0; i<num_FaceElements; i++) {
276                 for (int j=0; j<num_FaceElements_numNodes; j++) {
277                   mesh_p->FaceElements->Nodes[INDEX2(j,i,num_FaceElements_numNodes)]
278                     = FaceElements_Nodes[INDEX2(j,i,num_FaceElements_numNodes)];
279                 }
280               }
281               TMPMEMFREE(FaceElements_Nodes);
282             }
283             }
284          } /* num_FaceElements>0 */
285        }
286    
287          /* get the Contact face element */          /* get the Contact elements */
288            if (Finley_noError()) {
289              if (num_ContactElements>0) {
290             int num_ContactElements_numNodes = NetCDF_Get_Int_Attribute(&dataFile, fName, "num_ContactElements_numNodes");
291             int ContactElements_TypeId = NetCDF_Get_Int_Attribute(&dataFile, fName, "ContactElements_TypeId");
292                 mesh_p->ContactElements=Finley_ElementFile_alloc((ElementTypeId)ContactElements_TypeId,mesh_p->order, mesh_p->reduced_order, mpi_info);
293                 if (Finley_noError()) {
294                     Finley_ElementFile_allocTable(mesh_p->ContactElements, num_ContactElements);
295                     mesh_p->ContactElements->minColor=0;
296                     mesh_p->ContactElements->maxColor=num_ContactElements-1;
297                     if (Finley_noError()) {
298                   // ContactElements_Id
299                       if (! ( nc_var_temp = dataFile.get_var("ContactElements_Id")) )
300                         throw DataException("Error - loadMesh:: unable to read ContactElements_Id from netCDF file: " + *fName);
301                       if (! nc_var_temp->get(&mesh_p->ContactElements->Id[0], num_ContactElements) ) {
302                         free(&mesh_p->ContactElements->Id);
303                         throw DataException("Error - loadMesh:: unable to recover ContactElements_Id from NetCDF file: " + *fName);
304                       }
305                   // ContactElements_Tag
306                       if (! ( nc_var_temp = dataFile.get_var("ContactElements_Tag")) )
307                         throw DataException("Error - loadMesh:: unable to read ContactElements_Tag from netCDF file: " + *fName);
308                       if (! nc_var_temp->get(&mesh_p->ContactElements->Tag[0], num_ContactElements) ) {
309                         free(&mesh_p->ContactElements->Tag);
310                         throw DataException("Error - loadMesh:: unable to recover ContactElements_Tag from NetCDF file: " + *fName);
311                       }
312                   // ContactElements_Owner
313                       if (! ( nc_var_temp = dataFile.get_var("ContactElements_Owner")) )
314                         throw DataException("Error - loadMesh:: unable to read ContactElements_Owner from netCDF file: " + *fName);
315                       if (! nc_var_temp->get(&mesh_p->ContactElements->Owner[0], num_ContactElements) ) {
316                         free(&mesh_p->ContactElements->Owner);
317                         throw DataException("Error - loadMesh:: unable to recover ContactElements_Owner from NetCDF file: " + *fName);
318                       }
319                   // ContactElements_Color
320                       if (! ( nc_var_temp = dataFile.get_var("ContactElements_Color")) )
321                         throw DataException("Error - loadMesh:: unable to read ContactElements_Color from netCDF file: " + *fName);
322                       if (! nc_var_temp->get(&mesh_p->ContactElements->Color[0], num_ContactElements) ) {
323                         free(&mesh_p->ContactElements->Color);
324                         throw DataException("Error - loadMesh:: unable to recover ContactElements_Color from NetCDF file: " + *fName);
325                       }
326                   // ContactElements_Nodes
327               int *ContactElements_Nodes = TMPMEMALLOC(num_ContactElements*num_ContactElements_numNodes,int);
328                       if (!(nc_var_temp = dataFile.get_var("ContactElements_Nodes"))) {
329                         free(&mesh_p->ContactElements->Nodes);
330                         throw DataException("Error - loadMesh:: unable to read ContactElements_Nodes from netCDF file: " + *fName);
331                       }
332                       if (! nc_var_temp->get(&(ContactElements_Nodes[0]), num_ContactElements, num_ContactElements_numNodes) ) {
333                         free(&ContactElements_Nodes);
334                         throw DataException("Error - load:: unable to recover ContactElements_Nodes from netCDF file: " + *fName);
335                       }
336               // Copy temp array into mesh_p->ContactElements->Nodes
337               for (int i=0; i<num_ContactElements; i++) {
338                 for (int j=0; j<num_ContactElements_numNodes; j++) {
339                   mesh_p->ContactElements->Nodes[INDEX2(j,i,num_ContactElements_numNodes)]
340                     = ContactElements_Nodes[INDEX2(j,i,num_ContactElements_numNodes)];
341                 }
342               }
343               TMPMEMFREE(ContactElements_Nodes);
344             }
345             }
346          } /* num_ContactElements>0 */
347        }
348    
349          /* get the nodal element */          /* get the Points (nodal elements) */
350            if (Finley_noError()) {
351              if (num_Points>0) {
352             int Points_TypeId = NetCDF_Get_Int_Attribute(&dataFile, fName, "Points_TypeId");
353                 mesh_p->Points=Finley_ElementFile_alloc((ElementTypeId)Points_TypeId,mesh_p->order, mesh_p->reduced_order, mpi_info);
354                 if (Finley_noError()) {
355                     Finley_ElementFile_allocTable(mesh_p->Points, num_Points);
356                     mesh_p->Points->minColor=0;
357                     mesh_p->Points->maxColor=num_Points-1;
358                     if (Finley_noError()) {
359                   // Points_Id
360                       if (! ( nc_var_temp = dataFile.get_var("Points_Id")) )
361                         throw DataException("Error - loadMesh:: unable to read Points_Id from netCDF file: " + *fName);
362                       if (! nc_var_temp->get(&mesh_p->Points->Id[0], num_Points) ) {
363                         free(&mesh_p->Points->Id);
364                         throw DataException("Error - loadMesh:: unable to recover Points_Id from NetCDF file: " + *fName);
365                       }
366                   // Points_Tag
367                       if (! ( nc_var_temp = dataFile.get_var("Points_Tag")) )
368                         throw DataException("Error - loadMesh:: unable to read Points_Tag from netCDF file: " + *fName);
369                       if (! nc_var_temp->get(&mesh_p->Points->Tag[0], num_Points) ) {
370                         free(&mesh_p->Points->Tag);
371                         throw DataException("Error - loadMesh:: unable to recover Points_Tag from NetCDF file: " + *fName);
372                       }
373                   // Points_Owner
374                       if (! ( nc_var_temp = dataFile.get_var("Points_Owner")) )
375                         throw DataException("Error - loadMesh:: unable to read Points_Owner from netCDF file: " + *fName);
376                       if (! nc_var_temp->get(&mesh_p->Points->Owner[0], num_Points) ) {
377                         free(&mesh_p->Points->Owner);
378                         throw DataException("Error - loadMesh:: unable to recover Points_Owner from NetCDF file: " + *fName);
379                       }
380                   // Points_Color
381                       if (! ( nc_var_temp = dataFile.get_var("Points_Color")) )
382                         throw DataException("Error - loadMesh:: unable to read Points_Color from netCDF file: " + *fName);
383                       if (! nc_var_temp->get(&mesh_p->Points->Color[0], num_Points) ) {
384                         free(&mesh_p->Points->Color);
385                         throw DataException("Error - loadMesh:: unable to recover Points_Color from NetCDF file: " + *fName);
386                       }
387                   // Points_Nodes
388               int *Points_Nodes = TMPMEMALLOC(num_Points,int);
389                       if (!(nc_var_temp = dataFile.get_var("Points_Nodes"))) {
390                         free(&mesh_p->Points->Nodes);
391                         throw DataException("Error - loadMesh:: unable to read Points_Nodes from netCDF file: " + *fName);
392                       }
393                       if (! nc_var_temp->get(&(Points_Nodes[0]), num_Points) ) {
394                         free(&Points_Nodes);
395                         throw DataException("Error - load:: unable to recover Points_Nodes from netCDF file: " + *fName);
396                       }
397               // Copy temp array into mesh_p->Points->Nodes
398               for (int i=0; i<num_Points; i++) {
399                 mesh_p->Nodes->Id[mesh_p->Points->Nodes[INDEX2(0,i,1)]] = Points_Nodes[i];
400               }
401               TMPMEMFREE(Points_Nodes);
402             }
403             }
404          } /* num_Points>0 */
405        }
406    
407          /* get the name tags */          /* get the name tags */
408    
409      } /* Finley_noError() after Finley_Mesh_alloc() */      } /* Finley_noError() after Finley_Mesh_alloc() */
410        
 #if 0 /* Not yet...finish the above first */  
411      if (Finley_noError()) Finley_Mesh_resolveNodeIds(mesh_p);      if (Finley_noError()) Finley_Mesh_resolveNodeIds(mesh_p);
412      if (Finley_noError()) Finley_Mesh_prepare(mesh_p, optimize);      if (Finley_noError()) Finley_Mesh_prepare(mesh_p, optimize);
 #endif  
413    
414      checkFinleyError();      checkFinleyError();
415      temp=new MeshAdapter(mesh_p);      temp=new MeshAdapter(mesh_p);

Legend:
Removed from v.1345  
changed lines
  Added in v.1346

  ViewVC Help
Powered by ViewVC 1.1.26