/[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 800 - (show annotations)
Tue Aug 8 11:23:18 2006 UTC (13 years, 3 months ago) by gross
Original Path: trunk/escript/src/Data.h
File MIME type: text/plain
File size: 43024 byte(s)
new function _swap. Python wrapper + testing is still missing.


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

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26