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

Diff of /trunk/escript/src/DataTagged.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/escript/src/DataTagged.h revision 496 by jgs, Tue Feb 7 01:27:14 2006 UTC temp_trunk_copy/escript/src/DataTagged.h revision 1384 by phornby, Fri Jan 11 02:29:38 2008 UTC
# Line 1  Line 1 
 // $Id$  
1    
2  /*  /* $Id$ */
3   ******************************************************************************  
4   *                                                                            *  /*******************************************************
5   *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *   *
6   *                                                                            *   *           Copyright 2003-2007 by ACceSS MNRF
7   * This software is the property of ACcESS. No part of this code              *   *       Copyright 2007 by University of Queensland
8   * may be copied in any form or by any means without the expressed written    *   *
9   * consent of ACcESS.  Copying, use or modification of this software          *   *                http://esscc.uq.edu.au
10   * by any unauthorised person is illegal unless that person has a software    *   *        Primary Business: Queensland, Australia
11   * license agreement with ACcESS.                                             *   *  Licensed under the Open Software License version 3.0
12   *                                                                            *   *     http://www.opensource.org/licenses/osl-3.0.php
13   ******************************************************************************   *
14  */   *******************************************************/
15    
16  #if !defined escript_DataTagged_20040615_H  #if !defined escript_DataTagged_20040615_H
17  #define escript_DataTagged_20040615_H  #define escript_DataTagged_20040615_H
18    #include "system_dep.h"
19    
20  #include "DataAbstract.h"  #include "DataAbstract.h"
21  #include "DataArrayView.h"  #include "DataArrayView.h"
# Line 58  class DataTagged : public DataAbstract { Line 58  class DataTagged : public DataAbstract {
58    
59       Description:       Description:
60       Default constructor for DataTagged. Creates a DataTagged object for which       Default constructor for DataTagged. Creates a DataTagged object for which
61       the only data-point is a scalar data-point with value 0.0. All tags       the default data-point is a scalar data-point with value 0.0, and no other
62       will map to this single data-point.       tag values are stored.
63        T
64    */    */
65      ESCRIPT_DLL_API
66    DataTagged();    DataTagged();
67    
68    /**    /**
# Line 69  class DataTagged : public DataAbstract { Line 71  class DataTagged : public DataAbstract {
71    
72       Description:       Description:
73       Constructor for DataTagged.       Constructor for DataTagged.
74       \param tagKeys - Input - A vector of integer keys.       \param tagKeys - Input - A vector of integer tags.
75       \param values - Input - A vector of DataArrayViews. If this is empty       \param values - Input - A vector of DataArrayViews. If this is empty
76                       all tag values will be assigned a value of zero. If                       all tag values will be assigned a scalar data-point of value
77                       it contains one value all tag values will be assigned the                       0. If it contains one value all tag values will be assigned
78               same value. Otherwise if there is a mismatch between               this value. Otherwise consecutive tags will be assigned
79               the number of keys and the number of values an exception                       consecutive values.  If there is a mismatch between  the
80                 number of keys and the number of values an exception
81               will be generated.               will be generated.
82       \param defaultValue - Input - Value returned if a requested tag doesn't exist.       \param defaultValue - Input - Value returned if a requested tag doesn't exist.
83       \param what - Input - A description of what this data represents.       \param what - Input - A description of what this data represents.
84        T
85    */    */
86      ESCRIPT_DLL_API
87    DataTagged(const TagListType& tagKeys,    DataTagged(const TagListType& tagKeys,
88               const ValueListType& values,               const ValueListType& values,
89           const DataArrayView& defaultValue,           const DataArrayView& defaultValue,
# Line 94  class DataTagged : public DataAbstract { Line 99  class DataTagged : public DataAbstract {
99       \param shape - Input - The shape of each data-point.       \param shape - Input - The shape of each data-point.
100       \param tags - Input - An array of tags, one for each sample number.       \param tags - Input - An array of tags, one for each sample number.
101       \param data - The data values for each tag.       \param data - The data values for each tag.
102        NB: no unit testing yet
103    */    */
104      ESCRIPT_DLL_API
105    DataTagged(const FunctionSpace& what,    DataTagged(const FunctionSpace& what,
106               const DataArrayView::ShapeType &shape,               const DataArrayView::ShapeType &shape,
107               const int tags[],               const int tags[],
108               const ValueType &data);               const ValueType& data);
109    
110    /**    /**
111       \brief       \brief
112       Slice Constructor for DataTagged.       Alternative Constructor for DataTagged.
113    
114       Description:       Description:
115       Slice Constructor for DataTagged.       Alternative Constructor for DataTagged.
116       Copies a slice from another DataTagged object.       \param what - Input - A description of what this data object represents.
117       \param other - Input - DataTagged object to copy from.       \param shape - Input - The shape of each data-point.
118       \param region - Input - Region to copy.       \param tags - Input - An vector of tags, one for each sample number.
119         \param data - The data values for each tag.
120        NB: no unit testing yet
121    */    */
122    DataTagged(const DataTagged& other,    ESCRIPT_DLL_API
123           const DataArrayView::RegionType& region);    DataTagged(const FunctionSpace& what,
124                 const DataArrayView::ShapeType &shape,
125                 const TagListType& tags,
126                 const ValueType& data);
127    
128    /**    /**
129       \brief       \brief
130       Copy Constructor for DataTagged.       Copy Constructor for DataTagged.
131       Performs a deep copy from the given DataTagged object.       Performs a deep copy from the given DataTagged object.
132        T
133    */    */
134      ESCRIPT_DLL_API
135    DataTagged(const DataTagged& other);    DataTagged(const DataTagged& other);
136    
137    /**    /**
138       \brief       \brief
139       Copy Constructor for DataTagged.       Copy Constructor for DataTagged.
140       Construct a tagged data from a DataConstant object.       Construct a DataTagged object from a DataConstant object.
141       The default value will be that held by the DataConstant object.       The default value will be the value of the DataConstant object.
142        T
143    */    */
144      ESCRIPT_DLL_API
145    DataTagged(const DataConstant& other);    DataTagged(const DataConstant& other);
146    
147    /**    /**
# Line 137  class DataTagged : public DataAbstract { Line 153  class DataTagged : public DataAbstract {
153       sample will be visible via the returned pointer.       sample will be visible via the returned pointer.
154    
155       ** This provides an interface into the data suitable for legacy C code.       ** This provides an interface into the data suitable for legacy C code.
156         ** NB: need to do array bounds checking when accessing returned value!
157        T
158    */    */
159      ESCRIPT_DLL_API
160    virtual    virtual
161    double*    double*
162    getSampleDataByTag(int tag);    getSampleDataByTag(int tag);
# Line 147  class DataTagged : public DataAbstract { Line 166  class DataTagged : public DataAbstract {
166       Write the data as a string.       Write the data as a string.
167       Writes out each tag, including the default, and the data-point which is       Writes out each tag, including the default, and the data-point which is
168       associated with each tag.       associated with each tag.
169        T
170    */    */
171      ESCRIPT_DLL_API
172    virtual    virtual
173    std::string    std::string
174    toString() const;    toString() const;
175     /**
176         \brief
177         dumps the object into a netCDF file
178      */
179      ESCRIPT_DLL_API
180      virtual
181      void
182      dump(const std::string fileName) const;
183    
184     /**
185         \brief
186        sets all values to zero
187      */
188      ESCRIPT_DLL_API
189      virtual
190      void
191      setToZero();
192    
193    /**    /**
194       \brief       \brief
195       Return the tag number associated with the given data-point number       Return the tag number associated with the given data-point number
196       according to the associated function space.       according to the associated function space.
197        T
198    */    */
199      ESCRIPT_DLL_API
200    virtual    virtual
201    int    int
202    getTagNumber(int dpno);    getTagNumber(int dpno);
# Line 171  class DataTagged : public DataAbstract { Line 211  class DataTagged : public DataAbstract {
211    
212       \param sampleNo - Input - sample number.       \param sampleNo - Input - sample number.
213       \param dataPointNo - Input - data-point number.       \param dataPointNo - Input - data-point number.
214     */      T
215      */
216      ESCRIPT_DLL_API
217    virtual    virtual
218    ValueType::size_type    ValueType::size_type
219    getPointOffset(int sampleNo,    getPointOffset(int sampleNo,
# Line 182  class DataTagged : public DataAbstract { Line 224  class DataTagged : public DataAbstract {
224       addTaggedValues       addTaggedValues
225    
226       Description:       Description:
227       Add the given tags and values to this DataTagged object, by repeatedly       Add the given tags and values to this DataTagged object.
228       using addTaggedValue for each given tag/value pair.       \param tagKeys - Input - A vector of integer tags.
      \param tagKeys - Input - A vector of integer keys.  
229       \param values - Input - A vector of DataArrayViews. If this is empty       \param values - Input - A vector of DataArrayViews. If this is empty
230                        then all given tags will be assigned a value of zero. If                       all tag values will be assigned a scalar data-point of value
231                        it contains one value all tags will be assigned the same value.                       0. If it contains one value all tag values will be assigned
232                        Otherwise if there is a mismatch between the number of tags and               this value. Otherwise consecutive tags will be assigned
233                        the number of values an exception will be generated.                       consecutive values.  If there is a mismatch between  the
234                 number of keys and the number of values an exception
235                 will be generated.
236        T
237    */    */
238      ESCRIPT_DLL_API
239    void    void
240    addTaggedValues(const TagListType& tagKeys,    addTaggedValues(const TagListType& tagKeys,
241                    const ValueListType& values);                      const ValueListType& values);  
# Line 202  class DataTagged : public DataAbstract { Line 247  class DataTagged : public DataAbstract {
247       Description:       Description:
248       Add a single tag and value to this DataTagged object. If this tag already has       Add a single tag and value to this DataTagged object. If this tag already has
249       a value associated with it, setTaggedValue will be used to update this value.       a value associated with it, setTaggedValue will be used to update this value.
250       \param tagKey - Input - Integer key.       \param tagKey - Input - Integer tag.
251       \param value - Input - Single DataArrayView value to be assigned to the tag.       \param value - Input - Single DataArrayView value to be assigned to the tag.
252        T
253    */    */
254      ESCRIPT_DLL_API
255    void    void
256    addTaggedValue(int tagKey,    addTaggedValue(int tagKey,
257                   const DataArrayView& value);                   const DataArrayView& value);
# Line 214  class DataTagged : public DataAbstract { Line 261  class DataTagged : public DataAbstract {
261       setTaggedValues       setTaggedValues
262    
263       Description:       Description:
264       Set the given tags to the given values in this DataTagged object, by repeatedly       Set the given tags to the given values in this DataTagged object.
265       using setTaggedValue for each given tag/value pair.       \param tagKeys - Input - A vector of integer tag.
      \param tagKeys - Input - A vector of integer keys.  
266       \param values - Input - A vector of DataArrayViews. If this is empty       \param values - Input - A vector of DataArrayViews. If this is empty
267                        then all given tags will be assigned a value of zero. If                       all tag values will be assigned a scalar data-point of value
268                        it contains one value all tag values will be assigned the same value.                       0. If it contains one value all tag values will be assigned
269                        Otherwise if there is a mismatch between the number of keys and               this value. Otherwise consecutive tags will be assigned
270                        the number of values an exception will be generated.                       consecutive values.  If there is a mismatch between  the
271                 number of keys and the number of values an exception
272                 will be generated.
273        T
274    */    */
275      ESCRIPT_DLL_API
276    void    void
277    setTaggedValues(const TagListType& tagKeys,    setTaggedValues(const TagListType& tagKeys,
278                    const ValueListType& values);                    const ValueListType& values);
# Line 232  class DataTagged : public DataAbstract { Line 282  class DataTagged : public DataAbstract {
282       setTaggedValue       setTaggedValue
283    
284       Description:       Description:
285       Assign the given value to the given tag. If this tag does not already have a value       Assign the given value to the given tag.
286       associated with it, addTaggedValue will be used to add this tag/value pair.       \param tagKey - Input - Integer tag.
      \param tagKey - Input - Integer key.  
287       \param value - Input - Single DataArrayView value to be assigned to the tag.       \param value - Input - Single DataArrayView value to be assigned to the tag.
288        T
289    */    */
290      ESCRIPT_DLL_API
291    virtual    virtual
292    void    void
293    setTaggedValue(int tagKey,    setTaggedValue(int tagKey,
# Line 247  class DataTagged : public DataAbstract { Line 298  class DataTagged : public DataAbstract {
298       getDataPointByTag       getDataPointByTag
299    
300       Description:       Description:
301       Return a view into the data-point associated with the given tag.       Return data-point associated with the given tag as a DataArrayView.
302       \param tag - Input - Integer key.       \param tag - Input - Integer key.
303        T
304    */    */
305      ESCRIPT_DLL_API
306    DataArrayView    DataArrayView
307    getDataPointByTag(int tag) const;    getDataPointByTag(int tag) const;
308    
# Line 258  class DataTagged : public DataAbstract { Line 311  class DataTagged : public DataAbstract {
311       getDataPoint       getDataPoint
312    
313       Description:       Description:
314       Return a view into the data-point specified by the given sample       Return the data-point specified by the given sample and data-point
315       and data-point numbers.       numbers as a DataArrayView.
316       \param sampleNo - Input.       \param sampleNo - Input.
317       \param dataPointNo - Input.       \param dataPointNo - Input.
318        T
319    */    */
320      ESCRIPT_DLL_API
321    virtual    virtual
322    DataArrayView    DataArrayView
323    getDataPoint(int sampleNo,    getDataPoint(int sampleNo,
324                 int dataPointNo);                 int dataPointNo);
325    
326    /**    /**
327         \brief
328         getData
329    
330         Description:
331         Return pointer to the data
332        T
333      */
334      ESCRIPT_DLL_API
335      const DataArrayView::ValueType::ElementType*
336      getData() const;
337    
338      /**
339       \brief       \brief
340       getTagLookup       getTagLookup
341    
342       Description:       Description:
343       Return a reference to the tag offset lookup table.       Return a reference to the tag offset lookup table.
344        T
345    */    */
346      ESCRIPT_DLL_API
347    const DataMapType&    const DataMapType&
348    getTagLookup() const;    getTagLookup() const;
349    
# Line 285  class DataTagged : public DataAbstract { Line 354  class DataTagged : public DataAbstract {
354       Description:       Description:
355       Return true if the given tag exists within the DataTagged tag map.       Return true if the given tag exists within the DataTagged tag map.
356    
357       NOTE: The DataTagged tag map does not necessarily coincide with the tag       *** NB: The DataTagged tag map does not necessarily coincide with the tag
358       keys in the associated function space.       keys in the associated function space.
359     */      T
360      */
361      ESCRIPT_DLL_API
362    bool    bool
363    isCurrentTag(int tag) const;    isCurrentTag(int tag) const;
364    
# Line 298  class DataTagged : public DataAbstract { Line 369  class DataTagged : public DataAbstract {
369       Description:       Description:
370       Return the default value. This value is associated with any tag which       Return the default value. This value is associated with any tag which
371       is not explicitly recorded in this DataTagged object's tag map.       is not explicitly recorded in this DataTagged object's tag map.
372        T
373    */    */
374      ESCRIPT_DLL_API
375    DataArrayView&    DataArrayView&
376    getDefaultValue();    getDefaultValue();
377    
378      ESCRIPT_DLL_API
379    const DataArrayView&    const DataArrayView&
380    getDefaultValue() const;    getDefaultValue() const;
381    
# Line 310  class DataTagged : public DataAbstract { Line 384  class DataTagged : public DataAbstract {
384       getLength       getLength
385    
386       Description:       Description:
387       Return the number of doubles stored for the Data.       Return the total number of doubles stored for this DataTagged object.
388        T
389    */    */
390      ESCRIPT_DLL_API
391    virtual    virtual
392    ValueType::size_type    ValueType::size_type
393    getLength() const;    getLength() const;
# Line 321  class DataTagged : public DataAbstract { Line 397  class DataTagged : public DataAbstract {
397       getSlice       getSlice
398    
399       Description:       Description:
400       Factory method that returns a newly created DataTagged object.       Factory method that returns a newly created DataTagged object generated
401       The caller is reponsible for managing the object created.       by taking the specified slice from this DataTagged object.
402         The caller is reponsible for managing the returned object.
403        T
404    */    */
405      ESCRIPT_DLL_API
406    virtual    virtual
407    DataAbstract*    DataAbstract*
408    getSlice(const DataArrayView::RegionType& region) const;    getSlice(const DataArrayView::RegionType& region) const;
409    
410    /**    /**
411       \brief       \brief
412       setSlice       Slice Constructor for DataTagged.
413    
414       Description:       Description:
415       Copy the specified region from the given value into this object.       Creates a DataTagged object which is the specified slice
416       \param value - Input - Data to copy from.       from the given DataTagged object.
417       \param region - Input - Region to copy.       \param other - Input - DataTagged object to slice from.
418         \param region - Input - Region to slice.
419        T
420    */    */
421    virtual    ESCRIPT_DLL_API
422    void    DataTagged(const DataTagged& other,
423    setSlice(const DataAbstract* value,           const DataArrayView::RegionType& region);
            const DataArrayView::RegionType& region);  
424    
425    /**    /**
426       \brief       \brief
427       reshapeDataPoint       setSlice
428    
429       Description:       Description:
430       Reshape the data point only if the data-point is currently rank 0.       Copy the given Data object into the specified region in this object.
431       An exception is thrown if the data-point has rank other than 0.       \param other - Input - Data object to copy from.
432       The original data point value is used for all values of the new       \param region - Input - Region to copy into (NB: must have same shape as other!).
433       data point.      T
434    */    */
435      ESCRIPT_DLL_API
436      virtual
437    void    void
438    reshapeDataPoint(const DataArrayView::ShapeType& shape);    setSlice(const DataAbstract* other,
439               const DataArrayView::RegionType& region);
440    
441    /**    /**
442      \brief       \brief
443      Archive the underlying data values to the file referenced       Archive the underlying data values to the file referenced
444      by ofstream. A count of the number of values expected to be written       by ofstream. A count of the number of values expected to be written
445      is provided as a cross-check.       is provided as a cross-check.
446    
447      The return value indicates success (0) or otherwise (1).       The return value indicates success (0) or otherwise (1).
448    */    */
449      ESCRIPT_DLL_API
450    int    int
451    archiveData(std::ofstream& archiveFile,    archiveData(std::ofstream& archiveFile,
452                const DataArrayView::ValueType::size_type noValues) const;                const DataArrayView::ValueType::size_type noValues) const;
453    
454    /**    /**
455      \brief       \brief
456      Extract the number of values specified by noValues from the file       Extract the number of values specified by noValues from the file
457      referenced by ifstream to the underlying data structure.       referenced by ifstream to the underlying data structure.
458    
459      The return value indicates success (0) or otherwise (1).       The return value indicates success (0) or otherwise (1).
460    */    */
461      ESCRIPT_DLL_API
462    int    int
463    extractData(std::ifstream& archiveFile,    extractData(std::ifstream& archiveFile,
464                const DataArrayView::ValueType::size_type noValues);                const DataArrayView::ValueType::size_type noValues);
465    
466      /**
467         \brief
468         Computes a symmetric matrix (A + AT) / 2
469    
470         \param ev - Output - symmetric matrix
471    
472      */
473      ESCRIPT_DLL_API
474      virtual void
475      symmetric(DataAbstract* ev);
476    
477      /**
478         \brief
479         Computes a nonsymmetric matrix (A - AT) / 2
480    
481         \param ev - Output - nonsymmetric matrix
482    
483      */
484      ESCRIPT_DLL_API
485      virtual void
486      nonsymmetric(DataAbstract* ev);
487    
488      /**
489         \brief
490         Computes the trace of a matrix
491    
492         \param ev - Output - the trace of a matrix
493    
494      */
495      ESCRIPT_DLL_API
496      virtual void
497      trace(DataAbstract* ev, int axis_offset);
498    
499      /**
500         \brief
501         swaps components axis0 and axis1
502    
503         \param ev - Output - swapped components
504    
505      */
506      ESCRIPT_DLL_API
507      virtual void
508      swapaxes(DataAbstract* ev, int axis0, int axis1);
509    
510      /**
511         \brief
512         Transpose each data point of this Data object around the given axis.
513    
514         \param ev - Output - the transpose of a matrix
515    
516      */
517      ESCRIPT_DLL_API
518      virtual void
519      transpose(DataAbstract* ev, int axis_offset);
520    
521      /**
522         \brief
523         solves the eigenvalue problem this*V=ev*V for the eigenvalues ev
524    
525         \param ev - Output - eigenvalues in increasing order at each data point
526    
527      */
528      ESCRIPT_DLL_API
529      virtual void
530      eigenvalues(DataAbstract* ev);
531    
532      /**
533         \brief
534         solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V
535    
536         \param ev - Output - eigenvalues in increasing order at each data point
537         \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
538                             and the first nonzero component is positive.
539         \param tol - Input - eigenvalue with relative distance tol are treated as equal.
540    
541      */
542    
543      ESCRIPT_DLL_API
544      virtual void
545      eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
546    
547    
548   protected:   protected:
549    
550   private:   private:
# Line 421  DataTagged::getDefaultValue() const Line 588  DataTagged::getDefaultValue() const
588  }  }
589    
590  inline  inline
591    const DataArrayView::ValueType::ElementType*
592    DataTagged::getData() const
593    {
594       return &(m_data[0]);
595    }
596    
597    inline
598  const DataTagged::DataMapType&  const DataTagged::DataMapType&
599  DataTagged::getTagLookup() const  DataTagged::getTagLookup() const
600  {  {

Legend:
Removed from v.496  
changed lines
  Added in v.1384

  ViewVC Help
Powered by ViewVC 1.1.26