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