/[escript]/branches/more_shared_ptrs_from_1812/finley/src/CPPAdapter/MeshAdapterFactory.cpp
ViewVC logotype

Diff of /branches/more_shared_ptrs_from_1812/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 1059 by gross, Fri Mar 23 11:01:53 2007 UTC
# Line 13  Line 13 
13   ******************************************************************************   ******************************************************************************
14  */  */
15    
16  extern "C" {  #ifdef PASO_MPI
17  #include "finley/finleyC/Finley.h"  #include <mpi.h>
18  #include "finley/finleyC/Mesh.h"  #endif
19  #include "finley/finleyC/RectangularMesh.h"  #include "MeshAdapterFactory.h"
20  }  #include "FinleyError.h"
 #include "finley/CPPAdapter/FinleyError.h"  
 #include "finley/CPPAdapter/MeshAdapterFactory.h"  
21    
22    #include <boost/python/extract.hpp>
23    
   
 #include <iostream>  
24  #include <sstream>  #include <sstream>
25    
26  using namespace std;  using namespace std;
# Line 32  using namespace escript; Line 29  using namespace escript;
29  namespace finley {  namespace finley {
30    
31    AbstractContinuousDomain* readMesh(const std::string& fileName,    AbstractContinuousDomain* readMesh(const std::string& fileName,
32                       int integrationOrder)                       int integrationOrder,
33                                         int reducedIntegrationOrder,
34                                         bool optimizeLabeling)
35    {    {
36      //      //
37      // 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
38      // to Finley_Mesh_read      // to Finley_Mesh_read
39      char fName[fileName.size()+1];      Finley_Mesh* fMesh=0;
40        // Win32 refactor
41        char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;
42      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
43      Finley_Mesh* fMesh=Finley_Mesh_read(fName,integrationOrder);  
44    #ifndef PASO_MPI
45        fMesh=Finley_Mesh_read(fName,integrationOrder);
46    #else
47        {
48          stringstream temp;
49          temp << "Unable to read meshes from file under MPI yet...";
50          setFinleyError(VALUE_ERROR,temp.str().c_str());
51        }
52    #endif
53      checkFinleyError();      checkFinleyError();
54      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
55        
56        /* win32 refactor */
57        TMPMEMFREE(fName);
58        
59        return temp;
60      }
61    
62      AbstractContinuousDomain* readGmsh(const std::string& fileName,
63                                         int numDim,
64                                         int integrationOrder,
65                                         int reducedIntegrationOrder,
66                                         bool optimizeLabeling)
67      {
68        //
69        // create a copy of the filename to overcome the non-constness of call
70        // to Finley_Mesh_read
71        Finley_Mesh* fMesh=0;
72        // Win32 refactor
73        char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;
74        strcpy(fName,fileName.c_str());
75    
76    #ifndef PASO_MPI
77        fMesh=Finley_Mesh_readGmsh(fName, numDim, integrationOrder, reducedIntegrationOrder, optimizeLabeling);
78    #else
79        {
80          stringstream temp;
81          temp << "Unable to read gmsh meshes from file under MPI yet...";
82          setFinleyError(VALUE_ERROR,temp.str().c_str());
83        }
84    #endif
85        checkFinleyError();
86        AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
87        
88        /* win32 refactor */
89        TMPMEMFREE(fName);
90        
91      return temp;      return temp;
92    }    }
93    
# Line 50  namespace finley { Line 96  namespace finley {
96              int periodic0,int periodic1,              int periodic0,int periodic1,
97              int periodic2,              int periodic2,
98              int integrationOrder,              int integrationOrder,
99                        int reducedIntegrationOrder,
100              int useElementsOnFace)              int useElementsOnFace)
101    {    {
102  //     cout << "n0=" << n0 << " n1=" << n1 << " n2=" << n2  //     cout << "n0=" << n0 << " n1=" << n1 << " n2=" << n2
# Line 67  namespace finley { Line 114  namespace finley {
114    
115      //      //
116      // linearInterpolation      // linearInterpolation
117      Finley_Mesh* fMesh;      Finley_Mesh* fMesh=NULL;
118    
119      if (order==1) {      if (order==1) {
120        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,
121                      useElementsOnFace) ;                      useElementsOnFace) ;
122      } else if (order==2) {      }
123            else if (order==2) {
124        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,
125                       useElementsOnFace) ;                       useElementsOnFace) ;
126      } else {      } else {
# Line 89  namespace finley { Line 138  namespace finley {
138              double l0, double l1,              double l0, double l1,
139              int periodic0,int periodic1,              int periodic0,int periodic1,
140              int integrationOrder,              int integrationOrder,
141                            int reducedIntegrationOrder,
142              int useElementsOnFace)              int useElementsOnFace)
143    {    {
144      int numElements[]={n0,n1};      int numElements[]={n0,n1};
145      double length[]={l0,l1};      double length[]={l0,l1};
146      int periodic[]={periodic0, periodic1};      int periodic[]={periodic0, periodic1};
147    
148      Finley_Mesh* fMesh;      Finley_Mesh* fMesh=0;
149      if (order==1) {      if (order==1) {
150        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,
151                      useElementsOnFace);                      useElementsOnFace);
152      } else if (order==2) {      }
153        else if (order==2) {
154        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,
155                      useElementsOnFace);                      useElementsOnFace);
156      } else {      }
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 115  namespace finley { Line 167  namespace finley {
167    }    }
168    AbstractContinuousDomain*  interval(int n0,int order,double l0,int periodic0,    AbstractContinuousDomain*  interval(int n0,int order,double l0,int periodic0,
169                 int integrationOrder,                 int integrationOrder,
170                           int reducedIntegrationOrder,
171                 int useElementsOnFace)                 int useElementsOnFace)
172    {    {
173      int numElements[]={n0};      int numElements[]={n0};
# Line 124  namespace finley { Line 177  namespace finley {
177      if (order==1) {      if (order==1) {
178        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,
179                       useElementsOnFace);                       useElementsOnFace);
180      } else if (order==2) {      }
181        else if (order==2) {
182        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,
183                       useElementsOnFace);                       useElementsOnFace);
184      } else {      }
185        else {
186        stringstream temp;        stringstream temp;
187        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
188        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
# Line 138  namespace finley { Line 193  namespace finley {
193      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
194      return temp;      return temp;
195    }    }
196    AbstractContinuousDomain*  meshMerge(const boost::python::list& meshList)    AbstractContinuousDomain* meshMerge(const boost::python::list& meshList)
197    {    {
198      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
199        //
200        // extract the meshes from meshList
201    #ifndef PASO_MPI
202        int numMsh=boost::python::extract<int>(meshList.attr("__len__")());
203        Finley_Mesh **mshes = (numMsh) ? TMPMEMALLOC(numMsh,Finley_Mesh*) : (Finley_Mesh**)NULL;
204        for (int i=0;i<numMsh;++i) {
205             AbstractContinuousDomain& meshListMember=boost::python::extract<AbstractContinuousDomain&>(meshList[i]);
206             const MeshAdapter* finley_meshListMember=static_cast<const MeshAdapter*>(&meshListMember);
207             mshes[i]=finley_meshListMember->getFinley_Mesh();
208        }
209        //
210        // merge the meshes:
211        fMesh=Finley_Mesh_merge(numMsh,mshes);
212          TMPMEMFREE(mshes);
213    #else
214        {
215          stringstream temp;
216          temp << "meshMerge() not available in MPI yet...";
217          setFinleyError(VALUE_ERROR,temp.str().c_str());
218        }
219    #endif
220        //
221        // Convert any finley errors into a C++ exception
222        checkFinleyError();
223        AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
224    
225      return temp;      return temp;
226    }    }
227    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,
228              double safetyFactor,              double safety_factor,
229              double tolerance)              double tolerance,
230                            bool optimizeLabeling)
231    {    {
232      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
233      return temp;  #ifndef PASO_MPI
234        //
235        // merge the meshes:
236        AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
237        //
238        // glue the faces:
239        const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
240        fMesh=merged_finley_meshes->getFinley_Mesh();
241        Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance);
242    
243        //
244        // Convert any finley errors into a C++ exception
245        checkFinleyError();
246        return merged_meshes;
247    #else
248        {
249          stringstream temp;
250          temp << "glueFaces() not available in MPI yet...";
251          setFinleyError(VALUE_ERROR,temp.str().c_str());
252        }
253    
254        //
255        // Convert any finley errors into a C++ exception
256        checkFinleyError();
257        return (AbstractContinuousDomain*)0;
258    #endif
259    
260    }    }
261    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,
262              double safety_factor,              double safety_factor,
263              double tolerance)              double tolerance,
264                            bool optimizeLabeling)
265    {    {
266      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
267      return temp;      //
268        // merge the meshes:
269    #ifndef PASO_MPI
270        AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
271        //
272        // join the faces:
273        const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
274        fMesh=merged_finley_meshes->getFinley_Mesh();
275        Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance);
276        //
277        // Convert any finley errors into a C++ exception
278        checkFinleyError();
279        return merged_meshes;
280    #else
281        {
282          stringstream temp;
283          temp << "joinFaces() not available in MPI yet...";
284          setFinleyError(VALUE_ERROR,temp.str().c_str());
285        }
286        //
287        // Convert any finley errors into a C++ exception
288        checkFinleyError();
289        return (AbstractContinuousDomain*)0;
290    
291    #endif
292    }    }
293    
294  }  // end of namespace  }  // end of namespace

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

  ViewVC Help
Powered by ViewVC 1.1.26