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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 854 - (show annotations)
Thu Sep 21 05:29:42 2006 UTC (13 years, 2 months ago) by gross
File MIME type: text/plain
File size: 41806 byte(s)
Some modifications to the binary operations +,-,*/, pow. 
The code is a bit simpler now and more efficient has there is
no reseising required now. the resizing method has been removed as
it is very, very inefficient. Even serial code should be faster now.
It is now forbidden to do an inplace update of scalar data object with an object 
of rank >0 as this is very slow (and does not make much sense). 


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

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26