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

revision 757 by woo409, Mon Jun 26 13:12:56 2006 UTC revision 1062 by gross, Mon Mar 26 06:17:53 2007 UTC
# Line 13  Line 13 
13   ******************************************************************************   ******************************************************************************
14  */  */
15    
16    #ifdef PASO_MPI
17    #include <mpi.h>
18    #endif
19  #include "MeshAdapterFactory.h"  #include "MeshAdapterFactory.h"
20  #include "FinleyError.h"  #include "FinleyError.h"
21    
# Line 26  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
# Line 37  namespace finley { Line 42  namespace finley {
42      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
43    
44  #ifndef PASO_MPI  #ifndef PASO_MPI
45      fMesh=Finley_Mesh_read(fName,integrationOrder);      fMesh=Finley_Mesh_read(fName,integrationOrder, reducedIntegrationOrder, (optimizeLabeling ? TRUE : FALSE));
46  #else  #else
47      {      {
48        stringstream temp;        stringstream temp;
# Line 54  namespace finley { Line 59  namespace finley {
59      return temp;      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 ? TRUE : FALSE));
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;
92      }
93    
94    AbstractContinuousDomain* brick(int n0,int n1,int n2,int order,    AbstractContinuousDomain* brick(int n0,int n1,int n2,int order,
95              double l0,double l1,double l2,              double l0,double l1,double l2,
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 79  namespace finley { Line 117  namespace finley {
117      Finley_Mesh* fMesh=NULL;      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,reducedIntegrationOrder,
121                      useElementsOnFace) ;                      useElementsOnFace) ;
122      }      }
 #ifndef PASO_MPI  
123          else if (order==2) {          else if (order==2) {
124        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,
125                       useElementsOnFace) ;                       useElementsOnFace) ;
126      } else {      } else {
127        stringstream temp;        stringstream temp;
128        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
129        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
130      }      }
 #else  
         else {  
       stringstream temp;  
       temp << "type of 3D regular mesh requested is unavailable under MPI\nOR\nIllegal interpolation order: " << order;  
       setFinleyError(VALUE_ERROR,temp.str().c_str());  
     }  
 #endif  
131      //      //
132      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
133      checkFinleyError();      checkFinleyError();
# Line 108  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};
# Line 116  namespace finley { Line 147  namespace finley {
147    
148      Finley_Mesh* fMesh=0;      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,reducedIntegrationOrder,
151                      useElementsOnFace);                      useElementsOnFace);
152      }      }
 #ifndef PASO_MPI  
153      else if (order==2) {      else if (order==2) {
154        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,
155                      useElementsOnFace);                      useElementsOnFace);
156      }      }
 #endif  
157      else {      else {
158        stringstream temp;        stringstream temp;
159        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
# Line 138  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 145  namespace finley { Line 175  namespace finley {
175      int periodic[]={periodic0};      int periodic[]={periodic0};
176      Finley_Mesh* fMesh;      Finley_Mesh* fMesh;
177      if (order==1) {      if (order==1) {
178        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,reducedIntegrationOrder,
179                       useElementsOnFace);                       useElementsOnFace);
180      }      }
 #ifndef PASO_MPI  
181      else if (order==2) {      else if (order==2) {
182        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,
183                       useElementsOnFace);                       useElementsOnFace);
184      }      }
 #endif  
185      else {      else {
186        stringstream temp;        stringstream temp;
187        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
# Line 165  namespace finley { Line 193  namespace finley {
193      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
194      return temp;      return temp;
195    }    }
196    
197    AbstractContinuousDomain* meshMerge(const boost::python::list& meshList)    AbstractContinuousDomain* meshMerge(const boost::python::list& meshList)
198    {    {
199      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
# Line 181  namespace finley { Line 210  namespace finley {
210      //      //
211      // merge the meshes:      // merge the meshes:
212      fMesh=Finley_Mesh_merge(numMsh,mshes);      fMesh=Finley_Mesh_merge(numMsh,mshes);
213          TMPMEMFREE(mshes);
214  #else  #else
215      {      {
216        stringstream temp;        stringstream temp;
# Line 192  namespace finley { Line 222  namespace finley {
222      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
223      checkFinleyError();      checkFinleyError();
224      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
     TMPMEMFREE(mshes);  
225    
226      return temp;      return temp;
227    }    }
228    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,
229              double safety_factor,                          double safety_factor,
230              double tolerance)              double tolerance,
231                            bool optimizeLabeling)
232    {    {
233      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
234  #ifndef PASO_MPI  #ifndef PASO_MPI
# Line 209  namespace finley { Line 239  namespace finley {
239      // glue the faces:      // glue the faces:
240      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
241      fMesh=merged_finley_meshes->getFinley_Mesh();      fMesh=merged_finley_meshes->getFinley_Mesh();
242      Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance);      Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance,(optimizeLabeling ? TRUE : FALSE));
243    
244      //      //
245      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
# Line 231  namespace finley { Line 261  namespace finley {
261    }    }
262    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,
263              double safety_factor,              double safety_factor,
264              double tolerance)              double tolerance,
265                            bool optimizeLabeling)
266    {    {
267      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
268      //      //
# Line 242  namespace finley { Line 273  namespace finley {
273      // join the faces:      // join the faces:
274      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
275      fMesh=merged_finley_meshes->getFinley_Mesh();      fMesh=merged_finley_meshes->getFinley_Mesh();
276      Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance);      Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance, (optimizeLabeling ? TRUE : FALSE));
277      //      //
278      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
279      checkFinleyError();      checkFinleyError();
# Line 261  namespace finley { Line 292  namespace finley {
292  #endif  #endif
293    }    }
294    
295  }  // end of namespace    // end of namespace
296    
297    }

Legend:
Removed from v.757  
changed lines
  Added in v.1062

  ViewVC Help
Powered by ViewVC 1.1.26