src/CPPAdapter/MeshAdapter.h

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

extern "C" {
#include "Mesh.h"
#include "Finley.h"
#include "Assemble.h"
#include "Finley.h"
#include "SystemMatrix.h"
}

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

#include "SystemMatrixAdapter.h"
#include "AbstractContinuousDomain.h"
#include "FunctionSpace.h"
#include "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 Elements;
  static const int FaceElements;
  static const int Points;
  static const int ContactElementsZero;
  static const int ContactElementsOne;

  /**
     \brief
     Constructor for MeshAdapter

     Description:
     Constructor for MeshAdapter. The pointer passed to MeshAdapter
     is deleted using a call to Finley_Mesh_deallocate 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_deallocate in the MeshAdapter 
                               destructor.
  */
  MeshAdapter(Finley_Mesh* finleyMesh=0);

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

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

  /**
     \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.
  */
  void write(const std::string& fileName) const;

  /**
     \brief
     return the pointer to the underlying finley mesh structure
  */
  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.
  */
  int getTagFromSampleNo(int functionSpaceType, int sampleNo) const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
     \brief
     Return the number of data points per sample, and the number of samples as a pair.
     \param functionSpaceCode Input -
  */
  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.
  */
  virtual void setToX(escript::Data& arg) const;

  /**
     \brief
     assigns new location to the domain
  */
  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.
  */
  virtual void interpolateOnDomain(escript::Data& target,const escript::Data& source) const;
  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.
  */
  virtual void interpolateACross(escript::Data& target, const escript::Data& source) const;
  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.
  */
  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.
  */
  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.
  */
  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.
  */
  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
     and symmetric matrix is used.
     \param solver 
     \param symmetry 
  */
  virtual int getSystemMatrixTypeId(const int solver, 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.
  */
  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.
  */
  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.
  */
  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 
  */
  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 stiffness matrix mat and a rhs 
  */
  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
    creates a SystemMatrixAdapter stiffness matrix an initializes it with zeros:
  */
  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 returns locations in the FEM nodes
  */
  virtual escript::Data getX() const;

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

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

  /**
     \brief comparison operators
  */
  virtual bool operator==(const AbstractDomain& other) const;
  virtual bool operator!=(const AbstractDomain& other) 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	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	jgs	149	#if !defined finley_MeshAdapter_20040526_H
17	jgs	82	#define finley_MeshAdapter_20040526_H
18
19			extern "C" {
20	jgs	203	#include "Mesh.h"
21	jgs	472	#include "Finley.h"
22			#include "Assemble.h"
23			#include "Finley.h"
24			#include "SystemMatrix.h"
25	jgs	82	}
26	jgs	472
27			#include "FinleyError.h"
28			#include "FinleyAdapterException.h"
29	jgs	149
30	jgs	480	#include "SystemMatrixAdapter.h"
31	jgs	474	#include "AbstractContinuousDomain.h"
32			#include "FunctionSpace.h"
33			#include "FunctionSpaceFactory.h"
34	jgs	472
35	jgs	82	#include <boost/shared_ptr.hpp>
36	jgs	153	#include <boost/python/dict.hpp>
37	jgs	472	#include <boost/python/extract.hpp>
38
39	jgs	82	#include <map>
40			#include <vector>
41			#include <string>
42	jgs	472	#include <sstream>
43	jgs	82
44	jgs	480	//
45			// forward declarations
46			class Data;
47
48			//using namespace escript;
49
50	jgs	82	namespace finley {
51
52	jgs	123	struct null_deleter
53			{
54			void operator()(void const *ptr) const
55			{
56			}
57			};
58
59
60	jgs	82	/**
61			\brief
62			MeshAdapter implements the AbstractContinuousDomain
63			interface for the Finley library.
64
65			Description:
66			MeshAdapter implements the AbstractContinuousDomain
67			interface for the Finley library.
68			*/
69
70	jgs	480	class MeshAdapter : public escript::AbstractContinuousDomain {
71	jgs	82
72			public:
73
74			//
75			// Codes for function space types supported
76			static const int DegreesOfFreedom;
77			static const int ReducedDegreesOfFreedom;
78			static const int Nodes;
79			static const int Elements;
80			static const int FaceElements;
81			static const int Points;
82			static const int ContactElementsZero;
83			static const int ContactElementsOne;
84
85			/**
86			\brief
87			Constructor for MeshAdapter
88
89			Description:
90			Constructor for MeshAdapter. The pointer passed to MeshAdapter
91			is deleted using a call to Finley_Mesh_deallocate in the
92			MeshAdapter destructor.
93
94			Throws:
95			May throw an exception derived from EsysException
96
97			\param finleyMesh Input - A pointer to the externally constructed
98			finley mesh.The pointer passed to MeshAdapter
99			is deleted using a call to
100			Finley_Mesh_deallocate in the MeshAdapter
101			destructor.
102			*/
103			MeshAdapter(Finley_Mesh* finleyMesh=0);
104	jgs	149
105	jgs	82	/**
106			\brief
107			Copy constructor.
108			*/
109			MeshAdapter(const MeshAdapter& in);
110	jgs	149
111	jgs	82	/**
112			\brief
113			Destructor for MeshAdapter. As specified in the constructor
114	jgs	149	this calls Finley_Mesh_deallocate for the pointer given to the
115	jgs	82	constructor.
116			*/
117			~MeshAdapter();
118	jgs	149
119	jgs	82	/**
120			\brief
121			return this as an AbstractContinuousDomain.
122			*/
123			inline const AbstractContinuousDomain& asAbstractContinuousDomain() const
124			{
125			return (static_cast<const AbstractContinuousDomain>(this));
126			}
127
128			/**
129			\brief
130			return this as an AbstractDomain.
131			*/
132			inline const AbstractDomain& asAbstractDomain() const
133			{
134			return (static_cast<const AbstractDomain>(this));
135			}
136	jgs	149
137	jgs	82	/**
138			\brief
139			Write the current mesh to a file with the given name.
140			\param fileName Input - The name of the file to write to.
141			*/
142			void write(const std::string& fileName) const;
143	jgs	149
144	jgs	82	/**
145			\brief
146	jgs	149	return the pointer to the underlying finley mesh structure
147	jgs	82	*/
148			Finley_Mesh* getFinley_Mesh() const;
149	jgs	149
150	jgs	110	/**
151			\brief
152			Return the tag key for the given sample number.
153			\param functionSpaceType Input - The function space type.
154			\param sampleNo Input - The sample number.
155			*/
156			int getTagFromSampleNo(int functionSpaceType, int sampleNo) const;
157	jgs	149
158	jgs	110	/**
159			\brief
160			Return the reference number of the given sample number.
161			\param functionSpaceType Input - The function space type.
162			\param sampleNo Input - The sample number.
163			*/
164			int getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const;
165
166			/**
167			\brief
168	jgs	82	Returns true if the given integer is a valid function space type
169			for this domain.
170			*/
171			virtual bool isValidFunctionSpaceType(int functionSpaceType) const;
172	jgs	149
173	jgs	82	/**
174			\brief
175			Return a description for this domain
176			*/
177			virtual std::string getDescription() const;
178	jgs	149
179	jgs	82	/**
180			\brief
181			Return a description for the given function space type code
182			*/
183			virtual std::string functionSpaceTypeAsString(int functionSpaceType) const;
184	jgs	110
185	jgs	82	/**
186			\brief
187			Build the table of function space type names
188			*/
189			void setFunctionSpaceTypeNames();
190	jgs	149
191	jgs	82	/**
192			\brief
193			Return a continuous FunctionSpace code
194			*/
195			virtual int getContinuousFunctionCode() const;
196	jgs	149
197	jgs	82	/**
198			\brief
199			Return a functon FunctionSpace code
200			*/
201			virtual int getFunctionCode() const;
202	jgs	149
203	jgs	82	/**
204			\brief
205			Return a function on boundary FunctionSpace code
206			*/
207			virtual int getFunctionOnBoundaryCode() const;
208	jgs	149
209	jgs	82	/**
210			\brief
211			Return a FunctionOnContactZero code
212			*/
213			virtual int getFunctionOnContactZeroCode() const;
214	jgs	149
215	jgs	82	/**
216			\brief
217			Return a FunctionOnContactOne code
218			*/
219			virtual int getFunctionOnContactOneCode() const;
220	jgs	149
221	jgs	82	/**
222			\brief
223			Return a Solution code
224			*/
225			virtual int getSolutionCode() const;
226	jgs	149
227	jgs	82	/**
228			\brief
229			Return a ReducedSolution code
230			*/
231			virtual int getReducedSolutionCode() const;
232	jgs	149
233	jgs	82	/**
234			\brief
235			Return a DiracDeltaFunction code
236			*/
237			virtual int getDiracDeltaFunctionCode() const;
238	jgs	149
239			/**
240			\brief
241			*/
242	jgs	82	typedef std::map<int, std::string> FunctionSpaceNamesMapType;
243	jgs	149
244	jgs	82	/**
245			\brief
246			*/
247			virtual int getDim() const;
248	jgs	149
249			/**
250	jgs	82	\brief
251			Return the number of data points per sample, and the number of samples as a pair.
252	jgs	121	\param functionSpaceCode Input -
253	jgs	82	*/
254			virtual std::pair<int,int> getDataShape(int functionSpaceCode) const;
255
256			/**
257			\brief
258			copies the location of data points into arg. The domain of arg has to match this.
259			has to be implemented by the actual Domain adapter.
260			*/
261			virtual void setToX(escript::Data& arg) const;
262	jgs	149
263	jgs	82	/**
264			\brief
265			assigns new location to the domain
266			*/
267			virtual void setNewX(const escript::Data& arg);
268	jgs	149
269	jgs	82	/**
270			\brief
271			interpolates data given on source onto target where source and target have to be given on the same domain.
272			*/
273			virtual void interpolateOnDomain(escript::Data& target,const escript::Data& source) const;
274			virtual bool probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const;
275	jgs	149
276	jgs	82	/**
277			\brief
278			interpolates data given on source onto target where source and target are given on different domains.
279			has to be implemented by the actual Domain adapter.
280			*/
281			virtual void interpolateACross(escript::Data& target, const escript::Data& source) const;
282			virtual bool probeInterpolationACross(int functionSpaceType_source,const AbstractDomain& targetDomain, int functionSpaceType_target) const;
283	jgs	149
284	jgs	82	/**
285			\brief
286	jgs	149	copies the surface normals at data points into out. The actual function space to be considered
287	jgs	82	is defined by out. out has to be defined on this.
288			*/
289			virtual void setToNormal(escript::Data& out) const;
290	jgs	149
291	jgs	82	/**
292			\brief
293			copies the size of samples into out. The actual function space to be considered
294			is defined by out. out has to be defined on this.
295			*/
296			virtual void setToSize(escript::Data& out) const;
297
298			/**
299			\brief
300			copies the gradient of arg into grad. The actual function space to be considered
301			for the gradient is defined by grad. arg and grad have to be defined on this.
302			*/
303			virtual void setToGradient(escript::Data& grad,const escript::Data& arg) const;
304
305			/**
306			\brief
307			copies the integrals of the function defined by arg into integrals.
308			arg has to be defined on this.
309			*/
310			virtual void setToIntegrals(std::vector<double>& integrals,const escript::Data& arg) const;
311
312	jgs	149	/**
313	jgs	102	\brief
314	jgs	150	return the identifier of the matrix type to be used for the global stiffness matrix when a particular solver, package
315	jgs	102	and symmetric matrix is used.
316			\param solver
317			\param symmetry
318			*/
319	jgs	150	virtual int getSystemMatrixTypeId(const int solver, const int package, const bool symmetry) const;
320	jgs	102
321	jgs	82	/**
322			\brief
323			returns true if data on this domain and a function space of type functionSpaceCode has to
324			considered as cell centered data.
325			*/
326			virtual bool isCellOriented(int functionSpaceCode) const;
327	jgs	149
328	jgs	82	/**
329			\brief
330	jgs	153	Saves a dictonary of Data objects to an OpenDX input file. The keywords are used as identifier
331
332			This has to be implemented by the actual Domain adapter.
333	jgs	82	*/
334	jgs	153	virtual void saveDX(const std::string& filename,const boost::python::dict& arg) const;
335	jgs	149
336	jgs	153
337	jgs	82	/**
338			\brief
339	jgs	153	Saves a dictonary of Data objects to an VTK XML input file. The keywords are used as identifier
340
341			This has to be implemented by the actual Domain adapter.
342	jgs	110	*/
343	jgs	153	virtual void saveVTK(const std::string& filename,const boost::python::dict& arg) const;
344	jgs	149
345	jgs	110	/**
346			\brief
347	jgs	82	returns the function space representation of the type functionSpaceCode on this domain
348			as a vtkObject.
349			*/
350			// vtkObject createVtkObject(int functionSpaceCode) const;
351	jgs	149
352	jgs	82	/**
353			\brief
354			adds a PDE onto the stiffness matrix mat and a rhs
355			*/
356			virtual void addPDEToSystem(
357			SystemMatrixAdapter& mat, escript::Data& rhs,
358			const escript::Data& A, const escript::Data& B, const escript::Data& C,
359	jgs	102	const escript::Data& D, const escript::Data& X, const escript::Data& Y,
360			const escript::Data& d, const escript::Data& y,
361			const escript::Data& d_contact, const escript::Data& y_contact) const;
362	jgs	149
363	jgs	82	/**
364			\brief
365	jgs	102	adds a PDE onto the stiffness matrix mat and a rhs
366	jgs	82	*/
367	jgs	102	virtual void addPDEToRHS(escript::Data& rhs,
368			const escript::Data& X, const escript::Data& Y,
369			const escript::Data& y, const escript::Data& y_contact) const;
370	jgs	149
371	jgs	82	/**
372			\brief
373			creates a SystemMatrixAdapter stiffness matrix an initializes it with zeros:
374			*/
375			SystemMatrixAdapter newSystemMatrix(
376			const int row_blocksize,
377			const escript::FunctionSpace& row_functionspace,
378			const int column_blocksize,
379			const escript::FunctionSpace& column_functionspace,
380	jgs	102	const int type) const;
381	jgs	82
382	jgs	102	/**
383			\brief returns locations in the FEM nodes
384			*/
385			virtual escript::Data getX() const;
386	jgs	149
387	jgs	102	/**
388			\brief return boundary normals at the quadrature point on the face elements
389			*/
390			virtual escript::Data getNormal() const;
391	jgs	149
392	jgs	102	/**
393			\brief returns the element size
394			*/
395			virtual escript::Data getSize() const;
396
397	jgs	149	/**
398			\brief comparison operators
399			*/
400	jgs	121	virtual bool operator==(const AbstractDomain& other) const;
401			virtual bool operator!=(const AbstractDomain& other) const;
402	jgs	102
403	jgs	82	protected:
404
405			private:
406	jgs	149
407	jgs	82	//
408			// pointer to the externally created finley mesh
409			boost::shared_ptr<Finley_Mesh> m_finleyMesh;
410
411			static FunctionSpaceNamesMapType m_functionSpaceTypeNames;
412
413			};
414
415			} // end of namespace
416	jgs	149
417	jgs	82	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision