/[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 1062 by gross, Mon Mar 26 06:17:53 2007 UTC revision 1312 by ksteube, Mon Sep 24 06:18:44 2007 UTC
# Line 1  Line 1 
1    
2  /* $Id$ */  /* $Id$ */
3  /*  
4   ******************************************************************************  /*******************************************************
5   *                                                                            *   *
6   *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *   *           Copyright 2003-2007 by ACceSS MNRF
7   *                                                                            *   *       Copyright 2007 by University of Queensland
8   * This software is the property of ACcESS. No part of this code              *   *
9   * may be copied in any form or by any means without the expressed written    *   *                http://esscc.uq.edu.au
10   * consent of ACcESS.  Copying, use or modification of this software          *   *        Primary Business: Queensland, Australia
11   * by any unauthorised person is illegal unless that person has a software    *   *  Licensed under the Open Software License version 3.0
12   * license agreement with ACcESS.                                             *   *     http://www.opensource.org/licenses/osl-3.0.php
13   *                                                                            *   *
14   ******************************************************************************   *******************************************************/
 */  
15    
16  #ifdef PASO_MPI  #ifdef PASO_MPI
17  #include <mpi.h>  #include <mpi.h>
# Line 28  using namespace escript; Line 28  using namespace escript;
28    
29  namespace finley {  namespace finley {
30    
31      AbstractContinuousDomain* loadMesh(const std::string& fileName)
32      {
33        //
34        // create a copy of the filename to overcome the non-constness of call
35        // to Finley_Mesh_read
36        Finley_Mesh* fMesh=0;
37        // Win32 refactor
38        char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;
39        strcpy(fName,fileName.c_str());
40    
41        fMesh=Finley_Mesh_load(fName);
42        checkFinleyError();
43        AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
44        
45        /* win32 refactor */
46        TMPMEMFREE(fName);
47        
48        return temp;
49      }
50    
51    AbstractContinuousDomain* readMesh(const std::string& fileName,    AbstractContinuousDomain* readMesh(const std::string& fileName,
52                       int integrationOrder,                       int integrationOrder,
53                                       int reducedIntegrationOrder,                                       int reducedIntegrationOrder,
54                                       bool optimizeLabeling)                                       int optimize)
55    {    {
56      //      //
57      // 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 41  namespace finley { Line 61  namespace finley {
61      char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;      char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;
62      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
63    
64  #ifndef PASO_MPI      fMesh=Finley_Mesh_read(fName,integrationOrder, reducedIntegrationOrder, (optimize ? TRUE : FALSE));
     fMesh=Finley_Mesh_read(fName,integrationOrder, reducedIntegrationOrder, (optimizeLabeling ? TRUE : FALSE));  
 #else  
     {  
       stringstream temp;  
       temp << "Unable to read meshes from file under MPI yet...";  
       setFinleyError(VALUE_ERROR,temp.str().c_str());  
     }  
 #endif  
65      checkFinleyError();      checkFinleyError();
66      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
67            
# Line 63  namespace finley { Line 75  namespace finley {
75                                       int numDim,                                       int numDim,
76                                       int integrationOrder,                                       int integrationOrder,
77                                       int reducedIntegrationOrder,                                       int reducedIntegrationOrder,
78                                       bool optimizeLabeling)                                       int optimize)
79    {    {
80      //      //
81      // 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 73  namespace finley { Line 85  namespace finley {
85      char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;      char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;
86      strcpy(fName,fileName.c_str());      strcpy(fName,fileName.c_str());
87    
88  #ifndef PASO_MPI      fMesh=Finley_Mesh_readGmsh(fName, numDim, integrationOrder, reducedIntegrationOrder, (optimize ? TRUE : FALSE));
     fMesh=Finley_Mesh_readGmsh(fName, numDim, integrationOrder, reducedIntegrationOrder, (optimizeLabeling ? TRUE : FALSE));  
 #else  
     {  
       stringstream temp;  
       temp << "Unable to read gmsh meshes from file under MPI yet...";  
       setFinleyError(VALUE_ERROR,temp.str().c_str());  
     }  
 #endif  
89      checkFinleyError();      checkFinleyError();
90      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
91            
# Line 97  namespace finley { Line 101  namespace finley {
101              int periodic2,              int periodic2,
102              int integrationOrder,              int integrationOrder,
103                      int reducedIntegrationOrder,                      int reducedIntegrationOrder,
104              int useElementsOnFace)              int useElementsOnFace,
105                int useFullElementOrder,
106                        int optimize)
107    {    {
 //     cout << "n0=" << n0 << " n1=" << n1 << " n2=" << n2  
 //   << " order=" << order  
 //   << " l0=" << l0 << " l1=" << l1 << " l2=" << l2  
 //   << " periodic0=" << periodic0  
 //   << " periodic1=" << periodic1  
 //   << " periodic2=" << periodic2  
 //   << " integerationOrder=" << integrationOrder  
 //   << " useElementsOnFace=" << useElementsOnFace << endl;  
         
108      int numElements[]={n0,n1,n2};      int numElements[]={n0,n1,n2};
109      double length[]={l0,l1,l2};      double length[]={l0,l1,l2};
110      int periodic[]={periodic0, periodic1, periodic2};      int periodic[]={periodic0, periodic1, periodic2};
# Line 118  namespace finley { Line 115  namespace finley {
115    
116      if (order==1) {      if (order==1) {
117        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,
118                      useElementsOnFace) ;                      useElementsOnFace,useFullElementOrder,(optimize ? TRUE : FALSE)) ;
119      }      }
120          else if (order==2) {          else if (order==2) {
121        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,
122                       useElementsOnFace) ;                       useElementsOnFace,useFullElementOrder,(optimize ? TRUE : FALSE)) ;
123      } else {      } else {
124        stringstream temp;        stringstream temp;
125        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
# Line 139  namespace finley { Line 136  namespace finley {
136              int periodic0,int periodic1,              int periodic0,int periodic1,
137              int integrationOrder,              int integrationOrder,
138                          int reducedIntegrationOrder,                          int reducedIntegrationOrder,
139              int useElementsOnFace)              int useElementsOnFace,
140                    int useFullElementOrder,
141                            int optimize)
142    {    {
143      int numElements[]={n0,n1};      int numElements[]={n0,n1};
144      double length[]={l0,l1};      double length[]={l0,l1};
# Line 148  namespace finley { Line 147  namespace finley {
147      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
148      if (order==1) {      if (order==1) {
149        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,reducedIntegrationOrder,        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,reducedIntegrationOrder,
150                      useElementsOnFace);                      useElementsOnFace,useFullElementOrder,(optimize ? TRUE : FALSE));
151      }      }
152      else if (order==2) {      else if (order==2) {
153        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,
154                      useElementsOnFace);                      useElementsOnFace,useFullElementOrder,(optimize ? TRUE : FALSE));
     }  
     else {  
       stringstream temp;  
       temp << "Illegal interpolation order: " << order;  
       setFinleyError(VALUE_ERROR,temp.str().c_str());  
155      }      }
     //  
     // Convert any finley errors into a C++ exception  
     checkFinleyError();  
     AbstractContinuousDomain* temp=new MeshAdapter(fMesh);  
     return temp;  
   }  
   AbstractContinuousDomain*  interval(int n0,int order,double l0,int periodic0,  
                int integrationOrder,  
                        int reducedIntegrationOrder,  
                int useElementsOnFace)  
   {  
     int numElements[]={n0};  
     double length[]={l0};  
     int periodic[]={periodic0};  
     Finley_Mesh* fMesh;  
     if (order==1) {  
       fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,reducedIntegrationOrder,  
                      useElementsOnFace);  
     }  
     else if (order==2) {  
       fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,  
                      useElementsOnFace);  
     }  
156      else {      else {
157        stringstream temp;        stringstream temp;
158        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
# Line 199  namespace finley { Line 170  namespace finley {
170      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
171      //      //
172      // extract the meshes from meshList      // extract the meshes from meshList
 #ifndef PASO_MPI  
173      int numMsh=boost::python::extract<int>(meshList.attr("__len__")());      int numMsh=boost::python::extract<int>(meshList.attr("__len__")());
174      Finley_Mesh **mshes = (numMsh) ? TMPMEMALLOC(numMsh,Finley_Mesh*) : (Finley_Mesh**)NULL;      Finley_Mesh **mshes = (numMsh) ? TMPMEMALLOC(numMsh,Finley_Mesh*) : (Finley_Mesh**)NULL;
175      for (int i=0;i<numMsh;++i) {      for (int i=0;i<numMsh;++i) {
# Line 211  namespace finley { Line 181  namespace finley {
181      // merge the meshes:      // merge the meshes:
182      fMesh=Finley_Mesh_merge(numMsh,mshes);      fMesh=Finley_Mesh_merge(numMsh,mshes);
183        TMPMEMFREE(mshes);        TMPMEMFREE(mshes);
 #else  
     {  
       stringstream temp;  
       temp << "meshMerge() not available in MPI yet...";  
       setFinleyError(VALUE_ERROR,temp.str().c_str());  
     }  
 #endif  
184      //      //
185      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
186      checkFinleyError();      checkFinleyError();
# Line 226  namespace finley { Line 189  namespace finley {
189      return temp;      return temp;
190    }    }
191    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,
192                          double safety_factor,                                     double safety_factor,
193              double tolerance,                             double tolerance,
194                          bool optimizeLabeling)                                         int optimize)
195    {    {
196      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
 #ifndef PASO_MPI  
197      //      //
198      // merge the meshes:      // merge the meshes:
199      AbstractContinuousDomain* merged_meshes=meshMerge(meshList);      AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
# Line 239  namespace finley { Line 201  namespace finley {
201      // glue the faces:      // glue the faces:
202      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
203      fMesh=merged_finley_meshes->getFinley_Mesh();      fMesh=merged_finley_meshes->getFinley_Mesh();
204      Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance,(optimizeLabeling ? TRUE : FALSE));      Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance,(optimize ? TRUE : FALSE));
205    
206      //      //
207      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
208      checkFinleyError();      checkFinleyError();
209      return merged_meshes;      return merged_meshes;
 #else  
     {  
       stringstream temp;  
       temp << "glueFaces() not available in MPI yet...";  
       setFinleyError(VALUE_ERROR,temp.str().c_str());  
     }  
   
     //  
     // Convert any finley errors into a C++ exception  
     checkFinleyError();  
     return (AbstractContinuousDomain*)0;  
 #endif  
   
210    }    }
211    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,    AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,
212              double safety_factor,              double safety_factor,
213              double tolerance,              double tolerance,
214                          bool optimizeLabeling)                          int optimize)
215    {    {
216      Finley_Mesh* fMesh=0;      Finley_Mesh* fMesh=0;
217      //      //
218      // merge the meshes:      // merge the meshes:
 #ifndef PASO_MPI  
219      AbstractContinuousDomain* merged_meshes=meshMerge(meshList);      AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
220      //      //
221      // join the faces:      // join the faces:
222      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);      const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
223      fMesh=merged_finley_meshes->getFinley_Mesh();      fMesh=merged_finley_meshes->getFinley_Mesh();
224      Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance, (optimizeLabeling ? TRUE : FALSE));      Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance, (optimize ? TRUE : FALSE));
225      //      //
226      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
227      checkFinleyError();      checkFinleyError();
228      return merged_meshes;      return merged_meshes;
 #else  
     {  
       stringstream temp;  
       temp << "joinFaces() not available in MPI yet...";  
       setFinleyError(VALUE_ERROR,temp.str().c_str());  
     }  
     //  
     // Convert any finley errors into a C++ exception  
     checkFinleyError();  
     return (AbstractContinuousDomain*)0;  
   
 #endif  
229    }    }
230    
231    // end of namespace    // end of namespace

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

  ViewVC Help
Powered by ViewVC 1.1.26