/[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

trunk/esys2/finley/src/CPPAdapter/MeshAdapterFactory.cpp revision 102 by jgs, Wed Dec 15 07:08:39 2004 UTC trunk/finley/src/CPPAdapter/MeshAdapterFactory.cpp revision 759 by bcumming, Thu Jun 29 01:53:23 2006 UTC
# Line 13  Line 13 
13   ******************************************************************************   ******************************************************************************
14  */  */
15    
16  extern "C" {  #include "MeshAdapterFactory.h"
17  #include "finley/finleyC/Finley.h"  #include "FinleyError.h"
 #include "finley/finleyC/Mesh.h"  
 #include "finley/finleyC/RectangularMesh.h"  
 }  
 #include "finley/CPPAdapter/FinleyError.h"  
 #include "finley/CPPAdapter/MeshAdapterFactory.h"  
18    
19    #include <boost/python/extract.hpp>
20    
   
 #include <iostream>  
21  #include <sstream>  #include <sstream>
22    
23  using namespace std;  using namespace std;
# Line 37  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      char fName[fileName.size()+1];      Finley_Mesh* fMesh=0;
35        // Win32 refactor
36        char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;
37      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
38      Finley_Mesh* fMesh=Finley_Mesh_read(fName,integrationOrder);  
39    #ifndef PASO_MPI
40        fMesh=Finley_Mesh_read(fName,integrationOrder);
41    #else
42        {
43          stringstream temp;
44          temp << "Unable to read meshes from file under MPI yet...";
45          setFinleyError(VALUE_ERROR,temp.str().c_str());
46        }
47    #endif
48      checkFinleyError();      checkFinleyError();
49      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
50        
51        /* win32 refactor */
52        TMPMEMFREE(fName);
53        
54      return temp;      return temp;
55    }    }
56    
# Line 67  namespace finley { Line 76  namespace finley {
76    
77      //      //
78      // linearInterpolation      // linearInterpolation
79      Finley_Mesh* fMesh;      Finley_Mesh* fMesh=NULL;
80    
81      if (order==1) {      if (order==1) {
82        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,
83                      useElementsOnFace) ;                      useElementsOnFace) ;
84      } else if (order==2) {      }
85    #ifndef PASO_MPI
86            else if (order==2) {
87        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,
88                       useElementsOnFace) ;                       useElementsOnFace) ;
89      } else {      } else {
# Line 79  namespace finley { Line 91  namespace finley {
91        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
92        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
93      }      }
94    #else
95            else {
96          stringstream temp;
97          temp << "type of 3D regular mesh requested is unavailable under MPI\nOR\nIllegal interpolation order: " << order;
98          setFinleyError(VALUE_ERROR,temp.str().c_str());
99        }
100    #endif
101      //      //
102      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
103      checkFinleyError();      checkFinleyError();
# Line 95  namespace finley { Line 114  namespace finley {
114      double length[]={l0,l1};      double length[]={l0,l1};
115      int periodic[]={periodic0, periodic1};      int periodic[]={periodic0, periodic1};
116    
117      Finley_Mesh* fMesh;      Finley_Mesh* fMesh=0;
118      if (order==1) {      if (order==1) {
119        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,
120                      useElementsOnFace);                      useElementsOnFace);
121      } else if (order==2) {      }
122    #ifndef PASO_MPI
123        else if (order==2) {
124        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,
125                      useElementsOnFace);                      useElementsOnFace);
126      } else {      }
127    #endif
128        else {
129        stringstream temp;        stringstream temp;
130        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
131        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
# Line 124  namespace finley { Line 147  namespace finley {
147      if (order==1) {      if (order==1) {
148        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,
149                       useElementsOnFace);                       useElementsOnFace);
150      } else if (order==2) {      }
151    #ifndef PASO_MPI
152        else if (order==2) {
153        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,
154                       useElementsOnFace);                       useElementsOnFace);
155      } else {      }
156    #endif
157        else {
158        stringstream temp;        stringstream temp;
159        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
160        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
# Line 138  namespace finley { Line 165  namespace finley {
165      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
166      return temp;      return temp;
167    }    }
168    AbstractContinuousDomain*  meshMerge(const boost::python::list& meshList)    AbstractContinuousDomain* meshMerge(const boost::python::list& meshList)
169    {    {
170      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
171        //
172        // extract the meshes from meshList
173    #ifndef PASO_MPI
174        int numMsh=boost::python::extract<int>(meshList.attr("__len__")());
175        Finley_Mesh **mshes = (numMsh) ? TMPMEMALLOC(numMsh,Finley_Mesh*) : (Finley_Mesh**)NULL;
176        for (int i=0;i<numMsh;++i) {
177             AbstractContinuousDomain& meshListMember=boost::python::extract<AbstractContinuousDomain&>(meshList[i]);
178             const MeshAdapter* finley_meshListMember=static_cast<const MeshAdapter*>(&meshListMember);
179             mshes[i]=finley_meshListMember->getFinley_Mesh();
180        }
181        //
182        // merge the meshes:
183        fMesh=Finley_Mesh_merge(numMsh,mshes);
184          TMPMEMFREE(mshes);
185    #else
186        {
187          stringstream temp;
188          temp << "meshMerge() not available in MPI yet...";
189          setFinleyError(VALUE_ERROR,temp.str().c_str());
190        }
191    #endif
192        //
193        // Convert any finley errors into a C++ exception
194        checkFinleyError();
195        AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
196    
197      return temp;      return temp;
198    }    }
199    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,
200              double safetyFactor,              double safety_factor,
201              double tolerance)              double tolerance)
202    {    {
203      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
204      return temp;  #ifndef PASO_MPI
205        //
206        // merge the meshes:
207        AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
208        //
209        // glue the faces:
210        const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
211        fMesh=merged_finley_meshes->getFinley_Mesh();
212        Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance);
213    
214        //
215        // Convert any finley errors into a C++ exception
216        checkFinleyError();
217        return merged_meshes;
218    #else
219        {
220          stringstream temp;
221          temp << "glueFaces() not available in MPI yet...";
222          setFinleyError(VALUE_ERROR,temp.str().c_str());
223        }
224    
225        //
226        // Convert any finley errors into a C++ exception
227        checkFinleyError();
228        return (AbstractContinuousDomain*)0;
229    #endif
230    
231    }    }
232    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,
233              double safety_factor,              double safety_factor,
234              double tolerance)              double tolerance)
235    {    {
236      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
237      return temp;      //
238        // merge the meshes:
239    #ifndef PASO_MPI
240        AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
241        //
242        // join the faces:
243        const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
244        fMesh=merged_finley_meshes->getFinley_Mesh();
245        Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance);
246        //
247        // Convert any finley errors into a C++ exception
248        checkFinleyError();
249        return merged_meshes;
250    #else
251        {
252          stringstream temp;
253          temp << "joinFaces() not available in MPI yet...";
254          setFinleyError(VALUE_ERROR,temp.str().c_str());
255        }
256        //
257        // Convert any finley errors into a C++ exception
258        checkFinleyError();
259        return (AbstractContinuousDomain*)0;
260    
261    #endif
262    }    }
263    
264  }  // end of namespace  }  // end of namespace

Legend:
Removed from v.102  
changed lines
  Added in v.759

  ViewVC Help
Powered by ViewVC 1.1.26