/[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 782 by bcumming, Tue Jul 18 00:47:47 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            else if (order==2) {
86        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,
87                       useElementsOnFace) ;                       useElementsOnFace) ;
88      } else {      } else {
# Line 95  namespace finley { Line 106  namespace finley {
106      double length[]={l0,l1};      double length[]={l0,l1};
107      int periodic[]={periodic0, periodic1};      int periodic[]={periodic0, periodic1};
108    
109      Finley_Mesh* fMesh;      Finley_Mesh* fMesh=0;
110      if (order==1) {      if (order==1) {
111        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,
112                      useElementsOnFace);                      useElementsOnFace);
113      } else if (order==2) {      }
114        else if (order==2) {
115        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,
116                      useElementsOnFace);                      useElementsOnFace);
117      } else {      }
118        else {
119        stringstream temp;        stringstream temp;
120        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
121        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
# Line 124  namespace finley { Line 137  namespace finley {
137      if (order==1) {      if (order==1) {
138        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,
139                       useElementsOnFace);                       useElementsOnFace);
140      } else if (order==2) {      }
141        else if (order==2) {
142        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,
143                       useElementsOnFace);                       useElementsOnFace);
144      } else {      }
145        else {
146        stringstream temp;        stringstream temp;
147        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
148        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
# Line 138  namespace finley { Line 153  namespace finley {
153      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
154      return temp;      return temp;
155    }    }
156    AbstractContinuousDomain*  meshMerge(const boost::python::list& meshList)    AbstractContinuousDomain* meshMerge(const boost::python::list& meshList)
157    {    {
158      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
159        //
160        // extract the meshes from meshList
161    #ifndef PASO_MPI
162        int numMsh=boost::python::extract<int>(meshList.attr("__len__")());
163        Finley_Mesh **mshes = (numMsh) ? TMPMEMALLOC(numMsh,Finley_Mesh*) : (Finley_Mesh**)NULL;
164        for (int i=0;i<numMsh;++i) {
165             AbstractContinuousDomain& meshListMember=boost::python::extract<AbstractContinuousDomain&>(meshList[i]);
166             const MeshAdapter* finley_meshListMember=static_cast<const MeshAdapter*>(&meshListMember);
167             mshes[i]=finley_meshListMember->getFinley_Mesh();
168        }
169        //
170        // merge the meshes:
171        fMesh=Finley_Mesh_merge(numMsh,mshes);
172          TMPMEMFREE(mshes);
173    #else
174        {
175          stringstream temp;
176          temp << "meshMerge() not available in MPI yet...";
177          setFinleyError(VALUE_ERROR,temp.str().c_str());
178        }
179    #endif
180        //
181        // Convert any finley errors into a C++ exception
182        checkFinleyError();
183        AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
184    
185      return temp;      return temp;
186    }    }
187    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,
188              double safetyFactor,              double safety_factor,
189              double tolerance)              double tolerance)
190    {    {
191      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
192      return temp;  #ifndef PASO_MPI
193        //
194        // merge the meshes:
195        AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
196        //
197        // glue the faces:
198        const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
199        fMesh=merged_finley_meshes->getFinley_Mesh();
200        Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance);
201    
202        //
203        // Convert any finley errors into a C++ exception
204        checkFinleyError();
205        return merged_meshes;
206    #else
207        {
208          stringstream temp;
209          temp << "glueFaces() not available in MPI yet...";
210          setFinleyError(VALUE_ERROR,temp.str().c_str());
211        }
212    
213        //
214        // Convert any finley errors into a C++ exception
215        checkFinleyError();
216        return (AbstractContinuousDomain*)0;
217    #endif
218    
219    }    }
220    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,
221              double safety_factor,              double safety_factor,
222              double tolerance)              double tolerance)
223    {    {
224      AbstractContinuousDomain* temp=new MeshAdapter(0);      Finley_Mesh* fMesh=0;
225      return temp;      //
226        // merge the meshes:
227    #ifndef PASO_MPI
228        AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
229        //
230        // join the faces:
231        const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
232        fMesh=merged_finley_meshes->getFinley_Mesh();
233        Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance);
234        //
235        // Convert any finley errors into a C++ exception
236        checkFinleyError();
237        return merged_meshes;
238    #else
239        {
240          stringstream temp;
241          temp << "joinFaces() not available in MPI yet...";
242          setFinleyError(VALUE_ERROR,temp.str().c_str());
243        }
244        //
245        // Convert any finley errors into a C++ exception
246        checkFinleyError();
247        return (AbstractContinuousDomain*)0;
248    
249    #endif
250    }    }
251    
252  }  // end of namespace  }  // end of namespace

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

  ViewVC Help
Powered by ViewVC 1.1.26