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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 854 - (hide annotations)
Thu Sep 21 05:29:42 2006 UTC (12 years, 7 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 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 woo409 757 #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     /**
258     \brief
259 jgs 121 Return the values of all data-points as a single python numarray object.
260 jgs 117 */
261 woo409 757 ESCRIPT_DLL_API
262 jgs 121 const boost::python::numeric::array
263 jgs 117 convertToNumArray();
264    
265     /**
266     \brief
267 jgs 121 Return the values of all data-points for the given sample as a single python numarray object.
268     */
269 woo409 757 ESCRIPT_DLL_API
270 jgs 121 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 dhawcroft 789 #ifndef PASO_MPI
278 woo409 757 ESCRIPT_DLL_API
279 jgs 121 const boost::python::numeric::array
280 bcumming 790 convertToNumArrayFromDPNo(int ProcNo,
281     int sampleNo,
282 jgs 121 int dataPointNo);
283 dhawcroft 789 #else
284     ESCRIPT_DLL_API
285     const boost::python::numeric::array
286     convertToNumArrayFromDPNo(int procNo,
287     int sampleNo,
288     int dataPointNo);
289     #endif
290 jgs 121
291 dhawcroft 789
292 jgs 121 /**
293     \brief
294 jgs 149 Fills the expanded Data object from values of a python numarray object.
295     */
296 woo409 757 ESCRIPT_DLL_API
297 jgs 149 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 woo409 757 ESCRIPT_DLL_API
308 jgs 149 int
309     getTagNumber(int dpno);
310    
311     /**
312     \brief
313 jgs 94 Return the C wrapper for the Data object.
314     */
315 woo409 757 ESCRIPT_DLL_API
316 jgs 102 escriptDataC
317     getDataC();
318 jgs 94
319     /**
320     \brief
321     Return the C wrapper for the Data object - const version.
322     */
323 woo409 757 ESCRIPT_DLL_API
324 jgs 102 escriptDataC
325     getDataC() const;
326 jgs 94
327     /**
328     \brief
329     Write the data as a string.
330     */
331 woo409 757 ESCRIPT_DLL_API
332 jgs 102 inline
333     std::string
334     toString() const
335     {
336     return m_data->toString();
337     }
338 jgs 94
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 woo409 757 ESCRIPT_DLL_API
346 jgs 94 inline
347     const DataArrayView&
348     getPointDataView() const
349     {
350     return m_data->getPointDataView();
351     }
352    
353     /**
354     \brief
355 jgs 102 Whatever the current Data type make this into a DataExpanded.
356 jgs 94 */
357 woo409 757 ESCRIPT_DLL_API
358 jgs 94 void
359     expand();
360    
361     /**
362     \brief
363 jgs 102 If possible convert this Data to DataTagged. This will only allow
364 jgs 94 Constant data to be converted to tagged. An attempt to convert
365     Expanded data to tagged will throw an exception.
366 jgs 544 ==>*
367 jgs 94 */
368 woo409 757 ESCRIPT_DLL_API
369 jgs 94 void
370     tag();
371    
372     /**
373     \brief
374     Return true if this Data is expanded.
375     */
376 woo409 757 ESCRIPT_DLL_API
377 jgs 94 bool
378     isExpanded() const;
379    
380     /**
381     \brief
382     Return true if this Data is tagged.
383     */
384 woo409 757 ESCRIPT_DLL_API
385 jgs 94 bool
386     isTagged() const;
387    
388     /**
389     \brief
390 jgs 102 Return true if this Data is constant.
391 jgs 94 */
392 woo409 757 ESCRIPT_DLL_API
393 jgs 94 bool
394 jgs 102 isConstant() const;
395 jgs 94
396     /**
397     \brief
398 jgs 102 Return true if this Data is empty.
399 jgs 94 */
400 woo409 757 ESCRIPT_DLL_API
401 jgs 94 bool
402 jgs 102 isEmpty() const;
403 jgs 94
404     /**
405     \brief
406     Return the function space.
407     */
408 woo409 757 ESCRIPT_DLL_API
409 jgs 94 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 woo409 757 ESCRIPT_DLL_API
421 jgs 94 const FunctionSpace
422     getCopyOfFunctionSpace() const;
423    
424     /**
425     \brief
426     Return the domain.
427     */
428 woo409 757 ESCRIPT_DLL_API
429 jgs 94 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 woo409 757 ESCRIPT_DLL_API
441 jgs 94 const AbstractDomain
442     getCopyOfDomain() const;
443    
444     /**
445     \brief
446     Return the rank of the point data.
447     */
448 woo409 757 ESCRIPT_DLL_API
449 jgs 94 inline
450     int
451     getDataPointRank() const
452     {
453     return m_data->getPointDataView().getRank();
454     }
455    
456     /**
457     \brief
458 jgs 102 Return the number of samples.
459 jgs 94 */
460 woo409 757 ESCRIPT_DLL_API
461 jgs 94 inline
462     int
463 jgs 102 getNumSamples() const
464 jgs 94 {
465 jgs 102 return m_data->getNumSamples();
466 jgs 94 }
467    
468     /**
469     \brief
470 jgs 102 Return the number of data points per sample.
471 jgs 94 */
472 woo409 757 ESCRIPT_DLL_API
473 jgs 102 inline
474 jgs 94 int
475 jgs 102 getNumDataPointsPerSample() const
476     {
477     return m_data->getNumDPPSample();
478     }
479 jgs 94
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 woo409 757 ESCRIPT_DLL_API
487 jgs 102 inline
488 jgs 94 DataAbstract::ValueType::value_type*
489 jgs 102 getSampleData(DataAbstract::ValueType::size_type sampleNo)
490     {
491     return m_data->getSampleData(sampleNo);
492     }
493 jgs 94
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 woo409 757 ESCRIPT_DLL_API
501 jgs 102 inline
502 jgs 94 DataAbstract::ValueType::value_type*
503 jgs 102 getSampleDataByTag(int tag)
504     {
505     return m_data->getSampleDataByTag(tag);
506     }
507 jgs 94
508     /**
509     \brief
510 jgs 110 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 woo409 757 ESCRIPT_DLL_API
525 jgs 110 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 woo409 757 ESCRIPT_DLL_API
545 jgs 110 void
546     getRefValue(int ref,
547     boost::python::numeric::array& value);
548    
549     /**
550     \brief
551 jgs 94 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 woo409 757 ESCRIPT_DLL_API
558 jgs 94 inline
559     DataArrayView
560     getDataPoint(int sampleNo,
561     int dataPointNo)
562     {
563 bcumming 790 return m_data->getDataPoint(sampleNo,dataPointNo);
564 jgs 94 }
565    
566     /**
567     \brief
568     Return a reference to the data point shape.
569     */
570 woo409 757 ESCRIPT_DLL_API
571 jgs 94 const DataArrayView::ShapeType&
572     getDataPointShape() const;
573    
574     /**
575     \brief
576 jgs 102 Return the data point shape as a tuple of integers.
577 jgs 94 */
578 woo409 757 ESCRIPT_DLL_API
579 jgs 121 const boost::python::tuple
580 jgs 94 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 woo409 757 ESCRIPT_DLL_API
588 jgs 94 int
589     getDataPointSize() const;
590    
591     /**
592     \brief
593 jgs 102 Return the number of doubles stored for this Data.
594 jgs 94 */
595 woo409 757 ESCRIPT_DLL_API
596 jgs 94 DataArrayView::ValueType::size_type
597     getLength() const;
598    
599     /**
600     \brief
601 jgs 102 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 jgs 544 ==>*
607 jgs 94 */
608 woo409 757 ESCRIPT_DLL_API
609 jgs 102 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 jgs 544 ==>*
621 jgs 102 */
622 woo409 757 ESCRIPT_DLL_API
623 jgs 102 void
624 jgs 121 setTaggedValueFromCPP(int tagKey,
625     const DataArrayView& value);
626 jgs 102
627     /**
628     \brief
629     Copy other Data object into this Data object where mask is positive.
630     */
631 woo409 757 ESCRIPT_DLL_API
632 jgs 102 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 jgs 123 *
645 jgs 102 */
646 woo409 757 ESCRIPT_DLL_API
647 jgs 94 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 jgs 123 *
655 jgs 94 */
656 woo409 757 ESCRIPT_DLL_API
657 jgs 94 Data
658     gradOn(const FunctionSpace& functionspace) const;
659    
660 woo409 757 ESCRIPT_DLL_API
661 jgs 94 Data
662     grad() const;
663    
664     /**
665     \brief
666     Calculate the integral over the function space domain.
667 jgs 123 *
668 jgs 94 */
669 woo409 757 ESCRIPT_DLL_API
670 jgs 94 boost::python::numeric::array
671     integrate() const;
672    
673     /**
674     \brief
675 gross 854 Returns 1./ Data object
676     *
677     */
678     ESCRIPT_DLL_API
679     Data
680     oneOver() const;
681     /**
682     \brief
683 jgs 94 Return a Data with a 1 for +ive values and a 0 for 0 or -ive values.
684 jgs 123 *
685 jgs 94 */
686 woo409 757 ESCRIPT_DLL_API
687 jgs 94 Data
688 gross 698 wherePositive() const;
689 jgs 94
690     /**
691     \brief
692 jgs 102 Return a Data with a 1 for -ive values and a 0 for +ive or 0 values.
693 jgs 123 *
694 jgs 94 */
695 woo409 757 ESCRIPT_DLL_API
696 jgs 94 Data
697 gross 698 whereNegative() const;
698 jgs 102
699     /**
700     \brief
701     Return a Data with a 1 for +ive or 0 values and a 0 for -ive values.
702 jgs 123 *
703 jgs 102 */
704 woo409 757 ESCRIPT_DLL_API
705 jgs 102 Data
706 gross 698 whereNonNegative() const;
707 jgs 94
708     /**
709     \brief
710 jgs 102 Return a Data with a 1 for -ive or 0 values and a 0 for +ive values.
711 jgs 123 *
712 jgs 94 */
713 woo409 757 ESCRIPT_DLL_API
714 jgs 94 Data
715 gross 698 whereNonPositive() const;
716 jgs 94
717     /**
718     \brief
719 jgs 102 Return a Data with a 1 for 0 values and a 0 for +ive or -ive values.
720 jgs 123 *
721 jgs 94 */
722 woo409 757 ESCRIPT_DLL_API
723 jgs 94 Data
724 jgs 571 whereZero(double tol=0.0) const;
725 jgs 94
726     /**
727     \brief
728 jgs 102 Return a Data with a 0 for 0 values and a 1 for +ive or -ive values.
729 jgs 123 *
730 jgs 94 */
731 woo409 757 ESCRIPT_DLL_API
732 jgs 94 Data
733 jgs 571 whereNonZero(double tol=0.0) const;
734 jgs 102
735     /**
736     \brief
737     Return the maximum absolute value of this Data object.
738 jgs 123 *
739 jgs 94 */
740 woo409 757 ESCRIPT_DLL_API
741 jgs 102 double
742     Lsup() const;
743 jgs 94
744     /**
745     \brief
746 jgs 117 Return the minimum absolute value of this Data object.
747 jgs 123 *
748 jgs 117 */
749 woo409 757 ESCRIPT_DLL_API
750 jgs 117 double
751     Linf() const;
752    
753     /**
754     \brief
755 jgs 102 Return the maximum value of this Data object.
756 jgs 123 *
757 jgs 94 */
758 woo409 757 ESCRIPT_DLL_API
759 jgs 102 double
760     sup() const;
761 jgs 94
762     /**
763     \brief
764 jgs 102 Return the minimum value of this Data object.
765 jgs 123 *
766 jgs 94 */
767 woo409 757 ESCRIPT_DLL_API
768 jgs 94 double
769 jgs 102 inf() const;
770 jgs 94
771     /**
772     \brief
773 jgs 102 Return the absolute value of each data point of this Data object.
774 jgs 123 *
775 jgs 94 */
776 woo409 757 ESCRIPT_DLL_API
777 jgs 102 Data
778     abs() const;
779 jgs 94
780     /**
781     \brief
782 jgs 102 Return the maximum value of each data point of this Data object.
783 jgs 123 *
784 jgs 94 */
785 woo409 757 ESCRIPT_DLL_API
786 jgs 102 Data
787     maxval() const;
788 jgs 94
789     /**
790     \brief
791 jgs 102 Return the minimum value of each data point of this Data object.
792 jgs 123 *
793 jgs 94 */
794 woo409 757 ESCRIPT_DLL_API
795 jgs 94 Data
796 jgs 102 minval() const;
797 jgs 94
798     /**
799     \brief
800 jgs 121 Return the (sample number, data-point number) of the data point with
801     the minimum value in this Data object.
802     */
803 woo409 757 ESCRIPT_DLL_API
804 jgs 121 const boost::python::tuple
805     mindp() const;
806    
807 woo409 757 ESCRIPT_DLL_API
808 jgs 148 void
809 bcumming 782 calc_mindp(int& ProcNo,
810     int& SampleNo,
811     int& DataPointNo) const;
812 jgs 121 /**
813     \brief
814 jgs 102 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 jgs 123 *
817 jgs 94 */
818 woo409 757 ESCRIPT_DLL_API
819 jgs 102 Data
820     sign() const;
821 jgs 94
822     /**
823 jgs 123 \brief
824 ksteube 775 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 gross 800 trace(int axis_offset) const;
848 ksteube 775
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 gross 576 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 woo409 757 ESCRIPT_DLL_API
865 gross 576 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 woo409 757 ESCRIPT_DLL_API
878 gross 576 const boost::python::tuple
879     eigenvalues_and_eigenvectors(const double tol=1.e-12) const;
880    
881     /**
882     \brief
883 gross 804 swaps the components axis0 and axis1
884 jgs 123 *
885 jgs 102 */
886 woo409 757 ESCRIPT_DLL_API
887 jgs 102 Data
888 gross 804 swapaxes(const int axis0, const int axis1) const;
889 jgs 102
890     /**
891 jgs 123 \brief
892     Return the sin of each data point of this Data object.
893     *
894 jgs 102 */
895 woo409 757 ESCRIPT_DLL_API
896 jgs 102 Data
897 jgs 123 sin() const;
898    
899     /**
900     \brief
901     Return the cos of each data point of this Data object.
902     *
903     */
904 woo409 757 ESCRIPT_DLL_API
905 jgs 123 Data
906     cos() const;
907    
908     /**
909     \brief
910     Return the tan of each data point of this Data object.
911     *
912     */
913 woo409 757 ESCRIPT_DLL_API
914 jgs 123 Data
915     tan() const;
916    
917     /**
918     \brief
919 jgs 150 Return the asin of each data point of this Data object.
920     *
921     */
922 woo409 757 ESCRIPT_DLL_API
923 jgs 150 Data
924     asin() const;
925    
926     /**
927     \brief
928     Return the acos of each data point of this Data object.
929     *
930     */
931 woo409 757 ESCRIPT_DLL_API
932 jgs 150 Data
933     acos() const;
934    
935     /**
936     \brief
937     Return the atan of each data point of this Data object.
938     *
939     */
940 woo409 757 ESCRIPT_DLL_API
941 jgs 150 Data
942     atan() const;
943    
944     /**
945     \brief
946     Return the sinh of each data point of this Data object.
947     *
948     */
949 woo409 757 ESCRIPT_DLL_API
950 jgs 150 Data
951     sinh() const;
952    
953     /**
954     \brief
955     Return the cosh of each data point of this Data object.
956     *
957     */
958 woo409 757 ESCRIPT_DLL_API
959 jgs 150 Data
960     cosh() const;
961    
962     /**
963     \brief
964     Return the tanh of each data point of this Data object.
965     *
966     */
967 woo409 757 ESCRIPT_DLL_API
968 jgs 150 Data
969     tanh() const;
970    
971     /**
972     \brief
973     Return the asinh of each data point of this Data object.
974     *
975     */
976 woo409 757 ESCRIPT_DLL_API
977 jgs 150 Data
978     asinh() const;
979    
980     /**
981     \brief
982     Return the acosh of each data point of this Data object.
983     *
984     */
985 woo409 757 ESCRIPT_DLL_API
986 jgs 150 Data
987     acosh() const;
988    
989     /**
990     \brief
991     Return the atanh of each data point of this Data object.
992     *
993     */
994 woo409 757 ESCRIPT_DLL_API
995 jgs 150 Data
996     atanh() const;
997    
998     /**
999     \brief
1000 jgs 123 Return the log to base 10 of each data point of this Data object.
1001     *
1002     */
1003 woo409 757 ESCRIPT_DLL_API
1004 jgs 123 Data
1005 gross 286 log10() const;
1006 jgs 123
1007     /**
1008     \brief
1009     Return the natural log of each data point of this Data object.
1010     *
1011     */
1012 woo409 757 ESCRIPT_DLL_API
1013 jgs 123 Data
1014 gross 286 log() const;
1015 jgs 123
1016     /**
1017     \brief
1018     Return the exponential function of each data point of this Data object.
1019     *
1020     */
1021 woo409 757 ESCRIPT_DLL_API
1022 jgs 123 Data
1023 jgs 102 exp() const;
1024    
1025     /**
1026 jgs 123 \brief
1027     Return the square root of each data point of this Data object.
1028     *
1029 jgs 102 */
1030 woo409 757 ESCRIPT_DLL_API
1031 jgs 102 Data
1032     sqrt() const;
1033    
1034     /**
1035 jgs 123 \brief
1036     Return the negation of each data point of this Data object.
1037     *
1038 jgs 121 */
1039 woo409 757 ESCRIPT_DLL_API
1040 jgs 121 Data
1041     neg() const;
1042    
1043     /**
1044 jgs 123 \brief
1045     Return the identity of each data point of this Data object.
1046     Simply returns this object unmodified.
1047     *
1048 jgs 121 */
1049 woo409 757 ESCRIPT_DLL_API
1050 jgs 121 Data
1051     pos() const;
1052    
1053     /**
1054 jgs 94 \brief
1055 jgs 102 Return the given power of each data point of this Data object.
1056 jgs 121
1057     \param right Input - the power to raise the object to.
1058 jgs 123 *
1059 jgs 102 */
1060 woo409 757 ESCRIPT_DLL_API
1061 jgs 102 Data
1062     powD(const Data& right) const;
1063    
1064 jgs 121 /**
1065 jgs 123 \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 jgs 121 */
1071 woo409 757 ESCRIPT_DLL_API
1072 jgs 102 Data
1073     powO(const boost::python::object& right) const;
1074    
1075     /**
1076 jgs 123 \brief
1077 gross 699 Return the given power of each data point of this boost python object.
1078    
1079     \param left Input - the bases
1080     *
1081     */
1082    
1083 woo409 757 ESCRIPT_DLL_API
1084 gross 699 Data
1085     rpowO(const boost::python::object& left) const;
1086    
1087     /**
1088     \brief
1089 jgs 123 writes the object to a file in the DX file format
1090 jgs 104 */
1091 woo409 757 ESCRIPT_DLL_API
1092 jgs 104 void
1093     saveDX(std::string fileName) const;
1094    
1095     /**
1096 jgs 123 \brief
1097     writes the object to a file in the VTK file format
1098 jgs 110 */
1099 woo409 757 ESCRIPT_DLL_API
1100 jgs 110 void
1101     saveVTK(std::string fileName) const;
1102    
1103     /**
1104 jgs 102 \brief
1105     Overloaded operator +=
1106     \param right - Input - The right hand side.
1107 jgs 123 *
1108 jgs 102 */
1109 woo409 757 ESCRIPT_DLL_API
1110 jgs 102 Data& operator+=(const Data& right);
1111 woo409 757 ESCRIPT_DLL_API
1112 jgs 102 Data& operator+=(const boost::python::object& right);
1113    
1114     /**
1115     \brief
1116     Overloaded operator -=
1117     \param right - Input - The right hand side.
1118 jgs 123 *
1119 jgs 102 */
1120 woo409 757 ESCRIPT_DLL_API
1121 jgs 102 Data& operator-=(const Data& right);
1122 woo409 757 ESCRIPT_DLL_API
1123 jgs 102 Data& operator-=(const boost::python::object& right);
1124    
1125     /**
1126     \brief
1127     Overloaded operator *=
1128     \param right - Input - The right hand side.
1129 jgs 123 *
1130 jgs 102 */
1131 woo409 757 ESCRIPT_DLL_API
1132 jgs 102 Data& operator*=(const Data& right);
1133 woo409 757 ESCRIPT_DLL_API
1134 jgs 102 Data& operator*=(const boost::python::object& right);
1135    
1136     /**
1137     \brief
1138     Overloaded operator /=
1139     \param right - Input - The right hand side.
1140 jgs 123 *
1141 jgs 102 */
1142 woo409 757 ESCRIPT_DLL_API
1143 jgs 102 Data& operator/=(const Data& right);
1144 woo409 757 ESCRIPT_DLL_API
1145 jgs 102 Data& operator/=(const boost::python::object& right);
1146    
1147     /**
1148     \brief
1149 jgs 94 Returns true if this can be interpolated to functionspace.
1150     */
1151 woo409 757 ESCRIPT_DLL_API
1152 jgs 94 bool
1153     probeInterpolation(const FunctionSpace& functionspace) const;
1154    
1155     /**
1156 jgs 102 Data object slicing methods.
1157     */
1158    
1159     /**
1160 jgs 94 \brief
1161 jgs 102 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 jgs 94 */
1170 woo409 757 ESCRIPT_DLL_API
1171 jgs 102 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 woo409 757 ESCRIPT_DLL_API
1186 jgs 94 void
1187 jgs 102 setItemD(const boost::python::object& key,
1188     const Data& value);
1189 jgs 94
1190 woo409 757 ESCRIPT_DLL_API
1191 jgs 102 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 jgs 94 /**
1198     \brief
1199 jgs 102 Perform the given unary operation on every element of every data point in
1200     this Data object.
1201 jgs 94 */
1202 jgs 102 template <class UnaryFunction>
1203 woo409 757 ESCRIPT_DLL_API
1204 jgs 102 inline
1205 jgs 94 void
1206 jgs 102 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 jgs 123 *
1214 jgs 94 */
1215 woo409 757 ESCRIPT_DLL_API
1216 jgs 102 Data
1217     getSlice(const DataArrayView::RegionType& region) const;
1218 jgs 94
1219 jgs 102 /**
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 jgs 123 *
1226 jgs 102 */
1227 woo409 757 ESCRIPT_DLL_API
1228 jgs 102 void
1229     setSlice(const Data& value,
1230     const DataArrayView::RegionType& region);
1231    
1232 jgs 119 /**
1233     \brief
1234     Archive the current Data object to the given file.
1235     \param fileName - Input - file to archive to.
1236     */
1237 woo409 757 ESCRIPT_DLL_API
1238 jgs 119 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 jgs 121 \param fspace - Input - a suitable FunctionSpace descibing the data.
1248 jgs 119 */
1249 woo409 757 ESCRIPT_DLL_API
1250 jgs 119 void
1251     extractData(const std::string fileName,
1252     const FunctionSpace& fspace);
1253    
1254 bcumming 751
1255     /**
1256     \brief
1257     print the data values to stdout. Used for debugging
1258     */
1259 bcumming 782 ESCRIPT_DLL_API
1260     void
1261     print(void);
1262 bcumming 751
1263 bcumming 782 /**
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 ksteube 813
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 jgs 102 protected:
1301    
1302 jgs 94 private:
1303    
1304     /**
1305     \brief
1306 jgs 102 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 jgs 113 this Data object according to the given function and return the single value result.
1321 jgs 102 */
1322 jgs 147 template <class BinaryFunction>
1323 jgs 102 inline
1324     double
1325 jgs 147 algorithm(BinaryFunction operation,
1326     double initial_value) const;
1327 jgs 102
1328 jgs 113 /**
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 jgs 147 template <class BinaryFunction>
1336 jgs 106 inline
1337     Data
1338 jgs 147 dp_algorithm(BinaryFunction operation,
1339     double initial_value) const;
1340 jgs 106
1341 jgs 102 /**
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 jgs 94 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 gross 783 // flag to protect the data object against any update
1383     bool m_protected;
1384    
1385     //
1386 jgs 102 // pointer to the actual data object
1387 jgs 94 boost::shared_ptr<DataAbstract> m_data;
1388    
1389 jgs 123 //
1390     // pointer to the internal profiling data
1391     struct profDataEntry *profData;
1392    
1393 jgs 94 };
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 jgs 102 boost::shared_ptr<DataAbstract> temp_data(temp);
1409     m_data=temp_data;
1410 jgs 94 } else {
1411     DataAbstract* temp=new DataConstant(value,what);
1412 jgs 102 boost::shared_ptr<DataAbstract> temp_data(temp);
1413     m_data=temp_data;
1414 jgs 94 }
1415     }
1416    
1417 jgs 102 /**
1418     Binary Data object operators.
1419     */
1420 gross 854 inline double rpow(double x,double y)
1421     {
1422     return pow(y,x);
1423     };
1424 jgs 94
1425     /**
1426     \brief
1427     Operator+
1428     Takes two Data objects.
1429     */
1430 woo409 757 ESCRIPT_DLL_API Data operator+(const Data& left, const Data& right);
1431 jgs 94
1432     /**
1433     \brief
1434     Operator-
1435     Takes two Data objects.
1436     */
1437 woo409 757 ESCRIPT_DLL_API Data operator-(const Data& left, const Data& right);
1438 jgs 94
1439     /**
1440     \brief
1441     Operator*
1442     Takes two Data objects.
1443     */
1444 woo409 757 ESCRIPT_DLL_API Data operator*(const Data& left, const Data& right);
1445 jgs 94
1446     /**
1447     \brief
1448     Operator/
1449     Takes two Data objects.
1450     */
1451 woo409 757 ESCRIPT_DLL_API Data operator/(const Data& left, const Data& right);
1452 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator+(const Data& left, const boost::python::object& right);
1460 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator-(const Data& left, const boost::python::object& right);
1468 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator*(const Data& left, const boost::python::object& right);
1476 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator/(const Data& left, const boost::python::object& right);
1484 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator+(const boost::python::object& left, const Data& right);
1492 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator-(const boost::python::object& left, const Data& right);
1500 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator*(const boost::python::object& left, const Data& right);
1508 jgs 94
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 woo409 757 ESCRIPT_DLL_API Data operator/(const boost::python::object& left, const Data& right);
1516 jgs 94
1517     /**
1518     \brief
1519     Output operator
1520     */
1521 woo409 757 ESCRIPT_DLL_API std::ostream& operator<<(std::ostream& o, const Data& data);
1522 jgs 94
1523     /**
1524     \brief
1525 ksteube 813 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 jgs 94 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 woo409 757 //ESCRIPT_DLL_API bool operator==(const Data& left, const Data& right);
1545 jgs 94
1546 jgs 102 /**
1547     \brief
1548     Perform the given binary operation with this and right as operands.
1549     Right is a Data object.
1550     */
1551 jgs 94 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 gross 854 throw DataException("Error - attempt to update rank zero object with object with rank bigger than zero.");
1561 jgs 94 }
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 jgs 102 typeMatchRight(tempRight);
1581 jgs 94 //
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 jgs 102 } else if (isConstant()) {
1607 jgs 94 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 gross 854 #if defined DOPROF
1613     profData->binary++;
1614     #endif
1615 jgs 94 }
1616    
1617 jgs 102 /**
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 jgs 94 template <class UnaryFunction>
1626     inline
1627 jgs 102 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 jgs 94 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 jgs 102 } else if (isConstant()) {
1657 jgs 94 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 jgs 102 /**
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 jgs 147 template <class BinaryFunction>
1671 jgs 94 inline
1672     double
1673 jgs 147 Data::algorithm(BinaryFunction operation, double initial_value) const
1674 jgs 94 {
1675     if (isExpanded()) {
1676     DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1677     EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1678 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1679 jgs 102 } else if (isTagged()) {
1680 jgs 94 DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1681     EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1682 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1683 jgs 102 } else if (isConstant()) {
1684 jgs 94 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1685     EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");
1686 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1687 jgs 94 }
1688 jgs 102 return 0;
1689 jgs 94 }
1690    
1691 jgs 102 /**
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 jgs 147 template <class BinaryFunction>
1700 jgs 94 inline
1701     Data
1702 jgs 147 Data::dp_algorithm(BinaryFunction operation, double initial_value) const
1703 jgs 94 {
1704 jgs 106 if (isExpanded()) {
1705 jgs 559 Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1706 jgs 106 DataExpanded* dataE=dynamic_cast<DataExpanded*>(m_data.get());
1707 jgs 102 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 jgs 147 escript::dp_algorithm(*dataE,*resultE,operation,initial_value);
1711 jgs 559 return result;
1712 jgs 106 } else if (isTagged()) {
1713     DataTagged* dataT=dynamic_cast<DataTagged*>(m_data.get());
1714 jgs 562 DataArrayView::ShapeType viewShape;
1715     DataArrayView::ValueType viewData(1);
1716     viewData[0]=0;
1717     DataArrayView defaultValue(viewData,viewShape);
1718 jgs 559 DataTagged::TagListType keys;
1719 jgs 562 DataTagged::ValueListType values;
1720 jgs 559 DataTagged::DataMapType::const_iterator i;
1721     for (i=dataT->getTagLookup().begin();i!=dataT->getTagLookup().end();i++) {
1722     keys.push_back(i->first);
1723 jgs 562 values.push_back(defaultValue);
1724 jgs 559 }
1725     Data result(keys,values,defaultValue,getFunctionSpace());
1726 jgs 102 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 jgs 147 escript::dp_algorithm(*dataT,*resultT,operation,initial_value);
1730 jgs 559 return result;
1731 jgs 106 } else if (isConstant()) {
1732 jgs 559 Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1733 jgs 106 DataConstant* dataC=dynamic_cast<DataConstant*>(m_data.get());
1734 jgs 102 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 jgs 147 escript::dp_algorithm(*dataC,*resultC,operation,initial_value);
1738 jgs 559 return result;
1739 jgs 102 }
1740 jgs 559 Data falseRetVal; // to keep compiler quiet
1741     return falseRetVal;
1742 jgs 94 }
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