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

Contents of /trunk/escript/src/DataTagged.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1811 - (show annotations)
Thu Sep 25 23:11:13 2008 UTC (10 years, 3 months ago) by ksteube
File size: 34650 byte(s)
Copyright updated in all files

1
2 /*******************************************************
3 *
4 * Copyright (c) 2003-2008 by University of Queensland
5 * Earth Systems Science Computational Center (ESSCC)
6 * http://www.uq.edu.au/esscc
7 *
8 * Primary Business: Queensland, Australia
9 * Licensed under the Open Software License version 3.0
10 * http://www.opensource.org/licenses/osl-3.0.php
11 *
12 *******************************************************/
13
14
15 #include "DataTagged.h"
16 #include "esysUtils/esys_malloc.h"
17
18 #include "DataConstant.h"
19 #include "DataException.h"
20 #ifdef USE_NETCDF
21 #include <netcdfcpp.h>
22 #endif
23 #include "DataMaths.h"
24
25 using namespace std;
26
27 namespace escript {
28
29 DataTagged::DataTagged()
30 : DataAbstract(FunctionSpace(),DataTypes::scalarShape)
31 {
32 // default constructor
33
34 // create a scalar default value
35 m_data.resize(1,0.,1);
36 /* DataArrayView temp(m_data,DataTypes::ShapeType());
37 setPointDataView(temp);*/
38 }
39
40 // DataTagged::DataTagged(const TagListType& tagKeys,
41 // const ValueListType& values,
42 // const DataArrayView& defaultValue,
43 // const FunctionSpace& what)
44 // : DataAbstract(what)
45 // {
46 // // constructor
47 //
48 // // initialise the array of data values
49 // // the default value is always the first item in the values list
50 // int len = defaultValue.noValues();
51 // m_data.resize(len,0.,len);
52 // for (int i=0; i<defaultValue.noValues(); i++) {
53 // m_data[i]=defaultValue.getData(i);
54 // }
55 //
56 // // create the data view
57 // DataArrayView temp(m_data,defaultValue.getShape());
58 // setPointDataView(temp);
59 //
60 // // add remaining tags and values
61 // addTaggedValues(tagKeys,values);
62 // }
63
64 DataTagged::DataTagged(const FunctionSpace& what,
65 const DataTypes::ShapeType &shape,
66 const int tags[],
67 const ValueType& data)
68 : DataAbstract(what,shape)
69 {
70 // alternative constructor
71 // not unit_tested tested yet
72 // It is not explicitly unit tested yet, but it is called from DataFactory
73
74 if (!what.canTag())
75 {
76 throw DataException("Programming error - DataTag created with a non-taggable FunctionSpace.");
77 }
78 // copy the data
79 m_data=data;
80
81 // create the view of the data
82 // DataArrayView tempView(m_data,shape);
83 // setPointDataView(tempView);
84
85 // we can't rely on the tag array to give us the number of tags so
86 // use the data we have been passed
87 int valsize=DataTypes::noValues(shape);
88 int ntags=data.size()/valsize;
89
90 // create the tag lookup map
91 // we assume that the first value and first tag are the default value so we skip
92 for (int i=1;i<ntags;++i)
93 {
94 m_offsetLookup.insert(DataMapType::value_type(tags[i],i*valsize));
95 }
96 }
97
98 DataTagged::DataTagged(const FunctionSpace& what,
99 const DataTypes::ShapeType &shape,
100 const TagListType& tags,
101 const ValueType& data)
102 : DataAbstract(what,shape)
103 {
104 // alternative constructor
105
106 if (!what.canTag())
107 {
108 throw DataException("Programming error - DataTag created with a non-taggable FunctionSpace.");
109 }
110
111 // copy the data
112 m_data=data;
113
114 // create the view of the data
115 // DataArrayView tempView(m_data,shape);
116 // setPointDataView(tempView);
117
118 // create the tag lookup map
119
120 // for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
121 // m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
122 // }
123
124 // The above code looks like it will create a map the wrong way around
125
126 int valsize=DataTypes::noValues(shape);
127 int npoints=(data.size()/valsize)-1;
128 int ntags=tags.size();
129 if (ntags>npoints)
130 { // This throw is not unit tested yet
131 throw DataException("Programming error - Too many tags for the supplied values.");
132 }
133
134 // create the tag lookup map
135 // we assume that the first value is the default value so we skip it (hence the i+1 below)
136 for (int i=0;i<ntags;++i)
137 {
138 m_offsetLookup.insert(DataMapType::value_type(tags[i],(i+1)*valsize));
139 }
140 }
141
142
143 DataTagged::DataTagged(const DataTagged& other)
144 : DataAbstract(other.getFunctionSpace(),other.getShape()),
145 m_data(other.m_data),
146 m_offsetLookup(other.m_offsetLookup)
147 {
148 // copy constructor
149
150 // create the data view
151 // DataArrayView temp(m_data,other.getPointDataView().getShape());
152 // setPointDataView(temp);
153 }
154
155 DataTagged::DataTagged(const DataConstant& other)
156 : DataAbstract(other.getFunctionSpace(),other.getShape())
157 {
158 // copy constructor
159
160 if (!other.getFunctionSpace().canTag())
161 {
162 throw DataException("Programming error - DataTag created with a non-taggable FunctionSpace.");
163 }
164
165 // fill the default value with the constant value item from "other"
166 // const DataArrayView& value=other.getPointDataView();
167 int len = other.getNoValues();
168 m_data.resize(len,0.,len);
169 for (int i=0; i<len; i++) {
170 m_data[i]=other.getVector()[i];
171 }
172
173 // // create the data view
174 // DataArrayView temp(m_data,value.getShape());
175 // setPointDataView(temp);
176 }
177
178
179 // Create a new object by copying tags
180 DataTagged::DataTagged(const FunctionSpace& what,
181 const DataTypes::ShapeType& shape,
182 const DataTypes::ValueType& defaultvalue,
183 const DataTagged* tagsource)
184 : DataAbstract(what,shape)
185 {
186 // This constructor has not been unit tested yet
187
188 if (defaultvalue.size()!=DataTypes::noValues(shape)) {
189 throw DataException("Programming error - defaultvalue does not match supplied shape.");
190 }
191
192
193 if (!what.canTag())
194 {
195 throw DataException("Programming error - DataTag created with a non-taggable FunctionSpace.");
196 }
197
198 if (tagsource!=0)
199 {
200 int numtags=tagsource->getTagLookup().size();
201 // m_offsetLookup.reserve(tagsource.getTagLookup().size());
202 m_data.resize(defaultvalue.size(),0.); // since this is tagged data, we should have blocksize=1
203
204 DataTagged::DataMapType::const_iterator i;
205 for (i=tagsource->getTagLookup().begin();i!=tagsource->getTagLookup().end();i++) {
206 addTag(i->first);
207 }
208 }
209 else
210 {
211 m_data.resize(defaultvalue.size());
212 }
213
214
215
216 // need to set the default value ....
217 for (int i=0; i<defaultvalue.size(); i++) {
218 m_data[i]=defaultvalue[i];
219 }
220 }
221
222 DataAbstract*
223 DataTagged::deepCopy()
224 {
225 return new DataTagged(*this);
226 }
227
228 DataAbstract*
229 DataTagged::getSlice(const DataTypes::RegionType& region) const
230 {
231 return new DataTagged(*this, region);
232 }
233
234 DataTagged::DataTagged(const DataTagged& other,
235 const DataTypes::RegionType& region)
236 : DataAbstract(other.getFunctionSpace(),DataTypes::getResultSliceShape(region))
237 {
238 // slice constructor
239
240 // get the shape of the slice to copy from other
241 DataTypes::ShapeType regionShape(DataTypes::getResultSliceShape(region));
242 DataTypes::RegionLoopRangeType regionLoopRange=DataTypes::getSliceRegionLoopRange(region);
243
244 // allocate enough space in this for all values
245 // (need to add one to allow for the default value)
246 int len = DataTypes::noValues(regionShape)*(other.m_offsetLookup.size()+1);
247 m_data.resize(len,0.0,len);
248
249 // create the data view
250 // DataArrayView temp(m_data,regionShape);
251 // setPointDataView(temp);
252
253 // copy the default value from other to this
254 // getDefaultValue().copySlice(other.getDefaultValue(), regionLoopRange);
255 const DataTypes::ShapeType& otherShape=other.getShape();
256 const DataTypes::ValueType& otherData=other.getVector();
257 DataTypes::copySlice(getVector(),getShape(),getDefaultOffset(),otherData,otherShape,other.getDefaultOffset(), regionLoopRange);
258
259 // loop through the tag values copying these
260 DataMapType::const_iterator pos;
261 DataTypes::ValueType::size_type tagOffset=getNoValues();
262 for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();pos++){
263 // getPointDataView().copySlice(tagOffset,other.getPointDataView(),pos->second,regionLoopRange);
264 DataTypes::copySlice(m_data,getShape(),tagOffset,otherData, otherShape, pos->second, regionLoopRange);
265 m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));
266 tagOffset+=getNoValues();
267 }
268 }
269
270 void
271 DataTagged::setSlice(const DataAbstract* other,
272 const DataTypes::RegionType& region)
273 {
274
275 // other must be another DataTagged object
276 // Data:setSlice implementation should ensure this
277 const DataTagged* otherTemp=dynamic_cast<const DataTagged*>(other);
278 if (otherTemp==0) {
279 throw DataException("Programming error - casting to DataTagged.");
280 }
281
282 // determine shape of the specified region
283 DataTypes::ShapeType regionShape(DataTypes::getResultSliceShape(region));
284
285 // modify region specification as needed to match rank of this object
286 DataTypes::RegionLoopRangeType regionLoopRange=DataTypes::getSliceRegionLoopRange(region);
287
288 // ensure rank/shape of this object is compatible with specified region
289 if (getRank()!=region.size()) {
290 throw DataException("Error - Invalid slice region.");
291 }
292 if (otherTemp->getRank()>0 && !DataTypes::checkShape(other->getShape(),regionShape)) {
293 throw DataException (DataTypes::createShapeErrorMessage(
294 "Error - Couldn't copy slice due to shape mismatch.",regionShape,other->getShape()));
295 }
296
297 const DataTypes::ValueType& otherData=otherTemp->getVector();
298 const DataTypes::ShapeType& otherShape=otherTemp->getShape();
299 // copy slice from other default value to this default value
300 // getDefaultValue().copySliceFrom(otherTemp->getDefaultValue(), regionLoopRange);
301 DataTypes::copySliceFrom(m_data,getShape(),getDefaultOffset(),otherData,otherShape,otherTemp->getDefaultOffset(),regionLoopRange);
302
303 // loop through tag values in other, adding any which aren't in this, using default value
304 DataMapType::const_iterator pos;
305 for (pos=otherTemp->m_offsetLookup.begin();pos!=otherTemp->m_offsetLookup.end();pos++) {
306 if (!isCurrentTag(pos->first)) {
307 addTag(pos->first);
308 }
309 }
310
311 // loop through the tag values copying slices from other to this
312 for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++) {
313 // getDataPointByTag(pos->first).copySliceFrom(otherTemp->getDataPointByTag(pos->first), regionLoopRange);
314 DataTypes::copySliceFrom(m_data,getShape(),getOffsetForTag(pos->first),otherData, otherShape, otherTemp->getOffsetForTag(pos->first), regionLoopRange);
315
316 }
317
318 }
319
320 int
321 DataTagged::getTagNumber(int dpno)
322 {
323 //
324 // Get the number of samples and data-points per sample
325 int numSamples = getNumSamples();
326 int numDataPointsPerSample = getNumDPPSample();
327 int numDataPoints = numSamples * numDataPointsPerSample;
328
329 if (numDataPointsPerSample==0) {
330 throw DataException("DataTagged::getTagNumber error: no data-points associated with this object.");
331 }
332
333 if (dpno<0 || dpno>numDataPoints-1) {
334 throw DataException("DataTagged::getTagNumber error: invalid data-point number supplied.");
335 }
336
337 //
338 // Determine the sample number which corresponds to this data-point number
339 int sampleNo = dpno / numDataPointsPerSample;
340
341 //
342 // Determine the tag number which corresponds to this sample number
343 int tagNo = getFunctionSpace().getTagFromSampleNo(sampleNo);
344
345 //
346 // return the tag number
347 return(tagNo);
348 }
349
350 // void
351 // DataTagged::setTaggedValues(const TagListType& tagKeys,
352 // const ValueListType& values)
353 // {
354 // addTaggedValues(tagKeys,values);
355 // }
356
357 void
358 DataTagged::setTaggedValue(int tagKey,
359 const DataTypes::ShapeType& pointshape,
360 const ValueType& value,
361 int dataOffset)
362 {
363 if (!DataTypes::checkShape(getShape(), pointshape)) {
364 throw DataException(DataTypes::createShapeErrorMessage(
365 "Error - Cannot setTaggedValue due to shape mismatch.", pointshape,getShape()));
366 }
367 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
368 if (pos==m_offsetLookup.end()) {
369 // tag couldn't be found so use addTaggedValue
370 addTaggedValue(tagKey,pointshape, value, dataOffset);
371 } else {
372 // copy the values into the data array at the offset determined by m_offsetLookup
373 int offset=pos->second;
374 for (int i=0; i<getNoValues(); i++) {
375 m_data[offset+i]=value[i+dataOffset];
376 }
377 }
378 }
379
380
381 /*
382 void
383 DataTagged::setTaggedValue(int tagKey,
384 const DataArrayView& value)
385 {
386 if (!getPointDataView().checkShape(value.getShape())) {
387 throw DataException(DataTypes::createShapeErrorMessage(
388 "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape(),getShape()));
389 }
390 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
391 if (pos==m_offsetLookup.end()) {
392 // tag couldn't be found so use addTaggedValue
393 addTaggedValue(tagKey,value);
394 } else {
395 // copy the values into the data array at the offset determined by m_offsetLookup
396 int offset=pos->second;
397 for (int i=0; i<getPointDataView().noValues(); i++) {
398 m_data[offset+i]=value.getData(i);
399 }
400 }
401 }*/
402
403 // void
404 // DataTagged::addTaggedValues(const TagListType& tagKeys,
405 // const ValueListType& values)
406 // {
407 // if (values.size()==0) {
408 // // copy the current default value for each of the tags
409 // TagListType::const_iterator iT;
410 // for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
411 // // the point data view for DataTagged points at the default value
412 // addTaggedValue(*iT,getPointDataView());
413 // }
414 // } else if (values.size()==1 && tagKeys.size()>1) {
415 // // assume the one given value will be used for all tag values
416 // TagListType::const_iterator iT;
417 // for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
418 // addTaggedValue(*iT,values[0]);
419 // }
420 // } else {
421 // if (tagKeys.size()!=values.size()) {
422 // stringstream temp;
423 // temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
424 // << " doesn't match number of values: " << values.size();
425 // throw DataException(temp.str());
426 // } else {
427 // unsigned int i;
428 // for (i=0;i<tagKeys.size();i++) {
429 // addTaggedValue(tagKeys[i],values[i]);
430 // }
431 // }
432 // }
433 // }
434
435
436 void
437 DataTagged::addTaggedValues(const TagListType& tagKeys,
438 const ValueBatchType& values,
439 const ShapeType& vShape)
440 {
441 DataTypes::ValueType t(values.size(),0);
442 for (int i=0;i<values.size();++i)
443 {
444 t[i]=values[i];
445 }
446 addTaggedValues(tagKeys,t,vShape);
447 }
448
449
450 // Note: The check to see if vShape==our shape is done in the addTaggedValue method
451 void
452 DataTagged::addTaggedValues(const TagListType& tagKeys,
453 const ValueType& values,
454 const ShapeType& vShape)
455 {
456 int n=getNoValues();
457 int numVals=values.size()/n;
458 if (values.size()==0) {
459 // copy the current default value for each of the tags
460 TagListType::const_iterator iT;
461 for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
462 // the point data view for DataTagged points at the default value
463 addTag(*iT);
464 }
465 } else if (numVals==1 && tagKeys.size()>1) {
466 // assume the one given value will be used for all tag values
467 TagListType::const_iterator iT;
468 for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
469 addTaggedValue(*iT, vShape, values,0);
470 }
471 } else {
472 if (tagKeys.size()!=numVals) {
473 stringstream temp;
474 temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
475 << " doesn't match number of values: " << values.size();
476 throw DataException(temp.str());
477 } else {
478 unsigned int i;
479 int offset=0;
480 for (i=0;i<tagKeys.size();i++ ,offset+=n) {
481 addTaggedValue(tagKeys[i],vShape,values,offset);
482 }
483 }
484 }
485 }
486
487
488
489
490 void
491 DataTagged::addTaggedValue(int tagKey,
492 const DataTypes::ShapeType& pointshape,
493 const ValueType& value,
494 int dataOffset)
495 {
496 if (!DataTypes::checkShape(getShape(), pointshape)) {
497 throw DataException(DataTypes::createShapeErrorMessage(
498 "Error - Cannot addTaggedValue due to shape mismatch.", pointshape,getShape()));
499 }
500 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
501 if (pos!=m_offsetLookup.end()) {
502 // tag already exists so use setTaggedValue
503 setTaggedValue(tagKey,pointshape, value, dataOffset);
504 } else {
505 // save the key and the location of its data in the lookup tab
506 m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
507 // add the data given in "value" at the end of m_data
508 // need to make a temp copy of m_data, resize m_data, then copy
509 // all the old values plus the value to be added back into m_data
510 ValueType m_data_temp(m_data);
511 int oldSize=m_data.size();
512 int newSize=m_data.size()+getNoValues();
513 m_data.resize(newSize,0.,newSize);
514 for (int i=0;i<oldSize;i++) {
515 m_data[i]=m_data_temp[i];
516 }
517 for (int i=0;i<getNoValues();i++) {
518 m_data[oldSize+i]=value[i+dataOffset];
519 }
520 }
521 }
522
523
524
525
526 // void
527 // DataTagged::addTaggedValue(int tagKey,
528 // const DataArrayView& value)
529 // {
530 // if (!getPointDataView().checkShape(value.getShape())) {
531 // throw DataException(DataTypes::createShapeErrorMessage(
532 // "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape(),getShape()));
533 // }
534 // DataMapType::iterator pos(m_offsetLookup.find(tagKey));
535 // if (pos!=m_offsetLookup.end()) {
536 // // tag already exists so use setTaggedValue
537 // setTaggedValue(tagKey,value);
538 // } else {
539 // // save the key and the location of its data in the lookup tab
540 // m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
541 // // add the data given in "value" at the end of m_data
542 // // need to make a temp copy of m_data, resize m_data, then copy
543 // // all the old values plus the value to be added back into m_data
544 // ValueType m_data_temp(m_data);
545 // int oldSize=m_data.size();
546 // int newSize=m_data.size()+value.noValues();
547 // m_data.resize(newSize,0.,newSize);
548 // for (int i=0;i<oldSize;i++) {
549 // m_data[i]=m_data_temp[i];
550 // }
551 // for (int i=0;i<value.noValues();i++) {
552 // m_data[oldSize+i]=value.getData(i);
553 // }
554 // }
555 // }
556
557
558 void
559 DataTagged::addTag(int tagKey)
560 {
561 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
562 if (pos!=m_offsetLookup.end()) {
563 // tag already exists so use setTaggedValue
564 // setTaggedValue(tagKey,value);
565 } else {
566 // save the key and the location of its data in the lookup tab
567 m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
568 // add the data given in "value" at the end of m_data
569 // need to make a temp copy of m_data, resize m_data, then copy
570 // all the old values plus the value to be added back into m_data
571 ValueType m_data_temp(m_data);
572 int oldSize=m_data.size();
573 int newSize=m_data.size()+getNoValues();
574 m_data.resize(newSize,0.,newSize);
575 for (int i=0;i<oldSize;i++) {
576 m_data[i]=m_data_temp[i];
577 }
578 for (int i=0;i<getNoValues();i++) {
579 m_data[oldSize+i]=m_data[m_defaultValueOffset+i];
580 }
581 }
582 }
583
584
585 double*
586 DataTagged::getSampleDataByTag(int tag)
587 {
588 DataMapType::iterator pos(m_offsetLookup.find(tag));
589 if (pos==m_offsetLookup.end()) {
590 // tag couldn't be found so return the default value
591 return &(m_data[0]);
592 } else {
593 // return the data-point corresponding to the given tag
594 return &(m_data[pos->second]);
595 }
596 }
597
598 string
599 DataTagged::toString() const
600 {
601 using namespace escript::DataTypes;
602 string empty="";
603 stringstream temp;
604 DataMapType::const_iterator i;
605 temp << "Tag(Default)" << endl;
606 temp << pointToString(m_data,getShape(),getDefaultOffset(),empty) << endl;
607 // create a temporary view as the offset will be changed
608 // DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());
609 for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {
610 temp << "Tag(" << i->first << ")" << endl;
611 temp << pointToString(m_data,getShape(),i->second,empty) << endl;
612 // tempView.setOffset(i->second);
613 // temp << tempView.toString() << endl;
614 }
615 return temp.str();
616 }
617
618 DataTypes::ValueType::size_type
619 DataTagged::getPointOffset(int sampleNo,
620 int dataPointNo) const
621 {
622 int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
623 DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));
624 DataTypes::ValueType::size_type offset=m_defaultValueOffset;
625 if (pos!=m_offsetLookup.end()) {
626 offset=pos->second;
627 }
628 return offset;
629 }
630
631 // DataArrayView
632 // DataTagged::getDataPointByTag(int tag) const
633 // {
634 // DataMapType::const_iterator pos(m_offsetLookup.find(tag));
635 // DataTypes::ValueType::size_type offset=m_defaultValueOffset;
636 // if (pos!=m_offsetLookup.end()) {
637 // offset=pos->second;
638 // }
639 // DataArrayView temp(getPointDataView());
640 // temp.setOffset(offset);
641 // return temp;
642 // }
643 //
644
645
646 DataTypes::ValueType::size_type
647 DataTagged::getOffsetForTag(int tag) const
648 {
649 DataMapType::const_iterator pos(m_offsetLookup.find(tag));
650 DataTypes::ValueType::size_type offset=m_defaultValueOffset;
651 if (pos!=m_offsetLookup.end()) {
652 offset=pos->second;
653 }
654 return offset;
655 }
656
657 DataTypes::ValueType::const_reference
658 DataTagged::getDataByTag(int tag, DataTypes::ValueType::size_type i) const
659 {
660 DataMapType::const_iterator pos(m_offsetLookup.find(tag));
661 DataTypes::ValueType::size_type offset=m_defaultValueOffset;
662 if (pos!=m_offsetLookup.end()) {
663 offset=pos->second;
664 }
665 return m_data[offset+i];
666 /* DataArrayView temp(getPointDataView());
667 temp.setOffset(offset);
668 return temp.getData()[offset+i];*/
669 }
670
671
672 DataTypes::ValueType::reference
673 DataTagged::getDataByTag(int tag, DataTypes::ValueType::size_type i)
674 {
675 DataMapType::const_iterator pos(m_offsetLookup.find(tag));
676 DataTypes::ValueType::size_type offset=m_defaultValueOffset;
677 if (pos!=m_offsetLookup.end()) {
678 offset=pos->second;
679 }
680 return m_data[offset+i];
681 /* DataArrayView temp(getPointDataView());
682 temp.setOffset(offset);
683 return temp.getData()[offset+i];*/
684 }
685
686
687
688
689
690
691 // DataArrayView
692 // DataTagged::getDataPoint(int sampleNo,
693 // int dataPointNo)
694 // {
695 // EsysAssert(validSampleNo(sampleNo),"(getDataPoint) Invalid sampleNo: " << sampleNo);
696 // int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
697 // return getDataPointByTag(tagKey);
698 // }
699
700
701 void
702 DataTagged::symmetric(DataAbstract* ev)
703 {
704 DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
705 if (temp_ev==0) {
706 throw DataException("Error - DataTagged::symmetric casting to DataTagged failed (probably a programming error).");
707 }
708 const DataTagged::DataMapType& thisLookup=getTagLookup();
709 DataTagged::DataMapType::const_iterator i;
710 DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
711 ValueType& evVec=temp_ev->getVector();
712 const ShapeType& evShape=temp_ev->getShape();
713 for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
714 temp_ev->addTag(i->first);
715 DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
716 // DataArrayView thisView=getDataPointByTag(i->first);
717 // DataArrayView evView=temp_ev->getDataPointByTag(i->first);
718 DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
719
720 // DataArrayView::symmetric(thisView,0,evView,0);
721 DataMaths::symmetric(m_data,getShape(),offset,evVec, evShape, evoffset);
722 }
723 // symmetric(m_data,getShape(),getDefaultOffset(),
724 DataMaths::symmetric(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset());
725 }
726
727
728 void
729 DataTagged::nonsymmetric(DataAbstract* ev)
730 {
731 DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
732 if (temp_ev==0) {
733 throw DataException("Error - DataTagged::nonsymmetric casting to DataTagged failed (probably a programming error).");
734 }
735 const DataTagged::DataMapType& thisLookup=getTagLookup();
736 DataTagged::DataMapType::const_iterator i;
737 DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
738 ValueType& evVec=temp_ev->getVector();
739 const ShapeType& evShape=temp_ev->getShape();
740 for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
741 temp_ev->addTag(i->first);
742 /* DataArrayView thisView=getDataPointByTag(i->first);
743 DataArrayView evView=temp_ev->getDataPointByTag(i->first);*/
744 DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
745 DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
746 DataMaths::nonsymmetric(m_data,getShape(),offset,evVec, evShape, evoffset);
747 }
748 DataMaths::nonsymmetric(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset());
749 }
750
751
752 void
753 DataTagged::trace(DataAbstract* ev, int axis_offset)
754 {
755 DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
756 if (temp_ev==0) {
757 throw DataException("Error - DataTagged::trace casting to DataTagged failed (probably a programming error).");
758 }
759 const DataTagged::DataMapType& thisLookup=getTagLookup();
760 DataTagged::DataMapType::const_iterator i;
761 DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
762 ValueType& evVec=temp_ev->getVector();
763 const ShapeType& evShape=temp_ev->getShape();
764 for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
765 temp_ev->addTag(i->first);
766 // DataArrayView thisView=getDataPointByTag(i->first);
767 // DataArrayView evView=temp_ev->getDataPointByTag(i->first);
768 DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
769 DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
770 DataMaths::trace(m_data,getShape(),offset,evVec, evShape, evoffset, axis_offset);
771 }
772 DataMaths::trace(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset(),axis_offset);
773 }
774
775 void
776 DataTagged::transpose(DataAbstract* ev, int axis_offset)
777 {
778 DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
779 if (temp_ev==0) {
780 throw DataException("Error - DataTagged::transpose casting to DataTagged failed (probably a programming error).");
781 }
782 const DataTagged::DataMapType& thisLookup=getTagLookup();
783 DataTagged::DataMapType::const_iterator i;
784 DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
785 ValueType& evVec=temp_ev->getVector();
786 const ShapeType& evShape=temp_ev->getShape();
787 for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
788 temp_ev->addTag(i->first);
789 // DataArrayView thisView=getDataPointByTag(i->first);
790 // DataArrayView evView=temp_ev->getDataPointByTag(i->first);
791 DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
792 DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
793 DataMaths::transpose(m_data,getShape(),offset,evVec, evShape, evoffset, axis_offset);
794 }
795 DataMaths::transpose(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset(),axis_offset);
796 }
797
798 void
799 DataTagged::swapaxes(DataAbstract* ev, int axis0, int axis1)
800 {
801 DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
802 if (temp_ev==0) {
803 throw DataException("Error - DataTagged::swapaxes casting to DataTagged failed (probably a programming error).");
804 }
805 const DataTagged::DataMapType& thisLookup=getTagLookup();
806 DataTagged::DataMapType::const_iterator i;
807 DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
808 ValueType& evVec=temp_ev->getVector();
809 const ShapeType& evShape=temp_ev->getShape();
810 for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
811 temp_ev->addTag(i->first);
812 /* DataArrayView thisView=getDataPointByTag(i->first);
813 DataArrayView evView=temp_ev->getDataPointByTag(i->first);*/
814 DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
815 DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
816 DataMaths::swapaxes(m_data,getShape(),offset,evVec, evShape, evoffset,axis0,axis1);
817 }
818 DataMaths::swapaxes(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset(),axis0,axis1);
819 }
820
821 void
822 DataTagged::eigenvalues(DataAbstract* ev)
823 {
824 DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
825 if (temp_ev==0) {
826 throw DataException("Error - DataTagged::eigenvalues casting to DataTagged failed (propably a programming error).");
827 }
828 const DataTagged::DataMapType& thisLookup=getTagLookup();
829 DataTagged::DataMapType::const_iterator i;
830 DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
831 ValueType& evVec=temp_ev->getVector();
832 const ShapeType& evShape=temp_ev->getShape();
833 for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
834 temp_ev->addTag(i->first);
835 // DataArrayView thisView=getDataPointByTag(i->first);
836 // DataArrayView evView=temp_ev->getDataPointByTag(i->first);
837 DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
838 DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
839 DataMaths::eigenvalues(m_data,getShape(),offset,evVec, evShape, evoffset);
840 }
841 DataMaths::eigenvalues(m_data,getShape(),getDefaultOffset(),evVec, evShape, temp_ev->getDefaultOffset());
842 }
843 void
844 DataTagged::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
845 {
846 DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
847 if (temp_ev==0) {
848 throw DataException("Error - DataTagged::eigenvalues_and_eigenvectors casting to DataTagged failed (propably a programming error).");
849 }
850 DataTagged* temp_V=dynamic_cast<DataTagged*>(V);
851 if (temp_V==0) {
852 throw DataException("Error - DataTagged::eigenvalues_and_eigenvectors casting to DataTagged failed (propably a programming error).");
853 }
854 const DataTagged::DataMapType& thisLookup=getTagLookup();
855 DataTagged::DataMapType::const_iterator i;
856 DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
857 ValueType& evVec=temp_ev->getVector();
858 const ShapeType& evShape=temp_ev->getShape();
859 ValueType& VVec=temp_V->getVector();
860 const ShapeType& VShape=temp_V->getShape();
861 for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
862 temp_ev->addTag(i->first);
863 temp_V->addTag(i->first);
864 /* DataArrayView thisView=getDataPointByTag(i->first);
865 DataArrayView evView=temp_ev->getDataPointByTag(i->first);
866 DataArrayView VView=temp_V->getDataPointByTag(i->first);*/
867 DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
868 DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
869 DataTypes::ValueType::size_type Voffset=temp_V->getOffsetForTag(i->first);
870 /* DataArrayView::eigenvalues_and_eigenvectors(thisView,0,evView,0,VView,0,tol);*/
871 DataMaths::eigenvalues_and_eigenvectors(m_data,getShape(),offset,evVec, evShape, evoffset,VVec,VShape,Voffset,tol);
872
873 }
874 DataMaths::eigenvalues_and_eigenvectors(m_data,getShape(),getDefaultOffset(),evVec, evShape,
875 temp_ev->getDefaultOffset(),VVec,VShape,
876 temp_V->getDefaultOffset(), tol);
877
878
879 }
880
881 void
882 DataTagged::setToZero(){
883 DataTypes::ValueType::size_type n=m_data.size();
884 for (int i=0; i<n ;++i) m_data[i]=0.;
885 }
886
887 void
888 DataTagged::dump(const std::string fileName) const
889 {
890 #ifdef PASO_MPI
891 throw DataException("Error - DataTagged:: dump is not implemented for MPI yet.");
892 #endif
893 #ifdef USE_NETCDF
894 const int ldims=DataTypes::maxRank+1;
895 const NcDim* ncdims[ldims];
896 NcVar *var, *tags_var;
897 int rank = getRank();
898 int type= getFunctionSpace().getTypeCode();
899 int ndims =0;
900 long dims[ldims];
901 const double* d_ptr=&(m_data[0]);
902 DataTypes::ShapeType shape = getShape();
903
904 // netCDF error handler
905 NcError err(NcError::verbose_nonfatal);
906 // Create the file.
907 NcFile dataFile(fileName.c_str(), NcFile::Replace);
908 // check if writing was successful
909 if (!dataFile.is_valid())
910 throw DataException("Error - DataTagged:: opening of netCDF file for output failed.");
911 if (!dataFile.add_att("type_id",1) )
912 throw DataException("Error - DataTagged:: appending data type to netCDF file failed.");
913 if (!dataFile.add_att("rank",rank) )
914 throw DataException("Error - DataTagged:: appending rank attribute to netCDF file failed.");
915 if (!dataFile.add_att("function_space_type",type))
916 throw DataException("Error - DataTagged:: appending function space attribute to netCDF file failed.");
917 ndims=rank+1;
918 if ( rank >0 ) {
919 dims[0]=shape[0];
920 if (! (ncdims[0] = dataFile.add_dim("d0",shape[0])) )
921 throw DataException("Error - DataTagged:: appending ncdimension 0 to netCDF file failed.");
922 }
923 if ( rank >1 ) {
924 dims[1]=shape[1];
925 if (! (ncdims[1] = dataFile.add_dim("d1",shape[1])) )
926 throw DataException("Error - DataTagged:: appending ncdimension 1 to netCDF file failed.");
927 }
928 if ( rank >2 ) {
929 dims[2]=shape[2];
930 if (! (ncdims[2] = dataFile.add_dim("d2", shape[2])) )
931 throw DataException("Error - DataTagged:: appending ncdimension 2 to netCDF file failed.");
932 }
933 if ( rank >3 ) {
934 dims[3]=shape[3];
935 if (! (ncdims[3] = dataFile.add_dim("d3", shape[3])) )
936 throw DataException("Error - DataTagged:: appending ncdimension 3 to netCDF file failed.");
937 }
938 const DataTagged::DataMapType& thisLookup=getTagLookup();
939 DataTagged::DataMapType::const_iterator i;
940 DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
941 int ntags=1;
942 for (i=thisLookup.begin();i!=thisLookupEnd;i++) ntags++;
943 int* tags =(int*) esysUtils::malloc(ntags*sizeof(int));
944 int c=1;
945 tags[0]=-1;
946 for (i=thisLookup.begin();i!=thisLookupEnd;i++) tags[c++]=i->first;
947 dims[rank]=ntags;
948 if (! (ncdims[rank] = dataFile.add_dim("num_tags", dims[rank])) )
949 {
950 esysUtils::free(tags);
951 throw DataException("Error - DataTagged:: appending num_tags to netCDF file failed.");
952 }
953 if (! ( tags_var = dataFile.add_var("tags", ncInt, ncdims[rank])) )
954 {
955 esysUtils::free(tags);
956 throw DataException("Error - DataTagged:: appending tags to netCDF file failed.");
957 }
958 if (! (tags_var->put(tags,dims[rank])) )
959 {
960 esysUtils::free(tags);
961 throw DataException("Error - DataTagged:: copy tags to netCDF buffer failed.");
962 }
963 if (! ( var = dataFile.add_var("data", ncDouble, ndims, ncdims)) )
964 {
965 esysUtils::free(tags);
966 throw DataException("Error - DataTagged:: appending variable to netCDF file failed.");
967 }
968 if (! (var->put(d_ptr,dims)) )
969 {
970 esysUtils::free(tags);
971 throw DataException("Error - DataTagged:: copy data to netCDF buffer failed.");
972 }
973 #else
974 throw DataException("Error - DataTagged:: dump is not configured with netCDF. Please contact your installation manager.");
975 #endif
976 }
977
978 DataTypes::ValueType&
979 DataTagged::getVector()
980 {
981 return m_data;
982 }
983
984 const DataTypes::ValueType&
985 DataTagged::getVector() const
986 {
987 return m_data;
988 }
989
990 } // end of namespace

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26