escript/src/DataAbstract.h

/* $Id$ */

/*******************************************************
 *
 *           Copyright 2003-2007 by ACceSS MNRF
 *       Copyright 2007 by University of Queensland
 *
 *                http://esscc.uq.edu.au
 *        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_DataAbstract_20040315_H
#define escript_DataAbstract_20040315_H
#include "system_dep.h"

#include "DataArrayView.h"
#include "FunctionSpace.h"

#include <boost/scoped_ptr.hpp>
#include <boost/python/numeric.hpp>

#include <string>
#include <fstream>

namespace escript {

/**
   \brief
   DataAbstract provides an abstract interface for the class of containers
   which hold ESyS data.

   Description:
   DataAbstract provides an abstract interface for the class of containers
   which hold ESyS data. The container may be thought of as a 2 dimensional
   array of data points where one dimension corresponds to the number of samples
   and the other to the number of data points per sample as defined by the function
   space associated with each Data object. The data points themselves are arrays of
   doubles of rank 0-4.
*/

class DataAbstract {

 public:

  typedef DataArrayView::ValueType ValueType;
  typedef DataArrayView::ShapeType ShapeType;

  /**
     \brief
     Constructor for DataAbstract.

     Description:
     Constructor for DataAbstract.

     \param what - Input - A description of what this data represents.
  */
  ESCRIPT_DLL_API
  DataAbstract(const FunctionSpace& what);

  /**
    \brief
    Destructor for DataAbstract.
  */
  ESCRIPT_DLL_API
  virtual
  ~DataAbstract();

  /**
     \brief
     Write the data as a string.
  */
  ESCRIPT_DLL_API
  virtual
  std::string
  toString() const = 0;

 /**
     \brief
     dumps the object into a netCDF file
  */
  ESCRIPT_DLL_API
  virtual
  void
  dump(const std::string fileName) const;

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

  /**
     \brief
     Return the number of samples.
  */
  ESCRIPT_DLL_API
  int
  getNumSamples() const;

  /**
     \brief
     Return the DataArrayView of the point data. This essentially contains
     the shape information for each data point although it also may be used
     to manipulate the point data.
  */
  ESCRIPT_DLL_API
  DataArrayView&
  getPointDataView();

  ESCRIPT_DLL_API
  const DataArrayView&
  getPointDataView() const;

  /**
     \brief
     Return the offset for the given sample. This returns the offset for the given
     point into the container holding the point data. Only really necessary to
     avoid creating many DataArrayView objects.

     \param sampleNo - Input - sample number.
     \param dataPointNo - Input - data point number.
   */
  ESCRIPT_DLL_API
  virtual
  ValueType::size_type
  getPointOffset(int sampleNo,
                 int dataPointNo) const = 0;

  /**
     \brief
     Return the sample data for the given sample number.
  */
  ESCRIPT_DLL_API
  double*
  getSampleData(ValueType::size_type sampleNo);

  /**
     \brief
     Return the number of doubles stored for this Data object.
  */
  ESCRIPT_DLL_API
  virtual
  ValueType::size_type
  getLength() const = 0;

  /**
     \brief
     Return the sample data for the given tag key.
     NB: If the data isn't tagged an exception will be thrown.
  */
  ESCRIPT_DLL_API
  virtual
  double*
  getSampleDataByTag(int tag);


  /**
     \brief
     Check this and the given RHS operands are compatible. Throws
     an exception if they aren't.

     \param right - Input - The right hand side.
  */
  ESCRIPT_DLL_API
  void
  operandCheck(const DataAbstract& right) const;

  /**
     \brief
     Return true if a valid sample point number.
  */
  ESCRIPT_DLL_API
  bool
  validSamplePointNo(int samplePointNo) const;

  /**
     \brief
     Return true if a valid sample number.
  */
  ESCRIPT_DLL_API
  bool
  validSampleNo(int sampleNo) const;

  /**
     \brief
     Return a view into the data for the data point specified.
     NOTE: Construction of the DataArrayView is a relatively expensive
     operation.

     \param sampleNo - Input - the sample number.
     \param dataPointNo - Input - the data point number.
  */
  ESCRIPT_DLL_API
  virtual
  DataArrayView
  getDataPoint(int sampleNo,
               int dataPointNo) = 0;

  /**
     \brief
     Return the function space associated with this Data object.
  */
  ESCRIPT_DLL_API
  const
  FunctionSpace&
  getFunctionSpace() const;

  /**
     \brief
     Return the given slice from this object.

     NB: The caller is responsible for managing the object created.
  */
  ESCRIPT_DLL_API
  virtual
  DataAbstract*
  getSlice(const DataArrayView::RegionType& region) const = 0;

  /**
     \brief
     Copy the specified region from the given object.

     \param value - Input - Data to copy from
     \param region - Input - Region to copy.
  */
  ESCRIPT_DLL_API
  virtual
  void
  setSlice(const DataAbstract* value,
           const DataArrayView::RegionType& region) = 0;


  /**
     \brief
     setTaggedValue

     Description:
     Assign the given value to the given tag.

     NB: If the data isn't tagged an exception will be thrown.

     \param tagKey - Input - Integer key.
     \param value - Input - Single DataArrayView value to be assigned to the tag.
  */
  ESCRIPT_DLL_API
  virtual
  void
  setTaggedValue(int tagKey,
                 const DataArrayView& value);

  /**
    \brief
    Archive the underlying data values to the file referenced
    by ofstream. A count of the number of values expected to be written
    is provided as a cross-check.

    The return value indicates success (0) or otherwise (1).
  */
  ESCRIPT_DLL_API
  virtual
  int
  archiveData(std::ofstream& archiveFile,
              const ValueType::size_type noValues) const;

  /**
    \brief
    Extract the number of values specified by noValues from the file
    referenced by ifstream to the underlying data structure.

    The return value indicates success (0) or otherwise (1).
  */
  ESCRIPT_DLL_API
  virtual
  int
  extractData(std::ifstream& archiveFile,
              const ValueType::size_type noValues);

  /**
     \brief
     Copy the numarray object to the data points in this object.

     Description:
     Copy the numarray object to the data points in this object.

     \param value Input - new values for the data points
  */
  ESCRIPT_DLL_API
  virtual void
  copyAll(const boost::python::numeric::array& value);

  /**
     \brief
     Copy a double value to the data point dataPointNo of sample sampleNo in this object.

     Description:
     Copy a double value to the data point dataPointNo of sample sampleNo in this object.

     \param sampleNo Input - sample number
     \param dataPointNo Input - data point of the sample
     \param value Input - new values for the data point
  */
  ESCRIPT_DLL_API
  virtual void
  copyToDataPoint(const int sampleNo, const int dataPointNo, const double value);

  /**
     \brief
     Copy the numarray object to the data point dataPointNo of sample sampleNo in this object.

     Description:
     Copy the numarray object to the data point dataPointNo of sample sampleNo in this object.

     \param sampleNo Input - sample number
     \param dataPointNo Input - data point of the sample
     \param value Input - new values for the data point
  */
  ESCRIPT_DLL_API
  virtual void
  copyToDataPoint(const int sampleNo, const int dataPointNo, const boost::python::numeric::array& value);


  /**
     \brief
     Return the tag number associated with the given data-point number.

     If the object cannot be referenced by tag numbers, an exception
     will be thrown.
  */
  ESCRIPT_DLL_API
  virtual
  int
  getTagNumber(int dpno);

  /**
     \brief
     Computes a symmetric matrix (A + AT) / 2

     \param ev - Output - a symmetric matrix

  */
  ESCRIPT_DLL_API
  virtual void
  symmetric(DataAbstract* ev);

  /**
     \brief
     Computes a nonsymmetric matrix (A - AT) / 2

     \param ev - Output - a nonsymmetric matrix

  */
  ESCRIPT_DLL_API
  virtual void
  nonsymmetric(DataAbstract* ev);

  /**
     \brief
     Computes the trace of a matrix

     \param ev - Output - the trace of a matrix

  */
  ESCRIPT_DLL_API
  virtual void
  trace(DataAbstract* ev, int axis_offset);

  /**
     \brief
     Transpose each data point of this Data object around the given axis.

     \param ev - Output - the transpose of a matrix

  */
  ESCRIPT_DLL_API
  virtual void
  transpose(DataAbstract* ev, int axis_offset);

  /**
     \brief
     swaps components axis0 and axis1

     \param ev - Output - swapped components

  */
  ESCRIPT_DLL_API
  virtual void
  swapaxes(DataAbstract* ev, int axis0, int axis1);
  /**
     \brief
     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev

     \param ev - Output - eigenvalues in increasing order at each data point

  */
  ESCRIPT_DLL_API
  virtual void
  eigenvalues(DataAbstract* ev);

  /**
     \brief
     sets values to zero

  */
  ESCRIPT_DLL_API
  virtual void
  setToZero();

  /**
     \brief
     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V

     \param ev - Output - eigenvalues in increasing order at each data point
     \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
                         and the first nonzero component is positive.
     \param tol - Input - eigenvalue with relative distance tol are treated as equal.

  */

  ESCRIPT_DLL_API
  virtual void
  eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);

  /**
     \brief
     reorders data sample ordered by reference_ids to the ordering of the functions space

     \param reference_ids - Input - reference_ids used for current ordering
  */
  ESCRIPT_DLL_API
  virtual void
  reorderByReferenceIDs(int *reference_ids);

 protected:

  /**
     \brief
     Set the pointDataView DataArrayView associated with this object.

     \param input - Input - The point data view. DataAbstract takes ownership
     of the DataArrayView provided. It will delete it when it is destructed.
  */
  ESCRIPT_DLL_API
  void
  setPointDataView(const DataArrayView& input);

  ESCRIPT_DLL_API
  void
  resetPointDataView();


 private:

  //
  // The number of samples in this Data object.
  // This is derived directly from the FunctionSpace.
  int m_noSamples;

  //
  // The number of data points per sample in this Data object.
  // This is derived directly from the FunctionSpace.
  int m_noDataPointsPerSample;

  //
  // The DataArrayView of the data array associated with this object.
  // The data array is defined only in child classes of this class, it
  // is not defined in this abstract parent class.
  boost::scoped_ptr<DataArrayView> m_pointDataView;

  //
  // A FunctionSpace which provides a description of the data associated
  // with this Data object.
  FunctionSpace m_functionSpace;

};

inline
bool
DataAbstract::validSamplePointNo(int samplePointNo) const
{
  return ((0 <= samplePointNo) && (samplePointNo < m_noDataPointsPerSample));
}

inline
bool
DataAbstract::validSampleNo(int sampleNo) const
{
  return ((0 <= sampleNo) && (sampleNo < m_noSamples));
}

inline
DataAbstract::ValueType::value_type*
DataAbstract::getSampleData(ValueType::size_type sampleNo)
{
  return &(m_pointDataView->getData(getPointOffset(sampleNo,0)));
}

inline
int
DataAbstract::getNumDPPSample() const
{
  return m_noDataPointsPerSample;
}

inline
int
DataAbstract::getNumSamples() const
{
  return m_noSamples;
}

inline
const
FunctionSpace&
DataAbstract::getFunctionSpace() const
{
  return m_functionSpace;
}

inline
const
DataArrayView&
DataAbstract::getPointDataView() const
{
  return *(m_pointDataView.get());
}

inline
DataArrayView&
DataAbstract::getPointDataView()
{
  return *(m_pointDataView.get());
}
} // end of namespace

#endif
1	ksteube	1312	/* $Id$ */
2	jgs	478
3	ksteube	1312	/*******************************************************
4			*
5			* Copyright 2003-2007 by ACceSS MNRF
6			* Copyright 2007 by University of Queensland
7			*
8			* http://esscc.uq.edu.au
9			* Primary Business: Queensland, Australia
10			* Licensed under the Open Software License version 3.0
11			* http://www.opensource.org/licenses/osl-3.0.php
12			*
13			*******************************************************/
14
15	jgs	106	#if !defined escript_DataAbstract_20040315_H
16	jgs	82	#define escript_DataAbstract_20040315_H
17	woo409	757	#include "system_dep.h"
18	jgs	82
19	jgs	474	#include "DataArrayView.h"
20			#include "FunctionSpace.h"
21	jgs	82
22			#include <boost/scoped_ptr.hpp>
23	jgs	478	#include <boost/python/numeric.hpp>
24	jgs	480
25	jgs	82	#include <string>
26	jgs	480	#include <fstream>
27	jgs	82
28			namespace escript {
29
30			/**
31			\brief
32	jgs	117	DataAbstract provides an abstract interface for the class of containers
33	matt	1325	which hold ESyS data.
34	jgs	82
35			Description:
36	jgs	117	DataAbstract provides an abstract interface for the class of containers
37	jgs	82	which hold ESyS data. The container may be thought of as a 2 dimensional
38	jgs	117	array of data points where one dimension corresponds to the number of samples
39			and the other to the number of data points per sample as defined by the function
40			space associated with each Data object. The data points themselves are arrays of
41			doubles of rank 0-4.
42	jgs	82	*/
43
44			class DataAbstract {
45
46			public:
47
48			typedef DataArrayView::ValueType ValueType;
49			typedef DataArrayView::ShapeType ShapeType;
50
51			/**
52			\brief
53			Constructor for DataAbstract.
54
55			Description:
56			Constructor for DataAbstract.
57	jgs	117
58	jgs	82	\param what - Input - A description of what this data represents.
59			*/
60	woo409	757	ESCRIPT_DLL_API
61	jgs	82	DataAbstract(const FunctionSpace& what);
62
63			/**
64			\brief
65			Destructor for DataAbstract.
66			*/
67	woo409	757	ESCRIPT_DLL_API
68	jgs	106	virtual
69			~DataAbstract();
70	jgs	82
71			/**
72			\brief
73			Write the data as a string.
74			*/
75	woo409	757	ESCRIPT_DLL_API
76	jgs	82	virtual
77			std::string
78			toString() const = 0;
79
80	gross	950	/**
81			\brief
82			dumps the object into a netCDF file
83			*/
84			ESCRIPT_DLL_API
85			virtual
86			void
87			dump(const std::string fileName) const;
88
89	jgs	82	/**
90			\brief
91			Return the number of data points per sample.
92			*/
93	woo409	757	ESCRIPT_DLL_API
94	jgs	82	int
95			getNumDPPSample() const;
96
97			/**
98			\brief
99			Return the number of samples.
100			*/
101	woo409	757	ESCRIPT_DLL_API
102	jgs	82	int
103			getNumSamples() const;
104
105			/**
106			\brief
107	matt	1325	Return the DataArrayView of the point data. This essentially contains
108	jgs	82	the shape information for each data point although it also may be used
109			to manipulate the point data.
110			*/
111	woo409	757	ESCRIPT_DLL_API
112	jgs	117	DataArrayView&
113			getPointDataView();
114
115	woo409	757	ESCRIPT_DLL_API
116	jgs	82	const DataArrayView&
117			getPointDataView() const;
118
119			/**
120			\brief
121	jgs	117	Return the offset for the given sample. This returns the offset for the given
122			point into the container holding the point data. Only really necessary to
123			avoid creating many DataArrayView objects.
124
125	jgs	82	\param sampleNo - Input - sample number.
126	jgs	117	\param dataPointNo - Input - data point number.
127	jgs	82	*/
128	woo409	757	ESCRIPT_DLL_API
129	jgs	82	virtual
130			ValueType::size_type
131			getPointOffset(int sampleNo,
132			int dataPointNo) const = 0;
133
134			/**
135			\brief
136	jgs	117	Return the sample data for the given sample number.
137	jgs	82	*/
138	woo409	757	ESCRIPT_DLL_API
139	jgs	82	double*
140			getSampleData(ValueType::size_type sampleNo);
141
142			/**
143			\brief
144	jgs	117	Return the number of doubles stored for this Data object.
145	jgs	82	*/
146	woo409	757	ESCRIPT_DLL_API
147	jgs	82	virtual
148			ValueType::size_type
149			getLength() const = 0;
150
151			/**
152			\brief
153			Return the sample data for the given tag key.
154			NB: If the data isn't tagged an exception will be thrown.
155			*/
156	woo409	757	ESCRIPT_DLL_API
157	jgs	82	virtual
158			double*
159			getSampleDataByTag(int tag);
160
161	jgs	110
162			/**
163			\brief
164	jgs	117	Check this and the given RHS operands are compatible. Throws
165	jgs	82	an exception if they aren't.
166	jgs	117
167	jgs	82	\param right - Input - The right hand side.
168			*/
169	woo409	757	ESCRIPT_DLL_API
170	jgs	82	void
171			operandCheck(const DataAbstract& right) const;
172
173			/**
174			\brief
175			Return true if a valid sample point number.
176			*/
177	woo409	757	ESCRIPT_DLL_API
178	jgs	82	bool
179			validSamplePointNo(int samplePointNo) const;
180
181			/**
182			\brief
183	jgs	117	Return true if a valid sample number.
184	jgs	82	*/
185	woo409	757	ESCRIPT_DLL_API
186	jgs	82	bool
187			validSampleNo(int sampleNo) const;
188	matt	1325
189	jgs	82	/**
190			\brief
191			Return a view into the data for the data point specified.
192	matt	1325	NOTE: Construction of the DataArrayView is a relatively expensive
193	jgs	82	operation.
194	jgs	117
195			\param sampleNo - Input - the sample number.
196			\param dataPointNo - Input - the data point number.
197	jgs	82	*/
198	woo409	757	ESCRIPT_DLL_API
199	jgs	82	virtual
200	jgs	106	DataArrayView
201	jgs	117	getDataPoint(int sampleNo,
202	jgs	106	int dataPointNo) = 0;
203	jgs	82
204			/**
205			\brief
206	jgs	117	Return the function space associated with this Data object.
207	jgs	82	*/
208	woo409	757	ESCRIPT_DLL_API
209	jgs	117	const
210			FunctionSpace&
211	jgs	82	getFunctionSpace() const;
212
213			/**
214			\brief
215	jgs	117	Return the given slice from this object.
216
217			NB: The caller is responsible for managing the object created.
218	jgs	82	*/
219	woo409	757	ESCRIPT_DLL_API
220	jgs	82	virtual
221			DataAbstract*
222			getSlice(const DataArrayView::RegionType& region) const = 0;
223
224			/**
225			\brief
226	jgs	117	Copy the specified region from the given object.
227
228	jgs	82	\param value - Input - Data to copy from
229			\param region - Input - Region to copy.
230			*/
231	woo409	757	ESCRIPT_DLL_API
232	jgs	82	virtual
233			void
234			setSlice(const DataAbstract* value,
235			const DataArrayView::RegionType& region) = 0;
236
237
238			/**
239			\brief
240			setTaggedValue
241	matt	1325
242	jgs	82	Description:
243			Assign the given value to the given tag.
244	jgs	117
245			NB: If the data isn't tagged an exception will be thrown.
246
247	jgs	82	\param tagKey - Input - Integer key.
248			\param value - Input - Single DataArrayView value to be assigned to the tag.
249			*/
250	woo409	757	ESCRIPT_DLL_API
251	jgs	82	virtual
252			void
253			setTaggedValue(int tagKey,
254			const DataArrayView& value);
255
256	jgs	123	/**
257			\brief
258			Archive the underlying data values to the file referenced
259			by ofstream. A count of the number of values expected to be written
260			is provided as a cross-check.
261
262			The return value indicates success (0) or otherwise (1).
263			*/
264	woo409	757	ESCRIPT_DLL_API
265	jgs	123	virtual
266			int
267			archiveData(std::ofstream& archiveFile,
268			const ValueType::size_type noValues) const;
269
270			/**
271			\brief
272			Extract the number of values specified by noValues from the file
273			referenced by ifstream to the underlying data structure.
274
275			The return value indicates success (0) or otherwise (1).
276			*/
277	woo409	757	ESCRIPT_DLL_API
278	jgs	123	virtual
279			int
280			extractData(std::ifstream& archiveFile,
281			const ValueType::size_type noValues);
282
283	jgs	126	/**
284			\brief
285			Copy the numarray object to the data points in this object.
286
287			Description:
288			Copy the numarray object to the data points in this object.
289
290			\param value Input - new values for the data points
291			*/
292	woo409	757	ESCRIPT_DLL_API
293	jgs	126	virtual void
294			copyAll(const boost::python::numeric::array& value);
295
296	jgs	149	/**
297			\brief
298	gross	922	Copy a double value to the data point dataPointNo of sample sampleNo in this object.
299
300			Description:
301			Copy a double value to the data point dataPointNo of sample sampleNo in this object.
302
303			\param sampleNo Input - sample number
304			\param dataPointNo Input - data point of the sample
305			\param value Input - new values for the data point
306			*/
307			ESCRIPT_DLL_API
308			virtual void
309			copyToDataPoint(const int sampleNo, const int dataPointNo, const double value);
310
311			/**
312			\brief
313	gross	921	Copy the numarray object to the data point dataPointNo of sample sampleNo in this object.
314
315			Description:
316			Copy the numarray object to the data point dataPointNo of sample sampleNo in this object.
317
318			\param sampleNo Input - sample number
319			\param dataPointNo Input - data point of the sample
320			\param value Input - new values for the data point
321			*/
322			ESCRIPT_DLL_API
323			virtual void
324			copyToDataPoint(const int sampleNo, const int dataPointNo, const boost::python::numeric::array& value);
325
326
327			/**
328			\brief
329	jgs	149	Return the tag number associated with the given data-point number.
330	jgs	126
331	jgs	149	If the object cannot be referenced by tag numbers, an exception
332			will be thrown.
333			*/
334	woo409	757	ESCRIPT_DLL_API
335	jgs	149	virtual
336			int
337			getTagNumber(int dpno);
338
339	gross	576	/**
340			\brief
341	ksteube	775	Computes a symmetric matrix (A + AT) / 2
342
343			\param ev - Output - a symmetric matrix
344
345			*/
346	gross	800	ESCRIPT_DLL_API
347	ksteube	775	virtual void
348			symmetric(DataAbstract* ev);
349
350			/**
351			\brief
352			Computes a nonsymmetric matrix (A - AT) / 2
353
354			\param ev - Output - a nonsymmetric matrix
355
356			*/
357	gross	800	ESCRIPT_DLL_API
358	ksteube	775	virtual void
359			nonsymmetric(DataAbstract* ev);
360
361			/**
362			\brief
363			Computes the trace of a matrix
364
365			\param ev - Output - the trace of a matrix
366
367			*/
368	gross	800	ESCRIPT_DLL_API
369	ksteube	775	virtual void
370	gross	800	trace(DataAbstract* ev, int axis_offset);
371	ksteube	775
372			/**
373			\brief
374			Transpose each data point of this Data object around the given axis.
375
376			\param ev - Output - the transpose of a matrix
377
378			*/
379	gross	800	ESCRIPT_DLL_API
380	ksteube	775	virtual void
381			transpose(DataAbstract* ev, int axis_offset);
382
383			/**
384			\brief
385	gross	804	swaps components axis0 and axis1
386	gross	800
387			\param ev - Output - swapped components
388
389			*/
390			ESCRIPT_DLL_API
391			virtual void
392	gross	804	swapaxes(DataAbstract* ev, int axis0, int axis1);
393	gross	800	/**
394			\brief
395	gross	576	solves the eigenvalue problem thisV=evV for the eigenvalues ev
396
397			\param ev - Output - eigenvalues in increasing order at each data point
398
399			*/
400	woo409	757	ESCRIPT_DLL_API
401	gross	576	virtual void
402			eigenvalues(DataAbstract* ev);
403
404			/**
405			\brief
406	gross	1118	sets values to zero
407
408			*/
409			ESCRIPT_DLL_API
410			virtual void
411			setToZero();
412
413			/**
414			\brief
415	gross	576	solves the eigenvalue problem thisV=evV for the eigenvalues ev and eigenvectors V
416
417			\param ev - Output - eigenvalues in increasing order at each data point
418			\param V - Output - corresponding eigenvectors. They are normalized such that their length is one
419			and the first nonzero component is positive.
420			\param tol - Input - eigenvalue with relative distance tol are treated as equal.
421
422			*/
423
424	woo409	757	ESCRIPT_DLL_API
425	gross	576	virtual void
426			eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
427
428	gross	1487	/**
429			\brief
430			reorders data sample ordered by reference_ids to the ordering of the functions space
431
432			\param reference_ids - Input - reference_ids used for current ordering
433			*/
434			ESCRIPT_DLL_API
435			virtual void
436			reorderByReferenceIDs(int *reference_ids);
437
438	jgs	82	protected:
439
440			/**
441			\brief
442	jgs	117	Set the pointDataView DataArrayView associated with this object.
443
444	jgs	121	\param input - Input - The point data view. DataAbstract takes ownership
445	jgs	82	of the DataArrayView provided. It will delete it when it is destructed.
446			*/
447	woo409	757	ESCRIPT_DLL_API
448	jgs	82	void
449			setPointDataView(const DataArrayView& input);
450
451	woo409	757	ESCRIPT_DLL_API
452	jgs	119	void
453			resetPointDataView();
454
455	gross	1487
456
457	jgs	82	private:
458
459	jgs	117	//
460			// The number of samples in this Data object.
461			// This is derived directly from the FunctionSpace.
462	jgs	82	int m_noSamples;
463
464			//
465	jgs	117	// The number of data points per sample in this Data object.
466			// This is derived directly from the FunctionSpace.
467			int m_noDataPointsPerSample;
468
469			//
470			// The DataArrayView of the data array associated with this object.
471			// The data array is defined only in child classes of this class, it
472			// is not defined in this abstract parent class.
473	jgs	82	boost::scoped_ptr<DataArrayView> m_pointDataView;
474
475			//
476	jgs	117	// A FunctionSpace which provides a description of the data associated
477			// with this Data object.
478	jgs	82	FunctionSpace m_functionSpace;
479
480			};
481
482			inline
483			bool
484	matt	1325	DataAbstract::validSamplePointNo(int samplePointNo) const
485	jgs	82	{
486			return ((0 <= samplePointNo) && (samplePointNo < m_noDataPointsPerSample));
487			}
488
489			inline
490			bool
491			DataAbstract::validSampleNo(int sampleNo) const
492			{
493			return ((0 <= sampleNo) && (sampleNo < m_noSamples));
494			}
495
496			inline
497			DataAbstract::ValueType::value_type*
498			DataAbstract::getSampleData(ValueType::size_type sampleNo)
499			{
500			return &(m_pointDataView->getData(getPointOffset(sampleNo,0)));
501			}
502
503			inline
504			int
505	matt	1325	DataAbstract::getNumDPPSample() const
506	jgs	82	{
507			return m_noDataPointsPerSample;
508			}
509
510			inline
511			int
512			DataAbstract::getNumSamples() const
513			{
514			return m_noSamples;
515			}
516
517			inline
518	jgs	106	const
519			FunctionSpace&
520	jgs	82	DataAbstract::getFunctionSpace() const
521			{
522			return m_functionSpace;
523			}
524
525			inline
526	jgs	106	const
527			DataArrayView&
528	jgs	82	DataAbstract::getPointDataView() const
529			{
530			return *(m_pointDataView.get());
531			}
532
533			inline
534			DataArrayView&
535			DataAbstract::getPointDataView()
536			{
537			return *(m_pointDataView.get());
538			}
539			} // end of namespace
540	jgs	117
541	jgs	82	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision