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 |
/** \file Data.h */ |
15 |
|
16 |
#ifndef DATA_H |
17 |
#define DATA_H |
18 |
#include "system_dep.h" |
19 |
|
20 |
#include "DataAbstract.h" |
21 |
#include "DataAlgorithm.h" |
22 |
#include "FunctionSpace.h" |
23 |
#include "BinaryOp.h" |
24 |
#include "UnaryOp.h" |
25 |
#include "DataException.h" |
26 |
|
27 |
extern "C" { |
28 |
#include "DataC.h" |
29 |
#include "paso/Paso.h" |
30 |
} |
31 |
|
32 |
#ifndef PASO_MPI |
33 |
#define MPI_Comm long |
34 |
#endif |
35 |
|
36 |
#include <string> |
37 |
#include <algorithm> |
38 |
|
39 |
#include <boost/shared_ptr.hpp> |
40 |
#include <boost/python/object.hpp> |
41 |
#include <boost/python/tuple.hpp> |
42 |
#include <boost/python/numeric.hpp> |
43 |
|
44 |
namespace escript { |
45 |
|
46 |
// |
47 |
// Forward declaration for various implementations of Data. |
48 |
class DataConstant; |
49 |
class DataTagged; |
50 |
class DataExpanded; |
51 |
|
52 |
/** |
53 |
\brief |
54 |
Data creates the appropriate Data object for the given construction |
55 |
arguments. |
56 |
|
57 |
Description: |
58 |
Data is essentially a factory class which creates the appropriate Data |
59 |
object for the given construction arguments. It retains control over |
60 |
the object created for the lifetime of the object. |
61 |
The type of Data object referred to may change during the lifetime of |
62 |
the Data object. |
63 |
*/ |
64 |
class Data { |
65 |
|
66 |
public: |
67 |
|
68 |
// These typedefs allow function names to be cast to pointers |
69 |
// to functions of the appropriate type when calling unaryOp etc. |
70 |
typedef double (*UnaryDFunPtr)(double); |
71 |
typedef double (*BinaryDFunPtr)(double,double); |
72 |
|
73 |
|
74 |
/** |
75 |
Constructors. |
76 |
*/ |
77 |
|
78 |
/** |
79 |
\brief |
80 |
Default constructor. |
81 |
Creates a DataEmpty object. |
82 |
*/ |
83 |
ESCRIPT_DLL_API |
84 |
Data(); |
85 |
|
86 |
/** |
87 |
\brief |
88 |
Copy constructor. |
89 |
WARNING: Only performs a shallow copy. |
90 |
*/ |
91 |
ESCRIPT_DLL_API |
92 |
Data(const Data& inData); |
93 |
|
94 |
/** |
95 |
\brief |
96 |
Constructor from another Data object. If "what" is different from the |
97 |
function space of inData the inData are tried to be interpolated to what, |
98 |
otherwise a shallow copy of inData is returned. |
99 |
*/ |
100 |
ESCRIPT_DLL_API |
101 |
Data(const Data& inData, |
102 |
const FunctionSpace& what); |
103 |
|
104 |
/** |
105 |
\brief |
106 |
Constructor which copies data from a DataArrayView. |
107 |
|
108 |
\param value - Input - Data value for a single point. |
109 |
\param what - Input - A description of what this data represents. |
110 |
\param expanded - Input - Flag, if true fill the entire container with |
111 |
the value. Otherwise a more efficient storage |
112 |
mechanism will be used. |
113 |
*/ |
114 |
ESCRIPT_DLL_API |
115 |
Data(const DataArrayView& value, |
116 |
const FunctionSpace& what=FunctionSpace(), |
117 |
bool expanded=false); |
118 |
|
119 |
/** |
120 |
\brief |
121 |
Constructor which creates a Data from a DataArrayView shape. |
122 |
|
123 |
\param value - Input - Single value applied to all Data. |
124 |
\param dataPointShape - Input - The shape of each data point. |
125 |
\param what - Input - A description of what this data represents. |
126 |
\param expanded - Input - Flag, if true fill the entire container with |
127 |
the given value. Otherwise a more efficient storage |
128 |
mechanism will be used. |
129 |
*/ |
130 |
ESCRIPT_DLL_API |
131 |
Data(double value, |
132 |
const DataArrayView::ShapeType& dataPointShape=DataArrayView::ShapeType(), |
133 |
const FunctionSpace& what=FunctionSpace(), |
134 |
bool expanded=false); |
135 |
|
136 |
/** |
137 |
\brief |
138 |
Constructor which performs a deep copy of a region from another Data object. |
139 |
|
140 |
\param inData - Input - Input Data object. |
141 |
\param region - Input - Region to copy. |
142 |
*/ |
143 |
ESCRIPT_DLL_API |
144 |
Data(const Data& inData, |
145 |
const DataArrayView::RegionType& region); |
146 |
|
147 |
/** |
148 |
\brief |
149 |
Constructor which will create Tagged data if expanded is false. |
150 |
No attempt is made to ensure the tag keys match the tag keys |
151 |
within the function space. |
152 |
|
153 |
\param tagKeys - Input - List of tag values. |
154 |
\param values - Input - List of values, one for each tag. |
155 |
\param defaultValue - Input - A default value, used if tag doesn't exist. |
156 |
\param what - Input - A description of what this data represents. |
157 |
\param expanded - Input - Flag, if true fill the entire container with |
158 |
the appropriate values. |
159 |
==>* |
160 |
*/ |
161 |
ESCRIPT_DLL_API |
162 |
Data(const DataTagged::TagListType& tagKeys, |
163 |
const DataTagged::ValueListType& values, |
164 |
const DataArrayView& defaultValue, |
165 |
const FunctionSpace& what=FunctionSpace(), |
166 |
bool expanded=false); |
167 |
|
168 |
/** |
169 |
\brief |
170 |
Constructor which copies data from a python numarray. |
171 |
|
172 |
\param value - Input - Data value for a single point. |
173 |
\param what - Input - A description of what this data represents. |
174 |
\param expanded - Input - Flag, if true fill the entire container with |
175 |
the value. Otherwise a more efficient storage |
176 |
mechanism will be used. |
177 |
*/ |
178 |
ESCRIPT_DLL_API |
179 |
Data(const boost::python::numeric::array& value, |
180 |
const FunctionSpace& what=FunctionSpace(), |
181 |
bool expanded=false); |
182 |
|
183 |
/** |
184 |
\brief |
185 |
Constructor which copies data from any object that can be converted into |
186 |
a python numarray. |
187 |
|
188 |
\param value - Input - Input data. |
189 |
\param what - Input - A description of what this data represents. |
190 |
\param expanded - Input - Flag, if true fill the entire container with |
191 |
the value. Otherwise a more efficient storage |
192 |
mechanism will be used. |
193 |
*/ |
194 |
ESCRIPT_DLL_API |
195 |
Data(const boost::python::object& value, |
196 |
const FunctionSpace& what=FunctionSpace(), |
197 |
bool expanded=false); |
198 |
|
199 |
/** |
200 |
\brief |
201 |
Constructor which creates a DataConstant. |
202 |
Copies data from any object that can be converted |
203 |
into a numarray. All other parameters are copied from other. |
204 |
|
205 |
\param value - Input - Input data. |
206 |
\param other - Input - contains all other parameters. |
207 |
*/ |
208 |
ESCRIPT_DLL_API |
209 |
Data(const boost::python::object& value, |
210 |
const Data& other); |
211 |
|
212 |
/** |
213 |
\brief |
214 |
Constructor which creates a DataConstant of "shape" with constant value. |
215 |
*/ |
216 |
ESCRIPT_DLL_API |
217 |
Data(double value, |
218 |
const boost::python::tuple& shape=boost::python::make_tuple(), |
219 |
const FunctionSpace& what=FunctionSpace(), |
220 |
bool expanded=false); |
221 |
/** |
222 |
\brief |
223 |
Destructor |
224 |
*/ |
225 |
ESCRIPT_DLL_API |
226 |
~Data(); |
227 |
|
228 |
/** |
229 |
\brief |
230 |
Perform a deep copy. |
231 |
*/ |
232 |
ESCRIPT_DLL_API |
233 |
void |
234 |
copy(const Data& other); |
235 |
|
236 |
/** |
237 |
Member access methods. |
238 |
*/ |
239 |
|
240 |
/** |
241 |
\brief |
242 |
switches on update protection |
243 |
|
244 |
*/ |
245 |
ESCRIPT_DLL_API |
246 |
void |
247 |
setProtection(); |
248 |
|
249 |
/** |
250 |
\brief |
251 |
Returns trueif the data object is protected against update |
252 |
|
253 |
*/ |
254 |
ESCRIPT_DLL_API |
255 |
bool |
256 |
isProtected() const; |
257 |
|
258 |
/** |
259 |
\brief |
260 |
Return the values of a data point on this process |
261 |
*/ |
262 |
ESCRIPT_DLL_API |
263 |
const boost::python::numeric::array |
264 |
getValueOfDataPoint(int dataPointNo); |
265 |
|
266 |
/** |
267 |
\brief |
268 |
sets the values of a data-point from a python object on this process |
269 |
*/ |
270 |
ESCRIPT_DLL_API |
271 |
void |
272 |
setValueOfDataPointToPyObject(int dataPointNo, const boost::python::object& py_object); |
273 |
|
274 |
/** |
275 |
\brief |
276 |
sets the values of a data-point from a numarray object on this process |
277 |
*/ |
278 |
ESCRIPT_DLL_API |
279 |
void |
280 |
setValueOfDataPointToArray(int dataPointNo, const boost::python::numeric::array&); |
281 |
|
282 |
/** |
283 |
\brief |
284 |
sets the values of a data-point on this process |
285 |
*/ |
286 |
ESCRIPT_DLL_API |
287 |
void |
288 |
setValueOfDataPoint(int dataPointNo, const double); |
289 |
|
290 |
/** |
291 |
\brief |
292 |
Return the value of the specified data-point across all processors |
293 |
*/ |
294 |
ESCRIPT_DLL_API |
295 |
const boost::python::numeric::array |
296 |
getValueOfGlobalDataPoint(int procNo, int dataPointNo); |
297 |
|
298 |
/** |
299 |
\brief |
300 |
Return the tag number associated with the given data-point. |
301 |
|
302 |
The data-point number here corresponds to the data-point number in the |
303 |
numarray returned by convertToNumArray. |
304 |
*/ |
305 |
ESCRIPT_DLL_API |
306 |
int |
307 |
getTagNumber(int dpno); |
308 |
|
309 |
/** |
310 |
\brief |
311 |
Return the C wrapper for the Data object. |
312 |
*/ |
313 |
ESCRIPT_DLL_API |
314 |
escriptDataC |
315 |
getDataC(); |
316 |
|
317 |
/** |
318 |
\brief |
319 |
Return the C wrapper for the Data object - const version. |
320 |
*/ |
321 |
ESCRIPT_DLL_API |
322 |
escriptDataC |
323 |
getDataC() const; |
324 |
|
325 |
/** |
326 |
\brief |
327 |
Write the data as a string. |
328 |
*/ |
329 |
ESCRIPT_DLL_API |
330 |
inline |
331 |
std::string |
332 |
toString() const |
333 |
{ |
334 |
return m_data->toString(); |
335 |
} |
336 |
|
337 |
/** |
338 |
\brief |
339 |
Return the DataArrayView of the point data. This essentially contains |
340 |
the shape information for each data point although it also may be used |
341 |
to manipulate the point data. |
342 |
*/ |
343 |
ESCRIPT_DLL_API |
344 |
inline |
345 |
const DataArrayView& |
346 |
getPointDataView() const |
347 |
{ |
348 |
return m_data->getPointDataView(); |
349 |
} |
350 |
|
351 |
/** |
352 |
\brief |
353 |
Whatever the current Data type make this into a DataExpanded. |
354 |
*/ |
355 |
ESCRIPT_DLL_API |
356 |
void |
357 |
expand(); |
358 |
|
359 |
/** |
360 |
\brief |
361 |
If possible convert this Data to DataTagged. This will only allow |
362 |
Constant data to be converted to tagged. An attempt to convert |
363 |
Expanded data to tagged will throw an exception. |
364 |
==>* |
365 |
*/ |
366 |
ESCRIPT_DLL_API |
367 |
void |
368 |
tag(); |
369 |
|
370 |
/** |
371 |
\brief |
372 |
Return true if this Data is expanded. |
373 |
*/ |
374 |
ESCRIPT_DLL_API |
375 |
bool |
376 |
isExpanded() const; |
377 |
|
378 |
/** |
379 |
\brief |
380 |
Return true if this Data is tagged. |
381 |
*/ |
382 |
ESCRIPT_DLL_API |
383 |
bool |
384 |
isTagged() const; |
385 |
|
386 |
/** |
387 |
\brief |
388 |
Return true if this Data is constant. |
389 |
*/ |
390 |
ESCRIPT_DLL_API |
391 |
bool |
392 |
isConstant() const; |
393 |
|
394 |
/** |
395 |
\brief |
396 |
Return true if this Data is empty. |
397 |
*/ |
398 |
ESCRIPT_DLL_API |
399 |
bool |
400 |
isEmpty() const; |
401 |
|
402 |
/** |
403 |
\brief |
404 |
Return the function space. |
405 |
*/ |
406 |
ESCRIPT_DLL_API |
407 |
inline |
408 |
const FunctionSpace& |
409 |
getFunctionSpace() const |
410 |
{ |
411 |
return m_data->getFunctionSpace(); |
412 |
} |
413 |
|
414 |
/** |
415 |
\brief |
416 |
Return a copy of the function space. |
417 |
*/ |
418 |
ESCRIPT_DLL_API |
419 |
const FunctionSpace |
420 |
getCopyOfFunctionSpace() const; |
421 |
|
422 |
/** |
423 |
\brief |
424 |
Return the domain. |
425 |
*/ |
426 |
ESCRIPT_DLL_API |
427 |
inline |
428 |
const AbstractDomain& |
429 |
getDomain() const |
430 |
{ |
431 |
return getFunctionSpace().getDomain(); |
432 |
} |
433 |
|
434 |
/** |
435 |
\brief |
436 |
Return a copy of the domain. |
437 |
*/ |
438 |
ESCRIPT_DLL_API |
439 |
const AbstractDomain |
440 |
getCopyOfDomain() const; |
441 |
|
442 |
/** |
443 |
\brief |
444 |
Return the rank of the point data. |
445 |
*/ |
446 |
ESCRIPT_DLL_API |
447 |
inline |
448 |
int |
449 |
getDataPointRank() const |
450 |
{ |
451 |
return m_data->getPointDataView().getRank(); |
452 |
} |
453 |
|
454 |
/** |
455 |
\brief |
456 |
Return the number of data points |
457 |
*/ |
458 |
ESCRIPT_DLL_API |
459 |
inline |
460 |
int |
461 |
getNumDataPoints() const |
462 |
{ |
463 |
return getNumSamples() * getNumDataPointsPerSample(); |
464 |
} |
465 |
/** |
466 |
\brief |
467 |
Return the number of samples. |
468 |
*/ |
469 |
ESCRIPT_DLL_API |
470 |
inline |
471 |
int |
472 |
getNumSamples() const |
473 |
{ |
474 |
return m_data->getNumSamples(); |
475 |
} |
476 |
|
477 |
/** |
478 |
\brief |
479 |
Return the number of data points per sample. |
480 |
*/ |
481 |
ESCRIPT_DLL_API |
482 |
inline |
483 |
int |
484 |
getNumDataPointsPerSample() const |
485 |
{ |
486 |
return m_data->getNumDPPSample(); |
487 |
} |
488 |
/** |
489 |
\brief |
490 |
dumps the object into a netCDF file |
491 |
*/ |
492 |
ESCRIPT_DLL_API |
493 |
inline |
494 |
void |
495 |
dump(const std::string fileName) const |
496 |
{ |
497 |
return m_data->dump(fileName); |
498 |
} |
499 |
|
500 |
/** |
501 |
\brief |
502 |
Return the sample data for the given sample no. This is not the |
503 |
preferred interface but is provided for use by C code. |
504 |
\param sampleNo - Input - the given sample no. |
505 |
*/ |
506 |
ESCRIPT_DLL_API |
507 |
inline |
508 |
DataAbstract::ValueType::value_type* |
509 |
getSampleData(DataAbstract::ValueType::size_type sampleNo) |
510 |
{ |
511 |
return m_data->getSampleData(sampleNo); |
512 |
} |
513 |
|
514 |
/** |
515 |
\brief |
516 |
Return the sample data for the given tag. If an attempt is made to |
517 |
access data that isn't tagged an exception will be thrown. |
518 |
\param tag - Input - the tag key. |
519 |
*/ |
520 |
ESCRIPT_DLL_API |
521 |
inline |
522 |
DataAbstract::ValueType::value_type* |
523 |
getSampleDataByTag(int tag) |
524 |
{ |
525 |
return m_data->getSampleDataByTag(tag); |
526 |
} |
527 |
|
528 |
/** |
529 |
\brief |
530 |
Return a view into the data for the data point specified. |
531 |
NOTE: Construction of the DataArrayView is a relatively expensive |
532 |
operation. |
533 |
\param sampleNo - Input - |
534 |
\param dataPointNo - Input - |
535 |
*/ |
536 |
ESCRIPT_DLL_API |
537 |
inline |
538 |
DataArrayView |
539 |
getDataPoint(int sampleNo, |
540 |
int dataPointNo) |
541 |
{ |
542 |
return m_data->getDataPoint(sampleNo,dataPointNo); |
543 |
} |
544 |
|
545 |
/** |
546 |
\brief |
547 |
Return a reference to the data point shape. |
548 |
*/ |
549 |
ESCRIPT_DLL_API |
550 |
const DataArrayView::ShapeType& |
551 |
getDataPointShape() const; |
552 |
|
553 |
/** |
554 |
\brief |
555 |
Return the data point shape as a tuple of integers. |
556 |
*/ |
557 |
ESCRIPT_DLL_API |
558 |
const boost::python::tuple |
559 |
getShapeTuple() const; |
560 |
|
561 |
/** |
562 |
\brief |
563 |
Return the size of the data point. It is the product of the |
564 |
data point shape dimensions. |
565 |
*/ |
566 |
ESCRIPT_DLL_API |
567 |
int |
568 |
getDataPointSize() const; |
569 |
|
570 |
/** |
571 |
\brief |
572 |
Return the number of doubles stored for this Data. |
573 |
*/ |
574 |
ESCRIPT_DLL_API |
575 |
DataArrayView::ValueType::size_type |
576 |
getLength() const; |
577 |
|
578 |
/** |
579 |
\brief |
580 |
Assign the given value to the tag. Implicitly converts this |
581 |
object to type DataTagged. Throws an exception if this object |
582 |
cannot be converted to a DataTagged object. |
583 |
\param tagKey - Input - Integer key. |
584 |
\param value - Input - Value to associate with given key. |
585 |
==>* |
586 |
*/ |
587 |
ESCRIPT_DLL_API |
588 |
void |
589 |
setTaggedValue(int tagKey, |
590 |
const boost::python::object& value); |
591 |
|
592 |
/** |
593 |
\brief |
594 |
Assign the given value to the tag. Implicitly converts this |
595 |
object to type DataTagged. Throws an exception if this object |
596 |
cannot be converted to a DataTagged object. |
597 |
\param tagKey - Input - Integer key. |
598 |
\param value - Input - Value to associate with given key. |
599 |
==>* |
600 |
*/ |
601 |
ESCRIPT_DLL_API |
602 |
void |
603 |
setTaggedValueFromCPP(int tagKey, |
604 |
const DataArrayView& value); |
605 |
|
606 |
/** |
607 |
\brief |
608 |
Copy other Data object into this Data object where mask is positive. |
609 |
*/ |
610 |
ESCRIPT_DLL_API |
611 |
void |
612 |
copyWithMask(const Data& other, |
613 |
const Data& mask); |
614 |
|
615 |
/** |
616 |
Data object operation methods and operators. |
617 |
*/ |
618 |
|
619 |
/** |
620 |
\brief |
621 |
Interpolates this onto the given functionspace and returns |
622 |
the result as a Data object. |
623 |
* |
624 |
*/ |
625 |
ESCRIPT_DLL_API |
626 |
Data |
627 |
interpolate(const FunctionSpace& functionspace) const; |
628 |
|
629 |
/** |
630 |
\brief |
631 |
Calculates the gradient of the data at the data points of functionspace. |
632 |
If functionspace is not present the function space of Function(getDomain()) is used. |
633 |
* |
634 |
*/ |
635 |
ESCRIPT_DLL_API |
636 |
Data |
637 |
gradOn(const FunctionSpace& functionspace) const; |
638 |
|
639 |
ESCRIPT_DLL_API |
640 |
Data |
641 |
grad() const; |
642 |
|
643 |
/** |
644 |
\brief |
645 |
Calculate the integral over the function space domain. |
646 |
* |
647 |
*/ |
648 |
ESCRIPT_DLL_API |
649 |
boost::python::numeric::array |
650 |
integrate() const; |
651 |
|
652 |
/** |
653 |
\brief |
654 |
Returns 1./ Data object |
655 |
* |
656 |
*/ |
657 |
ESCRIPT_DLL_API |
658 |
Data |
659 |
oneOver() const; |
660 |
/** |
661 |
\brief |
662 |
Return a Data with a 1 for +ive values and a 0 for 0 or -ive values. |
663 |
* |
664 |
*/ |
665 |
ESCRIPT_DLL_API |
666 |
Data |
667 |
wherePositive() const; |
668 |
|
669 |
/** |
670 |
\brief |
671 |
Return a Data with a 1 for -ive values and a 0 for +ive or 0 values. |
672 |
* |
673 |
*/ |
674 |
ESCRIPT_DLL_API |
675 |
Data |
676 |
whereNegative() const; |
677 |
|
678 |
/** |
679 |
\brief |
680 |
Return a Data with a 1 for +ive or 0 values and a 0 for -ive values. |
681 |
* |
682 |
*/ |
683 |
ESCRIPT_DLL_API |
684 |
Data |
685 |
whereNonNegative() const; |
686 |
|
687 |
/** |
688 |
\brief |
689 |
Return a Data with a 1 for -ive or 0 values and a 0 for +ive values. |
690 |
* |
691 |
*/ |
692 |
ESCRIPT_DLL_API |
693 |
Data |
694 |
whereNonPositive() const; |
695 |
|
696 |
/** |
697 |
\brief |
698 |
Return a Data with a 1 for 0 values and a 0 for +ive or -ive values. |
699 |
* |
700 |
*/ |
701 |
ESCRIPT_DLL_API |
702 |
Data |
703 |
whereZero(double tol=0.0) const; |
704 |
|
705 |
/** |
706 |
\brief |
707 |
Return a Data with a 0 for 0 values and a 1 for +ive or -ive values. |
708 |
* |
709 |
*/ |
710 |
ESCRIPT_DLL_API |
711 |
Data |
712 |
whereNonZero(double tol=0.0) const; |
713 |
|
714 |
/** |
715 |
\brief |
716 |
Return the maximum absolute value of this Data object. |
717 |
* |
718 |
*/ |
719 |
ESCRIPT_DLL_API |
720 |
double |
721 |
Lsup() const; |
722 |
|
723 |
/** |
724 |
\brief |
725 |
Return the minimum absolute value of this Data object. |
726 |
* |
727 |
*/ |
728 |
ESCRIPT_DLL_API |
729 |
double |
730 |
Linf() const; |
731 |
|
732 |
/** |
733 |
\brief |
734 |
Return the maximum value of this Data object. |
735 |
* |
736 |
*/ |
737 |
ESCRIPT_DLL_API |
738 |
double |
739 |
sup() const; |
740 |
|
741 |
/** |
742 |
\brief |
743 |
Return the minimum value of this Data object. |
744 |
* |
745 |
*/ |
746 |
ESCRIPT_DLL_API |
747 |
double |
748 |
inf() const; |
749 |
|
750 |
/** |
751 |
\brief |
752 |
Return the absolute value of each data point of this Data object. |
753 |
* |
754 |
*/ |
755 |
ESCRIPT_DLL_API |
756 |
Data |
757 |
abs() const; |
758 |
|
759 |
/** |
760 |
\brief |
761 |
Return the maximum value of each data point of this Data object. |
762 |
* |
763 |
*/ |
764 |
ESCRIPT_DLL_API |
765 |
Data |
766 |
maxval() const; |
767 |
|
768 |
/** |
769 |
\brief |
770 |
Return the minimum value of each data point of this Data object. |
771 |
* |
772 |
*/ |
773 |
ESCRIPT_DLL_API |
774 |
Data |
775 |
minval() const; |
776 |
|
777 |
/** |
778 |
\brief |
779 |
Return the (sample number, data-point number) of the data point with |
780 |
the minimum value in this Data object. |
781 |
*/ |
782 |
ESCRIPT_DLL_API |
783 |
const boost::python::tuple |
784 |
minGlobalDataPoint() const; |
785 |
|
786 |
ESCRIPT_DLL_API |
787 |
void |
788 |
calc_minGlobalDataPoint(int& ProcNo, int& DataPointNo) const; |
789 |
/** |
790 |
\brief |
791 |
Return the sign of each data point of this Data object. |
792 |
-1 for negative values, zero for zero values, 1 for positive values. |
793 |
* |
794 |
*/ |
795 |
ESCRIPT_DLL_API |
796 |
Data |
797 |
sign() const; |
798 |
|
799 |
/** |
800 |
\brief |
801 |
Return the symmetric part of a matrix which is half the matrix plus its transpose. |
802 |
* |
803 |
*/ |
804 |
ESCRIPT_DLL_API |
805 |
Data |
806 |
symmetric() const; |
807 |
|
808 |
/** |
809 |
\brief |
810 |
Return the nonsymmetric part of a matrix which is half the matrix minus its transpose. |
811 |
* |
812 |
*/ |
813 |
ESCRIPT_DLL_API |
814 |
Data |
815 |
nonsymmetric() const; |
816 |
|
817 |
/** |
818 |
\brief |
819 |
Return the trace of a matrix |
820 |
* |
821 |
*/ |
822 |
ESCRIPT_DLL_API |
823 |
Data |
824 |
trace(int axis_offset) const; |
825 |
|
826 |
/** |
827 |
\brief |
828 |
Transpose each data point of this Data object around the given axis. |
829 |
* |
830 |
*/ |
831 |
ESCRIPT_DLL_API |
832 |
Data |
833 |
transpose(int axis_offset) const; |
834 |
|
835 |
/** |
836 |
\brief |
837 |
Return the eigenvalues of the symmetric part at each data point of this Data object in increasing values. |
838 |
Currently this function is restricted to rank 2, square shape, and dimension 3. |
839 |
* |
840 |
*/ |
841 |
ESCRIPT_DLL_API |
842 |
Data |
843 |
eigenvalues() const; |
844 |
|
845 |
/** |
846 |
\brief |
847 |
Return the eigenvalues and corresponding eigenvcetors of the symmetric part at each data point of this Data object. |
848 |
the eigenvalues are ordered in increasing size where eigenvalues with relative difference less than |
849 |
tol are treated as equal. The eigenvectors are orthogonal, normalized and the sclaed such that the |
850 |
first non-zero entry is positive. |
851 |
Currently this function is restricted to rank 2, square shape, and dimension 3 |
852 |
* |
853 |
*/ |
854 |
ESCRIPT_DLL_API |
855 |
const boost::python::tuple |
856 |
eigenvalues_and_eigenvectors(const double tol=1.e-12) const; |
857 |
|
858 |
/** |
859 |
\brief |
860 |
swaps the components axis0 and axis1 |
861 |
* |
862 |
*/ |
863 |
ESCRIPT_DLL_API |
864 |
Data |
865 |
swapaxes(const int axis0, const int axis1) const; |
866 |
|
867 |
/** |
868 |
\brief |
869 |
Return the error function erf of each data point of this Data object. |
870 |
* |
871 |
*/ |
872 |
ESCRIPT_DLL_API |
873 |
Data |
874 |
erf() const; |
875 |
|
876 |
/** |
877 |
\brief |
878 |
Return the sin of each data point of this Data object. |
879 |
* |
880 |
*/ |
881 |
ESCRIPT_DLL_API |
882 |
Data |
883 |
sin() const; |
884 |
|
885 |
/** |
886 |
\brief |
887 |
Return the cos of each data point of this Data object. |
888 |
* |
889 |
*/ |
890 |
ESCRIPT_DLL_API |
891 |
Data |
892 |
cos() const; |
893 |
|
894 |
/** |
895 |
\brief |
896 |
Return the tan of each data point of this Data object. |
897 |
* |
898 |
*/ |
899 |
ESCRIPT_DLL_API |
900 |
Data |
901 |
tan() const; |
902 |
|
903 |
/** |
904 |
\brief |
905 |
Return the asin of each data point of this Data object. |
906 |
* |
907 |
*/ |
908 |
ESCRIPT_DLL_API |
909 |
Data |
910 |
asin() const; |
911 |
|
912 |
/** |
913 |
\brief |
914 |
Return the acos of each data point of this Data object. |
915 |
* |
916 |
*/ |
917 |
ESCRIPT_DLL_API |
918 |
Data |
919 |
acos() const; |
920 |
|
921 |
/** |
922 |
\brief |
923 |
Return the atan of each data point of this Data object. |
924 |
* |
925 |
*/ |
926 |
ESCRIPT_DLL_API |
927 |
Data |
928 |
atan() const; |
929 |
|
930 |
/** |
931 |
\brief |
932 |
Return the sinh of each data point of this Data object. |
933 |
* |
934 |
*/ |
935 |
ESCRIPT_DLL_API |
936 |
Data |
937 |
sinh() const; |
938 |
|
939 |
/** |
940 |
\brief |
941 |
Return the cosh of each data point of this Data object. |
942 |
* |
943 |
*/ |
944 |
ESCRIPT_DLL_API |
945 |
Data |
946 |
cosh() const; |
947 |
|
948 |
/** |
949 |
\brief |
950 |
Return the tanh of each data point of this Data object. |
951 |
* |
952 |
*/ |
953 |
ESCRIPT_DLL_API |
954 |
Data |
955 |
tanh() const; |
956 |
|
957 |
/** |
958 |
\brief |
959 |
Return the asinh of each data point of this Data object. |
960 |
* |
961 |
*/ |
962 |
ESCRIPT_DLL_API |
963 |
Data |
964 |
asinh() const; |
965 |
|
966 |
/** |
967 |
\brief |
968 |
Return the acosh of each data point of this Data object. |
969 |
* |
970 |
*/ |
971 |
ESCRIPT_DLL_API |
972 |
Data |
973 |
acosh() const; |
974 |
|
975 |
/** |
976 |
\brief |
977 |
Return the atanh of each data point of this Data object. |
978 |
* |
979 |
*/ |
980 |
ESCRIPT_DLL_API |
981 |
Data |
982 |
atanh() const; |
983 |
|
984 |
/** |
985 |
\brief |
986 |
Return the log to base 10 of each data point of this Data object. |
987 |
* |
988 |
*/ |
989 |
ESCRIPT_DLL_API |
990 |
Data |
991 |
log10() const; |
992 |
|
993 |
/** |
994 |
\brief |
995 |
Return the natural log of each data point of this Data object. |
996 |
* |
997 |
*/ |
998 |
ESCRIPT_DLL_API |
999 |
Data |
1000 |
log() const; |
1001 |
|
1002 |
/** |
1003 |
\brief |
1004 |
Return the exponential function of each data point of this Data object. |
1005 |
* |
1006 |
*/ |
1007 |
ESCRIPT_DLL_API |
1008 |
Data |
1009 |
exp() const; |
1010 |
|
1011 |
/** |
1012 |
\brief |
1013 |
Return the square root of each data point of this Data object. |
1014 |
* |
1015 |
*/ |
1016 |
ESCRIPT_DLL_API |
1017 |
Data |
1018 |
sqrt() const; |
1019 |
|
1020 |
/** |
1021 |
\brief |
1022 |
Return the negation of each data point of this Data object. |
1023 |
* |
1024 |
*/ |
1025 |
ESCRIPT_DLL_API |
1026 |
Data |
1027 |
neg() const; |
1028 |
|
1029 |
/** |
1030 |
\brief |
1031 |
Return the identity of each data point of this Data object. |
1032 |
Simply returns this object unmodified. |
1033 |
* |
1034 |
*/ |
1035 |
ESCRIPT_DLL_API |
1036 |
Data |
1037 |
pos() const; |
1038 |
|
1039 |
/** |
1040 |
\brief |
1041 |
Return the given power of each data point of this Data object. |
1042 |
|
1043 |
\param right Input - the power to raise the object to. |
1044 |
* |
1045 |
*/ |
1046 |
ESCRIPT_DLL_API |
1047 |
Data |
1048 |
powD(const Data& right) const; |
1049 |
|
1050 |
/** |
1051 |
\brief |
1052 |
Return the given power of each data point of this boost python object. |
1053 |
|
1054 |
\param right Input - the power to raise the object to. |
1055 |
* |
1056 |
*/ |
1057 |
ESCRIPT_DLL_API |
1058 |
Data |
1059 |
powO(const boost::python::object& right) const; |
1060 |
|
1061 |
/** |
1062 |
\brief |
1063 |
Return the given power of each data point of this boost python object. |
1064 |
|
1065 |
\param left Input - the bases |
1066 |
* |
1067 |
*/ |
1068 |
|
1069 |
ESCRIPT_DLL_API |
1070 |
Data |
1071 |
rpowO(const boost::python::object& left) const; |
1072 |
|
1073 |
/** |
1074 |
\brief |
1075 |
writes the object to a file in the DX file format |
1076 |
*/ |
1077 |
ESCRIPT_DLL_API |
1078 |
void |
1079 |
saveDX(std::string fileName) const; |
1080 |
|
1081 |
/** |
1082 |
\brief |
1083 |
writes the object to a file in the VTK file format |
1084 |
*/ |
1085 |
ESCRIPT_DLL_API |
1086 |
void |
1087 |
saveVTK(std::string fileName) const; |
1088 |
|
1089 |
/** |
1090 |
\brief |
1091 |
Overloaded operator += |
1092 |
\param right - Input - The right hand side. |
1093 |
* |
1094 |
*/ |
1095 |
ESCRIPT_DLL_API |
1096 |
Data& operator+=(const Data& right); |
1097 |
ESCRIPT_DLL_API |
1098 |
Data& operator+=(const boost::python::object& right); |
1099 |
|
1100 |
/** |
1101 |
\brief |
1102 |
Overloaded operator -= |
1103 |
\param right - Input - The right hand side. |
1104 |
* |
1105 |
*/ |
1106 |
ESCRIPT_DLL_API |
1107 |
Data& operator-=(const Data& right); |
1108 |
ESCRIPT_DLL_API |
1109 |
Data& operator-=(const boost::python::object& right); |
1110 |
|
1111 |
/** |
1112 |
\brief |
1113 |
Overloaded operator *= |
1114 |
\param right - Input - The right hand side. |
1115 |
* |
1116 |
*/ |
1117 |
ESCRIPT_DLL_API |
1118 |
Data& operator*=(const Data& right); |
1119 |
ESCRIPT_DLL_API |
1120 |
Data& operator*=(const boost::python::object& right); |
1121 |
|
1122 |
/** |
1123 |
\brief |
1124 |
Overloaded operator /= |
1125 |
\param right - Input - The right hand side. |
1126 |
* |
1127 |
*/ |
1128 |
ESCRIPT_DLL_API |
1129 |
Data& operator/=(const Data& right); |
1130 |
ESCRIPT_DLL_API |
1131 |
Data& operator/=(const boost::python::object& right); |
1132 |
|
1133 |
/** |
1134 |
\brief |
1135 |
Returns true if this can be interpolated to functionspace. |
1136 |
*/ |
1137 |
ESCRIPT_DLL_API |
1138 |
bool |
1139 |
probeInterpolation(const FunctionSpace& functionspace) const; |
1140 |
|
1141 |
/** |
1142 |
Data object slicing methods. |
1143 |
*/ |
1144 |
|
1145 |
/** |
1146 |
\brief |
1147 |
Returns a slice from this Data object. |
1148 |
|
1149 |
/description |
1150 |
Implements the [] get operator in python. |
1151 |
Calls getSlice. |
1152 |
|
1153 |
\param key - Input - python slice tuple specifying |
1154 |
slice to return. |
1155 |
*/ |
1156 |
ESCRIPT_DLL_API |
1157 |
Data |
1158 |
getItem(const boost::python::object& key) const; |
1159 |
|
1160 |
/** |
1161 |
\brief |
1162 |
Copies slice from value into this Data object. |
1163 |
|
1164 |
Implements the [] set operator in python. |
1165 |
Calls setSlice. |
1166 |
|
1167 |
\param key - Input - python slice tuple specifying |
1168 |
slice to copy from value. |
1169 |
\param value - Input - Data object to copy from. |
1170 |
*/ |
1171 |
ESCRIPT_DLL_API |
1172 |
void |
1173 |
setItemD(const boost::python::object& key, |
1174 |
const Data& value); |
1175 |
|
1176 |
ESCRIPT_DLL_API |
1177 |
void |
1178 |
setItemO(const boost::python::object& key, |
1179 |
const boost::python::object& value); |
1180 |
|
1181 |
// These following public methods should be treated as private. |
1182 |
|
1183 |
/** |
1184 |
\brief |
1185 |
Perform the given unary operation on every element of every data point in |
1186 |
this Data object. |
1187 |
*/ |
1188 |
template <class UnaryFunction> |
1189 |
ESCRIPT_DLL_API |
1190 |
inline |
1191 |
void |
1192 |
unaryOp(UnaryFunction operation); |
1193 |
|
1194 |
/** |
1195 |
\brief |
1196 |
Return a Data object containing the specified slice of |
1197 |
this Data object. |
1198 |
\param region - Input - Region to copy. |
1199 |
* |
1200 |
*/ |
1201 |
ESCRIPT_DLL_API |
1202 |
Data |
1203 |
getSlice(const DataArrayView::RegionType& region) const; |
1204 |
|
1205 |
/** |
1206 |
\brief |
1207 |
Copy the specified slice from the given value into this |
1208 |
Data object. |
1209 |
\param value - Input - Data to copy from. |
1210 |
\param region - Input - Region to copy. |
1211 |
* |
1212 |
*/ |
1213 |
ESCRIPT_DLL_API |
1214 |
void |
1215 |
setSlice(const Data& value, |
1216 |
const DataArrayView::RegionType& region); |
1217 |
|
1218 |
/** |
1219 |
\brief |
1220 |
Archive the current Data object to the given file. |
1221 |
\param fileName - Input - file to archive to. |
1222 |
*/ |
1223 |
ESCRIPT_DLL_API |
1224 |
void |
1225 |
archiveData(const std::string fileName); |
1226 |
|
1227 |
/** |
1228 |
\brief |
1229 |
Extract the Data object archived in the given file, overwriting |
1230 |
the current Data object. |
1231 |
Note - the current object must be of type DataEmpty. |
1232 |
\param fileName - Input - file to extract from. |
1233 |
\param fspace - Input - a suitable FunctionSpace descibing the data. |
1234 |
*/ |
1235 |
ESCRIPT_DLL_API |
1236 |
void |
1237 |
extractData(const std::string fileName, |
1238 |
const FunctionSpace& fspace); |
1239 |
|
1240 |
|
1241 |
/** |
1242 |
\brief |
1243 |
print the data values to stdout. Used for debugging |
1244 |
*/ |
1245 |
ESCRIPT_DLL_API |
1246 |
void |
1247 |
print(void); |
1248 |
|
1249 |
/** |
1250 |
\brief |
1251 |
return the MPI rank number of the local data |
1252 |
MPI_COMM_WORLD is assumed and the result of MPI_Comm_size() |
1253 |
is returned |
1254 |
*/ |
1255 |
ESCRIPT_DLL_API |
1256 |
int |
1257 |
get_MPIRank(void) const; |
1258 |
|
1259 |
/** |
1260 |
\brief |
1261 |
return the MPI rank number of the local data |
1262 |
MPI_COMM_WORLD is assumed and the result of MPI_Comm_rank() |
1263 |
is returned |
1264 |
*/ |
1265 |
ESCRIPT_DLL_API |
1266 |
int |
1267 |
get_MPISize(void) const; |
1268 |
|
1269 |
/** |
1270 |
\brief |
1271 |
return the MPI rank number of the local data |
1272 |
MPI_COMM_WORLD is assumed and returned. |
1273 |
*/ |
1274 |
ESCRIPT_DLL_API |
1275 |
MPI_Comm |
1276 |
get_MPIComm(void) const; |
1277 |
|
1278 |
/** |
1279 |
\brief |
1280 |
return the object produced by the factory, which is a DataConstant or DataExpanded |
1281 |
*/ |
1282 |
ESCRIPT_DLL_API |
1283 |
DataAbstract* |
1284 |
borrowData(void) const; |
1285 |
|
1286 |
protected: |
1287 |
|
1288 |
private: |
1289 |
|
1290 |
/** |
1291 |
\brief |
1292 |
Check *this and the right operand are compatible. Throws |
1293 |
an exception if they aren't. |
1294 |
\param right - Input - The right hand side. |
1295 |
*/ |
1296 |
inline |
1297 |
void |
1298 |
operandCheck(const Data& right) const |
1299 |
{ |
1300 |
return m_data->operandCheck(*(right.m_data.get())); |
1301 |
} |
1302 |
|
1303 |
/** |
1304 |
\brief |
1305 |
Perform the specified reduction algorithm on every element of every data point in |
1306 |
this Data object according to the given function and return the single value result. |
1307 |
*/ |
1308 |
template <class BinaryFunction> |
1309 |
inline |
1310 |
double |
1311 |
algorithm(BinaryFunction operation, |
1312 |
double initial_value) const; |
1313 |
|
1314 |
/** |
1315 |
\brief |
1316 |
Reduce each data-point in this Data object using the given operation. Return a Data |
1317 |
object with the same number of data-points, but with each data-point containing only |
1318 |
one value - the result of the reduction operation on the corresponding data-point in |
1319 |
this Data object |
1320 |
*/ |
1321 |
template <class BinaryFunction> |
1322 |
inline |
1323 |
Data |
1324 |
dp_algorithm(BinaryFunction operation, |
1325 |
double initial_value) const; |
1326 |
|
1327 |
/** |
1328 |
\brief |
1329 |
Perform the given binary operation on all of the data's elements. |
1330 |
The underlying type of the right hand side (right) determines the final |
1331 |
type of *this after the operation. For example if the right hand side |
1332 |
is expanded *this will be expanded if necessary. |
1333 |
RHS is a Data object. |
1334 |
*/ |
1335 |
template <class BinaryFunction> |
1336 |
inline |
1337 |
void |
1338 |
binaryOp(const Data& right, |
1339 |
BinaryFunction operation); |
1340 |
|
1341 |
/** |
1342 |
\brief |
1343 |
Convert the data type of the RHS to match this. |
1344 |
\param right - Input - data type to match. |
1345 |
*/ |
1346 |
void |
1347 |
typeMatchLeft(Data& right) const; |
1348 |
|
1349 |
/** |
1350 |
\brief |
1351 |
Convert the data type of this to match the RHS. |
1352 |
\param right - Input - data type to match. |
1353 |
*/ |
1354 |
void |
1355 |
typeMatchRight(const Data& right); |
1356 |
|
1357 |
/** |
1358 |
\brief |
1359 |
Construct a Data object of the appropriate type. |
1360 |
*/ |
1361 |
template <class IValueType> |
1362 |
void |
1363 |
initialise(const IValueType& value, |
1364 |
const FunctionSpace& what, |
1365 |
bool expanded); |
1366 |
|
1367 |
// |
1368 |
// flag to protect the data object against any update |
1369 |
bool m_protected; |
1370 |
|
1371 |
// |
1372 |
// pointer to the actual data object |
1373 |
boost::shared_ptr<DataAbstract> m_data; |
1374 |
|
1375 |
// |
1376 |
// pointer to the internal profiling data |
1377 |
struct profDataEntry *profData; |
1378 |
|
1379 |
}; |
1380 |
|
1381 |
template <class IValueType> |
1382 |
void |
1383 |
Data::initialise(const IValueType& value, |
1384 |
const FunctionSpace& what, |
1385 |
bool expanded) |
1386 |
{ |
1387 |
// |
1388 |
// Construct a Data object of the appropriate type. |
1389 |
// Construct the object first as there seems to be a bug which causes |
1390 |
// undefined behaviour if an exception is thrown during construction |
1391 |
// within the shared_ptr constructor. |
1392 |
if (expanded) { |
1393 |
DataAbstract* temp=new DataExpanded(value,what); |
1394 |
boost::shared_ptr<DataAbstract> temp_data(temp); |
1395 |
m_data=temp_data; |
1396 |
} else { |
1397 |
DataAbstract* temp=new DataConstant(value,what); |
1398 |
boost::shared_ptr<DataAbstract> temp_data(temp); |
1399 |
m_data=temp_data; |
1400 |
} |
1401 |
} |
1402 |
|
1403 |
/** |
1404 |
Binary Data object operators. |
1405 |
*/ |
1406 |
inline double rpow(double x,double y) |
1407 |
{ |
1408 |
return pow(y,x); |
1409 |
} |
1410 |
|
1411 |
/** |
1412 |
\brief |
1413 |
Operator+ |
1414 |
Takes two Data objects. |
1415 |
*/ |
1416 |
ESCRIPT_DLL_API Data operator+(const Data& left, const Data& right); |
1417 |
|
1418 |
/** |
1419 |
\brief |
1420 |
Operator- |
1421 |
Takes two Data objects. |
1422 |
*/ |
1423 |
ESCRIPT_DLL_API Data operator-(const Data& left, const Data& right); |
1424 |
|
1425 |
/** |
1426 |
\brief |
1427 |
Operator* |
1428 |
Takes two Data objects. |
1429 |
*/ |
1430 |
ESCRIPT_DLL_API Data operator*(const Data& left, const Data& right); |
1431 |
|
1432 |
/** |
1433 |
\brief |
1434 |
Operator/ |
1435 |
Takes two Data objects. |
1436 |
*/ |
1437 |
ESCRIPT_DLL_API Data operator/(const Data& left, const Data& right); |
1438 |
|
1439 |
/** |
1440 |
\brief |
1441 |
Operator+ |
1442 |
Takes LHS Data object and RHS python::object. |
1443 |
python::object must be convertable to Data type. |
1444 |
*/ |
1445 |
ESCRIPT_DLL_API Data operator+(const Data& left, const boost::python::object& right); |
1446 |
|
1447 |
/** |
1448 |
\brief |
1449 |
Operator- |
1450 |
Takes LHS Data object and RHS python::object. |
1451 |
python::object must be convertable to Data type. |
1452 |
*/ |
1453 |
ESCRIPT_DLL_API Data operator-(const Data& left, const boost::python::object& right); |
1454 |
|
1455 |
/** |
1456 |
\brief |
1457 |
Operator* |
1458 |
Takes LHS Data object and RHS python::object. |
1459 |
python::object must be convertable to Data type. |
1460 |
*/ |
1461 |
ESCRIPT_DLL_API Data operator*(const Data& left, const boost::python::object& right); |
1462 |
|
1463 |
/** |
1464 |
\brief |
1465 |
Operator/ |
1466 |
Takes LHS Data object and RHS python::object. |
1467 |
python::object must be convertable to Data type. |
1468 |
*/ |
1469 |
ESCRIPT_DLL_API Data operator/(const Data& left, const boost::python::object& right); |
1470 |
|
1471 |
/** |
1472 |
\brief |
1473 |
Operator+ |
1474 |
Takes LHS python::object and RHS Data object. |
1475 |
python::object must be convertable to Data type. |
1476 |
*/ |
1477 |
ESCRIPT_DLL_API Data operator+(const boost::python::object& left, const Data& right); |
1478 |
|
1479 |
/** |
1480 |
\brief |
1481 |
Operator- |
1482 |
Takes LHS python::object and RHS Data object. |
1483 |
python::object must be convertable to Data type. |
1484 |
*/ |
1485 |
ESCRIPT_DLL_API Data operator-(const boost::python::object& left, const Data& right); |
1486 |
|
1487 |
/** |
1488 |
\brief |
1489 |
Operator* |
1490 |
Takes LHS python::object and RHS Data object. |
1491 |
python::object must be convertable to Data type. |
1492 |
*/ |
1493 |
ESCRIPT_DLL_API Data operator*(const boost::python::object& left, const Data& right); |
1494 |
|
1495 |
/** |
1496 |
\brief |
1497 |
Operator/ |
1498 |
Takes LHS python::object and RHS Data object. |
1499 |
python::object must be convertable to Data type. |
1500 |
*/ |
1501 |
ESCRIPT_DLL_API Data operator/(const boost::python::object& left, const Data& right); |
1502 |
|
1503 |
/** |
1504 |
\brief |
1505 |
Output operator |
1506 |
*/ |
1507 |
ESCRIPT_DLL_API std::ostream& operator<<(std::ostream& o, const Data& data); |
1508 |
|
1509 |
/** |
1510 |
\brief |
1511 |
Compute a tensor product of two Data objects |
1512 |
\param arg0 - Input - Data object |
1513 |
\param arg1 - Input - Data object |
1514 |
\param axis_offset - Input - axis offset |
1515 |
\param transpose - Input - 0: transpose neither, 1: transpose arg0, 2: transpose arg1 |
1516 |
*/ |
1517 |
ESCRIPT_DLL_API |
1518 |
Data |
1519 |
C_GeneralTensorProduct(Data& arg0, |
1520 |
Data& arg1, |
1521 |
int axis_offset=0, |
1522 |
int transpose=0); |
1523 |
|
1524 |
/** |
1525 |
\brief |
1526 |
Return true if operands are equivalent, else return false. |
1527 |
NB: this operator does very little at this point, and isn't to |
1528 |
be relied on. Requires further implementation. |
1529 |
*/ |
1530 |
//ESCRIPT_DLL_API bool operator==(const Data& left, const Data& right); |
1531 |
|
1532 |
/** |
1533 |
\brief |
1534 |
Perform the given binary operation with this and right as operands. |
1535 |
Right is a Data object. |
1536 |
*/ |
1537 |
template <class BinaryFunction> |
1538 |
inline |
1539 |
void |
1540 |
Data::binaryOp(const Data& right, |
1541 |
BinaryFunction operation) |
1542 |
{ |
1543 |
// |
1544 |
// if this has a rank of zero promote it to the rank of the RHS |
1545 |
if (getPointDataView().getRank()==0 && right.getPointDataView().getRank()!=0) { |
1546 |
throw DataException("Error - attempt to update rank zero object with object with rank bigger than zero."); |
1547 |
} |
1548 |
// |
1549 |
// initially make the temporary a shallow copy |
1550 |
Data tempRight(right); |
1551 |
if (getFunctionSpace()!=right.getFunctionSpace()) { |
1552 |
if (right.probeInterpolation(getFunctionSpace())) { |
1553 |
// |
1554 |
// an interpolation is required so create a new Data |
1555 |
tempRight=Data(right,this->getFunctionSpace()); |
1556 |
} else if (probeInterpolation(right.getFunctionSpace())) { |
1557 |
// |
1558 |
// interpolate onto the RHS function space |
1559 |
Data tempLeft(*this,right.getFunctionSpace()); |
1560 |
m_data=tempLeft.m_data; |
1561 |
} |
1562 |
} |
1563 |
operandCheck(tempRight); |
1564 |
// |
1565 |
// ensure this has the right type for the RHS |
1566 |
typeMatchRight(tempRight); |
1567 |
// |
1568 |
// Need to cast to the concrete types so that the correct binaryOp |
1569 |
// is called. |
1570 |
if (isExpanded()) { |
1571 |
// |
1572 |
// Expanded data will be done in parallel, the right hand side can be |
1573 |
// of any data type |
1574 |
DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get()); |
1575 |
EsysAssert((leftC!=0), "Programming error - casting to DataExpanded."); |
1576 |
escript::binaryOp(*leftC,*(tempRight.m_data.get()),operation); |
1577 |
} else if (isTagged()) { |
1578 |
// |
1579 |
// Tagged data is operated on serially, the right hand side can be |
1580 |
// either DataConstant or DataTagged |
1581 |
DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get()); |
1582 |
EsysAssert((leftC!=0), "Programming error - casting to DataTagged."); |
1583 |
if (right.isTagged()) { |
1584 |
DataTagged* rightC=dynamic_cast<DataTagged*>(tempRight.m_data.get()); |
1585 |
EsysAssert((rightC!=0), "Programming error - casting to DataTagged."); |
1586 |
escript::binaryOp(*leftC,*rightC,operation); |
1587 |
} else { |
1588 |
DataConstant* rightC=dynamic_cast<DataConstant*>(tempRight.m_data.get()); |
1589 |
EsysAssert((rightC!=0), "Programming error - casting to DataConstant."); |
1590 |
escript::binaryOp(*leftC,*rightC,operation); |
1591 |
} |
1592 |
} else if (isConstant()) { |
1593 |
DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get()); |
1594 |
DataConstant* rightC=dynamic_cast<DataConstant*>(tempRight.m_data.get()); |
1595 |
EsysAssert((leftC!=0 && rightC!=0), "Programming error - casting to DataConstant."); |
1596 |
escript::binaryOp(*leftC,*rightC,operation); |
1597 |
} |
1598 |
#if defined DOPROF |
1599 |
profData->binary++; |
1600 |
#endif |
1601 |
} |
1602 |
|
1603 |
/** |
1604 |
\brief |
1605 |
Perform the given unary operation on other and return the result. |
1606 |
Given operation is performed on each element of each data point, thus |
1607 |
argument object is a rank n Data object, and returned object is a rank n |
1608 |
Data object. |
1609 |
Calls Data::unaryOp. |
1610 |
*/ |
1611 |
template <class UnaryFunction> |
1612 |
inline |
1613 |
Data |
1614 |
unaryOp(const Data& other, |
1615 |
UnaryFunction operation) |
1616 |
{ |
1617 |
Data result; |
1618 |
result.copy(other); |
1619 |
result.unaryOp(operation); |
1620 |
return result; |
1621 |
} |
1622 |
|
1623 |
/** |
1624 |
\brief |
1625 |
Perform the given unary operation on this. |
1626 |
Given operation is performed on each element of each data point. |
1627 |
Calls escript::unaryOp. |
1628 |
*/ |
1629 |
template <class UnaryFunction> |
1630 |
inline |
1631 |
void |
1632 |
Data::unaryOp(UnaryFunction operation) |
1633 |
{ |
1634 |
if (isExpanded()) { |
1635 |
DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get()); |
1636 |
EsysAssert((leftC!=0), "Programming error - casting to DataExpanded."); |
1637 |
escript::unaryOp(*leftC,operation); |
1638 |
} else if (isTagged()) { |
1639 |
DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get()); |
1640 |
EsysAssert((leftC!=0), "Programming error - casting to DataTagged."); |
1641 |
escript::unaryOp(*leftC,operation); |
1642 |
} else if (isConstant()) { |
1643 |
DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get()); |
1644 |
EsysAssert((leftC!=0), "Programming error - casting to DataConstant."); |
1645 |
escript::unaryOp(*leftC,operation); |
1646 |
} |
1647 |
} |
1648 |
|
1649 |
/** |
1650 |
\brief |
1651 |
Perform the given Data object reduction algorithm on this and return the result. |
1652 |
Given operation combines each element of each data point, thus argument |
1653 |
object (*this) is a rank n Data object, and returned object is a scalar. |
1654 |
Calls escript::algorithm. |
1655 |
*/ |
1656 |
template <class BinaryFunction> |
1657 |
inline |
1658 |
double |
1659 |
Data::algorithm(BinaryFunction operation, double initial_value) const |
1660 |
{ |
1661 |
if (isExpanded()) { |
1662 |
DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get()); |
1663 |
EsysAssert((leftC!=0), "Programming error - casting to DataExpanded."); |
1664 |
return escript::algorithm(*leftC,operation,initial_value); |
1665 |
} else if (isTagged()) { |
1666 |
DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get()); |
1667 |
EsysAssert((leftC!=0), "Programming error - casting to DataTagged."); |
1668 |
return escript::algorithm(*leftC,operation,initial_value); |
1669 |
} else if (isConstant()) { |
1670 |
DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get()); |
1671 |
EsysAssert((leftC!=0), "Programming error - casting to DataConstant."); |
1672 |
return escript::algorithm(*leftC,operation,initial_value); |
1673 |
} |
1674 |
return 0; |
1675 |
} |
1676 |
|
1677 |
/** |
1678 |
\brief |
1679 |
Perform the given data point reduction algorithm on data and return the result. |
1680 |
Given operation combines each element within each data point into a scalar, |
1681 |
thus argument object is a rank n Data object, and returned object is a |
1682 |
rank 0 Data object. |
1683 |
Calls escript::dp_algorithm. |
1684 |
*/ |
1685 |
template <class BinaryFunction> |
1686 |
inline |
1687 |
Data |
1688 |
Data::dp_algorithm(BinaryFunction operation, double initial_value) const |
1689 |
{ |
1690 |
if (isExpanded()) { |
1691 |
Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded()); |
1692 |
DataExpanded* dataE=dynamic_cast<DataExpanded*>(m_data.get()); |
1693 |
DataExpanded* resultE=dynamic_cast<DataExpanded*>(result.m_data.get()); |
1694 |
EsysAssert((dataE!=0), "Programming error - casting data to DataExpanded."); |
1695 |
EsysAssert((resultE!=0), "Programming error - casting result to DataExpanded."); |
1696 |
escript::dp_algorithm(*dataE,*resultE,operation,initial_value); |
1697 |
return result; |
1698 |
} else if (isTagged()) { |
1699 |
DataTagged* dataT=dynamic_cast<DataTagged*>(m_data.get()); |
1700 |
DataArrayView::ShapeType viewShape; |
1701 |
DataArrayView::ValueType viewData(1); |
1702 |
viewData[0]=0; |
1703 |
DataArrayView defaultValue(viewData,viewShape); |
1704 |
DataTagged::TagListType keys; |
1705 |
DataTagged::ValueListType values; |
1706 |
DataTagged::DataMapType::const_iterator i; |
1707 |
for (i=dataT->getTagLookup().begin();i!=dataT->getTagLookup().end();i++) { |
1708 |
keys.push_back(i->first); |
1709 |
values.push_back(defaultValue); |
1710 |
} |
1711 |
Data result(keys,values,defaultValue,getFunctionSpace()); |
1712 |
DataTagged* resultT=dynamic_cast<DataTagged*>(result.m_data.get()); |
1713 |
EsysAssert((dataT!=0), "Programming error - casting data to DataTagged."); |
1714 |
EsysAssert((resultT!=0), "Programming error - casting result to DataTagged."); |
1715 |
escript::dp_algorithm(*dataT,*resultT,operation,initial_value); |
1716 |
return result; |
1717 |
} else if (isConstant()) { |
1718 |
Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded()); |
1719 |
DataConstant* dataC=dynamic_cast<DataConstant*>(m_data.get()); |
1720 |
DataConstant* resultC=dynamic_cast<DataConstant*>(result.m_data.get()); |
1721 |
EsysAssert((dataC!=0), "Programming error - casting data to DataConstant."); |
1722 |
EsysAssert((resultC!=0), "Programming error - casting result to DataConstant."); |
1723 |
escript::dp_algorithm(*dataC,*resultC,operation,initial_value); |
1724 |
return result; |
1725 |
} |
1726 |
Data falseRetVal; // to keep compiler quiet |
1727 |
return falseRetVal; |
1728 |
} |
1729 |
|
1730 |
} |
1731 |
#endif |