/[escript]/trunk/escript/src/DataAbstract.h
ViewVC logotype

Contents of /trunk/escript/src/DataAbstract.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 921 - (show annotations)
Fri Jan 5 00:54:37 2007 UTC (12 years, 3 months ago) by gross
File MIME type: text/plain
File size: 12397 byte(s)
I have done some clarification on functions that allow to access individual data point values in a Data object. 
The term "data point number" is always local on a MPI process and referes to the value (data_point_in_sample, sample)
as a single identifyer (data_point_in_sample + sample * number_data_points_per_sample). a "global data point number"
referes to a tuple of a processour id and local data point number.

The function convertToNumArrayFromSampleNo has been removed now and convertToNumArrayFromDPNo renamed to getValueOfDataPoint.
There are two new functions:

   getNumberOfDataPoints
   setValueOfDataPoint

This allows you to do things like:

  in=Data(..)
  out=Data(..)
   for i in xrange(in.getNumberOfDataPoints())
       in_loc=in.getValueOfDataPoint(i)
       out_loc=< some operations on in_loc>
       out.setValueOfDataPoint(i,out_loc)


Also mindp  is renamed to  minGlobalDataPoint and there is a new function getValueOfGlobalDataPoint. While in MPI the functions getNumberOfDataPoints and getValueOfDataPoint are working locally on each process (so the code above is executed in parallel).
the latter allows getting a single value across all processors. 


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

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26