finley/CPPAdapter/MeshAdapterFactory.cpp

/* $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.                                             *
 *                                                                            *
 ******************************************************************************
*/

extern "C" {
#include "finley/finleyC/Finley.h"
#include "finley/finleyC/Mesh.h"
#include "finley/finleyC/RectangularMesh.h"
}
#include "finley/CPPAdapter/FinleyError.h"
#include "finley/CPPAdapter/MeshAdapterFactory.h"

#include <iostream>
#include <sstream>
#include <boost/python/extract.hpp>

using namespace std;
using namespace escript;

namespace finley {

  AbstractContinuousDomain* readMesh(const std::string& fileName,
                     int integrationOrder) 
  {
    //
    // create a copy of the filename to overcome the non-constness of call
    // to Finley_Mesh_read
    char fName[fileName.size()+1];
    strcpy(fName,fileName.c_str());
    Finley_Mesh* fMesh=Finley_Mesh_read(fName,integrationOrder);
    checkFinleyError();
    AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
    return temp;
  }

  AbstractContinuousDomain* brick(int n0,int n1,int n2,int order,
            double l0,double l1,double l2,
            int periodic0,int periodic1,
            int periodic2,
            int integrationOrder,
            int useElementsOnFace) 
  {
//     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;
      
    int numElements[]={n0,n1,n2};
    double length[]={l0,l1,l2};
    int periodic[]={periodic0, periodic1, periodic2};

    //
    // linearInterpolation
    Finley_Mesh* fMesh;
    if (order==1) {
      fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,
                    useElementsOnFace) ;
    } else if (order==2) {
      fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,
                     useElementsOnFace) ;
    } 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*  rectangle(int n0,int n1,int order,
            double l0, double l1,
            int periodic0,int periodic1,
            int integrationOrder,
            int useElementsOnFace) 
  {
    int numElements[]={n0,n1};
    double length[]={l0,l1};
    int periodic[]={periodic0, periodic1};

    Finley_Mesh* fMesh;
    if (order==1) {
      fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,
                    useElementsOnFace);
    } else if (order==2) {
      fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,
                    useElementsOnFace);
    } 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);
    } else if (order==2) {
      fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,
                     useElementsOnFace);
    } 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* meshMerge(const boost::python::list& meshList)
  {
    Finley_Mesh* fMesh=0;
    //
    // extract the meshes from meshList
    int numMsh=boost::python::extract<int>(meshList.attr("__len__")());
    Finley_Mesh* mshes[numMsh];
    for (int i=0;i<numMsh;++i) {
         AbstractContinuousDomain& meshListMember=boost::python::extract<AbstractContinuousDomain&>(meshList[i]);
         const MeshAdapter* finley_meshListMember=static_cast<const MeshAdapter*>(&meshListMember);
         mshes[i]=finley_meshListMember->getFinley_Mesh();
    }
    //
    // merge the meshes:
    fMesh=Finley_Mesh_merge(numMsh,mshes);
    //
    // Convert any finley errors into a C++ exception
    checkFinleyError();
    AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
    return temp;
  }
  AbstractContinuousDomain*  glueFaces(const boost::python::list& meshList,
            double safety_factor, 
            double tolerance)
  {
    Finley_Mesh* fMesh=0;
    //
    // merge the meshes:
    AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
    //
    // glue the faces:
    const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
    fMesh=merged_finley_meshes->getFinley_Mesh();
    Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance);
    //
    // Convert any finley errors into a C++ exception
    checkFinleyError();
    return merged_meshes;
  }
  AbstractContinuousDomain*  joinFaces(const boost::python::list& meshList,
            double safety_factor, 
            double tolerance)
  {
    Finley_Mesh* fMesh=0;
    //
    // merge the meshes:
    AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
    //
    // join the faces:
    const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
    fMesh=merged_finley_meshes->getFinley_Mesh();
    Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance);
    //
    // Convert any finley errors into a C++ exception
    checkFinleyError();
    return merged_meshes;
  }

}  // end of namespace
1	jgs	102	/* $Id$ */
2	jgs	82	/*
3			******************************************************************************
4			* *
5			* COPYRIGHT ACcESS 2004 - All Rights Reserved *
6			* *
7			* This software is the property of ACcESS. No part of this code *
8			* may be copied in any form or by any means without the expressed written *
9			* consent of ACcESS. Copying, use or modification of this software *
10			* by any unauthorised person is illegal unless that person has a software *
11			* license agreement with ACcESS. *
12			* *
13			******************************************************************************
14			*/
15
16			extern "C" {
17			#include "finley/finleyC/Finley.h"
18			#include "finley/finleyC/Mesh.h"
19			#include "finley/finleyC/RectangularMesh.h"
20			}
21			#include "finley/CPPAdapter/FinleyError.h"
22			#include "finley/CPPAdapter/MeshAdapterFactory.h"
23
24			#include <iostream>
25			#include <sstream>
26	jgs	110	#include <boost/python/extract.hpp>
27	jgs	82
28			using namespace std;
29			using namespace escript;
30
31			namespace finley {
32
33			AbstractContinuousDomain* readMesh(const std::string& fileName,
34			int integrationOrder)
35			{
36			//
37			// create a copy of the filename to overcome the non-constness of call
38			// to Finley_Mesh_read
39			char fName[fileName.size()+1];
40			strcpy(fName,fileName.c_str());
41			Finley_Mesh* fMesh=Finley_Mesh_read(fName,integrationOrder);
42			checkFinleyError();
43			AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
44			return temp;
45			}
46
47			AbstractContinuousDomain* brick(int n0,int n1,int n2,int order,
48			double l0,double l1,double l2,
49			int periodic0,int periodic1,
50			int periodic2,
51			int integrationOrder,
52			int useElementsOnFace)
53			{
54			// cout << "n0=" << n0 << " n1=" << n1 << " n2=" << n2
55			// << " order=" << order
56			// << " l0=" << l0 << " l1=" << l1 << " l2=" << l2
57			// << " periodic0=" << periodic0
58			// << " periodic1=" << periodic1
59			// << " periodic2=" << periodic2
60			// << " integerationOrder=" << integrationOrder
61			// << " useElementsOnFace=" << useElementsOnFace << endl;
62
63			int numElements[]={n0,n1,n2};
64			double length[]={l0,l1,l2};
65			int periodic[]={periodic0, periodic1, periodic2};
66
67			//
68			// linearInterpolation
69			Finley_Mesh* fMesh;
70			if (order==1) {
71	jgs	102	fMesh=Finley_RectangularMesh_Hex8(numElements,length,periodic,integrationOrder,
72	jgs	82	useElementsOnFace) ;
73			} else if (order==2) {
74	jgs	102	fMesh=Finley_RectangularMesh_Hex20(numElements,length,periodic,integrationOrder,
75	jgs	82	useElementsOnFace) ;
76			} else {
77			stringstream temp;
78			temp << "Illegal interpolation order: " << order;
79			setFinleyError(VALUE_ERROR,temp.str().c_str());
80			}
81			//
82			// Convert any finley errors into a C++ exception
83			checkFinleyError();
84			AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
85			return temp;
86			}
87			AbstractContinuousDomain* rectangle(int n0,int n1,int order,
88			double l0, double l1,
89			int periodic0,int periodic1,
90			int integrationOrder,
91			int useElementsOnFace)
92			{
93			int numElements[]={n0,n1};
94			double length[]={l0,l1};
95			int periodic[]={periodic0, periodic1};
96
97			Finley_Mesh* fMesh;
98			if (order==1) {
99	jgs	102	fMesh=Finley_RectangularMesh_Rec4(numElements, length,periodic,integrationOrder,
100	jgs	82	useElementsOnFace);
101			} else if (order==2) {
102	jgs	102	fMesh=Finley_RectangularMesh_Rec8(numElements,length,periodic,integrationOrder,
103	jgs	82	useElementsOnFace);
104			} else {
105			stringstream temp;
106			temp << "Illegal interpolation order: " << order;
107			setFinleyError(VALUE_ERROR,temp.str().c_str());
108			}
109			//
110			// Convert any finley errors into a C++ exception
111			checkFinleyError();
112			AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
113			return temp;
114			}
115			AbstractContinuousDomain* interval(int n0,int order,double l0,int periodic0,
116			int integrationOrder,
117			int useElementsOnFace)
118			{
119			int numElements[]={n0};
120			double length[]={l0};
121			int periodic[]={periodic0};
122			Finley_Mesh* fMesh;
123			if (order==1) {
124	jgs	102	fMesh=Finley_RectangularMesh_Line2(numElements, length,periodic,integrationOrder,
125	jgs	82	useElementsOnFace);
126			} else if (order==2) {
127	jgs	102	fMesh=Finley_RectangularMesh_Line3(numElements,length,periodic,integrationOrder,
128	jgs	82	useElementsOnFace);
129			} else {
130			stringstream temp;
131			temp << "Illegal interpolation order: " << order;
132			setFinleyError(VALUE_ERROR,temp.str().c_str());
133			}
134			//
135			// Convert any finley errors into a C++ exception
136			checkFinleyError();
137			AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
138			return temp;
139			}
140	jgs	110	AbstractContinuousDomain* meshMerge(const boost::python::list& meshList)
141	jgs	82	{
142	jgs	110	Finley_Mesh* fMesh=0;
143			//
144			// extract the meshes from meshList
145			int numMsh=boost::python::extract<int>(meshList.attr("__len__")());
146			Finley_Mesh* mshes[numMsh];
147			for (int i=0;i<numMsh;++i) {
148			AbstractContinuousDomain& meshListMember=boost::python::extract<AbstractContinuousDomain&>(meshList[i]);
149			const MeshAdapter* finley_meshListMember=static_cast<const MeshAdapter*>(&meshListMember);
150			mshes[i]=finley_meshListMember->getFinley_Mesh();
151			}
152			//
153			// merge the meshes:
154			fMesh=Finley_Mesh_merge(numMsh,mshes);
155			//
156			// Convert any finley errors into a C++ exception
157			checkFinleyError();
158			AbstractContinuousDomain* temp=new MeshAdapter(fMesh);
159	jgs	82	return temp;
160			}
161			AbstractContinuousDomain* glueFaces(const boost::python::list& meshList,
162	jgs	110	double safety_factor,
163	jgs	82	double tolerance)
164			{
165	jgs	110	Finley_Mesh* fMesh=0;
166			//
167			// merge the meshes:
168			AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
169			//
170			// glue the faces:
171			const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
172			fMesh=merged_finley_meshes->getFinley_Mesh();
173			Finley_Mesh_glueFaces(fMesh,safety_factor,tolerance);
174			//
175			// Convert any finley errors into a C++ exception
176			checkFinleyError();
177			return merged_meshes;
178	jgs	82	}
179			AbstractContinuousDomain* joinFaces(const boost::python::list& meshList,
180			double safety_factor,
181			double tolerance)
182			{
183	jgs	110	Finley_Mesh* fMesh=0;
184			//
185			// merge the meshes:
186			AbstractContinuousDomain* merged_meshes=meshMerge(meshList);
187			//
188			// join the faces:
189			const MeshAdapter* merged_finley_meshes=static_cast<const MeshAdapter*>(merged_meshes);
190			fMesh=merged_finley_meshes->getFinley_Mesh();
191			Finley_Mesh_joinFaces(fMesh,safety_factor,tolerance);
192			//
193			// Convert any finley errors into a C++ exception
194			checkFinleyError();
195			return merged_meshes;
196	jgs	82	}
197
198			} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision