src/CPPAdapter/MeshAdapter.h


/*******************************************************
*
* Copyright (c) 2003-2008 by University of Queensland
* Earth Systems Science Computational Center (ESSCC)
* http://www.uq.edu.au/esscc
*
* Primary Business: Queensland, Australia
* Licensed under the Open Software License version 3.0
* http://www.opensource.org/licenses/osl-3.0.php
*
*******************************************************/


#if !defined finley_MeshAdapter_20040526_H
#define finley_MeshAdapter_20040526_H
#include "system_dep.h"

extern "C" {
#include "../Mesh.h"
#include "../Finley.h"
#include "../Assemble.h"
#include "paso/SystemMatrix.h"
#include "paso/SolverFCT.h"
#include "paso/Paso_MPI.h"
}

#include "FinleyError.h"
#include "FinleyAdapterException.h"

#include "SystemMatrixAdapter.h"
#include "TransportProblemAdapter.h"
#include "escript/AbstractContinuousDomain.h"
#include "escript/FunctionSpace.h"
#include "escript/FunctionSpaceFactory.h"

#include <boost/shared_ptr.hpp>
#include <boost/python/dict.hpp>
#include <boost/python/extract.hpp>

#include <map>
#include <vector>
#include <string>
#include <sstream>

//
// forward declarations
class Data;

//using namespace escript;

namespace finley {

struct null_deleter
{
  void operator()(void const *ptr) const
  {
  }
};


/**
   \brief
   MeshAdapter implements the AbstractContinuousDomain
   interface for the Finley library.

   Description:
   MeshAdapter implements the AbstractContinuousDomain
   interface for the Finley library.
*/

class MeshAdapter : public escript::AbstractContinuousDomain {

 public:

  //
  // Codes for function space types supported
  static const int DegreesOfFreedom;
  static const int ReducedDegreesOfFreedom;
  static const int Nodes;
  static const int ReducedNodes;
  static const int Elements;
  static const int ReducedElements;
  static const int FaceElements;
  static const int ReducedFaceElements;
  static const int Points;
  static const int ContactElementsZero;
  static const int ReducedContactElementsZero;
  static const int ContactElementsOne;
  static const int ReducedContactElementsOne;

  /**
     \brief
     Constructor for MeshAdapter

     Description:
     Constructor for MeshAdapter. The pointer passed to MeshAdapter
     is deleted using a call to Finley_Mesh_free in the
     MeshAdapter destructor.

     Throws:
     May throw an exception derived from EsysException

     \param finleyMesh Input - A pointer to the externally constructed 
                               finley mesh.The pointer passed to MeshAdapter
                               is deleted using a call to 
                               Finley_Mesh_free in the MeshAdapter 
                               destructor.
  */
  FINLEY_DLL_API
  MeshAdapter(Finley_Mesh* finleyMesh=0);

  /**
     \brief
     Copy constructor.
  */
  FINLEY_DLL_API
  MeshAdapter(const MeshAdapter& in);

  /**
     \brief
     Destructor for MeshAdapter. As specified in the constructor
     this calls Finley_Mesh_free for the pointer given to the 
     constructor.
  */
  FINLEY_DLL_API
  ~MeshAdapter();

  /**
     \brief
     return the number of processors used for this domain
  */
  FINLEY_DLL_API
  virtual int getMPISize() const;
  /**
     \brief
     return the number MPI rank of this processor
  */

  FINLEY_DLL_API
  virtual int getMPIRank() const;

  /**
     \brief
     If compiled for MPI then execute an MPI_Barrier, else do nothing
  */

  FINLEY_DLL_API
  virtual void MPIBarrier() const;

  /**
     \brief
     Return true if on MPI processor 0, else false
  */

  FINLEY_DLL_API
  virtual bool onMasterProcessor() const;

  /**
     \brief
     return this as an AbstractContinuousDomain.
  */
  inline const AbstractContinuousDomain& asAbstractContinuousDomain() const 
  {
     return *(static_cast<const AbstractContinuousDomain*>(this));
  }

  /**
     \brief
     return this as an AbstractDomain.
  */
  inline const AbstractDomain& asAbstractDomain() const 
  {
     return *(static_cast<const AbstractDomain*>(this));
  }

  /**
     \brief
     Write the current mesh to a file with the given name.
     \param fileName Input - The name of the file to write to.
  */
  FINLEY_DLL_API
  void write(const std::string& fileName) const;

  /**
     \brief
     Write the current mesh to a file with the given name.
     \param fileName Input - The name of the file to write to.
  */
  FINLEY_DLL_API
  void Print_Mesh_Info(const bool) const;

  /**
     \brief
     dumps the mesh to a file with the given name.
     \param fileName Input - The name of the file
  */
  FINLEY_DLL_API
  void dump(const std::string& fileName) const;

  /**
     \brief
     return the pointer to the underlying finley mesh structure
  */
  FINLEY_DLL_API
  Finley_Mesh* getFinley_Mesh() const;

   /**
     \brief
     Return the tag key for the given sample number.
     \param functionSpaceType Input - The function space type.
     \param sampleNo Input - The sample number.
  */
  FINLEY_DLL_API
  int getTagFromSampleNo(int functionSpaceType, int sampleNo) const;

  /**
     \brief
     Return the reference number of  the given sample number.
     \param functionSpaceType Input - The function space type.
  */
  FINLEY_DLL_API
  int* borrowSampleReferenceIDs(int functionSpaceType) const;

  /**
     \brief
     Returns true if the given integer is a valid function space type
     for this domain.
  */
  FINLEY_DLL_API
  virtual bool isValidFunctionSpaceType(int functionSpaceType) const;

  /**
     \brief
     Return a description for this domain
  */
  FINLEY_DLL_API
  virtual std::string getDescription() const;

  /**
     \brief
     Return a description for the given function space type code
  */
  FINLEY_DLL_API
  virtual std::string functionSpaceTypeAsString(int functionSpaceType) const;

  /**
     \brief
     Build the table of function space type names
  */
  FINLEY_DLL_API
  void setFunctionSpaceTypeNames();

  /**
     \brief
     Return a continuous FunctionSpace code
  */
  FINLEY_DLL_API
  virtual int getContinuousFunctionCode() const;

  /**
     \brief
     Return a continuous on reduced order nodes FunctionSpace code
  */
  FINLEY_DLL_API
  virtual int getReducedContinuousFunctionCode() const;

  /**
     \brief
     Return a function FunctionSpace code
  */
  FINLEY_DLL_API
  virtual int getFunctionCode() const;

  /**
     \brief
     Return a function with reduced integration order FunctionSpace code
  */
  FINLEY_DLL_API
  virtual int getReducedFunctionCode() const;

  /**
     \brief
     Return a function on boundary FunctionSpace code
  */
  FINLEY_DLL_API
  virtual int getFunctionOnBoundaryCode() const;

  /**
     \brief
     Return a function on boundary with reduced integration order FunctionSpace code
  */
  FINLEY_DLL_API
  virtual int getReducedFunctionOnBoundaryCode() const;

  /**
     \brief
     Return a FunctionOnContactZero code
  */
  FINLEY_DLL_API
  virtual int getFunctionOnContactZeroCode() const;

  /**
     \brief
     Return a FunctionOnContactZero code  with reduced integration order
  */
  FINLEY_DLL_API
  virtual int getReducedFunctionOnContactZeroCode() const;

  /**
     \brief
     Return a FunctionOnContactOne code
  */
  FINLEY_DLL_API
  virtual int getFunctionOnContactOneCode() const;

  /**
     \brief
     Return a FunctionOnContactOne code  with reduced integration order
  */
  FINLEY_DLL_API
  virtual int getReducedFunctionOnContactOneCode() const;

  /**
     \brief
     Return a Solution code
  */
  FINLEY_DLL_API
  virtual int getSolutionCode() const;

  /**
     \brief
     Return a ReducedSolution code
  */
  FINLEY_DLL_API
  virtual int getReducedSolutionCode() const;

  /**
     \brief
     Return a DiracDeltaFunction code
  */
  FINLEY_DLL_API
  virtual int getDiracDeltaFunctionCode() const;

  /**
         5B
     \brief
  */
  typedef std::map<int, std::string> FunctionSpaceNamesMapType;

  /**
     \brief
  */
  FINLEY_DLL_API
  virtual int getDim() const;

  /**
     \brief
     Return the number of data points summed across all MPI processes
  */
  FINLEY_DLL_API
  virtual int getNumDataPointsGlobal() const;

  /**
     \brief
     Return the number of data points per sample, and the number of samples as a pair.
     \param functionSpaceCode Input -
  */
  FINLEY_DLL_API
  virtual std::pair<int,int> getDataShape(int functionSpaceCode) const;

  /**
     \brief
     copies the location of data points into arg. The domain of arg has to match this.
     has to be implemented by the actual Domain adapter.
  */
  FINLEY_DLL_API
  virtual void setToX(escript::Data& arg) const;

  /**
     \brief
     sets a map from a clear tag name to a tag key
     \param name Input - tag name.
     \param tag Input - tag key.
  */
  FINLEY_DLL_API
  virtual void setTagMap(const std::string& name,  int tag);

  /**
     \brief
     Return the tag key for tag name.
     \param name Input - tag name
  */
  FINLEY_DLL_API
  virtual int getTag(const std::string& name) const;

  /**
     \brief
     Returns true if name is a defined tage name. 
     \param name Input - tag name to be checked.
  */
  FINLEY_DLL_API
  virtual bool isValidTagName(const std::string& name) const;

  /**
     \brief
     Returns all tag names in a single string sperated by commas
  */
  FINLEY_DLL_API
  virtual std::string showTagNames() const;

  /**
     \brief
     assigns new location to the domain
  */
  FINLEY_DLL_API
  virtual void setNewX(const escript::Data& arg);

  /**
     \brief
     interpolates data given on source onto target where source and target have to be given on the same domain.
  */
  FINLEY_DLL_API
  virtual void interpolateOnDomain(escript::Data& target,const escript::Data& source) const;
  FINLEY_DLL_API
  virtual bool probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const;

  /**
     \brief
     interpolates data given on source onto target where source and target are given on different domains.
     has to be implemented by the actual Domain adapter.
  */
  FINLEY_DLL_API
  virtual void interpolateACross(escript::Data& target, const escript::Data& source) const;
  FINLEY_DLL_API
  virtual bool probeInterpolationACross(int functionSpaceType_source,const AbstractDomain& targetDomain, int functionSpaceType_target) const;

  /**
     \brief
     copies the surface normals at data points into out. The actual function space to be considered
     is defined by out. out has to be defined on this.
  */
  FINLEY_DLL_API
  virtual void setToNormal(escript::Data& out) const;

  /**
     \brief
     copies the size of samples into out. The actual function space to be considered
     is defined by out. out has to be defined on this.
  */
  FINLEY_DLL_API
  virtual void setToSize(escript::Data& out) const;

  /**
     \brief
     copies the gradient of arg into grad. The actual function space to be considered
     for the gradient is defined by grad. arg and grad have to be defined on this.
  */
  FINLEY_DLL_API
  virtual void setToGradient(escript::Data& grad,const escript::Data& arg) const;

  /**
     \brief
     copies the integrals of the function defined by arg into integrals.
     arg has to be defined on this.
  */
  FINLEY_DLL_API
  virtual void setToIntegrals(std::vector<double>& integrals,const escript::Data& arg) const;

  /**
     \brief
     return the identifier of the matrix type to be used for the global stiffness matrix when a particular solver, package, perconditioner,
     and symmetric matrix is used.
     \param precondioner
     \param solver 
     \param symmetry 
  */
  FINLEY_DLL_API
  virtual int getSystemMatrixTypeId(const int solver, const int preconditioner, const int package, const bool symmetry) const;

  /**
     \brief
     return the identifier of the transport problem type to be used when a particular solver, perconditioner, package
     and symmetric matrix is used.
     \param precondioner
     \param solver 
     \param symmetry 
  */
  FINLEY_DLL_API
  virtual int getTransportTypeId(const int solver, const int preconditioner, const int package, const bool symmetry) const;

  /**
     \brief
     returns true if data on this domain and a function space of type functionSpaceCode has to 
     considered as cell centered data.
  */
  FINLEY_DLL_API
  virtual bool isCellOriented(int functionSpaceCode) const;

  /**
     \brief
     Saves a dictonary of Data objects to an OpenDX input file. The keywords are used as identifier
                                                                                                                                                                        
     This has to be implemented by the actual Domain adapter.
  */
  FINLEY_DLL_API
  virtual void saveDX(const std::string& filename,const boost::python::dict& arg) const;


  /**
     \brief
     Saves a dictonary of Data objects to an VTK XML input file. The keywords are used as identifier
                                                                                                                                                                        
     This has to be implemented by the actual Domain adapter.
  */
  FINLEY_DLL_API
  virtual void saveVTK(const std::string& filename,const boost::python::dict& arg) const;

  /**
     \brief
     returns the function space representation of the type functionSpaceCode on this domain
     as a vtkObject.
  */
  // vtkObject createVtkObject(int functionSpaceCode) const;

  /**
     \brief
     adds a PDE onto the stiffness matrix mat and a rhs 
  */
  FINLEY_DLL_API
  virtual void addPDEToSystem(
                     SystemMatrixAdapter& mat, escript::Data& rhs,
                     const escript::Data& A, const escript::Data& B, const escript::Data& C, 
                     const escript::Data& D, const escript::Data& X, const escript::Data& Y,
                     const escript::Data& d, const escript::Data& y,
                     const escript::Data& d_contact, const escript::Data& y_contact) const;
  /**
     \brief
     adds a PDE onto the lumped stiffness matrix matrix
  */
  FINLEY_DLL_API
  virtual void addPDEToLumpedSystem(
                     escript::Data& mat,
                     const escript::Data& D, 
                     const escript::Data& d) const;

  /**
     \brief
     adds a PDE onto the stiffness matrix mat and a rhs 
  */
  FINLEY_DLL_API
  virtual void addPDEToRHS(escript::Data& rhs,
                     const escript::Data& X, const escript::Data& Y,
                     const escript::Data& y, const escript::Data& y_contact) const;
  /**
     \brief
     adds a PDE onto a transport problem
  */

  FINLEY_DLL_API
  virtual void addPDEToTransportProblem(
                     TransportProblemAdapter& tp, escript::Data& source, 
                     const escript::Data& M,
                     const escript::Data& A, const escript::Data& B, const escript::Data& C,const  escript::Data& D,
                     const  escript::Data& X,const  escript::Data& Y,
                     const escript::Data& d, const escript::Data& y,
                     const escript::Data& d_contact,const escript::Data& y_contact) const;


  /**
     \brief
    creates a SystemMatrixAdapter stiffness matrix and initializes it with zeros:
  */
  FINLEY_DLL_API
  SystemMatrixAdapter newSystemMatrix(
                      const int row_blocksize,
                      const escript::FunctionSpace& row_functionspace,
                      const int column_blocksize,
                      const escript::FunctionSpace& column_functionspace,
                      const int type) const;
  /**
   \brief 
    creates a TransportProblemAdapter 

  */

  FINLEY_DLL_API
  TransportProblemAdapter newTransportProblem(
                      const double theta,
                      const int blocksize,
                      const escript::FunctionSpace& functionspace,
                      const int type) const;

  /**
     \brief returns locations in the FEM nodes
  */
  FINLEY_DLL_API
  virtual escript::Data getX() const;

  /**
     \brief return boundary normals at the quadrature point on the face elements
  */
  FINLEY_DLL_API
  virtual escript::Data getNormal() const;

  /**
     \brief returns the element size
  */
  FINLEY_DLL_API
  virtual escript::Data getSize() const;

  /**
     \brief comparison operators
  */
  FINLEY_DLL_API
  virtual bool operator==(const AbstractDomain& other) const;
  FINLEY_DLL_API
  virtual bool operator!=(const AbstractDomain& other) const;

  /**
     \brief assigns new tag newTag to all samples of functionspace with a positive
     value of mask for any its sample point.

  */
  FINLEY_DLL_API
  virtual void setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const;

  /**
      \brief
          return the number of tags in use and a pointer to an array with the number of tags in use
  */
  FINLEY_DLL_API
  virtual int getNumberOfTagsInUse(int functionSpaceCode) const;

  FINLEY_DLL_API 
  virtual int* borrowListOfTagsInUse(int functionSpaceCode) const;


  /**
     \brief Checks if this domain allows tags for the specified functionSpaceCode.
  */
  FINLEY_DLL_API
  virtual
  bool canTag(int functionSpaceCode) const;


 protected:

 private:

  //
  // pointer to the externally created finley mesh
  boost::shared_ptr<Finley_Mesh> m_finleyMesh;
 
  static FunctionSpaceNamesMapType m_functionSpaceTypeNames;

};

} // end of namespace

#endif
1
2	/*******************************************************
3	*
4	* Copyright (c) 2003-2008 by University of Queensland
5	* Earth Systems Science Computational Center (ESSCC)
6	* http://www.uq.edu.au/esscc
7	*
8	* Primary Business: Queensland, Australia
9	* Licensed under the Open Software License version 3.0
10	* http://www.opensource.org/licenses/osl-3.0.php
11	*
12	*******************************************************/
13
14
15	#if !defined finley_MeshAdapter_20040526_H
16	#define finley_MeshAdapter_20040526_H
17	#include "system_dep.h"
18
19	extern "C" {
20	#include "../Mesh.h"
21	#include "../Finley.h"
22	#include "../Assemble.h"
23	#include "paso/SystemMatrix.h"
24	#include "paso/SolverFCT.h"
25	#include "paso/Paso_MPI.h"
26	}
27
28	#include "FinleyError.h"
29	#include "FinleyAdapterException.h"
30
31	#include "SystemMatrixAdapter.h"
32	#include "TransportProblemAdapter.h"
33	#include "escript/AbstractContinuousDomain.h"
34	#include "escript/FunctionSpace.h"
35	#include "escript/FunctionSpaceFactory.h"
36
37	#include <boost/shared_ptr.hpp>
38	#include <boost/python/dict.hpp>
39	#include <boost/python/extract.hpp>
40
41	#include <map>
42	#include <vector>
43	#include <string>
44	#include <sstream>
45
46	//
47	// forward declarations
48	class Data;
49
50	//using namespace escript;
51
52	namespace finley {
53
54	struct null_deleter
55	{
56	void operator()(void const *ptr) const
57	{
58	}
59	};
60
61
62	/**
63	\brief
64	MeshAdapter implements the AbstractContinuousDomain
65	interface for the Finley library.
66
67	Description:
68	MeshAdapter implements the AbstractContinuousDomain
69	interface for the Finley library.
70	*/
71
72	class MeshAdapter : public escript::AbstractContinuousDomain {
73
74	public:
75
76	//
77	// Codes for function space types supported
78	static const int DegreesOfFreedom;
79	static const int ReducedDegreesOfFreedom;
80	static const int Nodes;
81	static const int ReducedNodes;
82	static const int Elements;
83	static const int ReducedElements;
84	static const int FaceElements;
85	static const int ReducedFaceElements;
86	static const int Points;
87	static const int ContactElementsZero;
88	static const int ReducedContactElementsZero;
89	static const int ContactElementsOne;
90	static const int ReducedContactElementsOne;
91
92	/**
93	\brief
94	Constructor for MeshAdapter
95
96	Description:
97	Constructor for MeshAdapter. The pointer passed to MeshAdapter
98	is deleted using a call to Finley_Mesh_free in the
99	MeshAdapter destructor.
100
101	Throws:
102	May throw an exception derived from EsysException
103
104	\param finleyMesh Input - A pointer to the externally constructed
105	finley mesh.The pointer passed to MeshAdapter
106	is deleted using a call to
107	Finley_Mesh_free in the MeshAdapter
108	destructor.
109	*/
110	FINLEY_DLL_API
111	MeshAdapter(Finley_Mesh* finleyMesh=0);
112
113	/**
114	\brief
115	Copy constructor.
116	*/
117	FINLEY_DLL_API
118	MeshAdapter(const MeshAdapter& in);
119
120	/**
121	\brief
122	Destructor for MeshAdapter. As specified in the constructor
123	this calls Finley_Mesh_free for the pointer given to the
124	constructor.
125	*/
126	FINLEY_DLL_API
127	~MeshAdapter();
128
129	/**
130	\brief
131	return the number of processors used for this domain
132	*/
133	FINLEY_DLL_API
134	virtual int getMPISize() const;
135	/**
136	\brief
137	return the number MPI rank of this processor
138	*/
139
140	FINLEY_DLL_API
141	virtual int getMPIRank() const;
142
143	/**
144	\brief
145	If compiled for MPI then execute an MPI_Barrier, else do nothing
146	*/
147
148	FINLEY_DLL_API
149	virtual void MPIBarrier() const;
150
151	/**
152	\brief
153	Return true if on MPI processor 0, else false
154	*/
155
156	FINLEY_DLL_API
157	virtual bool onMasterProcessor() const;
158
159	/**
160	\brief
161	return this as an AbstractContinuousDomain.
162	*/
163	inline const AbstractContinuousDomain& asAbstractContinuousDomain() const
164	{
165	return (static_cast<const AbstractContinuousDomain>(this));
166	}
167
168	/**
169	\brief
170	return this as an AbstractDomain.
171	*/
172	inline const AbstractDomain& asAbstractDomain() const
173	{
174	return (static_cast<const AbstractDomain>(this));
175	}
176
177	/**
178	\brief
179	Write the current mesh to a file with the given name.
180	\param fileName Input - The name of the file to write to.
181	*/
182	FINLEY_DLL_API
183	void write(const std::string& fileName) const;
184
185	/**
186	\brief
187	Write the current mesh to a file with the given name.
188	\param fileName Input - The name of the file to write to.
189	*/
190	FINLEY_DLL_API
191	void Print_Mesh_Info(const bool) const;
192
193	/**
194	\brief
195	dumps the mesh to a file with the given name.
196	\param fileName Input - The name of the file
197	*/
198	FINLEY_DLL_API
199	void dump(const std::string& fileName) const;
200
201	/**
202	\brief
203	return the pointer to the underlying finley mesh structure
204	*/
205	FINLEY_DLL_API
206	Finley_Mesh* getFinley_Mesh() const;
207
208	/**
209	\brief
210	Return the tag key for the given sample number.
211	\param functionSpaceType Input - The function space type.
212	\param sampleNo Input - The sample number.
213	*/
214	FINLEY_DLL_API
215	int getTagFromSampleNo(int functionSpaceType, int sampleNo) const;
216
217	/**
218	\brief
219	Return the reference number of the given sample number.
220	\param functionSpaceType Input - The function space type.
221	*/
222	FINLEY_DLL_API
223	int* borrowSampleReferenceIDs(int functionSpaceType) const;
224
225	/**
226	\brief
227	Returns true if the given integer is a valid function space type
228	for this domain.
229	*/
230	FINLEY_DLL_API
231	virtual bool isValidFunctionSpaceType(int functionSpaceType) const;
232
233	/**
234	\brief
235	Return a description for this domain
236	*/
237	FINLEY_DLL_API
238	virtual std::string getDescription() const;
239
240	/**
241	\brief
242	Return a description for the given function space type code
243	*/
244	FINLEY_DLL_API
245	virtual std::string functionSpaceTypeAsString(int functionSpaceType) const;
246
247	/**
248	\brief
249	Build the table of function space type names
250	*/
251	FINLEY_DLL_API
252	void setFunctionSpaceTypeNames();
253
254	/**
255	\brief
256	Return a continuous FunctionSpace code
257	*/
258	FINLEY_DLL_API
259	virtual int getContinuousFunctionCode() const;
260
261	/**
262	\brief
263	Return a continuous on reduced order nodes FunctionSpace code
264	*/
265	FINLEY_DLL_API
266	virtual int getReducedContinuousFunctionCode() const;
267
268	/**
269	\brief
270	Return a function FunctionSpace code
271	*/
272	FINLEY_DLL_API
273	virtual int getFunctionCode() const;
274
275	/**
276	\brief
277	Return a function with reduced integration order FunctionSpace code
278	*/
279	FINLEY_DLL_API
280	virtual int getReducedFunctionCode() const;
281
282	/**
283	\brief
284	Return a function on boundary FunctionSpace code
285	*/
286	FINLEY_DLL_API
287	virtual int getFunctionOnBoundaryCode() const;
288
289	/**
290	\brief
291	Return a function on boundary with reduced integration order FunctionSpace code
292	*/
293	FINLEY_DLL_API
294	virtual int getReducedFunctionOnBoundaryCode() const;
295
296	/**
297	\brief
298	Return a FunctionOnContactZero code
299	*/
300	FINLEY_DLL_API
301	virtual int getFunctionOnContactZeroCode() const;
302
303	/**
304	\brief
305	Return a FunctionOnContactZero code with reduced integration order
306	*/
307	FINLEY_DLL_API
308	virtual int getReducedFunctionOnContactZeroCode() const;
309
310	/**
311	\brief
312	Return a FunctionOnContactOne code
313	*/
314	FINLEY_DLL_API
315	virtual int getFunctionOnContactOneCode() const;
316
317	/**
318	\brief
319	Return a FunctionOnContactOne code with reduced integration order
320	*/
321	FINLEY_DLL_API
322	virtual int getReducedFunctionOnContactOneCode() const;
323
324	/**
325	\brief
326	Return a Solution code
327	*/
328	FINLEY_DLL_API
329	virtual int getSolutionCode() const;
330
331	/**
332	\brief
333	Return a ReducedSolution code
334	*/
335	FINLEY_DLL_API
336	virtual int getReducedSolutionCode() const;
337
338	/**
339	\brief
340	Return a DiracDeltaFunction code
341	*/
342	FINLEY_DLL_API
343	virtual int getDiracDeltaFunctionCode() const;
344
345	/**
346	5B
347	\brief
348	*/
349	typedef std::map<int, std::string> FunctionSpaceNamesMapType;
350
351	/**
352	\brief
353	*/
354	FINLEY_DLL_API
355	virtual int getDim() const;
356
357	/**
358	\brief
359	Return the number of data points summed across all MPI processes
360	*/
361	FINLEY_DLL_API
362	virtual int getNumDataPointsGlobal() const;
363
364	/**
365	\brief
366	Return the number of data points per sample, and the number of samples as a pair.
367	\param functionSpaceCode Input -
368	*/
369	FINLEY_DLL_API
370	virtual std::pair<int,int> getDataShape(int functionSpaceCode) const;
371
372	/**
373	\brief
374	copies the location of data points into arg. The domain of arg has to match this.
375	has to be implemented by the actual Domain adapter.
376	*/
377	FINLEY_DLL_API
378	virtual void setToX(escript::Data& arg) const;
379
380	/**
381	\brief
382	sets a map from a clear tag name to a tag key
383	\param name Input - tag name.
384	\param tag Input - tag key.
385	*/
386	FINLEY_DLL_API
387	virtual void setTagMap(const std::string& name, int tag);
388
389	/**
390	\brief
391	Return the tag key for tag name.
392	\param name Input - tag name
393	*/
394	FINLEY_DLL_API
395	virtual int getTag(const std::string& name) const;
396
397	/**
398	\brief
399	Returns true if name is a defined tage name.
400	\param name Input - tag name to be checked.
401	*/
402	FINLEY_DLL_API
403	virtual bool isValidTagName(const std::string& name) const;
404
405	/**
406	\brief
407	Returns all tag names in a single string sperated by commas
408	*/
409	FINLEY_DLL_API
410	virtual std::string showTagNames() const;
411
412	/**
413	\brief
414	assigns new location to the domain
415	*/
416	FINLEY_DLL_API
417	virtual void setNewX(const escript::Data& arg);
418
419	/**
420	\brief
421	interpolates data given on source onto target where source and target have to be given on the same domain.
422	*/
423	FINLEY_DLL_API
424	virtual void interpolateOnDomain(escript::Data& target,const escript::Data& source) const;
425	FINLEY_DLL_API
426	virtual bool probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const;
427
428	/**
429	\brief
430	interpolates data given on source onto target where source and target are given on different domains.
431	has to be implemented by the actual Domain adapter.
432	*/
433	FINLEY_DLL_API
434	virtual void interpolateACross(escript::Data& target, const escript::Data& source) const;
435	FINLEY_DLL_API
436	virtual bool probeInterpolationACross(int functionSpaceType_source,const AbstractDomain& targetDomain, int functionSpaceType_target) const;
437
438	/**
439	\brief
440	copies the surface normals at data points into out. The actual function space to be considered
441	is defined by out. out has to be defined on this.
442	*/
443	FINLEY_DLL_API
444	virtual void setToNormal(escript::Data& out) const;
445
446	/**
447	\brief
448	copies the size of samples into out. The actual function space to be considered
449	is defined by out. out has to be defined on this.
450	*/
451	FINLEY_DLL_API
452	virtual void setToSize(escript::Data& out) const;
453
454	/**
455	\brief
456	copies the gradient of arg into grad. The actual function space to be considered
457	for the gradient is defined by grad. arg and grad have to be defined on this.
458	*/
459	FINLEY_DLL_API
460	virtual void setToGradient(escript::Data& grad,const escript::Data& arg) const;
461
462	/**
463	\brief
464	copies the integrals of the function defined by arg into integrals.
465	arg has to be defined on this.
466	*/
467	FINLEY_DLL_API
468	virtual void setToIntegrals(std::vector<double>& integrals,const escript::Data& arg) const;
469
470	/**
471	\brief
472	return the identifier of the matrix type to be used for the global stiffness matrix when a particular solver, package, perconditioner,
473	and symmetric matrix is used.
474	\param precondioner
475	\param solver
476	\param symmetry
477	*/
478	FINLEY_DLL_API
479	virtual int getSystemMatrixTypeId(const int solver, const int preconditioner, const int package, const bool symmetry) const;
480
481	/**
482	\brief
483	return the identifier of the transport problem type to be used when a particular solver, perconditioner, package
484	and symmetric matrix is used.
485	\param precondioner
486	\param solver
487	\param symmetry
488	*/
489	FINLEY_DLL_API
490	virtual int getTransportTypeId(const int solver, const int preconditioner, const int package, const bool symmetry) const;
491
492	/**
493	\brief
494	returns true if data on this domain and a function space of type functionSpaceCode has to
495	considered as cell centered data.
496	*/
497	FINLEY_DLL_API
498	virtual bool isCellOriented(int functionSpaceCode) const;
499
500	/**
501	\brief
502	Saves a dictonary of Data objects to an OpenDX input file. The keywords are used as identifier
503
504	This has to be implemented by the actual Domain adapter.
505	*/
506	FINLEY_DLL_API
507	virtual void saveDX(const std::string& filename,const boost::python::dict& arg) const;
508
509
510	/**
511	\brief
512	Saves a dictonary of Data objects to an VTK XML input file. The keywords are used as identifier
513
514	This has to be implemented by the actual Domain adapter.
515	*/
516	FINLEY_DLL_API
517	virtual void saveVTK(const std::string& filename,const boost::python::dict& arg) const;
518
519	/**
520	\brief
521	returns the function space representation of the type functionSpaceCode on this domain
522	as a vtkObject.
523	*/
524	// vtkObject createVtkObject(int functionSpaceCode) const;
525
526	/**
527	\brief
528	adds a PDE onto the stiffness matrix mat and a rhs
529	*/
530	FINLEY_DLL_API
531	virtual void addPDEToSystem(
532	SystemMatrixAdapter& mat, escript::Data& rhs,
533	const escript::Data& A, const escript::Data& B, const escript::Data& C,
534	const escript::Data& D, const escript::Data& X, const escript::Data& Y,
535	const escript::Data& d, const escript::Data& y,
536	const escript::Data& d_contact, const escript::Data& y_contact) const;
537	/**
538	\brief
539	adds a PDE onto the lumped stiffness matrix matrix
540	*/
541	FINLEY_DLL_API
542	virtual void addPDEToLumpedSystem(
543	escript::Data& mat,
544	const escript::Data& D,
545	const escript::Data& d) const;
546
547	/**
548	\brief
549	adds a PDE onto the stiffness matrix mat and a rhs
550	*/
551	FINLEY_DLL_API
552	virtual void addPDEToRHS(escript::Data& rhs,
553	const escript::Data& X, const escript::Data& Y,
554	const escript::Data& y, const escript::Data& y_contact) const;
555	/**
556	\brief
557	adds a PDE onto a transport problem
558	*/
559
560	FINLEY_DLL_API
561	virtual void addPDEToTransportProblem(
562	TransportProblemAdapter& tp, escript::Data& source,
563	const escript::Data& M,
564	const escript::Data& A, const escript::Data& B, const escript::Data& C,const escript::Data& D,
565	const escript::Data& X,const escript::Data& Y,
566	const escript::Data& d, const escript::Data& y,
567	const escript::Data& d_contact,const escript::Data& y_contact) const;
568
569
570	/**
571	\brief
572	creates a SystemMatrixAdapter stiffness matrix and initializes it with zeros:
573	*/
574	FINLEY_DLL_API
575	SystemMatrixAdapter newSystemMatrix(
576	const int row_blocksize,
577	const escript::FunctionSpace& row_functionspace,
578	const int column_blocksize,
579	const escript::FunctionSpace& column_functionspace,
580	const int type) const;
581	/**
582	\brief
583	creates a TransportProblemAdapter
584
585	*/
586
587	FINLEY_DLL_API
588	TransportProblemAdapter newTransportProblem(
589	const double theta,
590	const int blocksize,
591	const escript::FunctionSpace& functionspace,
592	const int type) const;
593
594	/**
595	\brief returns locations in the FEM nodes
596	*/
597	FINLEY_DLL_API
598	virtual escript::Data getX() const;
599
600	/**
601	\brief return boundary normals at the quadrature point on the face elements
602	*/
603	FINLEY_DLL_API
604	virtual escript::Data getNormal() const;
605
606	/**
607	\brief returns the element size
608	*/
609	FINLEY_DLL_API
610	virtual escript::Data getSize() const;
611
612	/**
613	\brief comparison operators
614	*/
615	FINLEY_DLL_API
616	virtual bool operator==(const AbstractDomain& other) const;
617	FINLEY_DLL_API
618	virtual bool operator!=(const AbstractDomain& other) const;
619
620	/**
621	\brief assigns new tag newTag to all samples of functionspace with a positive
622	value of mask for any its sample point.
623
624	*/
625	FINLEY_DLL_API
626	virtual void setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const;
627
628	/**
629	\brief
630	return the number of tags in use and a pointer to an array with the number of tags in use
631	*/
632	FINLEY_DLL_API
633	virtual int getNumberOfTagsInUse(int functionSpaceCode) const;
634
635	FINLEY_DLL_API
636	virtual int* borrowListOfTagsInUse(int functionSpaceCode) const;
637
638
639	/**
640	\brief Checks if this domain allows tags for the specified functionSpaceCode.
641	*/
642	FINLEY_DLL_API
643	virtual
644	bool canTag(int functionSpaceCode) const;
645
646
647	protected:
648
649	private:
650
651	//
652	// pointer to the externally created finley mesh
653	boost::shared_ptr<Finley_Mesh> m_finleyMesh;
654
655	static FunctionSpaceNamesMapType m_functionSpaceTypeNames;
656
657	};
658
659	} // end of namespace
660
661	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision