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

Diff of /branches/trilinos_from_5897/dudley/src/CPPAdapter/MeshAdapterFactory.cpp

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

revision 6078 by caltinay, Wed Mar 2 04:13:26 2016 UTC revision 6079 by caltinay, Mon Mar 21 12:22:38 2016 UTC
# Line 53  T ncReadAtt(NcFile* dataFile, const stri Line 53  T ncReadAtt(NcFile* dataFile, const stri
53  }  }
54  #endif  #endif
55    
56  inline void cleanupAndThrow(Dudley_Mesh* mesh, string msg)  inline void cleanupAndThrow(Mesh* mesh, string msg)
57  {  {
58      Dudley_Mesh_free(mesh);      delete mesh;
59      string msgPrefix("loadMesh: NetCDF operation failed - ");      string msgPrefix("loadMesh: NetCDF operation failed - ");
60      throw escript::IOError(msgPrefix+msg);      throw escript::IOError(msgPrefix+msg);
61  }  }
# Line 63  inline void cleanupAndThrow(Dudley_Mesh* Line 63  inline void cleanupAndThrow(Dudley_Mesh*
63  Domain_ptr loadMesh(const std::string& fileName)  Domain_ptr loadMesh(const std::string& fileName)
64  {  {
65  #ifdef USE_NETCDF  #ifdef USE_NETCDF
66      escript::JMPI mpi_info = escript::makeInfo( MPI_COMM_WORLD );      escript::JMPI mpi_info = escript::makeInfo(MPI_COMM_WORLD);
     Dudley_Mesh *mesh_p=NULL;  
67      const string fName(mpi_info->appendRankToFileName(fileName));      const string fName(mpi_info->appendRankToFileName(fileName));
68    
     int *first_DofComponent, *first_NodeComponent;  
   
69      // Open NetCDF file for reading      // Open NetCDF file for reading
70      NcAtt *attr;      NcAtt *attr;
71      NcVar *nc_var_temp;      NcVar *nc_var_temp;
# Line 139  Domain_ptr loadMesh(const std::string& f Line 136  Domain_ptr loadMesh(const std::string& f
136      delete attr;      delete attr;
137    
138      // allocate mesh      // allocate mesh
139      mesh_p = Dudley_Mesh_alloc(name.get(), numDim, mpi_info);      Mesh* mesh = new Mesh(name.get(), numDim, mpi_info);
140      // read nodes      // read nodes
141      Dudley_NodeFile_allocTable(mesh_p->Nodes, numNodes);      mesh->Nodes->allocTable(numNodes);
142      // Nodes_Id      // Nodes_Id
143      if (! ( nc_var_temp = dataFile.get_var("Nodes_Id")) )      if (! ( nc_var_temp = dataFile.get_var("Nodes_Id")) )
144          cleanupAndThrow(mesh_p, "get_var(Nodes_Id)");          cleanupAndThrow(mesh, "get_var(Nodes_Id)");
145      if (! nc_var_temp->get(&mesh_p->Nodes->Id[0], numNodes) )      if (! nc_var_temp->get(&mesh->Nodes->Id[0], numNodes) )
146          cleanupAndThrow(mesh_p, "get(Nodes_Id)");          cleanupAndThrow(mesh, "get(Nodes_Id)");
147      // Nodes_Tag      // Nodes_Tag
148      if (! ( nc_var_temp = dataFile.get_var("Nodes_Tag")) )      if (! ( nc_var_temp = dataFile.get_var("Nodes_Tag")) )
149          cleanupAndThrow(mesh_p, "get_var(Nodes_Tag)");          cleanupAndThrow(mesh, "get_var(Nodes_Tag)");
150      if (! nc_var_temp->get(&mesh_p->Nodes->Tag[0], numNodes) )      if (! nc_var_temp->get(&mesh->Nodes->Tag[0], numNodes) )
151          cleanupAndThrow(mesh_p, "get(Nodes_Tag)");          cleanupAndThrow(mesh, "get(Nodes_Tag)");
152      // Nodes_gDOF      // Nodes_gDOF
153      if (! ( nc_var_temp = dataFile.get_var("Nodes_gDOF")) )      if (! ( nc_var_temp = dataFile.get_var("Nodes_gDOF")) )
154          cleanupAndThrow(mesh_p, "get_var(Nodes_gDOF)");          cleanupAndThrow(mesh, "get_var(Nodes_gDOF)");
155      if (! nc_var_temp->get(&mesh_p->Nodes->globalDegreesOfFreedom[0], numNodes) )      if (! nc_var_temp->get(&mesh->Nodes->globalDegreesOfFreedom[0], numNodes) )
156          cleanupAndThrow(mesh_p, "get(Nodes_gDOF)");          cleanupAndThrow(mesh, "get(Nodes_gDOF)");
157      // Nodes_gNI      // Nodes_gNI
158      if (! ( nc_var_temp = dataFile.get_var("Nodes_gNI")) )      if (! ( nc_var_temp = dataFile.get_var("Nodes_gNI")) )
159          cleanupAndThrow(mesh_p, "get_var(Nodes_gNI)");          cleanupAndThrow(mesh, "get_var(Nodes_gNI)");
160      if (! nc_var_temp->get(&mesh_p->Nodes->globalNodesIndex[0], numNodes) )      if (! nc_var_temp->get(&mesh->Nodes->globalNodesIndex[0], numNodes) )
161          cleanupAndThrow(mesh_p, "get(Nodes_gNI)");          cleanupAndThrow(mesh, "get(Nodes_gNI)");
     // Nodes_grDfI  
     if (! ( nc_var_temp = dataFile.get_var("Nodes_grDfI")) )  
         cleanupAndThrow(mesh_p, "get_var(Nodes_grDfI)");  
     if (! nc_var_temp->get(&mesh_p->Nodes->globalReducedDOFIndex[0], numNodes) )  
         cleanupAndThrow(mesh_p, "get(Nodes_grDfI)");  
     // Nodes_grNI  
     if (! ( nc_var_temp = dataFile.get_var("Nodes_grNI")) )  
         cleanupAndThrow(mesh_p, "get_var(Nodes_grNI)");  
     if (! nc_var_temp->get(&mesh_p->Nodes->globalReducedNodesIndex[0], numNodes) )  
         cleanupAndThrow(mesh_p, "get(Nodes_grNI)");  
162      // Nodes_Coordinates      // Nodes_Coordinates
163      if (!(nc_var_temp = dataFile.get_var("Nodes_Coordinates")))      if (!(nc_var_temp = dataFile.get_var("Nodes_Coordinates")))
164          cleanupAndThrow(mesh_p, "get_var(Nodes_Coordinates)");          cleanupAndThrow(mesh, "get_var(Nodes_Coordinates)");
165      if (! nc_var_temp->get(&(mesh_p->Nodes->Coordinates[0]), numNodes, numDim) )      if (! nc_var_temp->get(&(mesh->Nodes->Coordinates[0]), numNodes, numDim) )
166          cleanupAndThrow(mesh_p, "get(Nodes_Coordinates)");          cleanupAndThrow(mesh, "get(Nodes_Coordinates)");
167    
168      Dudley_NodeFile_setTagsInUse(mesh_p->Nodes);      mesh->Nodes->updateTagList();
169    
170      /* read elements */      /* read elements */
171      mesh_p->Elements=Dudley_ElementFile_alloc((Dudley_ElementTypeId)Elements_TypeId, mpi_info);      mesh->Elements = new ElementFile((ElementTypeId)Elements_TypeId, mpi_info);
172      Dudley_ElementFile_allocTable(mesh_p->Elements, num_Elements);      mesh->Elements->allocTable(num_Elements);
173      mesh_p->Elements->minColor=0;      mesh->Elements->minColor = 0;
174      mesh_p->Elements->maxColor=num_Elements-1;      mesh->Elements->maxColor = num_Elements-1;
175      if (num_Elements>0) {      if (num_Elements > 0) {
176         // Elements_Id         // Elements_Id
177         if (! ( nc_var_temp = dataFile.get_var("Elements_Id")) )         if (! ( nc_var_temp = dataFile.get_var("Elements_Id")) )
178             cleanupAndThrow(mesh_p, "get_var(Elements_Id)");             cleanupAndThrow(mesh, "get_var(Elements_Id)");
179         if (! nc_var_temp->get(&mesh_p->Elements->Id[0], num_Elements) )         if (! nc_var_temp->get(&mesh->Elements->Id[0], num_Elements) )
180             cleanupAndThrow(mesh_p, "get(Elements_Id)");             cleanupAndThrow(mesh, "get(Elements_Id)");
181         // Elements_Tag         // Elements_Tag
182         if (! ( nc_var_temp = dataFile.get_var("Elements_Tag")) )         if (! ( nc_var_temp = dataFile.get_var("Elements_Tag")) )
183             cleanupAndThrow(mesh_p, "get_var(Elements_Tag)");             cleanupAndThrow(mesh, "get_var(Elements_Tag)");
184         if (! nc_var_temp->get(&mesh_p->Elements->Tag[0], num_Elements) )         if (! nc_var_temp->get(&mesh->Elements->Tag[0], num_Elements) )
185             cleanupAndThrow(mesh_p, "get(Elements_Tag)");             cleanupAndThrow(mesh, "get(Elements_Tag)");
186         // Elements_Owner         // Elements_Owner
187         if (! ( nc_var_temp = dataFile.get_var("Elements_Owner")) )         if (! ( nc_var_temp = dataFile.get_var("Elements_Owner")) )
188             cleanupAndThrow(mesh_p, "get_var(Elements_Owner)");             cleanupAndThrow(mesh, "get_var(Elements_Owner)");
189         if (! nc_var_temp->get(&mesh_p->Elements->Owner[0], num_Elements) )         if (! nc_var_temp->get(&mesh->Elements->Owner[0], num_Elements) )
190             cleanupAndThrow(mesh_p, "get(Elements_Owner)");             cleanupAndThrow(mesh, "get(Elements_Owner)");
191         // Elements_Color         // Elements_Color
192         if (! ( nc_var_temp = dataFile.get_var("Elements_Color")) )         if (! ( nc_var_temp = dataFile.get_var("Elements_Color")) )
193             cleanupAndThrow(mesh_p, "get_var(Elements_Color)");             cleanupAndThrow(mesh, "get_var(Elements_Color)");
194         if (! nc_var_temp->get(&mesh_p->Elements->Color[0], num_Elements) )         if (! nc_var_temp->get(&mesh->Elements->Color[0], num_Elements) )
195             cleanupAndThrow(mesh_p, "get(Elements_Color)");             cleanupAndThrow(mesh, "get(Elements_Color)");
196         // Elements_Nodes         // Elements_Nodes
197         int *Elements_Nodes = new int[num_Elements*num_Elements_numNodes];         int *Elements_Nodes = new int[num_Elements*num_Elements_numNodes];
198         if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {         if (!(nc_var_temp = dataFile.get_var("Elements_Nodes"))) {
199             delete[] Elements_Nodes;             delete[] Elements_Nodes;
200             cleanupAndThrow(mesh_p, "get_var(Elements_Nodes)");             cleanupAndThrow(mesh, "get_var(Elements_Nodes)");
201         }         }
202         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) ) {
203             delete[] Elements_Nodes;             delete[] Elements_Nodes;
204             cleanupAndThrow(mesh_p, "get(Elements_Nodes)");             cleanupAndThrow(mesh, "get(Elements_Nodes)");
205         }         }
206    
207         // Copy temp array into mesh_p->Elements->Nodes         // Copy temp array into mesh->Elements->Nodes
208         for (int i=0; i<num_Elements; i++) {         for (int i=0; i<num_Elements; i++) {
209             for (int j=0; j<num_Elements_numNodes; j++) {             for (int j=0; j<num_Elements_numNodes; j++) {
210                 mesh_p->Elements->Nodes[INDEX2(j,i,num_Elements_numNodes)]                 mesh->Elements->Nodes[INDEX2(j,i,num_Elements_numNodes)]
211                      = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];                      = Elements_Nodes[INDEX2(j,i,num_Elements_numNodes)];
212             }             }
213         }         }
214         delete[] Elements_Nodes;         delete[] Elements_Nodes;
215      } /* num_Elements>0 */      } // num_Elements > 0
216      Dudley_ElementFile_setTagsInUse(mesh_p->Elements);      mesh->Elements->updateTagList();
217    
218      /* get the face elements */      /* get the face elements */
219      mesh_p->FaceElements=Dudley_ElementFile_alloc((Dudley_ElementTypeId)FaceElements_TypeId, mpi_info);      mesh->FaceElements = new ElementFile((ElementTypeId)FaceElements_TypeId, mpi_info);
220      Dudley_ElementFile_allocTable(mesh_p->FaceElements, num_FaceElements);      mesh->FaceElements->allocTable(num_FaceElements);
221      mesh_p->FaceElements->minColor=0;      mesh->FaceElements->minColor = 0;
222      mesh_p->FaceElements->maxColor=num_FaceElements-1;      mesh->FaceElements->maxColor = num_FaceElements-1;
223      if (num_FaceElements>0) {      if (num_FaceElements > 0) {
224         // FaceElements_Id         // FaceElements_Id
225         if (! ( nc_var_temp = dataFile.get_var("FaceElements_Id")) )         if (! ( nc_var_temp = dataFile.get_var("FaceElements_Id")) )
226             cleanupAndThrow(mesh_p, "get_var(FaceElements_Id)");             cleanupAndThrow(mesh, "get_var(FaceElements_Id)");
227         if (! nc_var_temp->get(&mesh_p->FaceElements->Id[0], num_FaceElements) )         if (! nc_var_temp->get(&mesh->FaceElements->Id[0], num_FaceElements) )
228             cleanupAndThrow(mesh_p, "get(FaceElements_Id)");             cleanupAndThrow(mesh, "get(FaceElements_Id)");
229         // FaceElements_Tag         // FaceElements_Tag
230         if (! ( nc_var_temp = dataFile.get_var("FaceElements_Tag")) )         if (! ( nc_var_temp = dataFile.get_var("FaceElements_Tag")) )
231             cleanupAndThrow(mesh_p, "get_var(FaceElements_Tag)");             cleanupAndThrow(mesh, "get_var(FaceElements_Tag)");
232         if (! nc_var_temp->get(&mesh_p->FaceElements->Tag[0], num_FaceElements) )         if (! nc_var_temp->get(&mesh->FaceElements->Tag[0], num_FaceElements) )
233             cleanupAndThrow(mesh_p, "get(FaceElements_Tag)");             cleanupAndThrow(mesh, "get(FaceElements_Tag)");
234         // FaceElements_Owner         // FaceElements_Owner
235         if (! ( nc_var_temp = dataFile.get_var("FaceElements_Owner")) )         if (! ( nc_var_temp = dataFile.get_var("FaceElements_Owner")) )
236             cleanupAndThrow(mesh_p, "get_var(FaceElements_Owner)");             cleanupAndThrow(mesh, "get_var(FaceElements_Owner)");
237         if (! nc_var_temp->get(&mesh_p->FaceElements->Owner[0], num_FaceElements) )         if (! nc_var_temp->get(&mesh->FaceElements->Owner[0], num_FaceElements) )
238             cleanupAndThrow(mesh_p, "get(FaceElements_Owner)");             cleanupAndThrow(mesh, "get(FaceElements_Owner)");
239         // FaceElements_Color         // FaceElements_Color
240         if (! ( nc_var_temp = dataFile.get_var("FaceElements_Color")) )         if (! ( nc_var_temp = dataFile.get_var("FaceElements_Color")) )
241             cleanupAndThrow(mesh_p, "get_var(FaceElements_Color)");             cleanupAndThrow(mesh, "get_var(FaceElements_Color)");
242         if (! nc_var_temp->get(&mesh_p->FaceElements->Color[0], num_FaceElements) )         if (! nc_var_temp->get(&mesh->FaceElements->Color[0], num_FaceElements) )
243             cleanupAndThrow(mesh_p, "get(FaceElements_Color)");             cleanupAndThrow(mesh, "get(FaceElements_Color)");
244         // FaceElements_Nodes         // FaceElements_Nodes
245         int *FaceElements_Nodes = new int[num_FaceElements*num_FaceElements_numNodes];         int *FaceElements_Nodes = new int[num_FaceElements*num_FaceElements_numNodes];
246         if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {         if (!(nc_var_temp = dataFile.get_var("FaceElements_Nodes"))) {
247             delete[] FaceElements_Nodes;             delete[] FaceElements_Nodes;
248             cleanupAndThrow(mesh_p, "get_var(FaceElements_Nodes)");             cleanupAndThrow(mesh, "get_var(FaceElements_Nodes)");
249         }         }
250         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) ) {
251             delete[] FaceElements_Nodes;             delete[] FaceElements_Nodes;
252             cleanupAndThrow(mesh_p, "get(FaceElements_Nodes)");             cleanupAndThrow(mesh, "get(FaceElements_Nodes)");
253         }         }
254         // Copy temp array into mesh_p->FaceElements->Nodes         // Copy temp array into mesh->FaceElements->Nodes
255         for (int i=0; i<num_FaceElements; i++) {         for (int i=0; i<num_FaceElements; i++) {
256             for (int j=0; j<num_FaceElements_numNodes; j++) {             for (int j=0; j<num_FaceElements_numNodes; j++) {
257                 mesh_p->FaceElements->Nodes[INDEX2(j,i,num_FaceElements_numNodes)] = FaceElements_Nodes[INDEX2(j,i,num_FaceElements_numNodes)];                 mesh->FaceElements->Nodes[INDEX2(j,i,num_FaceElements_numNodes)] = FaceElements_Nodes[INDEX2(j,i,num_FaceElements_numNodes)];
258             }             }
259         }         }
260         delete[] FaceElements_Nodes;         delete[] FaceElements_Nodes;
261      } /* num_FaceElements>0 */      } // num_FaceElements > 0
262      Dudley_ElementFile_setTagsInUse(mesh_p->FaceElements);      mesh->FaceElements->updateTagList();
263    
264      /* get the Points (nodal elements) */      // get the Points (nodal elements)
265      mesh_p->Points=Dudley_ElementFile_alloc((Dudley_ElementTypeId)Points_TypeId, mpi_info);      mesh->Points = new ElementFile((ElementTypeId)Points_TypeId, mpi_info);
266      Dudley_ElementFile_allocTable(mesh_p->Points, num_Points);      mesh->Points->allocTable(num_Points);
267      mesh_p->Points->minColor=0;      mesh->Points->minColor = 0;
268      mesh_p->Points->maxColor=num_Points-1;      mesh->Points->maxColor = num_Points-1;
269      if (num_Points>0) {      if (num_Points > 0) {
270         // Points_Id         // Points_Id
271         if (! ( nc_var_temp = dataFile.get_var("Points_Id")))         if (! ( nc_var_temp = dataFile.get_var("Points_Id")))
272             cleanupAndThrow(mesh_p, "get_var(Points_Id)");             cleanupAndThrow(mesh, "get_var(Points_Id)");
273         if (! nc_var_temp->get(&mesh_p->Points->Id[0], num_Points))         if (! nc_var_temp->get(&mesh->Points->Id[0], num_Points))
274             cleanupAndThrow(mesh_p, "get(Points_Id)");             cleanupAndThrow(mesh, "get(Points_Id)");
275         // Points_Tag         // Points_Tag
276         if (! ( nc_var_temp = dataFile.get_var("Points_Tag")))         if (! ( nc_var_temp = dataFile.get_var("Points_Tag")))
277             cleanupAndThrow(mesh_p, "get_var(Points_Tag)");             cleanupAndThrow(mesh, "get_var(Points_Tag)");
278         if (! nc_var_temp->get(&mesh_p->Points->Tag[0], num_Points))         if (! nc_var_temp->get(&mesh->Points->Tag[0], num_Points))
279             cleanupAndThrow(mesh_p, "get(Points_Tag)");             cleanupAndThrow(mesh, "get(Points_Tag)");
280         // Points_Owner         // Points_Owner
281         if (! ( nc_var_temp = dataFile.get_var("Points_Owner")))         if (! ( nc_var_temp = dataFile.get_var("Points_Owner")))
282             cleanupAndThrow(mesh_p, "get_var(Points_Owner)");             cleanupAndThrow(mesh, "get_var(Points_Owner)");
283         if (!nc_var_temp->get(&mesh_p->Points->Owner[0], num_Points))         if (!nc_var_temp->get(&mesh->Points->Owner[0], num_Points))
284             cleanupAndThrow(mesh_p, "get(Points_Owner)");             cleanupAndThrow(mesh, "get(Points_Owner)");
285         // Points_Color         // Points_Color
286         if (! ( nc_var_temp = dataFile.get_var("Points_Color")))         if (! ( nc_var_temp = dataFile.get_var("Points_Color")))
287             cleanupAndThrow(mesh_p, "get_var(Points_Color)");             cleanupAndThrow(mesh, "get_var(Points_Color)");
288         if (!nc_var_temp->get(&mesh_p->Points->Color[0], num_Points))         if (!nc_var_temp->get(&mesh->Points->Color[0], num_Points))
289             cleanupAndThrow(mesh_p, "get(Points_Color)");             cleanupAndThrow(mesh, "get(Points_Color)");
290         // Points_Nodes         // Points_Nodes
291         int *Points_Nodes = new int[num_Points];         int *Points_Nodes = new int[num_Points];
292         if (!(nc_var_temp = dataFile.get_var("Points_Nodes"))) {         if (!(nc_var_temp = dataFile.get_var("Points_Nodes"))) {
293             delete[] Points_Nodes;             delete[] Points_Nodes;
294             cleanupAndThrow(mesh_p, "get_var(Points_Nodes)");             cleanupAndThrow(mesh, "get_var(Points_Nodes)");
295         }         }
296         if (! nc_var_temp->get(&(Points_Nodes[0]), num_Points) ) {         if (! nc_var_temp->get(&(Points_Nodes[0]), num_Points) ) {
297             delete[] Points_Nodes;             delete[] Points_Nodes;
298             cleanupAndThrow(mesh_p, "get(Points_Nodes)");             cleanupAndThrow(mesh, "get(Points_Nodes)");
299         }         }
300         // Copy temp array into mesh_p->Points->Nodes         // Copy temp array into mesh->Points->Nodes
301         for (int i=0; i<num_Points; i++) {         for (int i=0; i<num_Points; i++) {
302             mesh_p->Points->Id[mesh_p->Points->Nodes[INDEX2(0,i,1)]] = Points_Nodes[i];             mesh->Points->Id[mesh->Points->Nodes[INDEX2(0,i,1)]] = Points_Nodes[i];
303         }         }
304         delete[] Points_Nodes;         delete[] Points_Nodes;
305      } /* num_Points>0 */      } // num_Points > 0
306      Dudley_ElementFile_setTagsInUse(mesh_p->Points);      mesh->Points->updateTagList();
307    
308      /* get the tags */      // get the tags
309      if (num_Tags>0) {      if (num_Tags > 0) {
310          // Temp storage to gather node IDs          // Temp storage to gather node IDs
311          int *Tags_keys = new int[num_Tags];          int *Tags_keys = new int[num_Tags];
312          char name_temp[4096];          char name_temp[4096];
# Line 328  Domain_ptr loadMesh(const std::string& f Line 315  Domain_ptr loadMesh(const std::string& f
315          // Tags_keys          // Tags_keys
316          if (! ( nc_var_temp = dataFile.get_var("Tags_keys")) ) {          if (! ( nc_var_temp = dataFile.get_var("Tags_keys")) ) {
317              delete[] Tags_keys;              delete[] Tags_keys;
318              cleanupAndThrow(mesh_p, "get_var(Tags_keys)");              cleanupAndThrow(mesh, "get_var(Tags_keys)");
319          }          }
320          if (! nc_var_temp->get(&Tags_keys[0], num_Tags) ) {          if (! nc_var_temp->get(&Tags_keys[0], num_Tags) ) {
321              delete[] Tags_keys;              delete[] Tags_keys;
322              cleanupAndThrow(mesh_p, "get(Tags_keys)");              cleanupAndThrow(mesh, "get(Tags_keys)");
323          }          }
324          for (i=0; i<num_Tags; i++) {          for (i=0; i<num_Tags; i++) {
325            // Retrieve tag name            // Retrieve tag name
# Line 341  Domain_ptr loadMesh(const std::string& f Line 328  Domain_ptr loadMesh(const std::string& f
328                delete[] Tags_keys;                delete[] Tags_keys;
329                stringstream msg;                stringstream msg;
330                msg << "get_att(" << name_temp << ")";                msg << "get_att(" << name_temp << ")";
331                cleanupAndThrow(mesh_p, msg.str());                cleanupAndThrow(mesh, msg.str());
332            }            }
333            boost::scoped_array<char> name(attr->as_string(0));            boost::scoped_array<char> name(attr->as_string(0));
334            delete attr;            delete attr;
335            Dudley_Mesh_addTagMap(mesh_p, name.get(), Tags_keys[i]);            mesh->addTagMap(name.get(), Tags_keys[i]);
336          }          }
337          delete[] Tags_keys;          delete[] Tags_keys;
338      }      }
339    
340      // Nodes_DofDistribution      // Nodes_DofDistribution
341      first_DofComponent = new index_t[mpi_size+1];      std::vector<index_t> first_DofComponent(mpi_size+1);
342      if (! ( nc_var_temp = dataFile.get_var("Nodes_DofDistribution")) ) {      if (! ( nc_var_temp = dataFile.get_var("Nodes_DofDistribution")) ) {
343          delete[] first_DofComponent;          cleanupAndThrow(mesh, "get_var(Nodes_DofDistribution)");
         cleanupAndThrow(mesh_p, "get_var(Nodes_DofDistribution)");  
344      }      }
345      if (! nc_var_temp->get(&first_DofComponent[0], mpi_size+1) ) {      if (! nc_var_temp->get(&first_DofComponent[0], mpi_size+1) ) {
346          delete[] first_DofComponent;          cleanupAndThrow(mesh, "get(Nodes_DofDistribution)");
         cleanupAndThrow(mesh_p, "get(Nodes_DofDistribution)");  
347      }      }
348    
349      // Nodes_NodeDistribution      // Nodes_NodeDistribution
350      first_NodeComponent = new index_t[mpi_size+1];      std::vector<index_t> first_NodeComponent(mpi_size+1);
351      if (! ( nc_var_temp = dataFile.get_var("Nodes_NodeDistribution")) ) {      if (! ( nc_var_temp = dataFile.get_var("Nodes_NodeDistribution")) ) {
352          delete[] first_DofComponent;          cleanupAndThrow(mesh, "get_var(Nodes_NodeDistribution)");
         delete[] first_NodeComponent;  
         cleanupAndThrow(mesh_p, "get_var(Nodes_NodeDistribution)");  
353      }      }
354      if (! nc_var_temp->get(&first_NodeComponent[0], mpi_size+1) ) {      if (! nc_var_temp->get(&first_NodeComponent[0], mpi_size+1) ) {
355          delete[] first_DofComponent;          cleanupAndThrow(mesh, "get(Nodes_NodeDistribution)");
356          delete[] first_NodeComponent;      }
357          cleanupAndThrow(mesh_p, "get(Nodes_NodeDistribution)");      mesh->createMappings(first_DofComponent, first_NodeComponent);
     }  
     Dudley_Mesh_createMappings(mesh_p, first_DofComponent, first_NodeComponent);  
     delete[] first_DofComponent;  
     delete[] first_NodeComponent;  
358    
359      AbstractContinuousDomain* dom=new MeshAdapter(mesh_p);      AbstractContinuousDomain* dom(new MeshAdapter(mesh));
360      return dom->getPtr();      return dom->getPtr();
361  #else  #else
362      throw DataException("loadMesh: not compiled with NetCDF. Please contact your installation manager.");      throw DataException("loadMesh: not compiled with NetCDF. Please contact your installation manager.");
363  #endif /* USE_NETCDF */  #endif /* USE_NETCDF */
364    }    }
365    
366    Domain_ptr readMesh(const std::string& fileName,  Domain_ptr readMesh(const std::string& fileName, int integrationOrder,
367                        int integrationOrder,                      int reducedIntegrationOrder, bool optimize)
368                        int reducedIntegrationOrder,  {
369                        int optimize)      escript::JMPI mpiInfo = escript::makeInfo(MPI_COMM_WORLD);
370    {      Mesh* fMesh = Mesh::read(mpiInfo, fileName, optimize);
371      //      AbstractContinuousDomain* temp = new MeshAdapter(fMesh);
     // create a copy of the filename to overcome the non-constness of call  
     // to Dudley_Mesh_read  
     Dudley_Mesh* fMesh=0;  
     // Win32 refactor  
     if( fileName.size() == 0 )  
     {  
        throw DataException("Null file name!");  
     }  
   
     char *fName = new char[fileName.size()+1];  
           
     strcpy(fName,fileName.c_str());  
   
     fMesh=Dudley_Mesh_read(fName,integrationOrder, reducedIntegrationOrder, optimize!=0);  
     AbstractContinuousDomain* temp=new MeshAdapter(fMesh);  
       
     delete[] fName;  
       
372      return temp->getPtr();      return temp->getPtr();
373    }  }
374    
375    Domain_ptr readGmsh(const std::string& fileName,  Domain_ptr readGmsh(const std::string& fileName, int numDim,
376                        int numDim,                      int integrationOrder, int reducedIntegrationOrder,
377                        int integrationOrder,                      bool optimize)
378                        int reducedIntegrationOrder,  {
379                        int optimize)      escript::JMPI mpiInfo = escript::makeInfo(MPI_COMM_WORLD);
380    {      Mesh* fMesh = Mesh::readGmsh(mpiInfo, fileName, numDim, optimize);
     //  
     // create a copy of the filename to overcome the non-constness of call  
     // to Dudley_Mesh_read  
     Dudley_Mesh* fMesh=0;  
     if (fileName.size() == 0)  
        throw DudleyException("Null file name!");  
   
     char *fName = new char[fileName.size()+1];  
     strcpy(fName,fileName.c_str());  
     fMesh=Dudley_Mesh_readGmsh(fName, numDim, integrationOrder, reducedIntegrationOrder, optimize!=0);  
381      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
     delete[] fName;  
382      return temp->getPtr();      return temp->getPtr();
383    }  }
384    
385    Domain_ptr brick(escript::JMPI& mpi_info, double n0, double n1,double n2,int order,  Domain_ptr brick(escript::JMPI& mpi_info, double n0, double n1,double n2,
386                     double l0,double l1,double l2,                   int order, double l0, double l1, double l2, int periodic0,
387                     int periodic0,int periodic1,                   int periodic1, int periodic2, int integrationOrder,
388                     int periodic2,                   int reducedIntegrationOrder, int useElementsOnFace,
389                     int integrationOrder,                   int useFullElementOrder, bool optimize)
390                     int reducedIntegrationOrder,  {
                    int useElementsOnFace,  
                    int useFullElementOrder,  
                    int optimize)  
   {  
391      int numElements[]={static_cast<int>(n0),static_cast<int>(n1),static_cast<int>(n2)};      int numElements[]={static_cast<int>(n0),static_cast<int>(n1),static_cast<int>(n2)};
392      double length[]={l0,l1,l2};      double length[]={l0,l1,l2};
393    
394      if (periodic0 || periodic1) // we don't support periodic boundary conditions      // we don't support periodic boundary conditions
395      {      if (periodic0 || periodic1)
396          throw DudleyException("Dudley does not support periodic boundary conditions.");          throw DudleyException("Dudley does not support periodic boundary conditions.");
397      }  
398      else if (integrationOrder>3 || reducedIntegrationOrder>1)      if (integrationOrder>3 || reducedIntegrationOrder>1)
     {  
399          throw DudleyException("Dudley does not support the requested integrationOrders.");          throw DudleyException("Dudley does not support the requested integrationOrders.");
400      }  
401      else if (useElementsOnFace || useFullElementOrder)      if (useElementsOnFace || useFullElementOrder)
     {  
402          throw DudleyException("Dudley does not support useElementsOnFace or useFullElementOrder.");          throw DudleyException("Dudley does not support useElementsOnFace or useFullElementOrder.");
     }  
     if (order>1)  
     {  
         throw DudleyException("Dudley does not support element order greater than 1.");  
     }  
403    
404      //      if (order > 1)
405      // linearInterpolation          throw DudleyException("Dudley does not support element order greater than 1.");
     Dudley_Mesh* fMesh=NULL;  
406    
407      fMesh=Dudley_TriangularMesh_Tet4(numElements, length, integrationOrder,      Mesh* fMesh = TriangularMesh_Tet4(numElements, length, optimize, mpi_info);
                         reducedIntegrationOrder, optimize!=0,  
                         mpi_info);  
408    
409      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp(new MeshAdapter(fMesh));
410      return temp->getPtr();      return temp->getPtr();
411    }  }
412    
413    Domain_ptr brick_driver(const boost::python::list& args)  Domain_ptr brick_driver(const boost::python::list& args)
414    {  {
415        using boost::python::extract;        using boost::python::extract;
416        boost::python::object pworld=args[15];        boost::python::object pworld=args[15];
417        escript::JMPI info;        escript::JMPI info;
# Line 499  Domain_ptr loadMesh(const std::string& f Line 435  Domain_ptr loadMesh(const std::string& f
435                     extract<int>(args[11]), extract<int>(args[12]),                     extract<int>(args[11]), extract<int>(args[12]),
436                     extract<int>(args[13]), extract<int>(args[14])                     extract<int>(args[13]), extract<int>(args[14])
437                     );                     );
438    }    }  
439        
440        
441    Domain_ptr rectangle_driver(const boost::python::list& args)  Domain_ptr rectangle_driver(const boost::python::list& args)
442    {  {
443        using boost::python::extract;        using boost::python::extract;
444        boost::python::object pworld=args[12];        boost::python::object pworld=args[12];
445        escript::JMPI info;        escript::JMPI info;
# Line 525  Domain_ptr loadMesh(const std::string& f Line 461  Domain_ptr loadMesh(const std::string& f
461                         extract<int>(args[8]), extract<int>(args[9]),                         extract<int>(args[8]), extract<int>(args[9]),
462                         extract<int>(args[10]), extract<int>(args[11])                         extract<int>(args[10]), extract<int>(args[11])
463                         );                         );
464    }    }  
465        
466        
467        
468    Domain_ptr rectangle(escript::JMPI& mpi_info, double n0, double n1, int order,  Domain_ptr rectangle(escript::JMPI& mpi_info, double n0, double n1, int order,
469                         double l0, double l1,                       double l0, double l1,
470                         int periodic0,int periodic1,                       int periodic0,int periodic1,
471                         int integrationOrder,                       int integrationOrder,
472                         int reducedIntegrationOrder,                       int reducedIntegrationOrder,
473                         int useElementsOnFace,                       int useElementsOnFace,
474                         int useFullElementOrder,                       int useFullElementOrder,
475                         int optimize)                       bool optimize)
476    {  {
477      int numElements[]={static_cast<int>(n0), static_cast<int>(n1)};      int numElements[]={static_cast<int>(n0), static_cast<int>(n1)};
478      double length[]={l0,l1};      double length[]={l0,l1};
479    
480      if (periodic0 || periodic1) // we don't support periodic boundary conditions      if (periodic0 || periodic1) // we don't support periodic boundary conditions
     {  
481          throw DudleyException("Dudley does not support periodic boundary conditions.");          throw DudleyException("Dudley does not support periodic boundary conditions.");
482      }      if (integrationOrder>3 || reducedIntegrationOrder>1)
     else if (integrationOrder>3 || reducedIntegrationOrder>1)  
     {  
483          throw DudleyException("Dudley does not support the requested integrationOrders.");          throw DudleyException("Dudley does not support the requested integrationOrders.");
484      }      if (useElementsOnFace || useFullElementOrder)
     else if (useElementsOnFace || useFullElementOrder)  
     {  
485          throw DudleyException("Dudley does not support useElementsOnFace or useFullElementOrder.");          throw DudleyException("Dudley does not support useElementsOnFace or useFullElementOrder.");
     }  
486    
487      if (order>1)      if (order > 1)
     {  
488          throw DudleyException("Dudley does not support element order greater than 1.");          throw DudleyException("Dudley does not support element order greater than 1.");
489      }      Mesh* fMesh = TriangularMesh_Tri3(numElements, length, optimize, mpi_info);
     Dudley_Mesh* fMesh=Dudley_TriangularMesh_Tri3(numElements, length,  
           integrationOrder, reducedIntegrationOrder, optimize!=0,  
           mpi_info);  
490      //      //
491      // Convert any dudley errors into a C++ exception      // Convert any dudley errors into a C++ exception
492      MeshAdapter* ma=new MeshAdapter(fMesh);      MeshAdapter* ma = new MeshAdapter(fMesh);
493      return Domain_ptr(ma);      return Domain_ptr(ma);
494    }  }
495    
496    
497  } // namespace dudley  } // namespace dudley

Legend:
Removed from v.6078  
changed lines
  Added in v.6079

  ViewVC Help
Powered by ViewVC 1.1.26