escript/src/FunctionSpace.h


/*******************************************************
*
* Copyright (c) 2003-2009 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 escript_FunctionSpace_20040323_H
#define escript_FunctionSpace_20040323_H
#include "system_dep.h"

#include "AbstractDomain.h"
#include "NullDomain.h"

#include <string>
#include <list>

namespace escript {

//
// Forward declaration for class Data.
class Data;

/**
   \brief
   Give a short description of what FunctionSpace does.

   Description:
   Give a detailed description of FunctionSpace.

   Template Parameters:
   For templates describe any conditions that the parameters used in the
   template must satisfy.
*/

class FunctionSpace 
{
public:
  /**
     \brief
     Default constructor for FunctionSpace.

     Description:
     Default constructor for FunctionSpace
     Generates a function space with a null domain.

     Preconditions:
     Describe any preconditions.

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

  /**
     \brief
     Constructor for FunctionSpace.

     Description:
     Constructor for FunctionSpace.
  */
  ESCRIPT_DLL_API
  FunctionSpace(const_Domain_ptr domain,
                int functionSpaceType);


  ESCRIPT_DLL_API
  FunctionSpace(const FunctionSpace& other);

  /**
    \brief
    Return the function space type code.

    Note: The meaning of the code depends on the domain object the FunctionSpace is built on.
  */
  ESCRIPT_DLL_API
  int
  getTypeCode() const;

  /**
   \brief
   Return the function space domain.
  */
  ESCRIPT_DLL_API
//   const
//   AbstractDomain&
  const_Domain_ptr
  getDomain() const;

  /**
   \brief
   Return the function space domain.   
   Internal use only! This gets around some python difficulties by
   casting away the const. Do not use this in c++. 
  */
  ESCRIPT_DLL_API
//   const
//   AbstractDomain&
  Domain_ptr
  getDomainPython() const;


 /**
 \brief Checks if this functionspace support tags
 */
  ESCRIPT_DLL_API
  bool
  canTag() const;


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

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


  /**
   \brief
   Return the shape of the data needed to represent the function space.
  */
  ESCRIPT_DLL_API
  std::pair<int,int>
  getDataShape() const;

  /**
   \brief
   Comparison operator.
   Return true if function spaces are equal.
   ie: Same domain and same function space type.
  */
  ESCRIPT_DLL_API
  bool
  operator==(const FunctionSpace& other) const;

  ESCRIPT_DLL_API
  bool
  operator!=(const FunctionSpace& other) const;

  /**
   \brief
   Return a text description of the function space.
  */
  ESCRIPT_DLL_API
  std::string
  toString() const;

   //#define DEBUG_PY_STRINGS

#ifdef DEBUG_PY_STRINGS
  /**
   \brief
   Return a text description of the function space
   as a python string.
   NOTE: This code was used to debug a conversion of
   std::string to python string problem on windows. 
   An alternative approach was sought.
  */
  ESCRIPT_DLL_API
  PyObject *
  toPyString() const;
#endif

  /**
   \brief
   Return the tag associated with the given sample number.
  */
  ESCRIPT_DLL_API
  int
  getTagFromSampleNo(int sampleNo) const;

  /**
   \brief
   Return the tag associated with the given data-point number.
  */
  ESCRIPT_DLL_API
  int
  getTagFromDataPointNo(int dataPointNo) const;

  /**
   \brief
   Return the reference number associated with the given data-point number.
  */
  ESCRIPT_DLL_API
  int getReferenceIDFromDataPointNo(int dataPointNo) const;

  /**
   \brief
   Return the reference number associated with the given sample number.
   This function is not efficient. It is better to first call 
   borrowSampleReferenceIDs and then when iterating over sampleNo to use sampleNo as an offset.
  */
  ESCRIPT_DLL_API
  inline
  int
  getReferenceIDOfSample(int sampleNo) const
  {
      return borrowSampleReferenceIDs()[sampleNo];
  }


  ESCRIPT_DLL_API
  inline
  bool 
  ownSample(int sampleNo) const
  {
      return m_domain->ownSample(m_functionSpaceType, sampleNo);
  }

  /**
   \brief
   Return a borrowed reference to the list of sample reference IDs
  */
  ESCRIPT_DLL_API
  const int*
  borrowSampleReferenceIDs() const;

  /**
   \brief
   Return the spatial locations of the data points.
  */
  ESCRIPT_DLL_API
  escript::Data
  getX() const;
 
  /**
   \brief
   Return the surface normal field.
  */
  ESCRIPT_DLL_API
  escript::Data
  getNormal() const;

  /**
   \brief
   Return the sample size (e.g. the diameter of elements, radius of particles).
  */
  ESCRIPT_DLL_API
  escript::Data
  getSize() const;

  /**
   \brief
   Return the number of samples.
  */
  ESCRIPT_DLL_API
  inline
  int
  getNumSamples() const {
     return getDataShape().second;
  }

  /**
   \brief
   Return the number of data points per sample.
  */
  ESCRIPT_DLL_API
  inline
  int
  getNumDPPSample() const {
     return getNumDataPointsPerSample();
  }

  ESCRIPT_DLL_API
  inline
  int
  getNumDataPointsPerSample() const {
     return getDataShape().first;
  }

  /**
   \brief
   Return the spatial dimension of the underlying domain.
  */
  ESCRIPT_DLL_API
  inline
  int
  getDim() const {
      return getDomain()->getDim();
  }
  /**
   \brief
   Returns a list of the tags used in this function space
  */
  ESCRIPT_DLL_API
  boost::python::list
  getListOfTags() const;
  /**
   \brief
   Returns an stl::list of the tags used in this function space
  */
  ESCRIPT_DLL_API
  std::list<int>
  getListOfTagsSTL() const;

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

  ESCRIPT_DLL_API
  const int* borrowListOfTagsInUse() const;

  ESCRIPT_DLL_API
  bool
  probeInterpolation(const FunctionSpace& other) const
  {
    if (*this==other) {
      return true;
    } else {
      const_Domain_ptr domain=getDomain();
      if  (*domain==*other.getDomain()) {
        return domain->probeInterpolationOnDomain(getTypeCode(),other.getTypeCode());
      } else {
        return domain->probeInterpolationACross(getTypeCode(),*(other.getDomain()),other.getTypeCode());
      }
    }
  }


 protected:

 private:
  /**
   \brief
   Assignment operator. 
   This method is only defined (private) to prevent people from using it.
  */
  ESCRIPT_DLL_API
  FunctionSpace&
  operator=(const FunctionSpace& other);

  //
  // function space domain
  
//   const AbstractDomain*  m_domain;
   const_Domain_ptr m_domain;


  //
  // function space type code.
  int m_functionSpaceType;

};

} // end of namespace

#endif
1
2	/*******************************************************
3	*
4	* Copyright (c) 2003-2009 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 escript_FunctionSpace_20040323_H
16	#define escript_FunctionSpace_20040323_H
17	#include "system_dep.h"
18
19	#include "AbstractDomain.h"
20	#include "NullDomain.h"
21
22	#include <string>
23	#include <list>
24
25	namespace escript {
26
27	//
28	// Forward declaration for class Data.
29	class Data;
30
31	/**
32	\brief
33	Give a short description of what FunctionSpace does.
34
35	Description:
36	Give a detailed description of FunctionSpace.
37
38	Template Parameters:
39	For templates describe any conditions that the parameters used in the
40	template must satisfy.
41	*/
42
43	class FunctionSpace
44	{
45	public:
46	/**
47	\brief
48	Default constructor for FunctionSpace.
49
50	Description:
51	Default constructor for FunctionSpace
52	Generates a function space with a null domain.
53
54	Preconditions:
55	Describe any preconditions.
56
57	Throws:
58	Describe any exceptions thrown.
59	*/
60	ESCRIPT_DLL_API
61	FunctionSpace();
62
63	/**
64	\brief
65	Constructor for FunctionSpace.
66
67	Description:
68	Constructor for FunctionSpace.
69	*/
70	ESCRIPT_DLL_API
71	FunctionSpace(const_Domain_ptr domain,
72	int functionSpaceType);
73
74
75	ESCRIPT_DLL_API
76	FunctionSpace(const FunctionSpace& other);
77
78	/**
79	\brief
80	Return the function space type code.
81
82	Note: The meaning of the code depends on the domain object the FunctionSpace is built on.
83	*/
84	ESCRIPT_DLL_API
85	int
86	getTypeCode() const;
87
88	/**
89	\brief
90	Return the function space domain.
91	*/
92	ESCRIPT_DLL_API
93	// const
94	// AbstractDomain&
95	const_Domain_ptr
96	getDomain() const;
97
98	/**
99	\brief
100	Return the function space domain.
101	Internal use only! This gets around some python difficulties by
102	casting away the const. Do not use this in c++.
103	*/
104	ESCRIPT_DLL_API
105	// const
106	// AbstractDomain&
107	Domain_ptr
108	getDomainPython() const;
109
110
111
112	/**
113	\brief Checks if this functionspace support tags
114	*/
115	ESCRIPT_DLL_API
116	bool
117	canTag() const;
118
119
120	/**
121	\brief assigns new tag newTag to all samples with a positive
122	value of mask for any its sample point.
123
124	*/
125	ESCRIPT_DLL_API
126	void setTags(const int newTag, const escript::Data& mask) const;
127
128
129	/**
130	\brief
131	Return the shape of the data needed to represent the function space.
132	*/
133	ESCRIPT_DLL_API
134	std::pair<int,int>
135	getDataShape() const;
136
137	/**
138	\brief
139	Comparison operator.
140	Return true if function spaces are equal.
141	ie: Same domain and same function space type.
142	*/
143	ESCRIPT_DLL_API
144	bool
145	operator==(const FunctionSpace& other) const;
146
147	ESCRIPT_DLL_API
148	bool
149	operator!=(const FunctionSpace& other) const;
150
151	/**
152	\brief
153	Return a text description of the function space.
154	*/
155	ESCRIPT_DLL_API
156	std::string
157	toString() const;
158
159	//#define DEBUG_PY_STRINGS
160
161	#ifdef DEBUG_PY_STRINGS
162	/**
163	\brief
164	Return a text description of the function space
165	as a python string.
166	NOTE: This code was used to debug a conversion of
167	std::string to python string problem on windows.
168	An alternative approach was sought.
169	*/
170	ESCRIPT_DLL_API
171	PyObject *
172	toPyString() const;
173	#endif
174
175	/**
176	\brief
177	Return the tag associated with the given sample number.
178	*/
179	ESCRIPT_DLL_API
180	int
181	getTagFromSampleNo(int sampleNo) const;
182
183	/**
184	\brief
185	Return the tag associated with the given data-point number.
186	*/
187	ESCRIPT_DLL_API
188	int
189	getTagFromDataPointNo(int dataPointNo) const;
190
191	/**
192	\brief
193	Return the reference number associated with the given data-point number.
194	*/
195	ESCRIPT_DLL_API
196	int getReferenceIDFromDataPointNo(int dataPointNo) const;
197
198	/**
199	\brief
200	Return the reference number associated with the given sample number.
201	This function is not efficient. It is better to first call
202	borrowSampleReferenceIDs and then when iterating over sampleNo to use sampleNo as an offset.
203	*/
204	ESCRIPT_DLL_API
205	inline
206	int
207	getReferenceIDOfSample(int sampleNo) const
208	{
209	return borrowSampleReferenceIDs()[sampleNo];
210	}
211
212
213	ESCRIPT_DLL_API
214	inline
215	bool
216	ownSample(int sampleNo) const
217	{
218	return m_domain->ownSample(m_functionSpaceType, sampleNo);
219	}
220
221	/**
222	\brief
223	Return a borrowed reference to the list of sample reference IDs
224	*/
225	ESCRIPT_DLL_API
226	const int*
227	borrowSampleReferenceIDs() const;
228
229	/**
230	\brief
231	Return the spatial locations of the data points.
232	*/
233	ESCRIPT_DLL_API
234	escript::Data
235	getX() const;
236
237	/**
238	\brief
239	Return the surface normal field.
240	*/
241	ESCRIPT_DLL_API
242	escript::Data
243	getNormal() const;
244
245	/**
246	\brief
247	Return the sample size (e.g. the diameter of elements, radius of particles).
248	*/
249	ESCRIPT_DLL_API
250	escript::Data
251	getSize() const;
252
253	/**
254	\brief
255	Return the number of samples.
256	*/
257	ESCRIPT_DLL_API
258	inline
259	int
260	getNumSamples() const {
261	return getDataShape().second;
262	}
263
264	/**
265	\brief
266	Return the number of data points per sample.
267	*/
268	ESCRIPT_DLL_API
269	inline
270	int
271	getNumDPPSample() const {
272	return getNumDataPointsPerSample();
273	}
274
275	ESCRIPT_DLL_API
276	inline
277	int
278	getNumDataPointsPerSample() const {
279	return getDataShape().first;
280	}
281
282	/**
283	\brief
284	Return the spatial dimension of the underlying domain.
285	*/
286	ESCRIPT_DLL_API
287	inline
288	int
289	getDim() const {
290	return getDomain()->getDim();
291	}
292	/**
293	\brief
294	Returns a list of the tags used in this function space
295	*/
296	ESCRIPT_DLL_API
297	boost::python::list
298	getListOfTags() const;
299	/**
300	\brief
301	Returns an stl::list of the tags used in this function space
302	*/
303	ESCRIPT_DLL_API
304	std::list<int>
305	getListOfTagsSTL() const;
306
307	/**
308	\brief
309	return the number of tags in use and a pointer to an array with the number of tags in use
310	*/
311	ESCRIPT_DLL_API
312	int getNumberOfTagsInUse() const;
313
314	ESCRIPT_DLL_API
315	const int* borrowListOfTagsInUse() const;
316
317	ESCRIPT_DLL_API
318	bool
319	probeInterpolation(const FunctionSpace& other) const
320	{
321	if (*this==other) {
322	return true;
323	} else {
324	const_Domain_ptr domain=getDomain();
325	if (domain==other.getDomain()) {
326	return domain->probeInterpolationOnDomain(getTypeCode(),other.getTypeCode());
327	} else {
328	return domain->probeInterpolationACross(getTypeCode(),*(other.getDomain()),other.getTypeCode());
329	}
330	}
331	}
332
333
334	protected:
335
336	private:
337	/**
338	\brief
339	Assignment operator.
340	This method is only defined (private) to prevent people from using it.
341	*/
342	ESCRIPT_DLL_API
343	FunctionSpace&
344	operator=(const FunctionSpace& other);
345
346	//
347	// function space domain
348
349	// const AbstractDomain* m_domain;
350	const_Domain_ptr m_domain;
351
352
353	//
354	// function space type code.
355	int m_functionSpaceType;
356
357	};
358
359	} // end of namespace
360
361	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision