/[escript]/branches/arrexp_2137_win/escript/src/DataTagged.cpp
ViewVC logotype

Annotation of /branches/arrexp_2137_win/escript/src/DataTagged.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1455 - (hide annotations)
Thu Feb 28 17:19:44 2008 UTC (11 years, 3 months ago) by phornby
Original Path: trunk/escript/src/DataTagged.cpp
File size: 23188 byte(s)
Merge of branches/windows_from_1431_trunk.

Revamp of the exception system.
Fix unused vars and signed/unsigned comparisons.
defined a macro THROW(ARG) in the system_dep.h's to
deal with the expectations of declarations on different architectures.

Details in the logs of branches/windows_from_1431_trunk.

pre-merge snapshot of the trunk in tags/trunk_at_1452


1 jgs 121
2 ksteube 1312 /* $Id$ */
3 jgs 82
4 ksteube 1312 /*******************************************************
5     *
6     * Copyright 2003-2007 by ACceSS MNRF
7     * Copyright 2007 by University of Queensland
8     *
9     * http://esscc.uq.edu.au
10     * Primary Business: Queensland, Australia
11     * Licensed under the Open Software License version 3.0
12     * http://www.opensource.org/licenses/osl-3.0.php
13     *
14     *******************************************************/
15    
16 jgs 474 #include "DataTagged.h"
17 jgs 496
18 jgs 474 #include "DataConstant.h"
19     #include "DataException.h"
20 gross 1023 #ifdef USE_NETCDF
21 ksteube 1312 #include <netcdfcpp.h>
22 gross 1023 #endif
23 jgs 82
24     using namespace std;
25    
26     namespace escript {
27    
28 jgs 121 DataTagged::DataTagged()
29     : DataAbstract(FunctionSpace())
30 jgs 82 {
31 jgs 509 // default constructor
32    
33 jgs 82 // create a scalar default value
34 jgs 151 m_data.resize(1,0.,1);
35 jgs 82 DataArrayView temp(m_data,DataArrayView::ShapeType());
36     setPointDataView(temp);
37     }
38    
39     DataTagged::DataTagged(const TagListType& tagKeys,
40     const ValueListType& values,
41     const DataArrayView& defaultValue,
42 jgs 102 const FunctionSpace& what)
43     : DataAbstract(what)
44 jgs 82 {
45 jgs 509 // constructor
46    
47 jgs 121 // initialise the array of data values
48     // the default value is always the first item in the values list
49 jgs 151 int len = defaultValue.noValues();
50     m_data.resize(len,0.,len);
51 jgs 121 for (int i=0; i<defaultValue.noValues(); i++) {
52     m_data[i]=defaultValue.getData(i);
53     }
54    
55 jgs 119 // create the data view
56 jgs 82 DataArrayView temp(m_data,defaultValue.getShape());
57     setPointDataView(temp);
58 jgs 121
59 jgs 82 // add remaining tags and values
60     addTaggedValues(tagKeys,values);
61     }
62    
63 jgs 119 DataTagged::DataTagged(const FunctionSpace& what,
64     const DataArrayView::ShapeType &shape,
65     const int tags[],
66 jgs 500 const ValueType& data)
67 jgs 119 : DataAbstract(what)
68     {
69 jgs 509 // alternative constructor
70     // not unit_tested tested yet
71    
72 jgs 121 // copy the data
73 jgs 119 m_data=data;
74 jgs 121
75 jgs 119 // create the view of the data
76     DataArrayView tempView(m_data,shape);
77     setPointDataView(tempView);
78 jgs 121
79 jgs 119 // create the tag lookup map
80     for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
81     m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
82     }
83     }
84    
85 woo409 757 DataTagged::DataTagged(const FunctionSpace& what,
86     const DataArrayView::ShapeType &shape,
87     const TagListType& tags,
88     const ValueType& data)
89     : DataAbstract(what)
90     {
91     // alternative constructor
92     // not unit_tested tested yet
93    
94     // copy the data
95     m_data=data;
96    
97     // create the view of the data
98     DataArrayView tempView(m_data,shape);
99     setPointDataView(tempView);
100    
101     // create the tag lookup map
102     for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
103     m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
104     }
105     }
106    
107    
108 jgs 102 DataTagged::DataTagged(const DataTagged& other)
109     : DataAbstract(other.getFunctionSpace()),
110 jgs 82 m_data(other.m_data),
111     m_offsetLookup(other.m_offsetLookup)
112     {
113 jgs 509 // copy constructor
114    
115 jgs 119 // create the data view
116 jgs 82 DataArrayView temp(m_data,other.getPointDataView().getShape());
117     setPointDataView(temp);
118     }
119    
120 jgs 102 DataTagged::DataTagged(const DataConstant& other)
121     : DataAbstract(other.getFunctionSpace())
122 jgs 82 {
123 jgs 509 // copy constructor
124    
125 jgs 121 // fill the default value with the constant value item from "other"
126 jgs 82 const DataArrayView& value=other.getPointDataView();
127 jgs 151 int len = value.noValues();
128     m_data.resize(len,0.,len);
129 jgs 121 for (int i=0; i<value.noValues(); i++) {
130     m_data[i]=value.getData(i);
131     }
132    
133 jgs 119 // create the data view
134 jgs 82 DataArrayView temp(m_data,value.getShape());
135     setPointDataView(temp);
136     }
137    
138     DataAbstract*
139     DataTagged::getSlice(const DataArrayView::RegionType& region) const
140     {
141 jgs 513 return new DataTagged(*this, region);
142 jgs 82 }
143    
144 jgs 513 DataTagged::DataTagged(const DataTagged& other,
145     const DataArrayView::RegionType& region)
146     : DataAbstract(other.getFunctionSpace())
147     {
148     // slice constructor
149    
150     // get the shape of the slice to copy from other
151     DataArrayView::ShapeType regionShape(DataArrayView::getResultSliceShape(region));
152     DataArrayView::RegionLoopRangeType regionLoopRange=getSliceRegionLoopRange(region);
153    
154     // allocate enough space in this for all values
155     // (need to add one to allow for the default value)
156     int len = DataArrayView::noValues(regionShape)*(other.m_offsetLookup.size()+1);
157     m_data.resize(len,0.0,len);
158    
159     // create the data view
160     DataArrayView temp(m_data,regionShape);
161     setPointDataView(temp);
162    
163     // copy the default value from other to this
164     getDefaultValue().copySlice(other.getDefaultValue(), regionLoopRange);
165    
166     // loop through the tag values copying these
167     DataMapType::const_iterator pos;
168     DataArrayView::ValueType::size_type tagOffset=getPointDataView().noValues();
169     for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();pos++){
170     getPointDataView().copySlice(tagOffset,other.getPointDataView(),pos->second,regionLoopRange);
171     m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));
172     tagOffset+=getPointDataView().noValues();
173     }
174     }
175    
176 jgs 82 void
177 jgs 513 DataTagged::setSlice(const DataAbstract* other,
178     const DataArrayView::RegionType& region)
179 jgs 82 {
180 jgs 513
181     // other must be another DataTagged object
182     // Data:setSlice implementation should ensure this
183     const DataTagged* otherTemp=dynamic_cast<const DataTagged*>(other);
184     if (otherTemp==0) {
185 jgs 82 throw DataException("Programming error - casting to DataTagged.");
186     }
187 jgs 121
188 jgs 513 // determine shape of the specified region
189     DataArrayView::ShapeType regionShape(DataArrayView::getResultSliceShape(region));
190    
191     // modify region specification as needed to match rank of this object
192     DataArrayView::RegionLoopRangeType regionLoopRange=getSliceRegionLoopRange(region);
193    
194     // ensure rank/shape of this object is compatible with specified region
195 jgs 82 if (getPointDataView().getRank()!=region.size()) {
196     throw DataException("Error - Invalid slice region.");
197     }
198 woo409 757 if (otherTemp->getPointDataView().getRank()>0 && !other->getPointDataView().checkShape(regionShape)) {
199 jgs 513 throw DataException (other->getPointDataView().createShapeErrorMessage(
200     "Error - Couldn't copy slice due to shape mismatch.",regionShape));
201 jgs 82 }
202 jgs 121
203 jgs 513 // copy slice from other default value to this default value
204     getDefaultValue().copySliceFrom(otherTemp->getDefaultValue(), regionLoopRange);
205 jgs 121
206 jgs 541 // loop through tag values in other, adding any which aren't in this, using default value
207     DataMapType::const_iterator pos;
208     for (pos=otherTemp->m_offsetLookup.begin();pos!=otherTemp->m_offsetLookup.end();pos++) {
209     if (!isCurrentTag(pos->first)) {
210     addTaggedValue(pos->first,getDefaultValue());
211     }
212     }
213    
214 jgs 513 // loop through the tag values copying slices from other to this
215 jgs 121 for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++) {
216 jgs 513 getDataPointByTag(pos->first).copySliceFrom(otherTemp->getDataPointByTag(pos->first), regionLoopRange);
217 jgs 121 }
218 jgs 513
219 jgs 82 }
220    
221 jgs 149 int
222     DataTagged::getTagNumber(int dpno)
223     {
224     //
225     // Get the number of samples and data-points per sample
226     int numSamples = getNumSamples();
227     int numDataPointsPerSample = getNumDPPSample();
228     int numDataPoints = numSamples * numDataPointsPerSample;
229    
230     if (numDataPointsPerSample==0) {
231     throw DataException("DataTagged::getTagNumber error: no data-points associated with this object.");
232     }
233    
234 jgs 496 if (dpno<0 || dpno>numDataPoints-1) {
235 jgs 149 throw DataException("DataTagged::getTagNumber error: invalid data-point number supplied.");
236     }
237    
238     //
239     // Determine the sample number which corresponds to this data-point number
240     int sampleNo = dpno / numDataPointsPerSample;
241    
242     //
243     // Determine the tag number which corresponds to this sample number
244     int tagNo = getFunctionSpace().getTagFromSampleNo(sampleNo);
245    
246     //
247     // return the tag number
248     return(tagNo);
249     }
250    
251 jgs 82 void
252 jgs 509 DataTagged::setTaggedValues(const TagListType& tagKeys,
253     const ValueListType& values)
254     {
255     addTaggedValues(tagKeys,values);
256     }
257    
258     void
259 jgs 82 DataTagged::setTaggedValue(int tagKey,
260     const DataArrayView& value)
261     {
262 jgs 121 if (!getPointDataView().checkShape(value.getShape())) {
263     throw DataException(getPointDataView().createShapeErrorMessage(
264     "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape()));
265     }
266 jgs 82 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
267     if (pos==m_offsetLookup.end()) {
268 jgs 121 // tag couldn't be found so use addTaggedValue
269 jgs 82 addTaggedValue(tagKey,value);
270     } else {
271 jgs 121 // copy the values into the data array at the offset determined by m_offsetLookup
272     int offset=pos->second;
273     for (int i=0; i<getPointDataView().noValues(); i++) {
274     m_data[offset+i]=value.getData(i);
275 jgs 82 }
276     }
277     }
278    
279     void
280 jgs 509 DataTagged::addTaggedValues(const TagListType& tagKeys,
281     const ValueListType& values)
282     {
283     if (values.size()==0) {
284     // copy the current default value for each of the tags
285     TagListType::const_iterator iT;
286     for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
287     // the point data view for DataTagged points at the default value
288     addTaggedValue(*iT,getPointDataView());
289     }
290     } else if (values.size()==1 && tagKeys.size()>1) {
291     // assume the one given value will be used for all tag values
292     TagListType::const_iterator iT;
293     for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
294     addTaggedValue(*iT,values[0]);
295     }
296     } else {
297     if (tagKeys.size()!=values.size()) {
298     stringstream temp;
299     temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
300     << " doesn't match number of values: " << values.size();
301     throw DataException(temp.str());
302     } else {
303 phornby 1455 unsigned int i;
304     for (i=0;i<tagKeys.size();i++) {
305 jgs 509 addTaggedValue(tagKeys[i],values[i]);
306     }
307     }
308     }
309     }
310    
311     void
312 jgs 82 DataTagged::addTaggedValue(int tagKey,
313     const DataArrayView& value)
314     {
315     if (!getPointDataView().checkShape(value.getShape())) {
316     throw DataException(getPointDataView().createShapeErrorMessage(
317 jgs 121 "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape()));
318 jgs 82 }
319 jgs 121 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
320     if (pos!=m_offsetLookup.end()) {
321     // tag already exists so use setTaggedValue
322     setTaggedValue(tagKey,value);
323     } else {
324     // save the key and the location of its data in the lookup tab
325     m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
326     // add the data given in "value" at the end of m_data
327     // need to make a temp copy of m_data, resize m_data, then copy
328     // all the old values plus the value to be added back into m_data
329     ValueType m_data_temp(m_data);
330     int oldSize=m_data.size();
331     int newSize=m_data.size()+value.noValues();
332 jgs 151 m_data.resize(newSize,0.,newSize);
333 jgs 121 for (int i=0;i<oldSize;i++) {
334     m_data[i]=m_data_temp[i];
335     }
336     for (int i=0;i<value.noValues();i++) {
337     m_data[oldSize+i]=value.getData(i);
338     }
339     }
340 jgs 82 }
341    
342     double*
343     DataTagged::getSampleDataByTag(int tag)
344     {
345     DataMapType::iterator pos(m_offsetLookup.find(tag));
346     if (pos==m_offsetLookup.end()) {
347     // tag couldn't be found so return the default value
348     return &(m_data[0]);
349     } else {
350     // return the data-point corresponding to the given tag
351     return &(m_data[pos->second]);
352     }
353     }
354    
355     string
356     DataTagged::toString() const
357     {
358     stringstream temp;
359     DataMapType::const_iterator i;
360     temp << "Tag(Default)" << endl;
361     temp << getDefaultValue().toString() << endl;
362     // create a temporary view as the offset will be changed
363     DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());
364     for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {
365     temp << "Tag(" << i->first << ")" << endl;
366     tempView.setOffset(i->second);
367     temp << tempView.toString() << endl;
368     }
369 ksteube 1312 return temp.str();
370 jgs 82 }
371    
372 jgs 496 DataArrayView::ValueType::size_type
373     DataTagged::getPointOffset(int sampleNo,
374     int dataPointNo) const
375 jgs 82 {
376 jgs 496 int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
377     DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));
378 jgs 82 DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
379     if (pos!=m_offsetLookup.end()) {
380     offset=pos->second;
381     }
382 jgs 496 return offset;
383 jgs 82 }
384    
385 jgs 496 DataArrayView
386     DataTagged::getDataPointByTag(int tag) const
387 jgs 82 {
388 jgs 496 DataMapType::const_iterator pos(m_offsetLookup.find(tag));
389 jgs 82 DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
390     if (pos!=m_offsetLookup.end()) {
391     offset=pos->second;
392     }
393 jgs 496 DataArrayView temp(getPointDataView());
394     temp.setOffset(offset);
395     return temp;
396 jgs 82 }
397    
398     DataArrayView
399     DataTagged::getDataPoint(int sampleNo,
400     int dataPointNo)
401     {
402     EsysAssert(validSampleNo(sampleNo),"(getDataPoint) Invalid sampleNo: " << sampleNo);
403     int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
404     return getDataPointByTag(tagKey);
405     }
406    
407 jgs 123 int
408     DataTagged::archiveData(ofstream& archiveFile,
409     const DataArrayView::ValueType::size_type noValues) const
410     {
411     return(m_data.archiveData(archiveFile, noValues));
412     }
413    
414     int
415     DataTagged::extractData(ifstream& archiveFile,
416     const DataArrayView::ValueType::size_type noValues)
417     {
418     return(m_data.extractData(archiveFile, noValues));
419     }
420 gross 580 void
421 ksteube 775 DataTagged::symmetric(DataAbstract* ev)
422     {
423     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
424     if (temp_ev==0) {
425     throw DataException("Error - DataTagged::symmetric casting to DataTagged failed (probably a programming error).");
426     }
427     const DataTagged::DataMapType& thisLookup=getTagLookup();
428     DataTagged::DataMapType::const_iterator i;
429     DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
430     for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
431     temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
432     DataArrayView thisView=getDataPointByTag(i->first);
433     DataArrayView evView=temp_ev->getDataPointByTag(i->first);
434     DataArrayView::symmetric(thisView,0,evView,0);
435     }
436     DataArrayView::symmetric(getDefaultValue(),0,temp_ev->getDefaultValue(),0);
437     }
438     void
439     DataTagged::nonsymmetric(DataAbstract* ev)
440     {
441     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
442     if (temp_ev==0) {
443     throw DataException("Error - DataTagged::nonsymmetric casting to DataTagged failed (probably a programming error).");
444     }
445     const DataTagged::DataMapType& thisLookup=getTagLookup();
446     DataTagged::DataMapType::const_iterator i;
447     DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
448     for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
449     temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
450     DataArrayView thisView=getDataPointByTag(i->first);
451     DataArrayView evView=temp_ev->getDataPointByTag(i->first);
452     DataArrayView::nonsymmetric(thisView,0,evView,0);
453     }
454     DataArrayView::nonsymmetric(getDefaultValue(),0,temp_ev->getDefaultValue(),0);
455     }
456     void
457 gross 800 DataTagged::trace(DataAbstract* ev, int axis_offset)
458 ksteube 775 {
459     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
460     if (temp_ev==0) {
461 gross 800 throw DataException("Error - DataTagged::trace casting to DataTagged failed (probably a programming error).");
462 ksteube 775 }
463     const DataTagged::DataMapType& thisLookup=getTagLookup();
464     DataTagged::DataMapType::const_iterator i;
465     DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
466     for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
467     temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
468     DataArrayView thisView=getDataPointByTag(i->first);
469     DataArrayView evView=temp_ev->getDataPointByTag(i->first);
470 gross 800 DataArrayView::trace(thisView,0,evView,0, axis_offset);
471 ksteube 775 }
472 gross 800 DataArrayView::trace(getDefaultValue(),0,temp_ev->getDefaultValue(),0,axis_offset);
473 ksteube 775 }
474 gross 800
475 ksteube 775 void
476     DataTagged::transpose(DataAbstract* ev, int axis_offset)
477     {
478     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
479     if (temp_ev==0) {
480     throw DataException("Error - DataTagged::transpose casting to DataTagged failed (probably a programming error).");
481     }
482     const DataTagged::DataMapType& thisLookup=getTagLookup();
483     DataTagged::DataMapType::const_iterator i;
484     DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
485     for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
486     temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
487     DataArrayView thisView=getDataPointByTag(i->first);
488     DataArrayView evView=temp_ev->getDataPointByTag(i->first);
489     DataArrayView::transpose(thisView,0,evView,0, axis_offset);
490     }
491     DataArrayView::transpose(getDefaultValue(),0,temp_ev->getDefaultValue(),0,axis_offset);
492     }
493 gross 800
494 ksteube 775 void
495 gross 804 DataTagged::swapaxes(DataAbstract* ev, int axis0, int axis1)
496 gross 800 {
497     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
498     if (temp_ev==0) {
499 gross 804 throw DataException("Error - DataTagged::swapaxes casting to DataTagged failed (probably a programming error).");
500 gross 800 }
501     const DataTagged::DataMapType& thisLookup=getTagLookup();
502     DataTagged::DataMapType::const_iterator i;
503     DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
504     for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
505     temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
506     DataArrayView thisView=getDataPointByTag(i->first);
507     DataArrayView evView=temp_ev->getDataPointByTag(i->first);
508 gross 804 DataArrayView::swapaxes(thisView,0,evView,0,axis0,axis1);
509 gross 800 }
510 gross 804 DataArrayView::swapaxes(getDefaultValue(),0,temp_ev->getDefaultValue(),0,axis0,axis1);
511 gross 800 }
512    
513     void
514 gross 580 DataTagged::eigenvalues(DataAbstract* ev)
515     {
516     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
517     if (temp_ev==0) {
518     throw DataException("Error - DataTagged::eigenvalues casting to DataTagged failed (propably a programming error).");
519     }
520     const DataTagged::DataMapType& thisLookup=getTagLookup();
521     DataTagged::DataMapType::const_iterator i;
522     DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
523     for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
524     temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
525     DataArrayView thisView=getDataPointByTag(i->first);
526     DataArrayView evView=temp_ev->getDataPointByTag(i->first);
527     DataArrayView::eigenvalues(thisView,0,evView,0);
528     }
529     DataArrayView::eigenvalues(getDefaultValue(),0,temp_ev->getDefaultValue(),0);
530     }
531     void
532     DataTagged::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
533     {
534     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
535     if (temp_ev==0) {
536     throw DataException("Error - DataTagged::eigenvalues_and_eigenvectors casting to DataTagged failed (propably a programming error).");
537     }
538     DataTagged* temp_V=dynamic_cast<DataTagged*>(V);
539     if (temp_V==0) {
540     throw DataException("Error - DataTagged::eigenvalues_and_eigenvectors casting to DataTagged failed (propably a programming error).");
541     }
542     const DataTagged::DataMapType& thisLookup=getTagLookup();
543     DataTagged::DataMapType::const_iterator i;
544     DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
545     for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
546     temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
547     temp_V->addTaggedValue(i->first,temp_V->getDefaultValue());
548     DataArrayView thisView=getDataPointByTag(i->first);
549     DataArrayView evView=temp_ev->getDataPointByTag(i->first);
550     DataArrayView VView=temp_V->getDataPointByTag(i->first);
551     DataArrayView::eigenvalues_and_eigenvectors(thisView,0,evView,0,VView,0,tol);
552     }
553     DataArrayView::eigenvalues_and_eigenvectors(getDefaultValue(),0,
554     temp_ev->getDefaultValue(),0,
555     temp_V->getDefaultValue(),0,
556     tol);
557 jgs 123
558 gross 580
559     }
560    
561 gross 950 void
562 gross 1118 DataTagged::setToZero(){
563     DataArrayView::ValueType::size_type n=m_data.size();
564     for (int i=0; i<n ;++i) m_data[i]=0.;
565     }
566    
567     void
568 gross 950 DataTagged::dump(const std::string fileName) const
569     {
570 gross 1023 #ifdef PASO_MPI
571 ksteube 1312 throw DataException("Error - DataTagged:: dump is not implemented for MPI yet.");
572 gross 1023 #endif
573     #ifdef USE_NETCDF
574 gross 983 const int ldims=DataArrayView::maxRank+1;
575     const NcDim* ncdims[ldims];
576     NcVar *var, *tags_var;
577     int rank = getPointDataView().getRank();
578     int type= getFunctionSpace().getTypeCode();
579     int ndims =0;
580     long dims[ldims];
581 gross 1141 const double* d_ptr=&(m_data[0]);
582 gross 983 DataArrayView::ShapeType shape = getPointDataView().getShape();
583    
584     // netCDF error handler
585     NcError err(NcError::verbose_nonfatal);
586     // Create the file.
587     NcFile dataFile(fileName.c_str(), NcFile::Replace);
588     // check if writing was successful
589     if (!dataFile.is_valid())
590     throw DataException("Error - DataTagged:: opening of netCDF file for output failed.");
591 gross 1141 if (!dataFile.add_att("type_id",1) )
592 gross 983 throw DataException("Error - DataTagged:: appending data type to netCDF file failed.");
593     if (!dataFile.add_att("rank",rank) )
594     throw DataException("Error - DataTagged:: appending rank attribute to netCDF file failed.");
595     if (!dataFile.add_att("function_space_type",type))
596     throw DataException("Error - DataTagged:: appending function space attribute to netCDF file failed.");
597     ndims=rank+1;
598     if ( rank >0 ) {
599     dims[0]=shape[0];
600     if (! (ncdims[0] = dataFile.add_dim("d0",shape[0])) )
601     throw DataException("Error - DataTagged:: appending ncdimsion 0 to netCDF file failed.");
602     }
603     if ( rank >1 ) {
604     dims[1]=shape[1];
605     if (! (ncdims[1] = dataFile.add_dim("d1",shape[1])) )
606     throw DataException("Error - DataTagged:: appending ncdimsion 1 to netCDF file failed.");
607     }
608     if ( rank >2 ) {
609     dims[2]=shape[2];
610     if (! (ncdims[2] = dataFile.add_dim("d2", shape[2])) )
611     throw DataException("Error - DataTagged:: appending ncdimsion 2 to netCDF file failed.");
612     }
613     if ( rank >3 ) {
614     dims[3]=shape[3];
615     if (! (ncdims[3] = dataFile.add_dim("d3", shape[3])) )
616     throw DataException("Error - DataTagged:: appending ncdimsion 3 to netCDF file failed.");
617     }
618     const DataTagged::DataMapType& thisLookup=getTagLookup();
619     DataTagged::DataMapType::const_iterator i;
620     DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
621     int ntags=1;
622     for (i=thisLookup.begin();i!=thisLookupEnd;i++) ntags++;
623 phornby 1020 int* tags =(int*) malloc(ntags*sizeof(int));
624     int c=1;
625 gross 983 tags[0]=-1;
626     for (i=thisLookup.begin();i!=thisLookupEnd;i++) tags[c++]=i->first;
627     dims[rank]=ntags;
628     if (! (ncdims[rank] = dataFile.add_dim("num_tags", dims[rank])) )
629 phornby 1020 {
630     free(tags);
631     throw DataException("Error - DataTagged:: appending num_tags to netCDF file failed.");
632     }
633 gross 983 if (! ( tags_var = dataFile.add_var("tags", ncInt, ncdims[rank])) )
634 phornby 1020 {
635     free(tags);
636 gross 983 throw DataException("Error - DataTagged:: appending tags to netCDF file failed.");
637 phornby 1020 }
638 gross 983 if (! (tags_var->put(tags,dims[rank])) )
639 phornby 1020 {
640     free(tags);
641 gross 983 throw DataException("Error - DataTagged:: copy tags to netCDF buffer failed.");
642 phornby 1020 }
643 gross 983 if (! ( var = dataFile.add_var("data", ncDouble, ndims, ncdims)) )
644 phornby 1020 {
645     free(tags);
646 gross 983 throw DataException("Error - DataTagged:: appending variable to netCDF file failed.");
647 phornby 1020 }
648 gross 1141 if (! (var->put(d_ptr,dims)) )
649 phornby 1020 {
650     free(tags);
651 gross 983 throw DataException("Error - DataTagged:: copy data to netCDF buffer failed.");
652 phornby 1020 }
653 gross 1023 #else
654     throw DataException("Error - DataTagged:: dump is not configured with netCDF. Please contact your installation manager.");
655     #endif
656 gross 950 }
657 jgs 82 } // end of namespace

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26