src/CPPAdapter/MeshAdapterFactory.h

/* 
 ******************************************************************************
 *                                                                            *
 *       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.                                             *
 *                                                                            *
 ******************************************************************************
*/
                                                                           
#if !defined  finley_MeshAdapterFactory_20040526_H
#define finley_MeshAdapterFactory_20040526_H

#include "finley/CPPAdapter/MeshAdapter.h"

#include "escript/Data/AbstractContinuousDomain.h"

#include <boost/python/list.hpp>

namespace finley {
  /**
     \brief
     A suite of factory methods for creating various MeshAdapters.

     Description:
     A suite of factory methods for creating various MeshAdapters.
  */
 
  /**
     \brief
     Read a mesh from a file
     \param fileName Input -  The name of the file.
  */
  escript::AbstractContinuousDomain* readMesh(const std::string& fileName,
                     int integrationOrder=-1);
  /**
     \brief
     Creates a rectangular mesh with n1 x n2 x n3 elements over the brick 
     [0,l1] x [0,l2] x [0,l3].

     \param n1,n2,n3 Input - 
     \param order Input - =1 or =2 gives the order of shape function
     \param l1,l2,l3 Input - 
     \param integrationOrder Input - order of the quadrature scheme.
  */
  escript::AbstractContinuousDomain* brick(int n1=1,int n2=1,int n3=1,int order=1,
            double l1=1.0,double l2=1.0,double l3=1.0,
            int periodic0=0,int periodic1=0,
            int periodic2=0,
            int integrationOrder=-1,
            int useElementsOnFace=0);
  /**
     \brdirief
     Creates a rectangular mesh with n1 x n2 elements over the brick 
     [0,l1] x [0,l2].

     \param n1,n2 Input - 
     \param order Input - =1 or =2 gives the order of shape function
     \param l1,l2 Input - 
     \param integrationOrder Input - order of the quadrature scheme. 
     If integrationOrder<0 the integration order is selected 
     independently.
  */
  escript::AbstractContinuousDomain* rectangle(int n1=1,int n2=1,int order=1,
                      double l1=1.0, double l2=1.0,
                      int periodic0=false,int periodic1=false,
                      int integrationOrder=-1,
                      int useElementsOnFace=false);
  /**
     \brief
     Creates an equidistant mesh with n elements over the interval [0,l].
     \param n1 Input -
     \param order Input - =1 or =2 gives the order of shape function.
     \param integrationOrder Input - order of the quadrature scheme. 
     If integrationOrder<0 the integration order is selected 
     independently.
  */
  escript::AbstractContinuousDomain* interval(int n1=1,int order=1,double l1=1.0,
                     int periodic0=false,
                     int integrationOrder=-1,
                     int useElementsOnFace=false);
  /**
     \brief
     Merges a list of meshes into one list.
     \param meshList Input - The list of meshes.
  */
  escript::AbstractContinuousDomain* meshMerge(const boost::python::list& meshList);
  /**
     \brief
     Detects matching faces in the mesh, removes them from the mesh 
     and joins the elements touched by the face elements.
     \param meshList Input - The list of meshes.
     \param safetyFacto Input - ??
     \param tolerance Input - ??
  */
  escript::AbstractContinuousDomain* glueFaces(const boost::python::list& meshList,
               double safetyFactor=0.2, 
               double tolerance=std::numeric_limits<double>::epsilon());
  /**
     \brief
     Detects matching faces in the mesh and replaces them by joint elements.
     \param meshList Input - The list of meshes.
     \param safetyFacto Input - ??
     \param tolerance Input - ??
  */
  escript::AbstractContinuousDomain* joinFaces(const boost::python::list& meshList,
            double safety_factor=0.2, 
            double tolerance=std::numeric_limits<double>::epsilon());
 
} // end of namespace
#endif
1	jgs	82	/*
2			******************************************************************************
3			* *
4			* COPYRIGHT ACcESS 2004 - All Rights Reserved *
5			* *
6			* This software is the property of ACcESS. No part of this code *
7			* may be copied in any form or by any means without the expressed written *
8			* consent of ACcESS. Copying, use or modification of this software *
9			* by any unauthorised person is illegal unless that person has a software *
10			* license agreement with ACcESS. *
11			* *
12			******************************************************************************
13			*/
14
15			#if !defined finley_MeshAdapterFactory_20040526_H
16			#define finley_MeshAdapterFactory_20040526_H
17
18			#include "finley/CPPAdapter/MeshAdapter.h"
19
20			#include "escript/Data/AbstractContinuousDomain.h"
21
22			#include <boost/python/list.hpp>
23
24			namespace finley {
25			/**
26			\brief
27			A suite of factory methods for creating various MeshAdapters.
28
29			Description:
30			A suite of factory methods for creating various MeshAdapters.
31			*/
32
33			/**
34			\brief
35			Read a mesh from a file
36			\param fileName Input - The name of the file.
37			*/
38			escript::AbstractContinuousDomain* readMesh(const std::string& fileName,
39			int integrationOrder=-1);
40			/**
41			\brief
42			Creates a rectangular mesh with n1 x n2 x n3 elements over the brick
43			[0,l1] x [0,l2] x [0,l3].
44
45			\param n1,n2,n3 Input -
46			\param order Input - =1 or =2 gives the order of shape function
47			\param l1,l2,l3 Input -
48			\param integrationOrder Input - order of the quadrature scheme.
49			*/
50			escript::AbstractContinuousDomain* brick(int n1=1,int n2=1,int n3=1,int order=1,
51			double l1=1.0,double l2=1.0,double l3=1.0,
52			int periodic0=0,int periodic1=0,
53			int periodic2=0,
54			int integrationOrder=-1,
55			int useElementsOnFace=0);
56			/**
57			\brdirief
58			Creates a rectangular mesh with n1 x n2 elements over the brick
59			[0,l1] x [0,l2].
60
61			\param n1,n2 Input -
62			\param order Input - =1 or =2 gives the order of shape function
63			\param l1,l2 Input -
64			\param integrationOrder Input - order of the quadrature scheme.
65			If integrationOrder<0 the integration order is selected
66			independently.
67			*/
68			escript::AbstractContinuousDomain* rectangle(int n1=1,int n2=1,int order=1,
69			double l1=1.0, double l2=1.0,
70			int periodic0=false,int periodic1=false,
71			int integrationOrder=-1,
72			int useElementsOnFace=false);
73			/**
74			\brief
75			Creates an equidistant mesh with n elements over the interval [0,l].
76			\param n1 Input -
77			\param order Input - =1 or =2 gives the order of shape function.
78			\param integrationOrder Input - order of the quadrature scheme.
79			If integrationOrder<0 the integration order is selected
80			independently.
81			*/
82			escript::AbstractContinuousDomain* interval(int n1=1,int order=1,double l1=1.0,
83			int periodic0=false,
84			int integrationOrder=-1,
85			int useElementsOnFace=false);
86			/**
87			\brief
88			Merges a list of meshes into one list.
89			\param meshList Input - The list of meshes.
90			*/
91			escript::AbstractContinuousDomain* meshMerge(const boost::python::list& meshList);
92			/**
93			\brief
94			Detects matching faces in the mesh, removes them from the mesh
95			and joins the elements touched by the face elements.
96			\param meshList Input - The list of meshes.
97			\param safetyFacto Input - ??
98			\param tolerance Input - ??
99			*/
100			escript::AbstractContinuousDomain* glueFaces(const boost::python::list& meshList,
101			double safetyFactor=0.2,
102			double tolerance=std::numeric_limits<double>::epsilon());
103			/**
104			\brief
105			Detects matching faces in the mesh and replaces them by joint elements.
106			\param meshList Input - The list of meshes.
107			\param safetyFacto Input - ??
108			\param tolerance Input - ??
109			*/
110			escript::AbstractContinuousDomain* joinFaces(const boost::python::list& meshList,
111			double safety_factor=0.2,
112			double tolerance=std::numeric_limits<double>::epsilon());
113
114			} // end of namespace
115			#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision