/[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 750 by jgs, Wed Feb 1 05:15:12 2006 UTC revision 751 by bcumming, Mon Jun 26 01:46:34 2006 UTC
# Line 31  namespace finley { Line 31  namespace finley {
31      //      //
32      // create a copy of the filename to overcome the non-constness of call      // create a copy of the filename to overcome the non-constness of call
33      // to Finley_Mesh_read      // to Finley_Mesh_read
34        Finley_Mesh* fMesh=0;
35      char fName[fileName.size()+1];      char fName[fileName.size()+1];
36      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
37      Finley_Mesh* fMesh=Finley_Mesh_read(fName,integrationOrder);  
38    #ifndef PASO_MPI
39        fMesh=Finley_Mesh_read(fName,integrationOrder);
40    #else
41        {
42          stringstream temp;
43          temp << "Unable to read meshes from file under MPI yet...";
44          setFinleyError(VALUE_ERROR,temp.str().c_str());
45        }
46    #endif
47      checkFinleyError();      checkFinleyError();
48      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
49      return temp;      return temp;
# Line 61  namespace finley { Line 71  namespace finley {
71    
72      //      //
73      // linearInterpolation      // linearInterpolation
74      Finley_Mesh* fMesh;      Finley_Mesh* fMesh=NULL;
75    
76      if (order==1) {      if (order==1) {
77        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,
78                      useElementsOnFace) ;                      useElementsOnFace) ;
79      } else if (order==2) {      }
80    #ifndef PASO_MPI
81            else if (order==2) {
82        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,
83                       useElementsOnFace) ;                       useElementsOnFace) ;
84      } else {      } else {
# Line 73  namespace finley { Line 86  namespace finley {
86        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
87        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
88      }      }
89    #else
90            else {
91          stringstream temp;
92          temp << "type of 3D regular mesh requested is unavailable under MPI\nOR\nIllegal interpolation order: " << order;
93          setFinleyError(VALUE_ERROR,temp.str().c_str());
94        }
95    #endif
96      //      //
97      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
98      checkFinleyError();      checkFinleyError();
# Line 89  namespace finley { Line 109  namespace finley {
109      double length[]={l0,l1};      double length[]={l0,l1};
110      int periodic[]={periodic0, periodic1};      int periodic[]={periodic0, periodic1};
111    
112      Finley_Mesh* fMesh;      Finley_Mesh* fMesh=0;
113      if (order==1) {      if (order==1) {
114        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,
115                      useElementsOnFace);                      useElementsOnFace);
116      } else if (order==2) {      }
117    #ifndef PASO_MPI
118        else if (order==2) {
119        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,
120                      useElementsOnFace);                      useElementsOnFace);
121      } else {      }
122    #endif
123        else {
124        stringstream temp;        stringstream temp;
125        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
126        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
# Line 118  namespace finley { Line 142  namespace finley {
142      if (order==1) {      if (order==1) {
143        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,
144                       useElementsOnFace);                       useElementsOnFace);
145      } else if (order==2) {      }
146    #ifndef PASO_MPI
147        else if (order==2) {
148        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,
149                       useElementsOnFace);                       useElementsOnFace);
150      } else {      }
151    #endif
152        else {
153        stringstream temp;        stringstream temp;
154        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
155        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
# Line 137  namespace finley { Line 165  namespace finley {
165      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
166      //      //
167      // extract the meshes from meshList      // extract the meshes from meshList
168    #ifndef PASO_MPI
169      int numMsh=boost::python::extract<int>(meshList.attr("__len__")());      int numMsh=boost::python::extract<int>(meshList.attr("__len__")());
170      Finley_Mesh* mshes[numMsh];      Finley_Mesh* mshes[numMsh];
171      for (int i=0;i<numMsh;++i) {      for (int i=0;i<numMsh;++i) {
# Line 147  namespace finley { Line 176  namespace finley {
176      //      //
177      // merge the meshes:      // merge the meshes:
178      fMesh=Finley_Mesh_merge(numMsh,mshes);      fMesh=Finley_Mesh_merge(numMsh,mshes);
179    #else
180        {
181          stringstream temp;
182          temp << "meshMerge() not available in MPI yet...";
183          setFinleyError(VALUE_ERROR,temp.str().c_str());
184        }
185    #endif
186      //      //
187      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
188      checkFinleyError();      checkFinleyError();
# Line 158  namespace finley { Line 194  namespace finley {
194              double tolerance)              double tolerance)
195    {    {
196      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
197    #ifndef PASO_MPI
198      //      //
199      // merge the meshes:      // merge the meshes:
200      AbstractContinuousDomain* merged_meshes=meshMerge(meshList);      AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
# Line 166  namespace finley { Line 203  namespace finley {
203      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
204      fMesh=merged_finley_meshes->getFinley_Mesh();      fMesh=merged_finley_meshes->getFinley_Mesh();
205      Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance);      Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance);
206    
207      //      //
208      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
209      checkFinleyError();      checkFinleyError();
210      return merged_meshes;      return merged_meshes;
211    #else
212        {
213          stringstream temp;
214          temp << "glueFaces() not available in MPI yet...";
215          setFinleyError(VALUE_ERROR,temp.str().c_str());
216        }
217    
218        //
219        // Convert any finley errors into a C++ exception
220        checkFinleyError();
221        return (AbstractContinuousDomain*)0;
222    #endif
223    
224    }    }
225    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,
226              double safety_factor,              double safety_factor,
# Line 178  namespace finley { Line 229  namespace finley {
229      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
230      //      //
231      // merge the meshes:      // merge the meshes:
232    #ifndef PASO_MPI
233      AbstractContinuousDomain* merged_meshes=meshMerge(meshList);      AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
234      //      //
235      // join the faces:      // join the faces:
# Line 188  namespace finley { Line 240  namespace finley {
240      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
241      checkFinleyError();      checkFinleyError();
242      return merged_meshes;      return merged_meshes;
243    #else
244        {
245          stringstream temp;
246          temp << "joinFaces() not available in MPI yet...";
247          setFinleyError(VALUE_ERROR,temp.str().c_str());
248        }
249        //
250        // Convert any finley errors into a C++ exception
251        checkFinleyError();
252        return (AbstractContinuousDomain*)0;
253    
254    #endif
255    }    }
256    
257  }  // end of namespace  }  // end of namespace

Legend:
Removed from v.750  
changed lines
  Added in v.751

  ViewVC Help
Powered by ViewVC 1.1.26