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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1044 - (hide 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 jgs 94 // $Id$
2 jgs 121 /*
3 elspeth 615 ************************************************************
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 jgs 121 */
13 jgs 94
14 jgs 121 /** \file Data.h */
15 jgs 94
16     #ifndef DATA_H
17     #define DATA_H
18 woo409 757 #include "system_dep.h"
19 jgs 94
20 jgs 474 #include "DataAbstract.h"
21     #include "DataAlgorithm.h"
22     #include "FunctionSpace.h"
23     #include "BinaryOp.h"
24     #include "UnaryOp.h"
25     #include "DataException.h"
26 jgs 94
27     extern "C" {
28 jgs 474 #include "DataC.h"
29 ksteube 971 #include "paso/Paso.h"
30 jgs 94 }
31    
32 bcumming 790 #ifndef PASO_MPI
33     #define MPI_Comm long
34     #endif
35    
36 jgs 94 #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 jgs 121 namespace escript {
45    
46     //
47 jgs 149 // Forward declaration for various implementations of Data.
48 jgs 121 class DataConstant;
49     class DataTagged;
50     class DataExpanded;
51    
52 jgs 94 /**
53     \brief
54 jgs 121 Data creates the appropriate Data object for the given construction
55     arguments.
56 jgs 94
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 jgs 110 // These typedefs allow function names to be cast to pointers
69     // to functions of the appropriate type when calling unaryOp etc.
70 jgs 94 typedef double (*UnaryDFunPtr)(double);
71     typedef double (*BinaryDFunPtr)(double,double);
72    
73 gross 854
74 jgs 94 /**
75 jgs 102 Constructors.
76     */
77    
78     /**
79 jgs 94 \brief
80     Default constructor.
81     Creates a DataEmpty object.
82     */
83 woo409 757 ESCRIPT_DLL_API
84 jgs 94 Data();
85    
86     /**
87     \brief
88     Copy constructor.
89     WARNING: Only performs a shallow copy.
90     */
91 woo409 757 ESCRIPT_DLL_API
92 jgs 94 Data(const Data& inData);
93    
94     /**
95     \brief
96     Constructor from another Data object. If "what" is different from the
97 jgs 102 function space of inData the inData are tried to be interpolated to what,
98 jgs 94 otherwise a shallow copy of inData is returned.
99     */
100 woo409 757 ESCRIPT_DLL_API
101 jgs 94 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 woo409 757 ESCRIPT_DLL_API
115 jgs 94 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 woo409 757 ESCRIPT_DLL_API
131 jgs 94 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 woo409 757 ESCRIPT_DLL_API
144 jgs 94 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 jgs 544 ==>*
160 jgs 94 */
161 woo409 757 ESCRIPT_DLL_API
162 jgs 94 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 woo409 757 ESCRIPT_DLL_API
179 jgs 94 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 woo409 757 ESCRIPT_DLL_API
195 jgs 94 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 woo409 757 ESCRIPT_DLL_API
209 jgs 94 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 woo409 757 ESCRIPT_DLL_API
217 jgs 94 Data(double value,
218     const boost::python::tuple& shape=boost::python::make_tuple(),
219     const FunctionSpace& what=FunctionSpace(),
220     bool expanded=false);
221 jgs 151 /**
222     \brief
223     Destructor
224     */
225 woo409 757 ESCRIPT_DLL_API
226 jgs 151 ~Data();
227 jgs 94
228     /**
229     \brief
230 jgs 102 Perform a deep copy.
231 jgs 94 */
232 woo409 757 ESCRIPT_DLL_API
233 jgs 94 void
234 jgs 102 copy(const Data& other);
235 jgs 94
236     /**
237 jgs 102 Member access methods.
238 jgs 94 */
239    
240     /**
241     \brief
242 gross 783 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 gross 1034
258 gross 783 /**
259     \brief
260 gross 1034 Return the values of a data point on this process
261 jgs 117 */
262 woo409 757 ESCRIPT_DLL_API
263 jgs 121 const boost::python::numeric::array
264 gross 1034 getValueOfDataPoint(int dataPointNo);
265 jgs 117
266     /**
267     \brief
268 gross 1034 sets the values of a data-point from a python object on this process
269 jgs 121 */
270 woo409 757 ESCRIPT_DLL_API
271 gross 921 void
272 gross 1034 setValueOfDataPointToPyObject(int dataPointNo, const boost::python::object& py_object);
273 jgs 121
274     /**
275     \brief
276 gross 1034 sets the values of a data-point from a numarray object on this process
277 jgs 121 */
278 woo409 757 ESCRIPT_DLL_API
279 jgs 149 void
280 gross 1034 setValueOfDataPointToArray(int dataPointNo, const boost::python::numeric::array&);
281 jgs 149
282     /**
283     \brief
284 gross 922 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 gross 921 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 jgs 149 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 woo409 757 ESCRIPT_DLL_API
306 jgs 149 int
307     getTagNumber(int dpno);
308    
309     /**
310     \brief
311 jgs 94 Return the C wrapper for the Data object.
312     */
313 woo409 757 ESCRIPT_DLL_API
314 jgs 102 escriptDataC
315     getDataC();
316 jgs 94
317     /**
318     \brief
319     Return the C wrapper for the Data object - const version.
320     */
321 woo409 757 ESCRIPT_DLL_API
322 jgs 102 escriptDataC
323     getDataC() const;
324 jgs 94
325     /**
326     \brief
327     Write the data as a string.
328     */
329 woo409 757 ESCRIPT_DLL_API
330 jgs 102 inline
331     std::string
332     toString() const
333     {
334     return m_data->toString();
335     }
336 jgs 94
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 woo409 757 ESCRIPT_DLL_API
344 jgs 94 inline
345     const DataArrayView&
346     getPointDataView() const
347     {
348     return m_data->getPointDataView();
349     }
350    
351     /**
352     \brief
353 jgs 102 Whatever the current Data type make this into a DataExpanded.
354 jgs 94 */
355 woo409 757 ESCRIPT_DLL_API
356 jgs 94 void
357     expand();
358    
359     /**
360     \brief
361 jgs 102 If possible convert this Data to DataTagged. This will only allow
362 jgs 94 Constant data to be converted to tagged. An attempt to convert
363     Expanded data to tagged will throw an exception.
364 jgs 544 ==>*
365 jgs 94 */
366 woo409 757 ESCRIPT_DLL_API
367 jgs 94 void
368     tag();
369    
370     /**
371     \brief
372     Return true if this Data is expanded.
373     */
374 woo409 757 ESCRIPT_DLL_API
375 jgs 94 bool
376     isExpanded() const;
377    
378     /**
379     \brief
380     Return true if this Data is tagged.
381     */
382 woo409 757 ESCRIPT_DLL_API
383 jgs 94 bool
384     isTagged() const;
385    
386     /**
387     \brief
388 jgs 102 Return true if this Data is constant.
389 jgs 94 */
390 woo409 757 ESCRIPT_DLL_API
391 jgs 94 bool
392 jgs 102 isConstant() const;
393 jgs 94
394     /**
395     \brief
396 jgs 102 Return true if this Data is empty.
397 jgs 94 */
398 woo409 757 ESCRIPT_DLL_API
399 jgs 94 bool
400 jgs 102 isEmpty() const;
401 jgs 94
402     /**
403     \brief
404     Return the function space.
405     */
406 woo409 757 ESCRIPT_DLL_API
407 jgs 94 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 woo409 757 ESCRIPT_DLL_API
419 jgs 94 const FunctionSpace
420     getCopyOfFunctionSpace() const;
421    
422     /**
423     \brief
424     Return the domain.
425     */
426 woo409 757 ESCRIPT_DLL_API
427 jgs 94 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 woo409 757 ESCRIPT_DLL_API
439 jgs 94 const AbstractDomain
440     getCopyOfDomain() const;
441    
442     /**
443     \brief
444     Return the rank of the point data.
445     */
446 woo409 757 ESCRIPT_DLL_API
447 jgs 94 inline
448     int
449     getDataPointRank() const
450     {
451     return m_data->getPointDataView().getRank();
452     }
453    
454     /**
455     \brief
456 gross 921 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 jgs 102 Return the number of samples.
468 jgs 94 */
469 woo409 757 ESCRIPT_DLL_API
470 jgs 94 inline
471     int
472 jgs 102 getNumSamples() const
473 jgs 94 {
474 jgs 102 return m_data->getNumSamples();
475 jgs 94 }
476    
477     /**
478     \brief
479 jgs 102 Return the number of data points per sample.
480 jgs 94 */
481 woo409 757 ESCRIPT_DLL_API
482 jgs 102 inline
483 jgs 94 int
484 jgs 102 getNumDataPointsPerSample() const
485     {
486     return m_data->getNumDPPSample();
487     }
488 gross 950 /**
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 jgs 94
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 woo409 757 ESCRIPT_DLL_API
507 jgs 102 inline
508 jgs 94 DataAbstract::ValueType::value_type*
509 jgs 102 getSampleData(DataAbstract::ValueType::size_type sampleNo)
510     {
511     return m_data->getSampleData(sampleNo);
512     }
513 jgs 94
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 woo409 757 ESCRIPT_DLL_API
521 jgs 102 inline
522 jgs 94 DataAbstract::ValueType::value_type*
523 jgs 102 getSampleDataByTag(int tag)
524     {
525     return m_data->getSampleDataByTag(tag);
526     }
527 jgs 94
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 woo409 757 ESCRIPT_DLL_API
537 jgs 94 inline
538     DataArrayView
539     getDataPoint(int sampleNo,
540     int dataPointNo)
541     {
542 bcumming 790 return m_data->getDataPoint(sampleNo,dataPointNo);
543 jgs 94 }
544    
545     /**
546     \brief
547     Return a reference to the data point shape.
548     */
549 woo409 757 ESCRIPT_DLL_API
550 jgs 94 const DataArrayView::ShapeType&
551     getDataPointShape() const;
552    
553     /**
554     \brief
555 jgs 102 Return the data point shape as a tuple of integers.
556 jgs 94 */
557 woo409 757 ESCRIPT_DLL_API
558 jgs 121 const boost::python::tuple
559 jgs 94 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 woo409 757 ESCRIPT_DLL_API
567 jgs 94 int
568     getDataPointSize() const;
569    
570     /**
571     \brief
572 jgs 102 Return the number of doubles stored for this Data.
573 jgs 94 */
574 woo409 757 ESCRIPT_DLL_API
575 jgs 94 DataArrayView::ValueType::size_type
576     getLength() const;
577    
578 gross 1044
579    
580 jgs 94 /**
581     \brief
582 gross 1044 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 jgs 102 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 jgs 544 ==>*
602 jgs 94 */
603 woo409 757 ESCRIPT_DLL_API
604 jgs 102 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 jgs 544 ==>*
616 jgs 102 */
617 woo409 757 ESCRIPT_DLL_API
618 jgs 102 void
619 jgs 121 setTaggedValueFromCPP(int tagKey,
620     const DataArrayView& value);
621 jgs 102
622     /**
623     \brief
624     Copy other Data object into this Data object where mask is positive.
625     */
626 woo409 757 ESCRIPT_DLL_API
627 jgs 102 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 jgs 123 *
640 jgs 102 */
641 woo409 757 ESCRIPT_DLL_API
642 jgs 94 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 jgs 123 *
650 jgs 94 */
651 woo409 757 ESCRIPT_DLL_API
652 jgs 94 Data
653     gradOn(const FunctionSpace& functionspace) const;
654    
655 woo409 757 ESCRIPT_DLL_API
656 jgs 94 Data
657     grad() const;
658    
659     /**
660     \brief
661     Calculate the integral over the function space domain.
662 jgs 123 *
663 jgs 94 */
664 woo409 757 ESCRIPT_DLL_API
665 jgs 94 boost::python::numeric::array
666     integrate() const;
667    
668     /**
669     \brief
670 gross 854 Returns 1./ Data object
671     *
672     */
673     ESCRIPT_DLL_API
674     Data
675     oneOver() const;
676     /**
677     \brief
678 jgs 94 Return a Data with a 1 for +ive values and a 0 for 0 or -ive values.
679 jgs 123 *
680 jgs 94 */
681 woo409 757 ESCRIPT_DLL_API
682 jgs 94 Data
683 gross 698 wherePositive() const;
684 jgs 94
685     /**
686     \brief
687 jgs 102 Return a Data with a 1 for -ive values and a 0 for +ive or 0 values.
688 jgs 123 *
689 jgs 94 */
690 woo409 757 ESCRIPT_DLL_API
691 jgs 94 Data
692 gross 698 whereNegative() const;
693 jgs 102
694     /**
695     \brief
696     Return a Data with a 1 for +ive or 0 values and a 0 for -ive values.
697 jgs 123 *
698 jgs 102 */
699 woo409 757 ESCRIPT_DLL_API
700 jgs 102 Data
701 gross 698 whereNonNegative() const;
702 jgs 94
703     /**
704     \brief
705 jgs 102 Return a Data with a 1 for -ive or 0 values and a 0 for +ive values.
706 jgs 123 *
707 jgs 94 */
708 woo409 757 ESCRIPT_DLL_API
709 jgs 94 Data
710 gross 698 whereNonPositive() const;
711 jgs 94
712     /**
713     \brief
714 jgs 102 Return a Data with a 1 for 0 values and a 0 for +ive or -ive values.
715 jgs 123 *
716 jgs 94 */
717 woo409 757 ESCRIPT_DLL_API
718 jgs 94 Data
719 jgs 571 whereZero(double tol=0.0) const;
720 jgs 94
721     /**
722     \brief
723 jgs 102 Return a Data with a 0 for 0 values and a 1 for +ive or -ive values.
724 jgs 123 *
725 jgs 94 */
726 woo409 757 ESCRIPT_DLL_API
727 jgs 94 Data
728 jgs 571 whereNonZero(double tol=0.0) const;
729 jgs 102
730     /**
731     \brief
732     Return the maximum absolute value of this Data object.
733 jgs 123 *
734 jgs 94 */
735 woo409 757 ESCRIPT_DLL_API
736 jgs 102 double
737     Lsup() const;
738 jgs 94
739     /**
740     \brief
741 jgs 117 Return the minimum absolute value of this Data object.
742 jgs 123 *
743 jgs 117 */
744 woo409 757 ESCRIPT_DLL_API
745 jgs 117 double
746     Linf() const;
747    
748     /**
749     \brief
750 jgs 102 Return the maximum value of this Data object.
751 jgs 123 *
752 jgs 94 */
753 woo409 757 ESCRIPT_DLL_API
754 jgs 102 double
755     sup() const;
756 jgs 94
757     /**
758     \brief
759 jgs 102 Return the minimum value of this Data object.
760 jgs 123 *
761 jgs 94 */
762 woo409 757 ESCRIPT_DLL_API
763 jgs 94 double
764 jgs 102 inf() const;
765 jgs 94
766     /**
767     \brief
768 jgs 102 Return the absolute value of each data point of this Data object.
769 jgs 123 *
770 jgs 94 */
771 woo409 757 ESCRIPT_DLL_API
772 jgs 102 Data
773     abs() const;
774 jgs 94
775     /**
776     \brief
777 jgs 102 Return the maximum value of each data point of this Data object.
778 jgs 123 *
779 jgs 94 */
780 woo409 757 ESCRIPT_DLL_API
781 jgs 102 Data
782     maxval() const;
783 jgs 94
784     /**
785     \brief
786 jgs 102 Return the minimum value of each data point of this Data object.
787 jgs 123 *
788 jgs 94 */
789 woo409 757 ESCRIPT_DLL_API
790 jgs 94 Data
791 jgs 102 minval() const;
792 jgs 94
793     /**
794     \brief
795 jgs 121 Return the (sample number, data-point number) of the data point with
796     the minimum value in this Data object.
797     */
798 woo409 757 ESCRIPT_DLL_API
799 jgs 121 const boost::python::tuple
800 gross 921 minGlobalDataPoint() const;
801 jgs 121
802 woo409 757 ESCRIPT_DLL_API
803 jgs 148 void
804 gross 921 calc_minGlobalDataPoint(int& ProcNo, int& DataPointNo) const;
805 jgs 121 /**
806     \brief
807 jgs 102 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 jgs 123 *
810 jgs 94 */
811 woo409 757 ESCRIPT_DLL_API
812 jgs 102 Data
813     sign() const;
814 jgs 94
815     /**
816 jgs 123 \brief
817 ksteube 775 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 gross 800 trace(int axis_offset) const;
841 ksteube 775
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 gross 576 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 woo409 757 ESCRIPT_DLL_API
858 gross 576 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 woo409 757 ESCRIPT_DLL_API
871 gross 576 const boost::python::tuple
872     eigenvalues_and_eigenvectors(const double tol=1.e-12) const;
873    
874     /**
875     \brief
876 gross 804 swaps the components axis0 and axis1
877 jgs 123 *
878 jgs 102 */
879 woo409 757 ESCRIPT_DLL_API
880 jgs 102 Data
881 gross 804 swapaxes(const int axis0, const int axis1) const;
882 jgs 102
883     /**
884 jgs 123 \brief
885 ksteube 876 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 jgs 123 Return the sin of each data point of this Data object.
895     *
896 jgs 102 */
897 woo409 757 ESCRIPT_DLL_API
898 jgs 102 Data
899 jgs 123 sin() const;
900    
901     /**
902     \brief
903     Return the cos of each data point of this Data object.
904     *
905     */
906 woo409 757 ESCRIPT_DLL_API
907 jgs 123 Data
908     cos() const;
909    
910     /**
911     \brief
912     Return the tan of each data point of this Data object.
913     *
914     */
915 woo409 757 ESCRIPT_DLL_API
916 jgs 123 Data
917     tan() const;
918    
919     /**
920     \brief
921 jgs 150 Return the asin of each data point of this Data object.
922     *
923     */
924 woo409 757 ESCRIPT_DLL_API
925 jgs 150 Data
926     asin() const;
927    
928     /**
929     \brief
930     Return the acos of each data point of this Data object.
931     *
932     */
933 woo409 757 ESCRIPT_DLL_API
934 jgs 150 Data
935     acos() const;
936    
937     /**
938     \brief
939     Return the atan of each data point of this Data object.
940     *
941     */
942 woo409 757 ESCRIPT_DLL_API
943 jgs 150 Data
944     atan() const;
945    
946     /**
947     \brief
948     Return the sinh of each data point of this Data object.
949     *
950     */
951 woo409 757 ESCRIPT_DLL_API
952 jgs 150 Data
953     sinh() const;
954    
955     /**
956     \brief
957     Return the cosh of each data point of this Data object.
958     *
959     */
960 woo409 757 ESCRIPT_DLL_API
961 jgs 150 Data
962     cosh() const;
963    
964     /**
965     \brief
966     Return the tanh of each data point of this Data object.
967     *
968     */
969 woo409 757 ESCRIPT_DLL_API
970 jgs 150 Data
971     tanh() const;
972    
973     /**
974     \brief
975     Return the asinh of each data point of this Data object.
976     *
977     */
978 woo409 757 ESCRIPT_DLL_API
979 jgs 150 Data
980     asinh() const;
981    
982     /**
983     \brief
984     Return the acosh of each data point of this Data object.
985     *
986     */
987 woo409 757 ESCRIPT_DLL_API
988 jgs 150 Data
989     acosh() const;
990    
991     /**
992     \brief
993     Return the atanh of each data point of this Data object.
994     *
995     */
996 woo409 757 ESCRIPT_DLL_API
997 jgs 150 Data
998     atanh() const;
999    
1000     /**
1001     \brief
1002 jgs 123 Return the log to base 10 of each data point of this Data object.
1003     *
1004     */
1005 woo409 757 ESCRIPT_DLL_API
1006 jgs 123 Data
1007 gross 286 log10() const;
1008 jgs 123
1009     /**
1010     \brief
1011     Return the natural log of each data point of this Data object.
1012     *
1013     */
1014 woo409 757 ESCRIPT_DLL_API
1015 jgs 123 Data
1016 gross 286 log() const;
1017 jgs 123
1018     /**
1019     \brief
1020     Return the exponential function of each data point of this Data object.
1021     *
1022     */
1023 woo409 757 ESCRIPT_DLL_API
1024 jgs 123 Data
1025 jgs 102 exp() const;
1026    
1027     /**
1028 jgs 123 \brief
1029     Return the square root of each data point of this Data object.
1030     *
1031 jgs 102 */
1032 woo409 757 ESCRIPT_DLL_API
1033 jgs 102 Data
1034     sqrt() const;
1035    
1036     /**
1037 jgs 123 \brief
1038     Return the negation of each data point of this Data object.
1039     *
1040 jgs 121 */
1041 woo409 757 ESCRIPT_DLL_API
1042 jgs 121 Data
1043     neg() const;
1044    
1045     /**
1046 jgs 123 \brief
1047     Return the identity of each data point of this Data object.
1048     Simply returns this object unmodified.
1049     *
1050 jgs 121 */
1051 woo409 757 ESCRIPT_DLL_API
1052 jgs 121 Data
1053     pos() const;
1054    
1055     /**
1056 jgs 94 \brief
1057 jgs 102 Return the given power of each data point of this Data object.
1058 jgs 121
1059     \param right Input - the power to raise the object to.
1060 jgs 123 *
1061 jgs 102 */
1062 woo409 757 ESCRIPT_DLL_API
1063 jgs 102 Data
1064     powD(const Data& right) const;
1065    
1066 jgs 121 /**
1067 jgs 123 \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 jgs 121 */
1073 woo409 757 ESCRIPT_DLL_API
1074 jgs 102 Data
1075     powO(const boost::python::object& right) const;
1076    
1077     /**
1078 jgs 123 \brief
1079 gross 699 Return the given power of each data point of this boost python object.
1080    
1081     \param left Input - the bases
1082     *
1083     */
1084    
1085 woo409 757 ESCRIPT_DLL_API
1086 gross 699 Data
1087     rpowO(const boost::python::object& left) const;
1088    
1089     /**
1090     \brief
1091 jgs 123 writes the object to a file in the DX file format
1092 jgs 104 */
1093 woo409 757 ESCRIPT_DLL_API
1094 jgs 104 void
1095     saveDX(std::string fileName) const;
1096    
1097     /**
1098 jgs 123 \brief
1099     writes the object to a file in the VTK file format
1100 jgs 110 */
1101 woo409 757 ESCRIPT_DLL_API
1102 jgs 110 void
1103     saveVTK(std::string fileName) const;
1104    
1105     /**
1106 jgs 102 \brief
1107     Overloaded operator +=
1108     \param right - Input - The right hand side.
1109 jgs 123 *
1110 jgs 102 */
1111 woo409 757 ESCRIPT_DLL_API
1112 jgs 102 Data& operator+=(const Data& right);
1113 woo409 757 ESCRIPT_DLL_API
1114 jgs 102 Data& operator+=(const boost::python::object& right);
1115    
1116     /**
1117     \brief
1118     Overloaded operator -=
1119     \param right - Input - The right hand side.
1120 jgs 123 *
1121 jgs 102 */
1122 woo409 757 ESCRIPT_DLL_API
1123 jgs 102 Data& operator-=(const Data& right);
1124 woo409 757 ESCRIPT_DLL_API
1125 jgs 102 Data& operator-=(const boost::python::object& right);
1126    
1127     /**
1128     \brief
1129     Overloaded operator *=
1130     \param right - Input - The right hand side.
1131 jgs 123 *
1132 jgs 102 */
1133 woo409 757 ESCRIPT_DLL_API
1134 jgs 102 Data& operator*=(const Data& right);
1135 woo409 757 ESCRIPT_DLL_API
1136 jgs 102 Data& operator*=(const boost::python::object& right);
1137    
1138     /**
1139     \brief
1140     Overloaded operator /=
1141     \param right - Input - The right hand side.
1142 jgs 123 *
1143 jgs 102 */
1144 woo409 757 ESCRIPT_DLL_API
1145 jgs 102 Data& operator/=(const Data& right);
1146 woo409 757 ESCRIPT_DLL_API
1147 jgs 102 Data& operator/=(const boost::python::object& right);
1148    
1149     /**
1150     \brief
1151 jgs 94 Returns true if this can be interpolated to functionspace.
1152     */
1153 woo409 757 ESCRIPT_DLL_API
1154 jgs 94 bool
1155     probeInterpolation(const FunctionSpace& functionspace) const;
1156    
1157     /**
1158 jgs 102 Data object slicing methods.
1159     */
1160    
1161     /**
1162 jgs 94 \brief
1163 jgs 102 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 jgs 94 */
1172 woo409 757 ESCRIPT_DLL_API
1173 jgs 102 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 woo409 757 ESCRIPT_DLL_API
1188 jgs 94 void
1189 jgs 102 setItemD(const boost::python::object& key,
1190     const Data& value);
1191 jgs 94
1192 woo409 757 ESCRIPT_DLL_API
1193 jgs 102 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 jgs 94 /**
1200     \brief
1201 jgs 102 Perform the given unary operation on every element of every data point in
1202     this Data object.
1203 jgs 94 */
1204 jgs 102 template <class UnaryFunction>
1205 woo409 757 ESCRIPT_DLL_API
1206 jgs 102 inline
1207 jgs 94 void
1208 jgs 102 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 jgs 123 *
1216 jgs 94 */
1217 woo409 757 ESCRIPT_DLL_API
1218 jgs 102 Data
1219     getSlice(const DataArrayView::RegionType& region) const;
1220 jgs 94
1221 jgs 102 /**
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 jgs 123 *
1228 jgs 102 */
1229 woo409 757 ESCRIPT_DLL_API
1230 jgs 102 void
1231     setSlice(const Data& value,
1232     const DataArrayView::RegionType& region);
1233    
1234 jgs 119 /**
1235     \brief
1236     Archive the current Data object to the given file.
1237     \param fileName - Input - file to archive to.
1238     */
1239 woo409 757 ESCRIPT_DLL_API
1240 jgs 119 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 jgs 121 \param fspace - Input - a suitable FunctionSpace descibing the data.
1250 jgs 119 */
1251 woo409 757 ESCRIPT_DLL_API
1252 jgs 119 void
1253     extractData(const std::string fileName,
1254     const FunctionSpace& fspace);
1255    
1256 bcumming 751
1257     /**
1258     \brief
1259     print the data values to stdout. Used for debugging
1260     */
1261 bcumming 782 ESCRIPT_DLL_API
1262     void
1263     print(void);
1264 bcumming 751
1265 bcumming 782 /**
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 ksteube 813
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 jgs 102 protected:
1303    
1304 jgs 94 private:
1305    
1306     /**
1307     \brief
1308 jgs 102 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 jgs 113 this Data object according to the given function and return the single value result.
1323 jgs 102 */
1324 jgs 147 template <class BinaryFunction>
1325 jgs 102 inline
1326     double
1327 jgs 147 algorithm(BinaryFunction operation,
1328     double initial_value) const;
1329 jgs 102
1330 jgs 113 /**
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 jgs 147 template <class BinaryFunction>
1338 jgs 106 inline
1339     Data
1340 jgs 147 dp_algorithm(BinaryFunction operation,
1341     double initial_value) const;
1342 jgs 106
1343 jgs 102 /**
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 jgs 94 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 gross 783 // flag to protect the data object against any update
1385     bool m_protected;
1386    
1387     //
1388 jgs 102 // pointer to the actual data object
1389 jgs 94 boost::shared_ptr<DataAbstract> m_data;
1390    
1391 jgs 123 //
1392     // pointer to the internal profiling data
1393     struct profDataEntry *profData;
1394    
1395 jgs 94 };
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 jgs 102 boost::shared_ptr<DataAbstract> temp_data(temp);
1411     m_data=temp_data;
1412 jgs 94 } else {
1413     DataAbstract* temp=new DataConstant(value,what);
1414 jgs 102 boost::shared_ptr<DataAbstract> temp_data(temp);
1415     m_data=temp_data;
1416 jgs 94 }
1417     }
1418    
1419 jgs 102 /**
1420     Binary Data object operators.
1421     */
1422 gross 854 inline double rpow(double x,double y)
1423     {
1424     return pow(y,x);
1425 gross 1028 }
1426 jgs 94
1427     /**
1428     \brief
1429     Operator+
1430     Takes two Data objects.
1431     */
1432 woo409 757 ESCRIPT_DLL_API Data operator+(const Data& left, const Data& right);
1433 jgs 94
1434     /**
1435     \brief
1436     Operator-
1437     Takes two Data objects.
1438     */
1439 woo409 757 ESCRIPT_DLL_API Data operator-(const Data& left, const Data& right);
1440 jgs 94
1441     /**
1442     \brief
1443     Operator*
1444     Takes two Data objects.
1445     */
1446 woo409 757 ESCRIPT_DLL_API Data operator*(const Data& left, const Data& right);
1447 jgs 94
1448     /**
1449     \brief
1450     Operator/
1451     Takes two Data objects.
1452     */
1453 woo409 757 ESCRIPT_DLL_API Data operator/(const Data& left, const Data& right);
1454 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator+(const Data& left, const boost::python::object& right);
1462 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator-(const Data& left, const boost::python::object& right);
1470 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator*(const Data& left, const boost::python::object& right);
1478 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator/(const Data& left, const boost::python::object& right);
1486 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator+(const boost::python::object& left, const Data& right);
1494 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator-(const boost::python::object& left, const Data& right);
1502 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator*(const boost::python::object& left, const Data& right);
1510 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator/(const boost::python::object& left, const Data& right);
1518 jgs 94
1519     /**
1520     \brief
1521     Output operator
1522     */
1523 woo409 757 ESCRIPT_DLL_API std::ostream& operator<<(std::ostream& o, const Data& data);
1524 jgs 94
1525     /**
1526     \brief
1527 ksteube 813 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 jgs 94 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 woo409 757 //ESCRIPT_DLL_API bool operator==(const Data& left, const Data& right);
1547 jgs 94
1548 jgs 102 /**
1549     \brief
1550     Perform the given binary operation with this and right as operands.
1551     Right is a Data object.
1552     */
1553 jgs 94 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 gross 854 throw DataException("Error - attempt to update rank zero object with object with rank bigger than zero.");
1563 jgs 94 }
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 jgs 102 typeMatchRight(tempRight);
1583 jgs 94 //
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 jgs 102 } else if (isConstant()) {
1609 jgs 94 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 gross 854 #if defined DOPROF
1615     profData->binary++;
1616     #endif
1617 jgs 94 }
1618    
1619 jgs 102 /**
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 jgs 94 template <class UnaryFunction>
1628     inline
1629 jgs 102 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 jgs 94 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 jgs 102 } else if (isConstant()) {
1659 jgs 94 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 jgs 102 /**
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 jgs 147 template <class BinaryFunction>
1673 jgs 94 inline
1674     double
1675 jgs 147 Data::algorithm(BinaryFunction operation, double initial_value) const
1676 jgs 94 {
1677     if (isExpanded()) {
1678     DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1679     EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1680 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1681 jgs 102 } else if (isTagged()) {
1682 jgs 94 DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1683     EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1684 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1685 jgs 102 } else if (isConstant()) {
1686 jgs 94 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1687     EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");
1688 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1689 jgs 94 }
1690 jgs 102 return 0;
1691 jgs 94 }
1692    
1693 jgs 102 /**
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 jgs 147 template <class BinaryFunction>
1702 jgs 94 inline
1703     Data
1704 jgs 147 Data::dp_algorithm(BinaryFunction operation, double initial_value) const
1705 jgs 94 {
1706 jgs 106 if (isExpanded()) {
1707 jgs 559 Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1708 jgs 106 DataExpanded* dataE=dynamic_cast<DataExpanded*>(m_data.get());
1709 jgs 102 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 jgs 147 escript::dp_algorithm(*dataE,*resultE,operation,initial_value);
1713 jgs 559 return result;
1714 jgs 106 } else if (isTagged()) {
1715     DataTagged* dataT=dynamic_cast<DataTagged*>(m_data.get());
1716 jgs 562 DataArrayView::ShapeType viewShape;
1717     DataArrayView::ValueType viewData(1);
1718     viewData[0]=0;
1719     DataArrayView defaultValue(viewData,viewShape);
1720 jgs 559 DataTagged::TagListType keys;
1721 jgs 562 DataTagged::ValueListType values;
1722 jgs 559 DataTagged::DataMapType::const_iterator i;
1723     for (i=dataT->getTagLookup().begin();i!=dataT->getTagLookup().end();i++) {
1724     keys.push_back(i->first);
1725 jgs 562 values.push_back(defaultValue);
1726 jgs 559 }
1727     Data result(keys,values,defaultValue,getFunctionSpace());
1728 jgs 102 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 jgs 147 escript::dp_algorithm(*dataT,*resultT,operation,initial_value);
1732 jgs 559 return result;
1733 jgs 106 } else if (isConstant()) {
1734 jgs 559 Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1735 jgs 106 DataConstant* dataC=dynamic_cast<DataConstant*>(m_data.get());
1736 jgs 102 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 jgs 147 escript::dp_algorithm(*dataC,*resultC,operation,initial_value);
1740 jgs 559 return result;
1741 jgs 102 }
1742 jgs 559 Data falseRetVal; // to keep compiler quiet
1743     return falseRetVal;
1744 jgs 94 }
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