/[escript]/branches/schroedinger/escript/src/Data.h
ViewVC logotype

Contents of /branches/schroedinger/escript/src/Data.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1044 - (show annotations)
Mon Mar 19 07:29:31 2007 UTC (12 years, 8 months ago) by gross
Original Path: trunk/escript/src/Data.h
File MIME type: text/plain
File size: 41326 byte(s)
clear name tagging is supported now.
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
580 /**
581 \brief
582 Assign the given value to the tag assocciated with name. Implicitly converts this
583 object to type DataTagged. Throws an exception if this object
584 cannot be converted to a DataTagged object or name cannot be mapped onto a tag key.
585 \param tagKey - Input - Integer key.
586 \param value - Input - Value to associate with given key.
587 ==>*
588 */
589 ESCRIPT_DLL_API
590 void
591 setTaggedValueByName(std::string name,
592 const boost::python::object& value);
593
594 /**
595 \brief
596 Assign the given value to the tag. Implicitly converts this
597 object to type DataTagged. Throws an exception if this object
598 cannot be converted to a DataTagged object.
599 \param tagKey - Input - Integer key.
600 \param value - Input - Value to associate with given key.
601 ==>*
602 */
603 ESCRIPT_DLL_API
604 void
605 setTaggedValue(int tagKey,
606 const boost::python::object& value);
607
608 /**
609 \brief
610 Assign the given value to the tag. Implicitly converts this
611 object to type DataTagged. Throws an exception if this object
612 cannot be converted to a DataTagged object.
613 \param tagKey - Input - Integer key.
614 \param value - Input - Value to associate with given key.
615 ==>*
616 */
617 ESCRIPT_DLL_API
618 void
619 setTaggedValueFromCPP(int tagKey,
620 const DataArrayView& value);
621
622 /**
623 \brief
624 Copy other Data object into this Data object where mask is positive.
625 */
626 ESCRIPT_DLL_API
627 void
628 copyWithMask(const Data& other,
629 const Data& mask);
630
631 /**
632 Data object operation methods and operators.
633 */
634
635 /**
636 \brief
637 Interpolates this onto the given functionspace and returns
638 the result as a Data object.
639 *
640 */
641 ESCRIPT_DLL_API
642 Data
643 interpolate(const FunctionSpace& functionspace) const;
644
645 /**
646 \brief
647 Calculates the gradient of the data at the data points of functionspace.
648 If functionspace is not present the function space of Function(getDomain()) is used.
649 *
650 */
651 ESCRIPT_DLL_API
652 Data
653 gradOn(const FunctionSpace& functionspace) const;
654
655 ESCRIPT_DLL_API
656 Data
657 grad() const;
658
659 /**
660 \brief
661 Calculate the integral over the function space domain.
662 *
663 */
664 ESCRIPT_DLL_API
665 boost::python::numeric::array
666 integrate() const;
667
668 /**
669 \brief
670 Returns 1./ Data object
671 *
672 */
673 ESCRIPT_DLL_API
674 Data
675 oneOver() const;
676 /**
677 \brief
678 Return a Data with a 1 for +ive values and a 0 for 0 or -ive values.
679 *
680 */
681 ESCRIPT_DLL_API
682 Data
683 wherePositive() const;
684
685 /**
686 \brief
687 Return a Data with a 1 for -ive values and a 0 for +ive or 0 values.
688 *
689 */
690 ESCRIPT_DLL_API
691 Data
692 whereNegative() const;
693
694 /**
695 \brief
696 Return a Data with a 1 for +ive or 0 values and a 0 for -ive values.
697 *
698 */
699 ESCRIPT_DLL_API
700 Data
701 whereNonNegative() const;
702
703 /**
704 \brief
705 Return a Data with a 1 for -ive or 0 values and a 0 for +ive values.
706 *
707 */
708 ESCRIPT_DLL_API
709 Data
710 whereNonPositive() const;
711
712 /**
713 \brief
714 Return a Data with a 1 for 0 values and a 0 for +ive or -ive values.
715 *
716 */
717 ESCRIPT_DLL_API
718 Data
719 whereZero(double tol=0.0) const;
720
721 /**
722 \brief
723 Return a Data with a 0 for 0 values and a 1 for +ive or -ive values.
724 *
725 */
726 ESCRIPT_DLL_API
727 Data
728 whereNonZero(double tol=0.0) const;
729
730 /**
731 \brief
732 Return the maximum absolute value of this Data object.
733 *
734 */
735 ESCRIPT_DLL_API
736 double
737 Lsup() const;
738
739 /**
740 \brief
741 Return the minimum absolute value of this Data object.
742 *
743 */
744 ESCRIPT_DLL_API
745 double
746 Linf() const;
747
748 /**
749 \brief
750 Return the maximum value of this Data object.
751 *
752 */
753 ESCRIPT_DLL_API
754 double
755 sup() const;
756
757 /**
758 \brief
759 Return the minimum value of this Data object.
760 *
761 */
762 ESCRIPT_DLL_API
763 double
764 inf() const;
765
766 /**
767 \brief
768 Return the absolute value of each data point of this Data object.
769 *
770 */
771 ESCRIPT_DLL_API
772 Data
773 abs() const;
774
775 /**
776 \brief
777 Return the maximum value of each data point of this Data object.
778 *
779 */
780 ESCRIPT_DLL_API
781 Data
782 maxval() const;
783
784 /**
785 \brief
786 Return the minimum value of each data point of this Data object.
787 *
788 */
789 ESCRIPT_DLL_API
790 Data
791 minval() const;
792
793 /**
794 \brief
795 Return the (sample number, data-point number) of the data point with
796 the minimum value in this Data object.
797 */
798 ESCRIPT_DLL_API
799 const boost::python::tuple
800 minGlobalDataPoint() const;
801
802 ESCRIPT_DLL_API
803 void
804 calc_minGlobalDataPoint(int& ProcNo, int& DataPointNo) const;
805 /**
806 \brief
807 Return the sign of each data point of this Data object.
808 -1 for negative values, zero for zero values, 1 for positive values.
809 *
810 */
811 ESCRIPT_DLL_API
812 Data
813 sign() const;
814
815 /**
816 \brief
817 Return the symmetric part of a matrix which is half the matrix plus its transpose.
818 *
819 */
820 ESCRIPT_DLL_API
821 Data
822 symmetric() const;
823
824 /**
825 \brief
826 Return the nonsymmetric part of a matrix which is half the matrix minus its transpose.
827 *
828 */
829 ESCRIPT_DLL_API
830 Data
831 nonsymmetric() const;
832
833 /**
834 \brief
835 Return the trace of a matrix
836 *
837 */
838 ESCRIPT_DLL_API
839 Data
840 trace(int axis_offset) const;
841
842 /**
843 \brief
844 Transpose each data point of this Data object around the given axis.
845 *
846 */
847 ESCRIPT_DLL_API
848 Data
849 transpose(int axis_offset) const;
850
851 /**
852 \brief
853 Return the eigenvalues of the symmetric part at each data point of this Data object in increasing values.
854 Currently this function is restricted to rank 2, square shape, and dimension 3.
855 *
856 */
857 ESCRIPT_DLL_API
858 Data
859 eigenvalues() const;
860
861 /**
862 \brief
863 Return the eigenvalues and corresponding eigenvcetors of the symmetric part at each data point of this Data object.
864 the eigenvalues are ordered in increasing size where eigenvalues with relative difference less than
865 tol are treated as equal. The eigenvectors are orthogonal, normalized and the sclaed such that the
866 first non-zero entry is positive.
867 Currently this function is restricted to rank 2, square shape, and dimension 3
868 *
869 */
870 ESCRIPT_DLL_API
871 const boost::python::tuple
872 eigenvalues_and_eigenvectors(const double tol=1.e-12) const;
873
874 /**
875 \brief
876 swaps the components axis0 and axis1
877 *
878 */
879 ESCRIPT_DLL_API
880 Data
881 swapaxes(const int axis0, const int axis1) const;
882
883 /**
884 \brief
885 Return the error function erf of each data point of this Data object.
886 *
887 */
888 ESCRIPT_DLL_API
889 Data
890 erf() const;
891
892 /**
893 \brief
894 Return the sin of each data point of this Data object.
895 *
896 */
897 ESCRIPT_DLL_API
898 Data
899 sin() const;
900
901 /**
902 \brief
903 Return the cos of each data point of this Data object.
904 *
905 */
906 ESCRIPT_DLL_API
907 Data
908 cos() const;
909
910 /**
911 \brief
912 Return the tan of each data point of this Data object.
913 *
914 */
915 ESCRIPT_DLL_API
916 Data
917 tan() const;
918
919 /**
920 \brief
921 Return the asin of each data point of this Data object.
922 *
923 */
924 ESCRIPT_DLL_API
925 Data
926 asin() const;
927
928 /**
929 \brief
930 Return the acos of each data point of this Data object.
931 *
932 */
933 ESCRIPT_DLL_API
934 Data
935 acos() const;
936
937 /**
938 \brief
939 Return the atan of each data point of this Data object.
940 *
941 */
942 ESCRIPT_DLL_API
943 Data
944 atan() const;
945
946 /**
947 \brief
948 Return the sinh of each data point of this Data object.
949 *
950 */
951 ESCRIPT_DLL_API
952 Data
953 sinh() const;
954
955 /**
956 \brief
957 Return the cosh of each data point of this Data object.
958 *
959 */
960 ESCRIPT_DLL_API
961 Data
962 cosh() const;
963
964 /**
965 \brief
966 Return the tanh of each data point of this Data object.
967 *
968 */
969 ESCRIPT_DLL_API
970 Data
971 tanh() const;
972
973 /**
974 \brief
975 Return the asinh of each data point of this Data object.
976 *
977 */
978 ESCRIPT_DLL_API
979 Data
980 asinh() const;
981
982 /**
983 \brief
984 Return the acosh of each data point of this Data object.
985 *
986 */
987 ESCRIPT_DLL_API
988 Data
989 acosh() const;
990
991 /**
992 \brief
993 Return the atanh of each data point of this Data object.
994 *
995 */
996 ESCRIPT_DLL_API
997 Data
998 atanh() const;
999
1000 /**
1001 \brief
1002 Return the log to base 10 of each data point of this Data object.
1003 *
1004 */
1005 ESCRIPT_DLL_API
1006 Data
1007 log10() const;
1008
1009 /**
1010 \brief
1011 Return the natural log of each data point of this Data object.
1012 *
1013 */
1014 ESCRIPT_DLL_API
1015 Data
1016 log() const;
1017
1018 /**
1019 \brief
1020 Return the exponential function of each data point of this Data object.
1021 *
1022 */
1023 ESCRIPT_DLL_API
1024 Data
1025 exp() const;
1026
1027 /**
1028 \brief
1029 Return the square root of each data point of this Data object.
1030 *
1031 */
1032 ESCRIPT_DLL_API
1033 Data
1034 sqrt() const;
1035
1036 /**
1037 \brief
1038 Return the negation of each data point of this Data object.
1039 *
1040 */
1041 ESCRIPT_DLL_API
1042 Data
1043 neg() const;
1044
1045 /**
1046 \brief
1047 Return the identity of each data point of this Data object.
1048 Simply returns this object unmodified.
1049 *
1050 */
1051 ESCRIPT_DLL_API
1052 Data
1053 pos() const;
1054
1055 /**
1056 \brief
1057 Return the given power of each data point of this Data object.
1058
1059 \param right Input - the power to raise the object to.
1060 *
1061 */
1062 ESCRIPT_DLL_API
1063 Data
1064 powD(const Data& right) const;
1065
1066 /**
1067 \brief
1068 Return the given power of each data point of this boost python object.
1069
1070 \param right Input - the power to raise the object to.
1071 *
1072 */
1073 ESCRIPT_DLL_API
1074 Data
1075 powO(const boost::python::object& right) const;
1076
1077 /**
1078 \brief
1079 Return the given power of each data point of this boost python object.
1080
1081 \param left Input - the bases
1082 *
1083 */
1084
1085 ESCRIPT_DLL_API
1086 Data
1087 rpowO(const boost::python::object& left) const;
1088
1089 /**
1090 \brief
1091 writes the object to a file in the DX file format
1092 */
1093 ESCRIPT_DLL_API
1094 void
1095 saveDX(std::string fileName) const;
1096
1097 /**
1098 \brief
1099 writes the object to a file in the VTK file format
1100 */
1101 ESCRIPT_DLL_API
1102 void
1103 saveVTK(std::string fileName) const;
1104
1105 /**
1106 \brief
1107 Overloaded operator +=
1108 \param right - Input - The right hand side.
1109 *
1110 */
1111 ESCRIPT_DLL_API
1112 Data& operator+=(const Data& right);
1113 ESCRIPT_DLL_API
1114 Data& operator+=(const boost::python::object& right);
1115
1116 /**
1117 \brief
1118 Overloaded operator -=
1119 \param right - Input - The right hand side.
1120 *
1121 */
1122 ESCRIPT_DLL_API
1123 Data& operator-=(const Data& right);
1124 ESCRIPT_DLL_API
1125 Data& operator-=(const boost::python::object& right);
1126
1127 /**
1128 \brief
1129 Overloaded operator *=
1130 \param right - Input - The right hand side.
1131 *
1132 */
1133 ESCRIPT_DLL_API
1134 Data& operator*=(const Data& right);
1135 ESCRIPT_DLL_API
1136 Data& operator*=(const boost::python::object& right);
1137
1138 /**
1139 \brief
1140 Overloaded operator /=
1141 \param right - Input - The right hand side.
1142 *
1143 */
1144 ESCRIPT_DLL_API
1145 Data& operator/=(const Data& right);
1146 ESCRIPT_DLL_API
1147 Data& operator/=(const boost::python::object& right);
1148
1149 /**
1150 \brief
1151 Returns true if this can be interpolated to functionspace.
1152 */
1153 ESCRIPT_DLL_API
1154 bool
1155 probeInterpolation(const FunctionSpace& functionspace) const;
1156
1157 /**
1158 Data object slicing methods.
1159 */
1160
1161 /**
1162 \brief
1163 Returns a slice from this Data object.
1164
1165 /description
1166 Implements the [] get operator in python.
1167 Calls getSlice.
1168
1169 \param key - Input - python slice tuple specifying
1170 slice to return.
1171 */
1172 ESCRIPT_DLL_API
1173 Data
1174 getItem(const boost::python::object& key) const;
1175
1176 /**
1177 \brief
1178 Copies slice from value into this Data object.
1179
1180 Implements the [] set operator in python.
1181 Calls setSlice.
1182
1183 \param key - Input - python slice tuple specifying
1184 slice to copy from value.
1185 \param value - Input - Data object to copy from.
1186 */
1187 ESCRIPT_DLL_API
1188 void
1189 setItemD(const boost::python::object& key,
1190 const Data& value);
1191
1192 ESCRIPT_DLL_API
1193 void
1194 setItemO(const boost::python::object& key,
1195 const boost::python::object& value);
1196
1197 // These following public methods should be treated as private.
1198
1199 /**
1200 \brief
1201 Perform the given unary operation on every element of every data point in
1202 this Data object.
1203 */
1204 template <class UnaryFunction>
1205 ESCRIPT_DLL_API
1206 inline
1207 void
1208 unaryOp(UnaryFunction operation);
1209
1210 /**
1211 \brief
1212 Return a Data object containing the specified slice of
1213 this Data object.
1214 \param region - Input - Region to copy.
1215 *
1216 */
1217 ESCRIPT_DLL_API
1218 Data
1219 getSlice(const DataArrayView::RegionType& region) const;
1220
1221 /**
1222 \brief
1223 Copy the specified slice from the given value into this
1224 Data object.
1225 \param value - Input - Data to copy from.
1226 \param region - Input - Region to copy.
1227 *
1228 */
1229 ESCRIPT_DLL_API
1230 void
1231 setSlice(const Data& value,
1232 const DataArrayView::RegionType& region);
1233
1234 /**
1235 \brief
1236 Archive the current Data object to the given file.
1237 \param fileName - Input - file to archive to.
1238 */
1239 ESCRIPT_DLL_API
1240 void
1241 archiveData(const std::string fileName);
1242
1243 /**
1244 \brief
1245 Extract the Data object archived in the given file, overwriting
1246 the current Data object.
1247 Note - the current object must be of type DataEmpty.
1248 \param fileName - Input - file to extract from.
1249 \param fspace - Input - a suitable FunctionSpace descibing the data.
1250 */
1251 ESCRIPT_DLL_API
1252 void
1253 extractData(const std::string fileName,
1254 const FunctionSpace& fspace);
1255
1256
1257 /**
1258 \brief
1259 print the data values to stdout. Used for debugging
1260 */
1261 ESCRIPT_DLL_API
1262 void
1263 print(void);
1264
1265 /**
1266 \brief
1267 return the MPI rank number of the local data
1268 MPI_COMM_WORLD is assumed and the result of MPI_Comm_size()
1269 is returned
1270 */
1271 ESCRIPT_DLL_API
1272 int
1273 get_MPIRank(void) const;
1274
1275 /**
1276 \brief
1277 return the MPI rank number of the local data
1278 MPI_COMM_WORLD is assumed and the result of MPI_Comm_rank()
1279 is returned
1280 */
1281 ESCRIPT_DLL_API
1282 int
1283 get_MPISize(void) const;
1284
1285 /**
1286 \brief
1287 return the MPI rank number of the local data
1288 MPI_COMM_WORLD is assumed and returned.
1289 */
1290 ESCRIPT_DLL_API
1291 MPI_Comm
1292 get_MPIComm(void) const;
1293
1294 /**
1295 \brief
1296 return the object produced by the factory, which is a DataConstant or DataExpanded
1297 */
1298 ESCRIPT_DLL_API
1299 DataAbstract*
1300 borrowData(void) const;
1301
1302 protected:
1303
1304 private:
1305
1306 /**
1307 \brief
1308 Check *this and the right operand are compatible. Throws
1309 an exception if they aren't.
1310 \param right - Input - The right hand side.
1311 */
1312 inline
1313 void
1314 operandCheck(const Data& right) const
1315 {
1316 return m_data->operandCheck(*(right.m_data.get()));
1317 }
1318
1319 /**
1320 \brief
1321 Perform the specified reduction algorithm on every element of every data point in
1322 this Data object according to the given function and return the single value result.
1323 */
1324 template <class BinaryFunction>
1325 inline
1326 double
1327 algorithm(BinaryFunction operation,
1328 double initial_value) const;
1329
1330 /**
1331 \brief
1332 Reduce each data-point in this Data object using the given operation. Return a Data
1333 object with the same number of data-points, but with each data-point containing only
1334 one value - the result of the reduction operation on the corresponding data-point in
1335 this Data object
1336 */
1337 template <class BinaryFunction>
1338 inline
1339 Data
1340 dp_algorithm(BinaryFunction operation,
1341 double initial_value) const;
1342
1343 /**
1344 \brief
1345 Perform the given binary operation on all of the data's elements.
1346 The underlying type of the right hand side (right) determines the final
1347 type of *this after the operation. For example if the right hand side
1348 is expanded *this will be expanded if necessary.
1349 RHS is a Data object.
1350 */
1351 template <class BinaryFunction>
1352 inline
1353 void
1354 binaryOp(const Data& right,
1355 BinaryFunction operation);
1356
1357 /**
1358 \brief
1359 Convert the data type of the RHS to match this.
1360 \param right - Input - data type to match.
1361 */
1362 void
1363 typeMatchLeft(Data& right) const;
1364
1365 /**
1366 \brief
1367 Convert the data type of this to match the RHS.
1368 \param right - Input - data type to match.
1369 */
1370 void
1371 typeMatchRight(const Data& right);
1372
1373 /**
1374 \brief
1375 Construct a Data object of the appropriate type.
1376 */
1377 template <class IValueType>
1378 void
1379 initialise(const IValueType& value,
1380 const FunctionSpace& what,
1381 bool expanded);
1382
1383 //
1384 // flag to protect the data object against any update
1385 bool m_protected;
1386
1387 //
1388 // pointer to the actual data object
1389 boost::shared_ptr<DataAbstract> m_data;
1390
1391 //
1392 // pointer to the internal profiling data
1393 struct profDataEntry *profData;
1394
1395 };
1396
1397 template <class IValueType>
1398 void
1399 Data::initialise(const IValueType& value,
1400 const FunctionSpace& what,
1401 bool expanded)
1402 {
1403 //
1404 // Construct a Data object of the appropriate type.
1405 // Construct the object first as there seems to be a bug which causes
1406 // undefined behaviour if an exception is thrown during construction
1407 // within the shared_ptr constructor.
1408 if (expanded) {
1409 DataAbstract* temp=new DataExpanded(value,what);
1410 boost::shared_ptr<DataAbstract> temp_data(temp);
1411 m_data=temp_data;
1412 } else {
1413 DataAbstract* temp=new DataConstant(value,what);
1414 boost::shared_ptr<DataAbstract> temp_data(temp);
1415 m_data=temp_data;
1416 }
1417 }
1418
1419 /**
1420 Binary Data object operators.
1421 */
1422 inline double rpow(double x,double y)
1423 {
1424 return pow(y,x);
1425 }
1426
1427 /**
1428 \brief
1429 Operator+
1430 Takes two Data objects.
1431 */
1432 ESCRIPT_DLL_API Data operator+(const Data& left, const Data& right);
1433
1434 /**
1435 \brief
1436 Operator-
1437 Takes two Data objects.
1438 */
1439 ESCRIPT_DLL_API Data operator-(const Data& left, const Data& right);
1440
1441 /**
1442 \brief
1443 Operator*
1444 Takes two Data objects.
1445 */
1446 ESCRIPT_DLL_API Data operator*(const Data& left, const Data& right);
1447
1448 /**
1449 \brief
1450 Operator/
1451 Takes two Data objects.
1452 */
1453 ESCRIPT_DLL_API Data operator/(const Data& left, const Data& 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 Data object and RHS python::object.
1475 python::object must be convertable to Data type.
1476 */
1477 ESCRIPT_DLL_API Data operator*(const Data& left, const boost::python::object& right);
1478
1479 /**
1480 \brief
1481 Operator/
1482 Takes LHS Data object and RHS python::object.
1483 python::object must be convertable to Data type.
1484 */
1485 ESCRIPT_DLL_API Data operator/(const Data& left, const boost::python::object& 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 Operator*
1506 Takes LHS python::object and RHS Data object.
1507 python::object must be convertable to Data type.
1508 */
1509 ESCRIPT_DLL_API Data operator*(const boost::python::object& left, const Data& right);
1510
1511 /**
1512 \brief
1513 Operator/
1514 Takes LHS python::object and RHS Data object.
1515 python::object must be convertable to Data type.
1516 */
1517 ESCRIPT_DLL_API Data operator/(const boost::python::object& left, const Data& right);
1518
1519 /**
1520 \brief
1521 Output operator
1522 */
1523 ESCRIPT_DLL_API std::ostream& operator<<(std::ostream& o, const Data& data);
1524
1525 /**
1526 \brief
1527 Compute a tensor product of two Data objects
1528 \param arg0 - Input - Data object
1529 \param arg1 - Input - Data object
1530 \param axis_offset - Input - axis offset
1531 \param transpose - Input - 0: transpose neither, 1: transpose arg0, 2: transpose arg1
1532 */
1533 ESCRIPT_DLL_API
1534 Data
1535 C_GeneralTensorProduct(Data& arg0,
1536 Data& arg1,
1537 int axis_offset=0,
1538 int transpose=0);
1539
1540 /**
1541 \brief
1542 Return true if operands are equivalent, else return false.
1543 NB: this operator does very little at this point, and isn't to
1544 be relied on. Requires further implementation.
1545 */
1546 //ESCRIPT_DLL_API bool operator==(const Data& left, const Data& right);
1547
1548 /**
1549 \brief
1550 Perform the given binary operation with this and right as operands.
1551 Right is a Data object.
1552 */
1553 template <class BinaryFunction>
1554 inline
1555 void
1556 Data::binaryOp(const Data& right,
1557 BinaryFunction operation)
1558 {
1559 //
1560 // if this has a rank of zero promote it to the rank of the RHS
1561 if (getPointDataView().getRank()==0 && right.getPointDataView().getRank()!=0) {
1562 throw DataException("Error - attempt to update rank zero object with object with rank bigger than zero.");
1563 }
1564 //
1565 // initially make the temporary a shallow copy
1566 Data tempRight(right);
1567 if (getFunctionSpace()!=right.getFunctionSpace()) {
1568 if (right.probeInterpolation(getFunctionSpace())) {
1569 //
1570 // an interpolation is required so create a new Data
1571 tempRight=Data(right,this->getFunctionSpace());
1572 } else if (probeInterpolation(right.getFunctionSpace())) {
1573 //
1574 // interpolate onto the RHS function space
1575 Data tempLeft(*this,right.getFunctionSpace());
1576 m_data=tempLeft.m_data;
1577 }
1578 }
1579 operandCheck(tempRight);
1580 //
1581 // ensure this has the right type for the RHS
1582 typeMatchRight(tempRight);
1583 //
1584 // Need to cast to the concrete types so that the correct binaryOp
1585 // is called.
1586 if (isExpanded()) {
1587 //
1588 // Expanded data will be done in parallel, the right hand side can be
1589 // of any data type
1590 DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1591 EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1592 escript::binaryOp(*leftC,*(tempRight.m_data.get()),operation);
1593 } else if (isTagged()) {
1594 //
1595 // Tagged data is operated on serially, the right hand side can be
1596 // either DataConstant or DataTagged
1597 DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1598 EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1599 if (right.isTagged()) {
1600 DataTagged* rightC=dynamic_cast<DataTagged*>(tempRight.m_data.get());
1601 EsysAssert((rightC!=0), "Programming error - casting to DataTagged.");
1602 escript::binaryOp(*leftC,*rightC,operation);
1603 } else {
1604 DataConstant* rightC=dynamic_cast<DataConstant*>(tempRight.m_data.get());
1605 EsysAssert((rightC!=0), "Programming error - casting to DataConstant.");
1606 escript::binaryOp(*leftC,*rightC,operation);
1607 }
1608 } else if (isConstant()) {
1609 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1610 DataConstant* rightC=dynamic_cast<DataConstant*>(tempRight.m_data.get());
1611 EsysAssert((leftC!=0 && rightC!=0), "Programming error - casting to DataConstant.");
1612 escript::binaryOp(*leftC,*rightC,operation);
1613 }
1614 #if defined DOPROF
1615 profData->binary++;
1616 #endif
1617 }
1618
1619 /**
1620 \brief
1621 Perform the given unary operation on other and return the result.
1622 Given operation is performed on each element of each data point, thus
1623 argument object is a rank n Data object, and returned object is a rank n
1624 Data object.
1625 Calls Data::unaryOp.
1626 */
1627 template <class UnaryFunction>
1628 inline
1629 Data
1630 unaryOp(const Data& other,
1631 UnaryFunction operation)
1632 {
1633 Data result;
1634 result.copy(other);
1635 result.unaryOp(operation);
1636 return result;
1637 }
1638
1639 /**
1640 \brief
1641 Perform the given unary operation on this.
1642 Given operation is performed on each element of each data point.
1643 Calls escript::unaryOp.
1644 */
1645 template <class UnaryFunction>
1646 inline
1647 void
1648 Data::unaryOp(UnaryFunction operation)
1649 {
1650 if (isExpanded()) {
1651 DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1652 EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1653 escript::unaryOp(*leftC,operation);
1654 } else if (isTagged()) {
1655 DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1656 EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1657 escript::unaryOp(*leftC,operation);
1658 } else if (isConstant()) {
1659 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1660 EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");
1661 escript::unaryOp(*leftC,operation);
1662 }
1663 }
1664
1665 /**
1666 \brief
1667 Perform the given Data object reduction algorithm on this and return the result.
1668 Given operation combines each element of each data point, thus argument
1669 object (*this) is a rank n Data object, and returned object is a scalar.
1670 Calls escript::algorithm.
1671 */
1672 template <class BinaryFunction>
1673 inline
1674 double
1675 Data::algorithm(BinaryFunction operation, double initial_value) const
1676 {
1677 if (isExpanded()) {
1678 DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1679 EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1680 return escript::algorithm(*leftC,operation,initial_value);
1681 } else if (isTagged()) {
1682 DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1683 EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1684 return escript::algorithm(*leftC,operation,initial_value);
1685 } else if (isConstant()) {
1686 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1687 EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");
1688 return escript::algorithm(*leftC,operation,initial_value);
1689 }
1690 return 0;
1691 }
1692
1693 /**
1694 \brief
1695 Perform the given data point reduction algorithm on data and return the result.
1696 Given operation combines each element within each data point into a scalar,
1697 thus argument object is a rank n Data object, and returned object is a
1698 rank 0 Data object.
1699 Calls escript::dp_algorithm.
1700 */
1701 template <class BinaryFunction>
1702 inline
1703 Data
1704 Data::dp_algorithm(BinaryFunction operation, double initial_value) const
1705 {
1706 if (isExpanded()) {
1707 Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1708 DataExpanded* dataE=dynamic_cast<DataExpanded*>(m_data.get());
1709 DataExpanded* resultE=dynamic_cast<DataExpanded*>(result.m_data.get());
1710 EsysAssert((dataE!=0), "Programming error - casting data to DataExpanded.");
1711 EsysAssert((resultE!=0), "Programming error - casting result to DataExpanded.");
1712 escript::dp_algorithm(*dataE,*resultE,operation,initial_value);
1713 return result;
1714 } else if (isTagged()) {
1715 DataTagged* dataT=dynamic_cast<DataTagged*>(m_data.get());
1716 DataArrayView::ShapeType viewShape;
1717 DataArrayView::ValueType viewData(1);
1718 viewData[0]=0;
1719 DataArrayView defaultValue(viewData,viewShape);
1720 DataTagged::TagListType keys;
1721 DataTagged::ValueListType values;
1722 DataTagged::DataMapType::const_iterator i;
1723 for (i=dataT->getTagLookup().begin();i!=dataT->getTagLookup().end();i++) {
1724 keys.push_back(i->first);
1725 values.push_back(defaultValue);
1726 }
1727 Data result(keys,values,defaultValue,getFunctionSpace());
1728 DataTagged* resultT=dynamic_cast<DataTagged*>(result.m_data.get());
1729 EsysAssert((dataT!=0), "Programming error - casting data to DataTagged.");
1730 EsysAssert((resultT!=0), "Programming error - casting result to DataTagged.");
1731 escript::dp_algorithm(*dataT,*resultT,operation,initial_value);
1732 return result;
1733 } else if (isConstant()) {
1734 Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1735 DataConstant* dataC=dynamic_cast<DataConstant*>(m_data.get());
1736 DataConstant* resultC=dynamic_cast<DataConstant*>(result.m_data.get());
1737 EsysAssert((dataC!=0), "Programming error - casting data to DataConstant.");
1738 EsysAssert((resultC!=0), "Programming error - casting result to DataConstant.");
1739 escript::dp_algorithm(*dataC,*resultC,operation,initial_value);
1740 return result;
1741 }
1742 Data falseRetVal; // to keep compiler quiet
1743 return falseRetVal;
1744 }
1745
1746 }
1747 #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26