/[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 1312 by ksteube, Mon Sep 24 06:18:44 2007 UTC
# Line 1  Line 1 
1    
2  /* $Id$ */  /* $Id$ */
 /*  
  ******************************************************************************  
  *                                                                            *  
  *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *  
  *                                                                            *  
  * This software is the property of ACcESS. No part of this code              *  
  * may be copied in any form or by any means without the expressed written    *  
  * consent of ACcESS.  Copying, use or modification of this software          *  
  * by any unauthorised person is illegal unless that person has a software    *  
  * license agreement with ACcESS.                                             *  
  *                                                                            *  
  ******************************************************************************  
 */  
3    
4    /*******************************************************
5     *
6     *           Copyright 2003-2007 by ACceSS MNRF
7     *       Copyright 2007 by University of Queensland
8     *
9     *                http://esscc.uq.edu.au
10     *        Primary Business: Queensland, Australia
11     *  Licensed under the Open Software License version 3.0
12     *     http://www.opensource.org/licenses/osl-3.0.php
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 25  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,
54                                         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 36  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));
65      fMesh=Finley_Mesh_read(fName,integrationOrder);      checkFinleyError();
66  #else      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
67      {      
68        stringstream temp;      /* win32 refactor */
69        temp << "Unable to read meshes from file under MPI yet...";      TMPMEMFREE(fName);
70        setFinleyError(VALUE_ERROR,temp.str().c_str());      
71      }      return temp;
72  #endif    }
73    
74      AbstractContinuousDomain* readGmsh(const std::string& fileName,
75                                         int numDim,
76                                         int integrationOrder,
77                                         int reducedIntegrationOrder,
78                                         int optimize)
79      {
80        //
81        // create a copy of the filename to overcome the non-constness of call
82        // to Finley_Mesh_read
83        Finley_Mesh* fMesh=0;
84        // Win32 refactor
85        char *fName = ((fileName.size()+1)>0) ? TMPMEMALLOC((fileName.size()+1),char) : (char*)NULL;
86        strcpy(fName,fileName.c_str());
87    
88        fMesh=Finley_Mesh_readGmsh(fName, numDim, integrationOrder, reducedIntegrationOrder, (optimize ? TRUE : FALSE));
89      checkFinleyError();      checkFinleyError();
90      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
91            
# Line 59  namespace finley { Line 100  namespace finley {
100              int periodic0,int periodic1,              int periodic0,int periodic1,
101              int periodic2,              int periodic2,
102              int integrationOrder,              int integrationOrder,
103              int useElementsOnFace)                      int reducedIntegrationOrder,
104                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 79  namespace finley { Line 114  namespace finley {
114      Finley_Mesh* fMesh=NULL;      Finley_Mesh* fMesh=NULL;
115    
116      if (order==1) {      if (order==1) {
117        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,
118                      useElementsOnFace) ;                      useElementsOnFace,useFullElementOrder,(optimize ? TRUE : FALSE)) ;
119      }      }
 #ifndef PASO_MPI  
120          else if (order==2) {          else if (order==2) {
121        fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,        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;
126        setFinleyError(VALUE_ERROR,temp.str().c_str());        setFinleyError(VALUE_ERROR,temp.str().c_str());
127      }      }
 #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  
128      //      //
129      // Convert any finley errors into a C++ exception      // Convert any finley errors into a C++ exception
130      checkFinleyError();      checkFinleyError();
# Line 108  namespace finley { Line 135  namespace finley {
135              double l0, double l1,              double l0, double l1,
136              int periodic0,int periodic1,              int periodic0,int periodic1,
137              int integrationOrder,              int integrationOrder,
138              int useElementsOnFace)                          int reducedIntegrationOrder,
139                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 116  namespace finley { Line 146  namespace finley {
146    
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,        fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,reducedIntegrationOrder,
150                      useElementsOnFace);                      useElementsOnFace,useFullElementOrder,(optimize ? TRUE : FALSE));
151      }      }
 #ifndef PASO_MPI  
152      else if (order==2) {      else if (order==2) {
153        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,        fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,reducedIntegrationOrder,
154                      useElementsOnFace);                      useElementsOnFace,useFullElementOrder,(optimize ? TRUE : FALSE));
155      }      }
 #endif  
     else {  
       stringstream temp;  
       temp << "Illegal interpolation order: " << order;  
       setFinleyError(VALUE_ERROR,temp.str().c_str());  
     }  
     //  
     // 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 useElementsOnFace)  
   {  
     int numElements[]={n0};  
     double length[]={l0};  
     int periodic[]={periodic0};  
     Finley_Mesh* fMesh;  
     if (order==1) {  
       fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,  
                      useElementsOnFace);  
     }  
 #ifndef PASO_MPI  
     else if (order==2) {  
       fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,  
                      useElementsOnFace);  
     }  
 #endif  
156      else {      else {
157        stringstream temp;        stringstream temp;
158        temp << "Illegal interpolation order: " << order;        temp << "Illegal interpolation order: " << order;
# Line 165  namespace finley { Line 164  namespace finley {
164      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
165      return temp;      return temp;
166    }    }
167    
168    AbstractContinuousDomain* meshMerge(const boost::python::list& meshList)    AbstractContinuousDomain* meshMerge(const boost::python::list& meshList)
169    {    {
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 181  namespace finley { Line 180  namespace finley {
180      //      //
181      // merge the meshes:      // merge the meshes:
182      fMesh=Finley_Mesh_merge(numMsh,mshes);      fMesh=Finley_Mesh_merge(numMsh,mshes);
183  #else        TMPMEMFREE(mshes);
     {  
       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();
187      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);      AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
     TMPMEMFREE(mshes);  
188    
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                                           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 209  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);      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                            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);      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
232    
233    }

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

  ViewVC Help
Powered by ViewVC 1.1.26