escript/src/AbstractDomain.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 escript_AbstractDomain_20040609_H
#define escript_AbstractDomain_20040609_H

#include <string>
#include <boost/python/dict.hpp>

namespace escript {

//
// forward declarations
class Data;
//class AbstractSystemMatrix;
//class FunctionSpace;

/**
   \brief
   Base class for all escript domains.

   Description:
   Base class for all escript domains.
*/

class AbstractDomain {

 public:

  /**
     \brief
     Default constructor for AbstractDomain.

     Description:
     Default constructor for AbstractDomain. As the name suggests
     this is intended to be an abstract base class but by making it
     constructable we avoid a boost.python wrapper class. A call to 
     almost any of the base class functions will throw an exception
     as they are not intended to be used directly, but are overridden
     by the underlying solver package which escript is linked to.

     By default, this class is overridden by the class NullDomain.

     Preconditions:
     Describe any preconditions.

     Throws:
     Describe any exceptions thrown.
  */
  AbstractDomain();

  /**
     \brief
     Destructor for AbstractDomain.

     Description:
     Destructor for AbstractDomain.
  */
  virtual ~AbstractDomain();

  /**
     \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
      Returns the spatial dimension of the domain.

      This has to be implemented by the actual Domain adapter.
  */
  virtual int getDim() const;

  /**
     \brief
     Return true if given domains are equal.
  */
  virtual bool operator==(const AbstractDomain& other) const;
  virtual bool operator!=(const AbstractDomain& other) const;

  /**
     \brief
     Writes the domain to an external file filename.

     This has to be implemented by the actual Domain adapter.
  */
  virtual void write(const std::string& filename) const;

  /**
     \brief
     Return the number of data points per sample, and the number of samples as a pair.

     This has to be implemented by the actual Domain adapter.

     \param functionSpaceCode Input - Code for the function space type.
     \return pair, first - number of data points per sample, second - number of samples
  */
  virtual std::pair<int,int> getDataShape(int functionSpaceCode) const;

  /**
     \brief
     Return the tag key for the given sample number.
     \param functionSpaceType Input - The function space type.
     \param sampleNo Input - The sample number.
  */
  virtual 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.
  */
  virtual int getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const;

  /**
     \brief
     Assigns new location to the domain.

     This has to be implemented by the actual Domain adapter.
  */
  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.

     This has to be implemented by the actual Domain adapter.
  */
  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.

     This 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
     Returns locations in the domain. The function space is chosen appropriately.
  */
  virtual escript::Data getX() const;

  /**
     \brief
     Return boundary normals. The function space is chosen appropriately.
  */
  virtual escript::Data getNormal() const;

  /**
     \brief
     Returns the local size of samples. The function space is chosen appropriately.
  */
  virtual escript::Data getSize() const;
  
  /**
     \brief
     Copies the location of data points on the domain into out.
     The actual function space to be considered
     is defined by out. out has to be defined on this.

     This has to be implemented by the actual Domain adapter.
  */
  virtual void setToX(escript::Data& out) 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.

     This has to be implemented by the actual Domain adapter.
  */
  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.

     This has to be implemented by the actual Domain adapter.
  */
  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.

     This has to be implemented by the actual Domain adapter.
  */
  virtual void setToGradient(escript::Data& grad, const escript::Data& arg) 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.

     This has to be implemented by the actual Domain adapter.
  */
  //virtual vtkObject createVtkObject(int functionSpaceCode) const;

  /**
     \brief
     returns true if data on this domain and a function space of type functionSpaceCode has to
     considered as cell centered data.

     This has to be implemented by the actual Domain adapter.
  */
  virtual bool isCellOriented(int functionSpaceCode) const;

  /**
     \brief
     Throw a standard exception. This function is called if any attempt 
     is made to use a base class function.
  */
  void throwStandardException(const std::string& functionName) const;

 protected:

 private:

};

} // 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	jgs	115
16			#if !defined escript_AbstractDomain_20040609_H
17	jgs	82	#define escript_AbstractDomain_20040609_H
18	jgs	115
19	jgs	82	#include <string>
20	jgs	153	#include <boost/python/dict.hpp>
21	jgs	82
22			namespace escript {
23
24	jgs	117	//
25	jgs	149	// forward declarations
26	jgs	117	class Data;
27	jgs	480	//class AbstractSystemMatrix;
28			//class FunctionSpace;
29	jgs	115
30	jgs	82	/**
31			\brief
32			Base class for all escript domains.
33
34			Description:
35			Base class for all escript domains.
36			*/
37	jgs	115
38	jgs	82	class AbstractDomain {
39
40			public:
41
42			/**
43			\brief
44	jgs	117	Default constructor for AbstractDomain.
45	jgs	82
46			Description:
47			Default constructor for AbstractDomain. As the name suggests
48			this is intended to be an abstract base class but by making it
49	jgs	117	constructable we avoid a boost.python wrapper class. A call to
50	jgs	82	almost any of the base class functions will throw an exception
51	jgs	115	as they are not intended to be used directly, but are overridden
52	jgs	117	by the underlying solver package which escript is linked to.
53	jgs	82
54	jgs	115	By default, this class is overridden by the class NullDomain.
55
56	jgs	82	Preconditions:
57	jgs	117	Describe any preconditions.
58	jgs	82
59			Throws:
60	jgs	117	Describe any exceptions thrown.
61	jgs	82	*/
62			AbstractDomain();
63	jgs	115
64	jgs	82	/**
65			\brief
66	jgs	117	Destructor for AbstractDomain.
67	jgs	82
68			Description:
69	jgs	117	Destructor for AbstractDomain.
70	jgs	82	*/
71			virtual ~AbstractDomain();
72	jgs	115
73	jgs	82	/**
74			\brief
75			Returns true if the given integer is a valid function space type
76			for this domain.
77			*/
78			virtual bool isValidFunctionSpaceType(int functionSpaceType) const;
79	jgs	115
80	jgs	82	/**
81			\brief
82	jgs	117	Return a description for this domain.
83	jgs	82	*/
84			virtual std::string getDescription() const;
85	jgs	115
86	jgs	82	/**
87			\brief
88	jgs	117	Return a description for the given function space type code.
89	jgs	82	*/
90			virtual std::string functionSpaceTypeAsString(int functionSpaceType) const;
91	jgs	115
92	jgs	82	/**
93			\brief
94	jgs	117	Returns the spatial dimension of the domain.
95	jgs	115
96	jgs	117	This has to be implemented by the actual Domain adapter.
97	jgs	82	*/
98			virtual int getDim() const;
99
100			/**
101	jgs	117	\brief
102			Return true if given domains are equal.
103	jgs	82	*/
104	jgs	121	virtual bool operator==(const AbstractDomain& other) const;
105			virtual bool operator!=(const AbstractDomain& other) const;
106	jgs	115
107	jgs	82	/**
108			\brief
109	jgs	117	Writes the domain to an external file filename.
110
111	jgs	115	This has to be implemented by the actual Domain adapter.
112	jgs	82	*/
113			virtual void write(const std::string& filename) const;
114
115			/**
116			\brief
117			Return the number of data points per sample, and the number of samples as a pair.
118	jgs	117
119			This has to be implemented by the actual Domain adapter.
120
121	jgs	82	\param functionSpaceCode Input - Code for the function space type.
122			\return pair, first - number of data points per sample, second - number of samples
123			*/
124			virtual std::pair<int,int> getDataShape(int functionSpaceCode) const;
125
126			/**
127			\brief
128			Return the tag key for the given sample number.
129			\param functionSpaceType Input - The function space type.
130			\param sampleNo Input - The sample number.
131			*/
132			virtual int getTagFromSampleNo(int functionSpaceType, int sampleNo) const;
133	jgs	115
134	jgs	82	/**
135			\brief
136	jgs	115	Return the reference number of the given sample number.
137	jgs	110	\param functionSpaceType Input - The function space type.
138			\param sampleNo Input - The sample number.
139			*/
140			virtual int getReferenceNoFromSampleNo(int functionSpaceType, int sampleNo) const;
141	jgs	115
142	jgs	110	/**
143			\brief
144	jgs	117	Assigns new location to the domain.
145
146			This has to be implemented by the actual Domain adapter.
147	jgs	82	*/
148			virtual void setNewX(const escript::Data& arg);
149
150			/**
151			\brief
152	jgs	115	Interpolates data given on source onto target where source and target have to be given on the same domain.
153	jgs	117
154			This has to be implemented by the actual Domain adapter.
155	jgs	82	*/
156			virtual void interpolateOnDomain(escript::Data& target,const escript::Data& source) const;
157			virtual bool probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const;
158	jgs	115
159	jgs	82	/**
160			\brief
161	jgs	115	Interpolates data given on source onto target where source and target are given on different domains.
162	jgs	117
163			This has to be implemented by the actual Domain adapter.
164	jgs	82	*/
165			virtual void interpolateACross(escript::Data& target, const escript::Data& source) const;
166			virtual bool probeInterpolationACross(int functionSpaceType_source,const AbstractDomain& targetDomain, int functionSpaceType_target) const;
167
168			/**
169	jgs	117	\brief
170			Returns locations in the domain. The function space is chosen appropriately.
171	jgs	102	*/
172			virtual escript::Data getX() const;
173	jgs	115
174	jgs	102	/**
175	jgs	117	\brief
176			Return boundary normals. The function space is chosen appropriately.
177	jgs	102	*/
178			virtual escript::Data getNormal() const;
179	jgs	115
180	jgs	102	/**
181	jgs	117	\brief
182			Returns the local size of samples. The function space is chosen appropriately.
183	jgs	102	*/
184			virtual escript::Data getSize() const;
185
186			/**
187	jgs	82	\brief
188	jgs	115	Copies the location of data points on the domain into out.
189			The actual function space to be considered
190	jgs	82	is defined by out. out has to be defined on this.
191	jgs	117
192			This has to be implemented by the actual Domain adapter.
193	jgs	82	*/
194			virtual void setToX(escript::Data& out) const;
195	jgs	115
196	jgs	82	/**
197			\brief
198	jgs	115	Copies the surface normals at data points into out.
199			The actual function space to be considered
200	jgs	82	is defined by out. out has to be defined on this.
201	jgs	117
202			This has to be implemented by the actual Domain adapter.
203	jgs	82	*/
204			virtual void setToNormal(escript::Data& out) const;
205	jgs	115
206	jgs	82	/**
207			\brief
208	jgs	115	Copies the size of samples into out. The actual
209			function space to be considered
210	jgs	82	is defined by out. out has to be defined on this.
211	jgs	117
212			This has to be implemented by the actual Domain adapter.
213	jgs	82	*/
214			virtual void setToSize(escript::Data& out) const;
215
216			/**
217			\brief
218	jgs	115	Copies the gradient of arg into grad. The actual function space to be considered
219	jgs	82	for the gradient is defined by grad. arg and grad have to be defined on this.
220	jgs	117
221			This has to be implemented by the actual Domain adapter.
222	jgs	82	*/
223			virtual void setToGradient(escript::Data& grad, const escript::Data& arg) const;
224			/**
225			\brief
226	jgs	153	Saves a dictonary of Data objects to an OpenDX input file. The keywords are used as identifier
227	jgs	117
228			This has to be implemented by the actual Domain adapter.
229	jgs	82	*/
230	jgs	153	virtual void saveDX(const std::string& filename,const boost::python::dict& arg) const;
231	jgs	110
232	jgs	82	/**
233			\brief
234	jgs	153	Saves a dictonary of Data objects to an VTK XML input file. The keywords are used as identifier
235	jgs	117
236			This has to be implemented by the actual Domain adapter.
237	jgs	110	*/
238	jgs	153	virtual void saveVTK(const std::string& filename,const boost::python::dict& arg) const;
239	jgs	110
240			/**
241			\brief
242	jgs	82	returns the function space representation of the type functionSpaceCode on this domain
243			as a vtkObject.
244	jgs	117
245			This has to be implemented by the actual Domain adapter.
246	jgs	82	*/
247			//virtual vtkObject createVtkObject(int functionSpaceCode) const;
248
249	jgs	115	/**
250	jgs	82	\brief
251			returns true if data on this domain and a function space of type functionSpaceCode has to
252			considered as cell centered data.
253	jgs	117
254			This has to be implemented by the actual Domain adapter.
255	jgs	82	*/
256			virtual bool isCellOriented(int functionSpaceCode) const;
257
258	jgs	117	/**
259			\brief
260			Throw a standard exception. This function is called if any attempt
261			is made to use a base class function.
262			*/
263			void throwStandardException(const std::string& functionName) const;
264
265	jgs	82	protected:
266
267			private:
268	jgs	115
269	jgs	82	};
270
271			} // end of namespace
272	jgs	117
273	jgs	82	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision