/[escript]/branches/arrayview_from_1695_trunk/escript/test/DataTaggedTestCase.cpp
ViewVC logotype

Annotation of /branches/arrayview_from_1695_trunk/escript/test/DataTaggedTestCase.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1786 - (hide annotations)
Fri Sep 12 03:16:28 2008 UTC (12 years, 7 months ago) by jfenwick
File size: 144283 byte(s)
Fixed some memory leaks in unit_tests.
Fixed an empty array which was giving iso-c++ errors.
Fixed typo which meant scons build_tests didn't build unit tests.


1 jgs 548
2 ksteube 1312 /* $Id$ */
3 jgs 497
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 robwdcock 638 #include "esysUtils/EsysException.h"
17 jgs 497
18 matt 1325 #include "escript/DataVector.h"
19 robwdcock 670 #include "escript/DataTagged.h"
20     #include "escript/DataConstant.h"
21 jgs 497
22     #include "DataTaggedTestCase.h"
23    
24 robwdcock 670 #include "escript/BinaryOp.h"
25     #include "escript/UnaryOp.h"
26     #include "escript/FunctionSpaceFactory.h"
27     #include "escript/DataFactory.h"
28 jgs 82
29     #include <iostream>
30     #include <functional>
31     #include <algorithm>
32    
33     using namespace CppUnitTest;
34     using namespace escript;
35     using namespace esysUtils;
36     using namespace std;
37 jfenwick 1747 using namespace escript::DataTypes;
38 jgs 82
39     void DataTaggedTestCase::setUp() {
40     //
41     // This is called before each test is run
42 matt 1325
43 jgs 82 }
44    
45     void DataTaggedTestCase::tearDown() {
46     //
47     // This is called after each test has been run
48 matt 1325
49 jgs 82 }
50    
51    
52 jfenwick 1747 namespace {
53    
54     ValueType::reference
55     getRef(DataTagged& data,int offset, int i, int j, int k)
56     {
57     return data.getVector()[offset+getRelIndex(data.getShape(),i,j,k)];
58     }
59    
60     ValueType::reference
61 jfenwick 1751 getRef(DataTagged& data,int offset, int i, int j, int k, int l)
62     {
63     return data.getVector()[offset+getRelIndex(data.getShape(),i,j,k,l)];
64     }
65    
66     ValueType::reference
67 jfenwick 1747 getRef(DataTagged& data,int offset, int i, int j)
68     {
69     return data.getVector()[offset+getRelIndex(data.getShape(),i,j)];
70     }
71    
72     ValueType::const_reference
73     getRef(const DataTagged& data,int offset, int i)
74     {
75     return data.getVector()[offset+getRelIndex(data.getShape(),i)];
76     }
77    
78     }
79    
80 jgs 82 void DataTaggedTestCase::testOperations() {
81    
82     cout << endl;
83    
84     {
85 jgs 506 cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
86    
87 jgs 504 DataTagged myData;
88 jgs 82 DataTagged right;
89 jgs 121
90 jgs 504 binaryOp(myData,right,plus<double>());
91    
92     //cout << myData.toString() << endl;
93    
94     assert(myData.getNumSamples()==1);
95     assert(myData.getNumDPPSample()==1);
96    
97     assert(myData.validSamplePointNo(0));
98     assert(myData.validSampleNo(0));
99     assert(!myData.validSamplePointNo(1));
100     assert(!myData.validSampleNo(1));
101    
102     // data-point 0 has tag number 1 by default
103     assert(myData.getTagNumber(0)==1);
104    
105     assert(!myData.isCurrentTag(1));
106    
107     assert(myData.getTagLookup().size()==0);
108    
109     assert(myData.getLength()==1);
110    
111     assert(myData.getPointOffset(0,0)==0);
112    
113 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
114     // assert(!myDataView.isEmpty());
115     assert(myData.getPointOffset(0,0)==0);
116     assert(myData.getRank()==0);
117     assert(myData.getNoValues()==1);
118     assert(myData.getShape().size()==0);
119     assert(myData.getDataAtOffset(0)==0.0);
120 jgs 504
121     // Test non-existent tag returns the default value.
122 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
123     // assert(!myDataView.isEmpty());
124     assert(myData.getOffsetForTag(1)==0);
125     assert(myData.getRank()==0);
126     assert(myData.getNoValues()==1);
127     assert(myData.getShape().size()==0);
128     assert(myData.getDataAtOffset(0)==0.0);
129 jgs 504
130 jfenwick 1747 // myDataView = myData.getDefaultValue();
131     // assert(!myDataView.isEmpty());
132     assert(myData.getDefaultOffset()==0);
133     // assert(myDataView.getRank()==0); // there is no point in testing this again
134     // assert(myDataView.noValues()==1); // since we are not building DataArrayViews
135     // assert(myDataView.getShape().size()==0);
136     // assert(myDataView()==0.0);
137 jgs 506
138     // use a non-existent tag so we get a pointer to
139     // the first element of the data array
140     double* sampleData=myData.getSampleDataByTag(9);
141     for (int i=0; i<myData.getLength(); i++) {
142     assert(sampleData[i]==i);
143     }
144    
145 jgs 504 }
146    
147     {
148 jgs 506 cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
149    
150 jfenwick 1697 DataTypes::ShapeType viewShape;
151 jgs 506 viewShape.push_back(3);
152    
153 jfenwick 1747 // DataTagged::TagListType keys;
154     //
155     // DataTagged::ValueListType values;
156 jgs 506
157 jfenwick 1697 DataTypes::ValueType viewData(3);
158 jgs 506 for (int i=0;i<viewShape[0];i++) {
159     viewData[i]=i;
160     }
161    
162 jfenwick 1747 // DataTagged myData(keys,values,myView,FunctionSpace());
163     // DataTagged right(keys,values,myView,FunctionSpace());
164     DataTagged myData(FunctionSpace(),viewShape,viewData);
165     DataTagged right(FunctionSpace(),viewShape,viewData);
166 jgs 506
167 jfenwick 1747
168 jgs 506 binaryOp(myData,right,plus<double>());
169    
170     //cout << myData.toString() << endl;
171    
172     assert(myData.getNumSamples()==1);
173     assert(myData.getNumDPPSample()==1);
174    
175     assert(myData.validSamplePointNo(0));
176     assert(myData.validSampleNo(0));
177     assert(!myData.validSamplePointNo(1));
178     assert(!myData.validSampleNo(1));
179    
180     // data-point 0 has tag number 1 by default
181     assert(myData.getTagNumber(0)==1);
182    
183     assert(!myData.isCurrentTag(1));
184    
185     assert(myData.getTagLookup().size()==0);
186    
187     assert(myData.getLength()==3);
188    
189     assert(myData.getPointOffset(0,0)==0);
190    
191 jfenwick 1747 assert(myData.getRank()==1);
192     assert(myData.getNoValues()==3);
193     assert(myData.getShape().size()==1);
194 jgs 506
195 jfenwick 1747
196     int offset=myData.getDefaultOffset();
197     // DataArrayView myDataView = myData.getDefaultValue();
198     assert(offset==0);
199     assert(getRef(myData,offset,0)==0);
200     assert(getRef(myData,offset,1)==2);
201     assert(getRef(myData,offset,2)==4);
202    
203 jgs 506 // use a non-existent tag so we get a pointer to
204     // the first element of the data array
205     double* sampleData=myData.getSampleDataByTag(9);
206     for (int i=0; i<myData.getLength(); i++) {
207     assert(sampleData[i]==i*2);
208     }
209    
210     }
211    
212     {
213     cout << "\tTest binaryOp addition of two DataTagged objects with one identical tag each." << endl;
214    
215 jgs 504 DataTagged myData;
216     DataTagged right;
217    
218 matt 1325 DataVector vOneData(1, 1.0 ,1);
219     // create a view with an empty shape, a scalar.
220 jfenwick 1747 // DataArrayView vOneView(vOneData,DataTypes::ShapeType());
221 jgs 121
222 jfenwick 1747 myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
223     right.addTaggedValue(1,DataTypes::scalarShape,vOneData);
224 matt 1325
225 jgs 504 binaryOp(myData,right,plus<double>());
226    
227 jgs 506 assert(myData.getNumSamples()==1);
228     assert(myData.getNumDPPSample()==1);
229    
230     assert(myData.validSamplePointNo(0));
231     assert(myData.validSampleNo(0));
232     assert(!myData.validSamplePointNo(1));
233     assert(!myData.validSampleNo(1));
234    
235     // data-point 0 has tag number 1 by default
236     assert(myData.getTagNumber(0)==1);
237    
238     assert(myData.isCurrentTag(1));
239    
240     assert(myData.getTagLookup().size()==1);
241    
242     assert(myData.getLength()==2);
243    
244     assert(myData.getPointOffset(0,0)==1);
245    
246 jfenwick 1747
247     assert(myData.getRank()==0);
248     assert(myData.getNoValues()==1);
249     assert(myData.getShape().size()==0);
250    
251    
252    
253 jgs 504 // check result value for tag "1"
254 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(1);
255     int offset=myData.getOffsetForTag(1);
256     assert(offset==1);
257     assert(myData.getVector()[offset]==2.0);
258 jgs 504
259     // check result for default value
260 jfenwick 1747 // myDataView = myData.getDefaultValue();
261     offset=myData.getDefaultOffset();
262     assert(offset==0);
263     assert(myData.getVector()[offset]==0.0);
264 jgs 506
265     // use a non-existent tag so we get a pointer to
266     // the first element of the data array
267     double* sampleData=myData.getSampleDataByTag(9);
268     for (int i=0; i<myData.getLength(); i++) {
269     assert(sampleData[i]==i*2);
270     }
271    
272 jgs 82 }
273 jgs 501
274 jgs 82 {
275 jgs 506 cout << "\tTest binaryOp addition of two DataTagged objects with one different tag each." << endl;
276    
277 jgs 504 DataTagged myData;
278     DataTagged right;
279    
280 jgs 548 // it's important that default values are different, as we need to be able to
281     // verify that the tag values in each object are being added to the correct
282     // default values - since the tag lists don't match, the default values will
283     // be used for missing tags in each object
284 jfenwick 1747 // myData.getDefaultValue()()=1.0;
285     // right.getDefaultValue()()=2.0;
286     myData.getVector()[myData.getDefaultOffset()]=1.0;
287     right.getVector()[right.getDefaultOffset()]=2.0;
288 jgs 548
289 matt 1325 DataVector vOneData(1, 3.0 ,1);
290     // create a view with an empty shape, a scalar.
291 jfenwick 1747 // DataArrayView vOneView(vOneData,DataTypes::ShapeType());
292 jgs 504
293 matt 1325 DataVector vTwoData(1, 4.0 ,1);
294     // create a view with an empty shape, a scalar.
295 jfenwick 1747 // DataArrayView vTwoView(vTwoData,DataTypes::ShapeType());
296 matt 1325
297 jfenwick 1747 myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
298     right.addTaggedValue(2,DataTypes::scalarShape,vTwoData);
299 matt 1325
300 jgs 548 //cout << myData.toString() << endl;
301     //cout << right.toString() << endl;
302    
303 jgs 504 binaryOp(myData,right,plus<double>());
304    
305 jgs 548 //cout << myData.toString() << endl;
306    
307 jgs 506 assert(myData.getNumSamples()==1);
308     assert(myData.getNumDPPSample()==1);
309    
310     assert(myData.validSamplePointNo(0));
311     assert(myData.validSampleNo(0));
312     assert(!myData.validSamplePointNo(1));
313     assert(!myData.validSampleNo(1));
314    
315     // data-point 0 has tag number 1 by default
316     assert(myData.getTagNumber(0)==1);
317    
318     assert(myData.isCurrentTag(1));
319     assert(myData.isCurrentTag(2));
320    
321     assert(myData.getTagLookup().size()==2);
322    
323     assert(myData.getLength()==3);
324    
325     assert(myData.getPointOffset(0,0)==1);
326    
327 jfenwick 1747 assert(myData.getRank()==0);
328     assert(myData.getNoValues()==1);
329     assert(myData.getShape().size()==0);
330    
331    
332 jgs 504 // check result value for tag "1"
333 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(1);
334     int offset=myData.getOffsetForTag(1);
335     assert(offset==1);
336     assert(myData.getDataAtOffset(offset)==5.0);
337 jgs 504
338     // check result value for tag "2"
339 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
340     offset=myData.getOffsetForTag(2);
341     assert(offset==2);
342     assert(myData.getDataAtOffset(offset)==5.0);
343 jgs 504
344     // check result for default value
345 jfenwick 1747 // myDataView = myData.getDefaultValue();
346     offset=myData.getDefaultOffset();
347     assert(offset==0);
348     assert(myData.getDataAtOffset(offset)==3.0);
349 jgs 506
350     // use a non-existent tag so we get a pointer to
351     // the first element of the data array
352     double* sampleData=myData.getSampleDataByTag(9);
353 jgs 548 assert(sampleData[0]==3);
354     assert(sampleData[1]==5);
355     assert(sampleData[2]==5);
356 jgs 506
357 jgs 82 }
358 jgs 501
359 jgs 82 {
360 jgs 506 cout << "\tTest binaryOp addition of two DataTagged objects with overlapping tag sets." << endl;
361    
362 jgs 504 DataTagged myData;
363     DataTagged right;
364    
365 jgs 548 // it's important that default values are different, as we need to be able to
366     // verify that the tag values in each object are being added to the correct
367     // default values - since the tag lists don't match, the default values will
368     // be used for missing tags in each object
369 jfenwick 1747 /* myData.getDefaultValue()()=2.0;
370     right.getDefaultValue()()=3.0;*/
371     myData.getVector()[myData.getDefaultOffset()]=2.0;
372     right.getVector()[right.getDefaultOffset()]=3.0;
373 jgs 548
374 jfenwick 1747
375 matt 1325 DataVector vOneData(1, 1.0 ,1);
376     // create a view with an empty shape, a scalar.
377 jfenwick 1747 // DataArrayView vOneView(vOneData,DataTypes::ShapeType());
378 jgs 504
379 jfenwick 1747 myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
380     myData.addTaggedValue(2,DataTypes::scalarShape,vOneData);
381     right.addTaggedValue(2,DataTypes::scalarShape,vOneData);
382     right.addTaggedValue(3,DataTypes::scalarShape,vOneData);
383 matt 1325
384 jgs 548 //cout << myData.toString() << endl;
385     //cout << right.toString() << endl;
386    
387 jgs 504 binaryOp(myData,right,plus<double>());
388    
389 jgs 548 //cout << myData.toString() << endl;
390    
391 jgs 506 assert(myData.getNumSamples()==1);
392     assert(myData.getNumDPPSample()==1);
393    
394     assert(myData.validSamplePointNo(0));
395     assert(myData.validSampleNo(0));
396     assert(!myData.validSamplePointNo(1));
397     assert(!myData.validSampleNo(1));
398    
399     // data-point 0 has tag number 1 by default
400     assert(myData.getTagNumber(0)==1);
401    
402     assert(myData.isCurrentTag(1));
403     assert(myData.isCurrentTag(2));
404     assert(myData.isCurrentTag(3));
405    
406     assert(myData.getTagLookup().size()==3);
407    
408     assert(myData.getLength()==4);
409    
410     assert(myData.getPointOffset(0,0)==1);
411    
412 jfenwick 1747 assert(myData.getRank()==0);
413     assert(myData.getNoValues()==1);
414     assert(myData.getShape().size()==0);
415    
416    
417 jgs 504 // check result value for tag "1"
418 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(1);
419     int offset=myData.getOffsetForTag(1);
420     assert(offset==1);
421     assert(myData.getDataAtOffset(offset)==4.0);
422 jgs 504
423     // check result value for tag "2"
424 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
425     offset=myData.getOffsetForTag(2);
426     assert(offset==2);
427     assert(myData.getDataAtOffset(offset)==2.0);
428 jgs 504
429     // check result value for tag "3"
430 jfenwick 1747 // myDataView = myData.getDataPointByTag(3);
431     offset=myData.getOffsetForTag(3);
432     assert(offset==3);
433     assert(myData.getDataAtOffset(offset)==3.0);
434 jgs 504
435     // check result for default value
436 jfenwick 1747 // myDataView = myData.getDefaultValue();
437     offset=myData.getDefaultOffset();
438     assert(offset==0);
439     assert(myData.getDataAtOffset(offset)==5.0);
440 jgs 506
441     // use a non-existent tag so we get a pointer to
442     // the first element of the data array
443     double* sampleData=myData.getSampleDataByTag(9);
444 jgs 548 assert(sampleData[0]==5);
445     assert(sampleData[1]==4);
446     assert(sampleData[2]==2);
447     assert(sampleData[3]==3);
448 jgs 506
449 jgs 82 }
450 jgs 501
451 jgs 82 {
452 jgs 506 cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
453 jgs 504
454 jfenwick 1697 DataTypes::ShapeType viewShape;
455 jgs 506 viewShape.push_back(3);
456    
457 jfenwick 1747 // DataTagged::TagListType keys;
458 jgs 506
459 jfenwick 1747 // DataTagged::ValueListType values;
460 jgs 506
461 jfenwick 1697 DataTypes::ValueType viewData(3);
462 jgs 506 for (int i=0;i<viewShape[0];i++) {
463     viewData[i]=i;
464     }
465 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
466 jgs 506
467 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,viewData);
468     DataTagged right(FunctionSpace(),viewShape,viewData);
469 jgs 506
470     binaryOp(myData,right,multiplies<double>());
471    
472     //cout << myData.toString() << endl;
473    
474     assert(myData.getNumSamples()==1);
475     assert(myData.getNumDPPSample()==1);
476    
477     assert(myData.validSamplePointNo(0));
478     assert(myData.validSampleNo(0));
479     assert(!myData.validSamplePointNo(1));
480     assert(!myData.validSampleNo(1));
481    
482     // data-point 0 has tag number 1 by default
483     assert(myData.getTagNumber(0)==1);
484    
485     assert(!myData.isCurrentTag(1));
486    
487     assert(myData.getTagLookup().size()==0);
488    
489     assert(myData.getLength()==3);
490    
491     assert(myData.getPointOffset(0,0)==0);
492    
493 jfenwick 1747 assert(myData.getRank()==1);
494     assert(myData.getNoValues()==3);
495     assert(myData.getShape().size()==1);
496 jgs 506
497 jfenwick 1747
498     // DataArrayView myDataView = myData.getDefaultValue();
499     int offset=myData.getDefaultOffset();
500     assert(offset==0);
501     assert(getRef(myData,offset,0)==0);
502     assert(getRef(myData,offset,1)==1);
503     assert(getRef(myData,offset,2)==4);
504    
505 jgs 506 // use a non-existent tag so we get a pointer to
506     // the first element of the data array
507     double* sampleData=myData.getSampleDataByTag(9);
508     for (int i=0; i<myData.getLength(); i++) {
509     assert(sampleData[i]==i*i);
510     }
511    
512 jgs 82 }
513 jgs 501
514 jgs 504 {
515 jgs 557
516     cout << "\tTest binaryOp multiplication of DataTagged object with a scalar." << endl;
517    
518     DataTagged myData;
519    
520 matt 1325 DataVector vOneData(1, 1.0 ,1);
521     // create a view with an empty shape, a scalar.
522 jfenwick 1747 // DataArrayView vOneView(vOneData,DataTypes::ShapeType());
523 jgs 557
524 matt 1325 DataVector vTwoData(1, 2.0 ,1);
525     // create a view with an empty shape, a scalar.
526 jfenwick 1747 // DataArrayView vTwoView(vTwoData,DataTypes::ShapeType());
527 jgs 557
528 jfenwick 1747 myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
529     myData.addTaggedValue(2,DataTypes::scalarShape,vTwoData);
530 matt 1325
531     DataVector vThreeData(1, 3.0 ,1);
532     // create a view with an empty shape, a scalar.
533 jfenwick 1747 // DataArrayView vThreeView(vThreeData,DataTypes::ShapeType());
534 matt 1325
535 jfenwick 1747 // DataArrayView right=vThreeView;
536 matt 1325
537 jgs 557 //cout << myData.toString() << endl;
538     //cout << right.toString() << endl;
539    
540 jfenwick 1747 binaryOp(myData,vThreeData, DataTypes::scalarShape,multiplies<double>());
541 jgs 557
542     //cout << myData.toString() << endl;
543    
544     assert(myData.getNumSamples()==1);
545     assert(myData.getNumDPPSample()==1);
546    
547     assert(myData.validSamplePointNo(0));
548     assert(myData.validSampleNo(0));
549     assert(!myData.validSamplePointNo(1));
550     assert(!myData.validSampleNo(1));
551    
552     // data-point 0 has tag number 1 by default
553     assert(myData.getTagNumber(0)==1);
554    
555     assert(myData.isCurrentTag(1));
556     assert(myData.isCurrentTag(2));
557    
558     assert(myData.getTagLookup().size()==2);
559    
560     assert(myData.getLength()==3);
561    
562     assert(myData.getPointOffset(0,0)==1);
563    
564 jfenwick 1747 assert(myData.getRank()==0);
565     assert(myData.getNoValues()==1);
566     assert(myData.getShape().size()==0);
567    
568 jgs 557 // check result value for tag "1"
569 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(1);
570     int offset=myData.getOffsetForTag(1);
571     assert(offset==1);
572     assert(myData.getDataAtOffset(offset)==3.0);
573 jgs 557
574     // check result value for tag "2"
575 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
576     offset=myData.getOffsetForTag(2);
577     assert(offset==2);
578     assert(myData.getDataAtOffset(offset)==6.0);
579 jgs 557
580     // check result for default value
581 jfenwick 1747 // myDataView = myData.getDefaultValue();
582     offset=myData.getDefaultOffset();
583     assert(offset==0);
584     assert(myData.getDataAtOffset(offset)==0.0);
585 jgs 557
586     // use a non-existent tag so we get a pointer to
587     // the first element of the data array
588     double* sampleData=myData.getSampleDataByTag(9);
589     assert(sampleData[0]==0);
590     assert(sampleData[1]==3);
591     assert(sampleData[2]==6);
592    
593     }
594    
595     {
596 jgs 506 cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
597    
598     DataTagged myData;
599     DataTagged right;
600    
601 jgs 548 // it's important that default values are different, as we need to be able to
602     // verify that the tag values in each object are being added to the correct
603     // default values - since the tag lists don't match, the default values will
604     // be used for missing tags in each object
605 jfenwick 1747 // myData.getDefaultValue()()=2.0;
606     // right.getDefaultValue()()=3.0;
607     myData.getVector()[myData.getDefaultOffset()]=2.0;
608     right.getVector()[right.getDefaultOffset()]=3.0;
609 jgs 548
610 matt 1325 DataVector vOneData(1, 1.0 ,1);
611     // create a view with an empty shape, a scalar.
612 jfenwick 1747 // DataArrayView vOneView(vOneData,DataTypes::ShapeType());
613 jgs 506
614 matt 1325 DataVector vTwoData(1, 2.0 ,1);
615     // create a view with an empty shape, a scalar.
616 jfenwick 1747 // DataArrayView vTwoView(vTwoData,DataTypes::ShapeType());
617 matt 1325
618 jfenwick 1747 myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
619     myData.addTaggedValue(2,DataTypes::scalarShape,vOneData);
620     right.addTaggedValue(2,DataTypes::scalarShape,vTwoData);
621     right.addTaggedValue(3,DataTypes::scalarShape,vTwoData);
622 matt 1325
623 jgs 548 //cout << myData.toString() << endl;
624     //cout << right.toString() << endl;
625    
626 jgs 506 binaryOp(myData,right,multiplies<double>());
627    
628 jgs 548 //cout << myData.toString() << endl;
629    
630 jgs 506 assert(myData.getNumSamples()==1);
631     assert(myData.getNumDPPSample()==1);
632    
633     assert(myData.validSamplePointNo(0));
634     assert(myData.validSampleNo(0));
635     assert(!myData.validSamplePointNo(1));
636     assert(!myData.validSampleNo(1));
637    
638     // data-point 0 has tag number 1 by default
639     assert(myData.getTagNumber(0)==1);
640    
641     assert(myData.isCurrentTag(1));
642     assert(myData.isCurrentTag(2));
643     assert(myData.isCurrentTag(3));
644    
645     assert(myData.getTagLookup().size()==3);
646    
647     assert(myData.getLength()==4);
648    
649     assert(myData.getPointOffset(0,0)==1);
650    
651 jfenwick 1747 assert(myData.getRank()==0);
652     assert(myData.getNoValues()==1);
653     assert(myData.getShape().size()==0);
654    
655    
656 jgs 506 // check result value for tag "1"
657 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(1);
658     int offset=myData.getOffsetForTag(1);
659     assert(offset==1);
660     assert(myData.getDataAtOffset(offset)==3.0);
661 jgs 506
662     // check result value for tag "2"
663 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
664     offset=myData.getOffsetForTag(2);
665     assert(offset==2);
666     assert(myData.getDataAtOffset(offset)==2.0);
667 jgs 506
668     // check result value for tag "3"
669 jfenwick 1747 // myDataView = myData.getDataPointByTag(3);
670     offset=myData.getOffsetForTag(3);
671     assert(offset==3);
672     assert(myData.getDataAtOffset(offset)==4.0);
673 jgs 506
674     // check result for default value
675 jfenwick 1747 // myDataView = myData.getDefaultValue();
676     offset=myData.getDefaultOffset();
677     assert(offset==0);
678     assert(myData.getDataAtOffset(offset)==6.0);
679 jgs 506
680     // use a non-existent tag so we get a pointer to
681     // the first element of the data array
682     double* sampleData=myData.getSampleDataByTag(9);
683 jgs 548 assert(sampleData[0]==6);
684     assert(sampleData[1]==3);
685     assert(sampleData[2]==2);
686     assert(sampleData[3]==4);
687 jgs 506
688 jgs 504 }
689    
690     {
691 jgs 506 cout << "\tTest unaryOp negate on default DataTagged object." << endl;
692    
693     DataTagged myData;
694    
695     unaryOp(myData,negate<double>());
696    
697     //cout << myData.toString() << endl;
698    
699     assert(myData.getNumSamples()==1);
700     assert(myData.getNumDPPSample()==1);
701    
702     assert(myData.validSamplePointNo(0));
703     assert(myData.validSampleNo(0));
704     assert(!myData.validSamplePointNo(1));
705     assert(!myData.validSampleNo(1));
706    
707     // data-point 0 has tag number 1 by default
708     assert(myData.getTagNumber(0)==1);
709    
710     assert(!myData.isCurrentTag(1));
711    
712     assert(myData.getTagLookup().size()==0);
713    
714     assert(myData.getLength()==1);
715    
716     assert(myData.getPointOffset(0,0)==0);
717    
718 jfenwick 1747 assert(myData.getRank()==0);
719     assert(myData.getNoValues()==1);
720     assert(myData.getShape().size()==0);
721 jgs 506
722 jfenwick 1747
723     // DataArrayView myDataView = myData.getDataPoint(0,0);
724     int offset=myData.getPointOffset(0,0);
725     assert(offset==0);
726     assert(myData.getDataAtOffset(offset)==0.0);
727    
728 jgs 506 // Test non-existent tag returns the default value.
729 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
730     offset=myData.getOffsetForTag(1);
731     assert(offset==0);
732     assert(myData.getDataAtOffset(offset)==0.0);
733 jgs 506
734 jfenwick 1747 // myDataView = myData.getDefaultValue();
735     offset=myData.getDefaultOffset();
736     assert(offset==0);
737     assert(myData.getDataAtOffset(offset)==0.0);
738 jgs 506
739     // use a non-existent tag so we get a pointer to
740     // the first element of the data array
741     double* sampleData=myData.getSampleDataByTag(9);
742     for (int i=0; i<myData.getLength(); i++) {
743     assert(sampleData[i]==i);
744     }
745    
746 jgs 504 }
747    
748     {
749 jgs 506 cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
750    
751 jfenwick 1697 DataTypes::ShapeType viewShape;
752 jgs 506 viewShape.push_back(3);
753    
754 jfenwick 1747 // DataTagged::TagListType keys;
755 jgs 506
756 jfenwick 1747 // DataTagged::ValueListType values;
757 jgs 506
758 jfenwick 1697 DataTypes::ValueType viewData(3);
759 jgs 506 for (int i=0;i<viewShape[0];i++) {
760     viewData[i]=i;
761     }
762 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
763 jgs 506
764 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,viewData);
765 jgs 506
766     unaryOp(myData,negate<double>());
767    
768     //cout << myData.toString() << endl;
769    
770     assert(myData.getNumSamples()==1);
771     assert(myData.getNumDPPSample()==1);
772    
773     assert(myData.validSamplePointNo(0));
774     assert(myData.validSampleNo(0));
775     assert(!myData.validSamplePointNo(1));
776     assert(!myData.validSampleNo(1));
777    
778     // data-point 0 has tag number 1 by default
779     assert(myData.getTagNumber(0)==1);
780    
781     assert(!myData.isCurrentTag(1));
782    
783     assert(myData.getTagLookup().size()==0);
784    
785     assert(myData.getLength()==3);
786    
787     assert(myData.getPointOffset(0,0)==0);
788    
789 jfenwick 1747 assert(myData.getRank()==1);
790     assert(myData.getNoValues()==3);
791     assert(myData.getShape().size()==1);
792 jgs 506
793 jfenwick 1747
794     int offset=myData.getDefaultOffset();
795     // DataArrayView myDataView = myData.getDefaultValue();
796     assert(offset==0);
797     assert(getRef(myData,offset,0)==0);
798     assert(getRef(myData,offset,1)==-1);
799     assert(getRef(myData,offset,2)==-2);
800    
801 jgs 506 // use a non-existent tag so we get a pointer to
802     // the first element of the data array
803     double* sampleData=myData.getSampleDataByTag(9);
804     for (int i=0; i<myData.getLength(); i++) {
805     assert(sampleData[i]==0-i);
806     }
807    
808 jgs 504 }
809    
810 jgs 506 {
811 matt 1325 cout << "\tTest unnaryOp negate on DataTagged object with two tags." << endl;
812 jgs 506
813     DataTagged myData;
814    
815 matt 1325 DataVector vOneData(1, 1.0 ,1);
816     // create a view with an empty shape, a scalar.
817 jfenwick 1747 // DataArrayView vOneView(vOneData,DataTypes::ShapeType());
818 jgs 506
819 matt 1325 DataVector vTwoData(1, 2.0 ,1);
820     // create a view with an empty shape, a scalar.
821 jfenwick 1747 // DataArrayView vTwoView(vTwoData,DataTypes::ShapeType());
822 matt 1325
823 jfenwick 1747 myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
824     myData.addTaggedValue(2,DataTypes::scalarShape,vTwoData);
825 matt 1325
826 jgs 506 unaryOp(myData,negate<double>());
827    
828     assert(myData.getNumSamples()==1);
829     assert(myData.getNumDPPSample()==1);
830    
831     assert(myData.validSamplePointNo(0));
832     assert(myData.validSampleNo(0));
833     assert(!myData.validSamplePointNo(1));
834     assert(!myData.validSampleNo(1));
835    
836     // data-point 0 has tag number 1 by default
837     assert(myData.getTagNumber(0)==1);
838    
839     assert(myData.isCurrentTag(1));
840     assert(myData.isCurrentTag(2));
841    
842     assert(myData.getTagLookup().size()==2);
843    
844     assert(myData.getLength()==3);
845    
846     assert(myData.getPointOffset(0,0)==1);
847    
848 jfenwick 1747 assert(myData.getRank()==0);
849     assert(myData.getNoValues()==1);
850     assert(myData.getShape().size()==0);
851    
852    
853 jgs 506 // check result value for tag "1"
854 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(1);
855     int offset=myData.getOffsetForTag(1);
856     assert(offset==1);
857     assert(myData.getDataAtOffset(offset)==-1.0);
858 jgs 506
859     // check result value for tag "2"
860 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
861     offset=myData.getOffsetForTag(2);
862     assert(offset==2);
863     assert(myData.getDataAtOffset(offset)==-2.0);
864 jgs 506
865     // check result for default value
866 jfenwick 1747 // myDataView = myData.getDefaultValue();
867     offset=myData.getDefaultOffset();
868     assert(offset==0);
869     assert(myData.getDataAtOffset(offset)==0.0);
870 jgs 506
871     // use a non-existent tag so we get a pointer to
872     // the first element of the data array
873     double* sampleData=myData.getSampleDataByTag(9);
874     for (int i=0; i<myData.getLength(); i++) {
875     assert(sampleData[i]==0-i);
876     }
877    
878     }
879    
880 jgs 82 }
881    
882 jgs 501 void DataTaggedTestCase::testAddTaggedValues() {
883    
884     cout << endl;
885    
886     {
887    
888     cout << "\tTest adding one key with empty value list to default DataTagged." << endl;
889     DataTagged myData;
890    
891     DataTagged::TagListType keys;
892     keys.push_back(1);
893    
894 jfenwick 1747 DataTagged::ValueBatchType values;
895 jgs 501
896 jfenwick 1747 myData.addTaggedValues(keys,values,DataTypes::scalarShape);
897 jgs 501
898     assert(myData.isCurrentTag(1));
899    
900     assert(myData.getTagLookup().size()==1);
901    
902     assert(myData.getLength()==2);
903    
904     // data-point 0 has tag number 1 by default
905     assert(myData.getTagNumber(0)==1);
906    
907     assert(myData.getPointOffset(0,0)==1);
908    
909 jfenwick 1747 assert(myData.getRank()==0);
910     assert(myData.getNoValues()==1);
911     assert(myData.getShape().size()==0);
912 jgs 501
913    
914 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
915     int offset=myData.getPointOffset(0,0);
916     assert(offset==1);
917     assert(myData.getDataAtOffset(offset)==0.0);
918 jgs 501
919 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
920     offset=myData.getOffsetForTag(1);
921     assert(offset==1);
922     assert(myData.getDataAtOffset(offset)==0.0);
923    
924     // myDataView = myData.getDefaultValue();
925     offset=myData.getDefaultOffset();
926     assert(offset==0);
927     assert(myData.getDataAtOffset(offset)==0.0);
928    
929 jgs 506 // use a non-existent tag so we get a pointer to
930     // the first element of the data array
931     double* sampleData=myData.getSampleDataByTag(9);
932     for (int i=0; i<myData.getLength(); i++) {
933     assert(sampleData[i]==0);
934     }
935    
936 jgs 501 }
937    
938     {
939    
940     cout << "\tTest adding one key with one value to default DataTagged." << endl;
941     DataTagged myData;
942    
943     DataTagged::TagListType keys;
944     keys.push_back(1);
945    
946 jfenwick 1747 DataTagged::ValueBatchType values;
947 jgs 501
948 jfenwick 1697 DataTypes::ShapeType viewShape;
949 jfenwick 1747 /* DataTypes::ValueType viewData(1);
950     viewData[0]=1.0;*/
951     // DataArrayView myView(viewData,viewShape);
952     values.push_back(1.0);
953 jgs 501
954 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
955 jgs 501
956     assert(myData.isCurrentTag(1));
957    
958     assert(myData.getTagLookup().size()==1);
959    
960     assert(myData.getLength()==2);
961    
962     // data-point 0 has tag number 1 by default
963     assert(myData.getTagNumber(0)==1);
964    
965     assert(myData.getPointOffset(0,0)==1);
966    
967 jfenwick 1747 assert(myData.getRank()==0);
968     assert(myData.getNoValues()==1);
969     assert(myData.getShape().size()==0);
970 jgs 501
971    
972 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
973     int offset=myData.getPointOffset(0,0);
974     assert(offset==1);
975     assert(myData.getDataAtOffset(offset)==1.0);
976 jgs 501
977 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
978     offset=myData.getOffsetForTag(1);
979     assert(offset==1);
980     assert(myData.getDataAtOffset(offset)==1.0);
981    
982     // myDataView = myData.getDefaultValue();
983     offset=myData.getDefaultOffset();
984     assert(offset==0);
985     assert(myData.getDataAtOffset(offset)==0.0);
986    
987 jgs 506 // use a non-existent tag so we get a pointer to
988     // the first element of the data array
989     double* sampleData=myData.getSampleDataByTag(9);
990     for (int i=0; i<myData.getLength(); i++) {
991     assert(sampleData[i]==i);
992     }
993    
994 jgs 501 }
995    
996     {
997    
998     cout << "\tTest adding three keys with one value to default DataTagged." << endl;
999     DataTagged myData;
1000    
1001     DataTagged::TagListType keys;
1002     keys.push_back(1);
1003     keys.push_back(2);
1004     keys.push_back(3);
1005    
1006 jfenwick 1747 DataTagged::ValueBatchType values;
1007 jgs 501
1008 jfenwick 1697 DataTypes::ShapeType viewShape;
1009 jfenwick 1747 /* DataTypes::ValueType viewData(1);
1010 jgs 501 viewData[0]=1.0;
1011 jfenwick 1747 DataArrayView myView(viewData,viewShape);*/
1012     values.push_back(1.0);
1013 jgs 501
1014 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1015 jgs 501
1016     assert(myData.isCurrentTag(1));
1017     assert(myData.isCurrentTag(2));
1018     assert(myData.isCurrentTag(3));
1019    
1020     assert(myData.getTagLookup().size()==3);
1021    
1022     assert(myData.getLength()==4);
1023    
1024     // data-point 0 has tag number 1 by default
1025     assert(myData.getTagNumber(0)==1);
1026    
1027     assert(myData.getPointOffset(0,0)==1);
1028    
1029 jfenwick 1747 assert(myData.getRank()==0);
1030     assert(myData.getNoValues()==1);
1031     assert(myData.getShape().size()==0);
1032 jgs 501
1033    
1034 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
1035     int offset=myData.getPointOffset(0,0);
1036     assert(offset==1);
1037     assert(myData.getDataAtOffset(offset)==1.0);
1038 jgs 501
1039 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
1040     offset=myData.getOffsetForTag(1);
1041     assert(offset==1);
1042     assert(myData.getDataAtOffset(offset)==1.0);
1043 jgs 501
1044 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
1045     offset=myData.getOffsetForTag(2);
1046     assert(offset==2);
1047     assert(myData.getDataAtOffset(offset)==1.0);
1048 jgs 501
1049 jfenwick 1747 // myDataView = myData.getDataPointByTag(3);
1050     offset=myData.getOffsetForTag(3);
1051     assert(offset==3);
1052     assert(myData.getDataAtOffset(offset)==1.0);
1053    
1054     // myDataView = myData.getDefaultValue();
1055     offset=myData.getDefaultOffset();
1056     assert(offset==0);
1057     assert(myData.getDataAtOffset(offset)==0.0);
1058    
1059 jgs 506 // use a non-existent tag so we get a pointer to
1060     // the first element of the data array
1061     double* sampleData=myData.getSampleDataByTag(9);
1062     for (int i=0; i<myData.getLength(); i++) {
1063     if (i==0) {
1064     assert(sampleData[i]==0);
1065     } else {
1066     assert(sampleData[i]==1);
1067     }
1068     }
1069    
1070 jgs 501 }
1071    
1072     {
1073    
1074     cout << "\tTest adding three keys with three values to default DataTagged." << endl;
1075     DataTagged myData;
1076    
1077     DataTagged::TagListType keys;
1078     keys.push_back(1);
1079     keys.push_back(2);
1080     keys.push_back(3);
1081    
1082 jfenwick 1747 DataTagged::ValueBatchType values;
1083 jgs 501
1084 jfenwick 1697 DataTypes::ShapeType viewShape;
1085 jfenwick 1747 /* DataTypes::ValueType viewData1(1);
1086 jgs 501 viewData1[0]=1.0;
1087 jfenwick 1697 DataTypes::ValueType viewData2(1);
1088 jgs 501 viewData2[0]=2.0;
1089 jfenwick 1697 DataTypes::ValueType viewData3(1);
1090 jgs 501 viewData3[0]=3.0;
1091     DataArrayView myView1(viewData1,viewShape);
1092     DataArrayView myView2(viewData2,viewShape);
1093 jfenwick 1747 DataArrayView myView3(viewData3,viewShape);*/
1094     values.push_back(1.0);
1095     values.push_back(2.0);
1096     values.push_back(3.0);
1097 jgs 501
1098 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1099 jgs 501
1100     assert(myData.isCurrentTag(1));
1101     assert(myData.isCurrentTag(2));
1102     assert(myData.isCurrentTag(3));
1103    
1104     assert(myData.getTagLookup().size()==3);
1105    
1106     assert(myData.getLength()==4);
1107    
1108     // data-point 0 has tag number 1 by default
1109     assert(myData.getTagNumber(0)==1);
1110    
1111     assert(myData.getPointOffset(0,0)==1);
1112    
1113 jfenwick 1747 assert(myData.getRank()==0);
1114     assert(myData.getNoValues()==1);
1115     assert(myData.getShape().size()==0);
1116 jgs 501
1117    
1118 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
1119     int offset=myData.getPointOffset(0,0);
1120     assert(offset==1);
1121     assert(myData.getDataAtOffset(offset)==1.0);
1122 jgs 501
1123 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
1124     offset=myData.getOffsetForTag(1);
1125     assert(offset==1);
1126     assert(myData.getDataAtOffset(offset)==1.0);
1127 jgs 501
1128 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
1129     offset=myData.getOffsetForTag(2);
1130     assert(offset==2);
1131     assert(myData.getDataAtOffset(offset)==2.0);
1132 jgs 501
1133 jfenwick 1747 // myDataView = myData.getDataPointByTag(3);
1134     offset=myData.getOffsetForTag(3);
1135     assert(offset==3);
1136     assert(myData.getDataAtOffset(offset)==3.0);
1137    
1138     // myDataView = myData.getDefaultValue();
1139     offset=myData.getDefaultOffset();
1140     assert(offset==0);
1141     assert(myData.getDataAtOffset(offset)==0.0);
1142    
1143 jgs 506 // use a non-existent tag so we get a pointer to
1144     // the first element of the data array
1145     double* sampleData=myData.getSampleDataByTag(9);
1146     for (int i=0; i<myData.getLength(); i++) {
1147     assert(sampleData[i]==i);
1148     }
1149    
1150 jgs 501 }
1151    
1152     {
1153    
1154     cout << "\tTest adding one key with empty value list to DataTagged with default value only." << endl;
1155    
1156 jfenwick 1697 DataTypes::ShapeType viewShape;
1157 jgs 501 viewShape.push_back(3);
1158    
1159     DataTagged::TagListType keys;
1160    
1161 jfenwick 1747 DataTagged::ValueBatchType values;
1162 jgs 501
1163 jfenwick 1697 DataTypes::ValueType viewData(3);
1164 jgs 501 for (int i=0;i<viewShape[0];i++) {
1165     viewData[i]=i;
1166     }
1167    
1168 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,viewData);
1169 jgs 501
1170     keys.push_back(1);
1171     values.clear();
1172    
1173 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1174 jgs 501
1175     assert(myData.isCurrentTag(1));
1176    
1177     assert(myData.getTagLookup().size()==1);
1178    
1179     assert(myData.getLength()==6);
1180    
1181     // data-point 0 has tag number 1 by default
1182     assert(myData.getTagNumber(0)==1);
1183    
1184     assert(myData.getPointOffset(0,0)==3);
1185    
1186 jfenwick 1747 assert(myData.getRank()==1);
1187     assert(myData.getNoValues()==3);
1188     assert(myData.getShape().size()==1);
1189 jgs 501
1190    
1191 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
1192     int offset=myData.getPointOffset(0,0);
1193     assert(offset==3);
1194     assert(getRef(myData,offset,0)==0);
1195     assert(getRef(myData,offset,1)==1);
1196     assert(getRef(myData,offset,2)==2);
1197 jgs 501
1198 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
1199     offset=myData.getOffsetForTag(1);
1200     assert(offset==3);
1201     assert(getRef(myData,offset,0)==0);
1202     assert(getRef(myData,offset,1)==1);
1203     assert(getRef(myData,offset,2)==2);
1204    
1205     // myDataView = myData.getDefaultValue();
1206     offset=myData.getDefaultOffset();
1207     assert(offset==0);
1208     assert(getRef(myData,offset,0)==0);
1209     assert(getRef(myData,offset,1)==1);
1210     assert(getRef(myData,offset,2)==2);
1211    
1212 jgs 506 // use a non-existent tag so we get a pointer to
1213     // the first element of the data array
1214     double* sampleData=myData.getSampleDataByTag(9);
1215     for (int i=0; i<myData.getLength(); i++) {
1216     assert(sampleData[i]==i%3);
1217     }
1218    
1219 jgs 501 }
1220    
1221     {
1222    
1223     cout << "\tTest adding one key with one value to DataTagged with default value only." << endl;
1224    
1225 jfenwick 1697 DataTypes::ShapeType viewShape;
1226 jgs 501 viewShape.push_back(3);
1227    
1228     DataTagged::TagListType keys;
1229    
1230 jfenwick 1747 DataTagged::ValueBatchType values;
1231 jgs 501
1232 jfenwick 1697 DataTypes::ValueType viewData(3);
1233 jgs 501 for (int i=0;i<viewShape[0];i++) {
1234     viewData[i]=i;
1235     }
1236 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
1237 jgs 501
1238 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,viewData);
1239 jgs 501
1240     keys.push_back(1);
1241    
1242 jfenwick 1747 // DataTypes::ValueType viewData1(3);
1243 jgs 501 for (int i=0;i<viewShape[0];i++) {
1244 jfenwick 1747 // viewData1[i]=i+3;
1245     values.push_back(i+3);
1246 jgs 501 }
1247 jfenwick 1747 // DataArrayView myView1(viewData1,viewShape);
1248     // values.push_back(myView1);
1249 jgs 501
1250 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1251 jgs 501
1252     assert(myData.isCurrentTag(1));
1253    
1254     assert(myData.getTagLookup().size()==1);
1255    
1256     assert(myData.getLength()==6);
1257    
1258     // data-point 0 has tag number 1 by default
1259     assert(myData.getTagNumber(0)==1);
1260    
1261     assert(myData.getPointOffset(0,0)==3);
1262    
1263 jfenwick 1747 assert(myData.getRank()==1);
1264     assert(myData.getNoValues()==3);
1265     assert(myData.getShape().size()==1);
1266 jgs 501
1267    
1268 jfenwick 1747 int offset=myData.getPointOffset(0,0);
1269     // DataArrayView myDataView = myData.getDataPoint(0,0);
1270     assert(offset==3);
1271     assert(getRef(myData,offset,0)==3);
1272     assert(getRef(myData,offset,1)==4);
1273     assert(getRef(myData,offset,2)==5);
1274 jgs 501
1275 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
1276     offset=myData.getOffsetForTag(1);
1277     assert(offset==3);
1278     assert(getRef(myData,offset,0)==3);
1279     assert(getRef(myData,offset,1)==4);
1280     assert(getRef(myData,offset,2)==5);
1281    
1282     // myDataView = myData.getDefaultValue();
1283     offset=myData.getDefaultOffset();
1284     assert(offset==0);
1285     assert(getRef(myData,offset,0)==0);
1286     assert(getRef(myData,offset,1)==1);
1287     assert(getRef(myData,offset,2)==2);
1288    
1289 jgs 506 // use a non-existent tag so we get a pointer to
1290     // the first element of the data array
1291     double* sampleData=myData.getSampleDataByTag(9);
1292     for (int i=0; i<myData.getLength(); i++) {
1293     assert(sampleData[i]==i);
1294     }
1295    
1296 jgs 501 }
1297    
1298     {
1299    
1300     cout << "\tTest adding three keys with one value to DataTagged with default value only." << endl;
1301    
1302 jfenwick 1697 DataTypes::ShapeType viewShape;
1303 jgs 501 viewShape.push_back(3);
1304    
1305     DataTagged::TagListType keys;
1306    
1307 jfenwick 1747 DataTagged::ValueBatchType values;
1308 jgs 501
1309 jfenwick 1697 DataTypes::ValueType viewData(3);
1310 jgs 501 for (int i=0;i<viewShape[0];i++) {
1311     viewData[i]=i;
1312     }
1313 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
1314 jgs 501
1315 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,viewData);
1316 jgs 501
1317     keys.push_back(1);
1318     keys.push_back(2);
1319     keys.push_back(3);
1320    
1321 jfenwick 1747 // DataTypes::ValueType viewData1(3);
1322 jgs 501 for (int i=0;i<viewShape[0];i++) {
1323 jfenwick 1747 // viewData1[i]=3;
1324     values.push_back(3);
1325 jgs 501 }
1326 jfenwick 1747 // DataArrayView myView1(viewData1,viewShape);
1327     // values.push_back(myView1);
1328 jgs 501
1329 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1330 jgs 501
1331     assert(myData.isCurrentTag(1));
1332     assert(myData.isCurrentTag(2));
1333     assert(myData.isCurrentTag(3));
1334    
1335     assert(myData.getTagLookup().size()==3);
1336    
1337     assert(myData.getLength()==12);
1338    
1339     // data-point 0 has tag number 1 by default
1340     assert(myData.getTagNumber(0)==1);
1341    
1342     assert(myData.getPointOffset(0,0)==3);
1343    
1344 jfenwick 1747 assert(myData.getRank()==1);
1345     assert(myData.getNoValues()==3);
1346     assert(myData.getShape().size()==1);
1347 jgs 501
1348 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
1349     int offset=myData.getPointOffset(0,0);
1350     assert(offset==3);
1351     assert(getRef(myData,offset,0)==3);
1352     assert(getRef(myData,offset,1)==3);
1353     assert(getRef(myData,offset,2)==3);
1354 jgs 501
1355 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
1356     offset=myData.getOffsetForTag(1);
1357     assert(offset==3);
1358     assert(getRef(myData,offset,0)==3);
1359     assert(getRef(myData,offset,1)==3);
1360     assert(getRef(myData,offset,2)==3);
1361 jgs 501
1362 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
1363     offset=myData.getOffsetForTag(2);
1364     assert(offset==6);
1365     assert(getRef(myData,offset,0)==3);
1366     assert(getRef(myData,offset,1)==3);
1367     assert(getRef(myData,offset,2)==3);
1368 jgs 501
1369 jfenwick 1747 // myDataView = myData.getDataPointByTag(3);
1370     offset=myData.getOffsetForTag(3);
1371     assert(offset==9);
1372     assert(getRef(myData,offset,0)==3);
1373     assert(getRef(myData,offset,1)==3);
1374     assert(getRef(myData,offset,2)==3);
1375 jgs 501
1376 jfenwick 1747 // myDataView = myData.getDefaultValue();
1377     offset=myData.getDefaultOffset();
1378     assert(offset==0);
1379     assert(getRef(myData,offset,0)==0);
1380     assert(getRef(myData,offset,1)==1);
1381     assert(getRef(myData,offset,2)==2);
1382    
1383 jgs 506 // use a non-existent tag so we get a pointer to
1384     // the first element of the data array
1385     double* sampleData=myData.getSampleDataByTag(9);
1386     for (int i=0; i<myData.getLength(); i++) {
1387     if (i<3) {
1388     assert(sampleData[i]==i);
1389     } else {
1390     assert(sampleData[i]==3);
1391     }
1392     }
1393    
1394 jgs 501 }
1395    
1396     {
1397    
1398     cout << "\tTest adding three keys with three values to DataTagged with default value only." << endl;
1399    
1400 jfenwick 1697 DataTypes::ShapeType viewShape;
1401 jgs 501 viewShape.push_back(3);
1402    
1403     DataTagged::TagListType keys;
1404    
1405 jfenwick 1747 DataTagged::ValueBatchType values;
1406 jgs 501
1407 jfenwick 1697 DataTypes::ValueType viewData(3);
1408 jgs 501 for (int i=0;i<viewShape[0];i++) {
1409     viewData[i]=i;
1410     }
1411 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
1412 jgs 501
1413 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,viewData);
1414 jgs 501
1415     keys.push_back(1);
1416     keys.push_back(2);
1417     keys.push_back(3);
1418    
1419 jfenwick 1747 // DataTypes::ValueType viewData1(3);
1420 jgs 501 for (int i=0;i<viewShape[0];i++) {
1421 jfenwick 1747 // viewData1[i]=i+1;
1422     values.push_back(i+1);
1423 jgs 501 }
1424 jfenwick 1747 // DataArrayView myView1(viewData1,viewShape);
1425     // values.push_back(myView1);
1426 jgs 501
1427 jfenwick 1747 // DataTypes::ValueType viewData2(3);
1428 jgs 501 for (int i=0;i<viewShape[0];i++) {
1429 jfenwick 1747 // viewData2[i]=i+2;
1430     values.push_back(i+2);
1431 jgs 501 }
1432 jfenwick 1747 // DataArrayView myView2(viewData2,viewShape);
1433     // values.push_back(myView2);
1434 jgs 501
1435 jfenwick 1747 // DataTypes::ValueType viewData3(3);
1436 jgs 501 for (int i=0;i<viewShape[0];i++) {
1437 jfenwick 1747 // viewData3[i]=i+3;
1438     values.push_back(i+3);
1439 jgs 501 }
1440 jfenwick 1747 // DataArrayView myView3(viewData3,viewShape);
1441     // values.push_back(myView3);
1442 jgs 501
1443 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1444 jgs 501
1445     assert(myData.isCurrentTag(1));
1446     assert(myData.isCurrentTag(2));
1447     assert(myData.isCurrentTag(3));
1448    
1449     assert(myData.getTagLookup().size()==3);
1450    
1451     assert(myData.getLength()==12);
1452    
1453     // data-point 0 has tag number 1 by default
1454     assert(myData.getTagNumber(0)==1);
1455    
1456     assert(myData.getPointOffset(0,0)==3);
1457    
1458 jfenwick 1747 assert(myData.getRank()==1);
1459     assert(myData.getNoValues()==3);
1460     assert(myData.getShape().size()==1);
1461 jgs 501
1462    
1463 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
1464     int offset=myData.getPointOffset(0,0);
1465     assert(offset==3);
1466     assert(getRef(myData,offset,0)==1);
1467     assert(getRef(myData,offset,1)==2);
1468     assert(getRef(myData,offset,2)==3);
1469 jgs 501
1470 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
1471     offset=myData.getOffsetForTag(1);
1472     assert(offset==3);
1473     assert(getRef(myData,offset,0)==1);
1474     assert(getRef(myData,offset,1)==2);
1475     assert(getRef(myData,offset,2)==3);
1476 jgs 501
1477 jfenwick 1747 // myDataView = myData.getDataPointByTag(2);
1478     offset=myData.getOffsetForTag(2);
1479     assert(offset==6);
1480     assert(getRef(myData,offset,0)==2);
1481     assert(getRef(myData,offset,1)==3);
1482     assert(getRef(myData,offset,2)==4);
1483 jgs 501
1484 jfenwick 1747 // myDataView = myData.getDataPointByTag(3);
1485     offset=myData.getOffsetForTag(3);
1486     assert(offset==9);
1487     assert(getRef(myData,offset,0)==3);
1488     assert(getRef(myData,offset,1)==4);
1489     assert(getRef(myData,offset,2)==5);
1490    
1491     // myDataView = myData.getDefaultValue();
1492     offset=myData.getDefaultOffset();
1493     assert(offset==0);
1494     assert(getRef(myData,offset,0)==0);
1495     assert(getRef(myData,offset,1)==1);
1496     assert(getRef(myData,offset,2)==2);
1497    
1498 jgs 506 // use a non-existent tag so we get a pointer to
1499     // the first element of the data array
1500     double* sampleData=myData.getSampleDataByTag(9);
1501     for (int i=0; i<myData.getLength(); i++) {
1502     if (i<3) {
1503     assert(sampleData[i]==i);
1504 jgs 508 } else if ((i>=3) && (i<6)) {
1505 jgs 506 assert(sampleData[i]==i-2);
1506 jgs 508 } else if ((i>=6) && (i<9)) {
1507 jgs 506 assert(sampleData[i]==i-4);
1508 jgs 508 } else {
1509 jgs 506 assert(sampleData[i]==i-6);
1510     }
1511     }
1512    
1513 jgs 501 }
1514    
1515     {
1516    
1517     cout << "\tTest adding one key with empty value list to DataTagged with three tags." << endl;
1518    
1519     DataTagged::TagListType keys;
1520     keys.push_back(1);
1521     keys.push_back(2);
1522     keys.push_back(3);
1523    
1524 jfenwick 1747 DataTagged::ValueBatchType values;
1525 jgs 501
1526 jfenwick 1697 DataTypes::ShapeType viewShape;
1527 jgs 501 viewShape.push_back(3);
1528    
1529     // default value
1530 jfenwick 1747 DataTypes::ValueType viewData(3*4);
1531 jgs 501 for (int i=0;i<viewShape[0];i++) {
1532     viewData[i]=i;
1533     }
1534 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
1535 jgs 501
1536     // value for tag "1"
1537 jfenwick 1747 // DataTypes::ValueType eOneData(viewData);
1538     // DataArrayView eOneView(eOneData, viewShape);
1539     for (int i=0;i<viewShape[0];i++) {
1540     // eOneView(i)=i+1.0;
1541     viewData[viewShape[0]+i]=i+1.0;
1542 jgs 501 }
1543 jfenwick 1747 // values.push_back(eOneView);
1544 jgs 501
1545     // value for tag "2"
1546 jfenwick 1747 // DataTypes::ValueType eTwoData(viewData);
1547     // DataArrayView eTwoView(eTwoData, viewShape);
1548     for (int i=0;i<viewShape[0];i++) {
1549     // eTwoView(i)=i+2.0;
1550     viewData[2*viewShape[0]+i]=i+2.0;
1551 jgs 501 }
1552 jfenwick 1747 // values.push_back(eTwoView);
1553 jgs 501
1554     // value for tag "3"
1555 jfenwick 1747 // DataTypes::ValueType eThreeData(viewData);
1556     // DataArrayView eThreeView(eThreeData, viewShape);
1557     for (int i=0;i<viewShape[0];i++) {
1558     // eThreeView(i)=i+3.0;
1559     viewData[3*viewShape[0]+i]=i+3.0;
1560 jgs 501 }
1561 jfenwick 1747 // values.push_back(eThreeView);
1562 jgs 501
1563 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
1564 jgs 501
1565     keys.clear();
1566     keys.push_back(4);
1567     values.clear();
1568    
1569 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1570 jgs 501
1571     assert(myData.isCurrentTag(4));
1572    
1573     assert(myData.getTagLookup().size()==4);
1574    
1575     assert(myData.getLength()==15);
1576    
1577 jfenwick 1747 assert(myData.getRank()==1);
1578     assert(myData.getNoValues()==3);
1579     assert(myData.getShape().size()==1);
1580 jgs 501
1581 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(4);
1582     int offset=myData.getOffsetForTag(4);
1583     assert(offset==12);
1584     assert(getRef(myData,offset,0)==0);
1585     assert(getRef(myData,offset,1)==1);
1586     assert(getRef(myData,offset,2)==2);
1587    
1588 jgs 506 // use a non-existent tag so we get a pointer to
1589     // the first element of the data array
1590     double* sampleData=myData.getSampleDataByTag(9);
1591     for (int i=0; i<myData.getLength(); i++) {
1592     if (i<3) {
1593     assert(sampleData[i]==i);
1594 jgs 508 } else if ((i>=3) && (i<6)) {
1595 jgs 506 assert(sampleData[i]==i-2);
1596 jgs 508 } else if ((i>=6) && (i<9)) {
1597 jgs 506 assert(sampleData[i]==i-4);
1598 jgs 508 } else if ((i>=9) && (i<12)) {
1599 jgs 506 assert(sampleData[i]==i-6);
1600 jgs 508 } else {
1601 jgs 506 assert(sampleData[i]==i-12);
1602     }
1603     }
1604    
1605 jgs 501 }
1606    
1607     {
1608    
1609     cout << "\tTest adding one key with one value to DataTagged with three tags." << endl;
1610    
1611     DataTagged::TagListType keys;
1612     keys.push_back(1);
1613     keys.push_back(2);
1614     keys.push_back(3);
1615    
1616 jfenwick 1747 DataTagged::ValueBatchType values;
1617 jgs 501
1618 jfenwick 1697 DataTypes::ShapeType viewShape;
1619 jgs 501 viewShape.push_back(3);
1620    
1621     // default value
1622 jfenwick 1747 DataTypes::ValueType viewData(3*4);
1623 jgs 501 for (int i=0;i<viewShape[0];i++) {
1624     viewData[i]=i;
1625     }
1626 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
1627 jgs 501
1628     // value for tag "1"
1629 jfenwick 1747 // DataTypes::ValueType eOneData(viewData);
1630     // DataArrayView eOneView(eOneData, viewShape);
1631     for (int i=0;i<viewShape[0];i++) {
1632     // eOneView(i)=i+1.0;
1633     viewData[viewShape[0]+i]=i+1.0;
1634 jgs 501 }
1635 jfenwick 1747 // values.push_back(eOneView);
1636 jgs 501
1637     // value for tag "2"
1638 jfenwick 1747 // DataTypes::ValueType eTwoData(viewData);
1639     // DataArrayView eTwoView(eTwoData, viewShape);
1640     for (int i=0;i<viewShape[0];i++) {
1641     // eTwoView(i)=i+2.0;
1642     viewData[2*viewShape[0]+i]=i+2.0;
1643 jgs 501 }
1644 jfenwick 1747 // values.push_back(eTwoView);
1645 jgs 501
1646     // value for tag "3"
1647 jfenwick 1747 // DataTypes::ValueType eThreeData(viewData);
1648     // DataArrayView eThreeView(eThreeData, viewShape);
1649     for (int i=0;i<viewShape[0];i++) {
1650     // eThreeView(i)=i+3.0;
1651     viewData[3*viewShape[0]+i]=i+3.0;
1652 jgs 501 }
1653 jfenwick 1747 // values.push_back(eThreeView);
1654 jgs 501
1655 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
1656 jgs 501
1657     keys.clear();
1658     keys.push_back(4);
1659    
1660     values.clear();
1661     // value for tag "4"
1662 jfenwick 1747 // DataTypes::ValueType eFourData(viewData);
1663     // DataArrayView eFourView(eFourData, viewShape);
1664     for (int i=0;i<viewShape[0];i++) {
1665     values.push_back(i+4.0);
1666 jgs 501 }
1667 jfenwick 1747 // values.push_back(eFourView);
1668 jgs 501
1669 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1670 jgs 501
1671     assert(myData.isCurrentTag(4));
1672    
1673     assert(myData.getTagLookup().size()==4);
1674    
1675     assert(myData.getLength()==15);
1676    
1677 jfenwick 1747 assert(myData.getRank()==1);
1678     assert(myData.getNoValues()==3);
1679     assert(myData.getShape().size()==1);
1680 jgs 501
1681 jfenwick 1747
1682     // DataArrayView myDataView = myData.getDataPointByTag(4);
1683     int offset=myData.getOffsetForTag(4);
1684     assert(offset==12);
1685     assert(getRef(myData,offset,0)==4);
1686     assert(getRef(myData,offset,1)==5);
1687     assert(getRef(myData,offset,2)==6);
1688    
1689 jgs 506 // use a non-existent tag so we get a pointer to
1690     // the first element of the data array
1691     double* sampleData=myData.getSampleDataByTag(9);
1692     for (int i=0; i<myData.getLength(); i++) {
1693     if (i<3) {
1694     assert(sampleData[i]==i);
1695 jgs 508 } else if ((i>=3) && (i<6)) {
1696 jgs 506 assert(sampleData[i]==i-2);
1697 jgs 508 } else if ((i>=6) && (i<9)) {
1698 jgs 506 assert(sampleData[i]==i-4);
1699 jgs 508 } else if ((i>=9) && (i<12)) {
1700 jgs 506 assert(sampleData[i]==i-6);
1701 jgs 508 } else {
1702 jgs 506 assert(sampleData[i]==i-8);
1703     }
1704     }
1705    
1706 jgs 501 }
1707    
1708     {
1709    
1710     cout << "\tTest adding three keys with one value to DataTagged with three tags." << endl;
1711    
1712     DataTagged::TagListType keys;
1713     keys.push_back(1);
1714     keys.push_back(2);
1715     keys.push_back(3);
1716    
1717 jfenwick 1747 DataTagged::ValueBatchType values;
1718 jgs 501
1719 jfenwick 1697 DataTypes::ShapeType viewShape;
1720 jgs 501 viewShape.push_back(3);
1721    
1722     // default value
1723 jfenwick 1747 DataTypes::ValueType viewData(3*4);
1724 jgs 501 for (int i=0;i<viewShape[0];i++) {
1725     viewData[i]=i;
1726     }
1727 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
1728 jgs 501
1729     // value for tag "1"
1730 jfenwick 1747 // DataTypes::ValueType eOneData(viewData);
1731     // DataArrayView eOneView(eOneData, viewShape);
1732     for (int i=0;i<viewShape[0];i++) {
1733     viewData[viewShape[0]+i]=i+1.0;
1734 jgs 501 }
1735 jfenwick 1747 // values.push_back(eOneView);
1736 jgs 501
1737     // value for tag "2"
1738 jfenwick 1747 // DataTypes::ValueType eTwoData(viewData);
1739     // DataArrayView eTwoView(eTwoData, viewShape);
1740     for (int i=0;i<viewShape[0];i++) {
1741     // eTwoView(i)=i+2.0;
1742     viewData[2*viewShape[0]+i]=i+2.0;
1743 jgs 501 }
1744 jfenwick 1747 // values.push_back(eTwoView);
1745 jgs 501
1746     // value for tag "3"
1747 jfenwick 1747 // DataTypes::ValueType eThreeData(viewData);
1748     // DataArrayView eThreeView(eThreeData, viewShape);
1749     for (int i=0;i<viewShape[0];i++) {
1750     // eThreeView(i)=i+3.0;
1751     viewData[3*viewShape[0]+i]=i+3.0;
1752 jgs 501 }
1753 jfenwick 1747 // values.push_back(eThreeView);
1754 jgs 501
1755 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
1756 jgs 501
1757     keys.clear();
1758     keys.push_back(4);
1759     keys.push_back(5);
1760     keys.push_back(6);
1761    
1762     values.clear();
1763     // value for tags "4", "5" and "6"
1764 jfenwick 1747 // DataTypes::ValueType eFourData(viewData);
1765     // DataArrayView eFourView(eFourData, viewShape);
1766     for (int i=0;i<viewShape[0];i++) {
1767     // eFourView(i)=i+4.0;
1768     values.push_back(i+4.0);
1769 jgs 501 }
1770 jfenwick 1747 // values.push_back(eFourView);
1771 jgs 501
1772 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1773 jgs 501
1774     assert(myData.isCurrentTag(4));
1775     assert(myData.isCurrentTag(5));
1776     assert(myData.isCurrentTag(6));
1777    
1778     assert(myData.getTagLookup().size()==6);
1779    
1780     assert(myData.getLength()==21);
1781    
1782 jfenwick 1747 assert(myData.getRank()==1);
1783     assert(myData.getNoValues()==3);
1784     assert(myData.getShape().size()==1);
1785 jgs 501
1786 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(4);
1787     int offset=myData.getOffsetForTag(4);
1788     assert(offset==12);
1789     assert(getRef(myData,offset,0)==4);
1790     assert(getRef(myData,offset,1)==5);
1791     assert(getRef(myData,offset,2)==6);
1792 jgs 501
1793 jfenwick 1747 // myDataView = myData.getDataPointByTag(5);
1794     offset=myData.getOffsetForTag(5);
1795     assert(offset==15);
1796     assert(getRef(myData,offset,0)==4);
1797     assert(getRef(myData,offset,1)==5);
1798     assert(getRef(myData,offset,2)==6);
1799 jgs 501
1800 jfenwick 1747 // myDataView = myData.getDataPointByTag(6);
1801     offset=myData.getOffsetForTag(6);
1802     assert(offset==18);
1803     assert(getRef(myData,offset,0)==4);
1804     assert(getRef(myData,offset,1)==5);
1805     assert(getRef(myData,offset,2)==6);
1806    
1807 jgs 506 // use a non-existent tag so we get a pointer to
1808     // the first element of the data array
1809     double* sampleData=myData.getSampleDataByTag(9);
1810     for (int i=0; i<myData.getLength(); i++) {
1811     if (i<3) {
1812     assert(sampleData[i]==i);
1813 jgs 508 } else if ((i>=3) && (i<6)) {
1814 jgs 506 assert(sampleData[i]==i-2);
1815 jgs 508 } else if ((i>=6) && (i<9)) {
1816 jgs 506 assert(sampleData[i]==i-4);
1817 jgs 508 } else if ((i>=9) && (i<12)) {
1818 jgs 506 assert(sampleData[i]==i-6);
1819 jgs 508 } else if ((i>=12) && (i<15)) {
1820 jgs 506 assert(sampleData[i]==i-8);
1821 jgs 508 } else if ((i>=15) && (i<18)) {
1822 jgs 506 assert(sampleData[i]==i-11);
1823 jgs 508 } else {
1824 jgs 506 assert(sampleData[i]==i-14);
1825     }
1826     }
1827    
1828 jgs 501 }
1829    
1830     {
1831    
1832     cout << "\tTest adding three keys with three values to DataTagged with three tags." << endl;
1833    
1834     DataTagged::TagListType keys;
1835     keys.push_back(1);
1836     keys.push_back(2);
1837     keys.push_back(3);
1838    
1839 jfenwick 1747 DataTagged::ValueBatchType values;
1840 jgs 501
1841 jfenwick 1697 DataTypes::ShapeType viewShape;
1842 jgs 501 viewShape.push_back(3);
1843    
1844     // default value
1845 jfenwick 1747 DataTypes::ValueType viewData(3*4);
1846 jgs 501 for (int i=0;i<viewShape[0];i++) {
1847     viewData[i]=i;
1848     }
1849 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
1850 jgs 501
1851     // value for tag "1"
1852 jfenwick 1747 // DataTypes::ValueType eOneData(viewData);
1853     // DataArrayView eOneView(eOneData, viewShape);
1854     for (int i=0;i<viewShape[0];i++) {
1855     viewData[viewShape[0]+i]=i+1.0;
1856 jgs 501 }
1857 jfenwick 1747 // values.push_back(eOneView);
1858 jgs 501
1859     // value for tag "2"
1860 jfenwick 1747 // DataTypes::ValueType eTwoData(viewData);
1861     // DataArrayView eTwoView(eTwoData, viewShape);
1862     for (int i=0;i<viewShape[0];i++) {
1863     // eTwoView(i)=i+2.0;
1864     viewData[2*viewShape[0]+i]=i+2.0;
1865 jgs 501 }
1866 jfenwick 1747 // values.push_back(eTwoView);
1867 jgs 501
1868     // value for tag "3"
1869 jfenwick 1747 // DataTypes::ValueType eThreeData(viewData);
1870     // DataArrayView eThreeView(eThreeData, viewShape);
1871     for (int i=0;i<viewShape[0];i++) {
1872     viewData[3*viewShape[0]+i]=i+3.0;
1873 jgs 501 }
1874 jfenwick 1747 // values.push_back(eThreeView);
1875 jgs 501
1876 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
1877 jgs 501
1878     keys.clear();
1879     keys.push_back(4);
1880     keys.push_back(5);
1881     keys.push_back(6);
1882    
1883     values.clear();
1884    
1885     // value for tag "4"
1886 jfenwick 1747 // DataTypes::ValueType eFourData(viewData);
1887     // DataArrayView eFourView(eFourData, viewShape);
1888     for (int i=0;i<viewShape[0];i++) {
1889     values.push_back(i+4.0);
1890 jgs 501 }
1891 jfenwick 1747 // values.push_back(eFourView);
1892 jgs 501
1893     // value for tag "5"
1894 jfenwick 1747 // DataTypes::ValueType eFiveData(viewData);
1895     // DataArrayView eFiveView(eFiveData, viewShape);
1896     for (int i=0;i<viewShape[0];i++) {
1897     values.push_back(i+5.0);
1898 jgs 501 }
1899 jfenwick 1747 // values.push_back(eFiveView);
1900 jgs 501
1901     // value for tag "6"
1902 jfenwick 1747 // DataTypes::ValueType eSixData(viewData);
1903     // DataArrayView eSixView(eSixData, viewShape);
1904     for (int i=0;i<viewShape[0];i++) {
1905     // eSixView(i)=i+6.0;
1906     values.push_back(i+6.0);
1907 jgs 501 }
1908 jfenwick 1747 // values.push_back(eSixView);
1909 jgs 501
1910 jfenwick 1747 myData.addTaggedValues(keys,values,viewShape);
1911 jgs 501
1912     assert(myData.isCurrentTag(4));
1913     assert(myData.isCurrentTag(5));
1914     assert(myData.isCurrentTag(6));
1915    
1916     assert(myData.getTagLookup().size()==6);
1917    
1918     assert(myData.getLength()==21);
1919    
1920 jfenwick 1747 assert(myData.getRank()==1);
1921     assert(myData.getNoValues()==3);
1922     assert(myData.getShape().size()==1);
1923 jgs 501
1924 jfenwick 1747 // DataArrayView myDataView = myData.getDataPointByTag(4);
1925     int offset=myData.getOffsetForTag(4);
1926     assert(offset==12);
1927     assert(getRef(myData,offset,0)==4);
1928     assert(getRef(myData,offset,1)==5);
1929     assert(getRef(myData,offset,2)==6);
1930 jgs 501
1931 jfenwick 1747 // myDataView = myData.getDataPointByTag(5);
1932     offset=myData.getOffsetForTag(5);
1933     assert(offset==15);
1934     assert(getRef(myData,offset,0)==5);
1935     assert(getRef(myData,offset,1)==6);
1936     assert(getRef(myData,offset,2)==7);
1937 jgs 501
1938 jfenwick 1747 // myDataView = myData.getDataPointByTag(6);
1939     offset=myData.getOffsetForTag(6);
1940     assert(offset==18);
1941     assert(getRef(myData,offset,0)==6);
1942     assert(getRef(myData,offset,1)==7);
1943     assert(getRef(myData,offset,2)==8);
1944    
1945 jgs 506 // use a non-existent tag so we get a pointer to
1946     // the first element of the data array
1947     double* sampleData=myData.getSampleDataByTag(9);
1948     for (int i=0; i<myData.getLength(); i++) {
1949     if (i<3) {
1950     assert(sampleData[i]==i);
1951 jgs 508 } else if ((i>=3) && (i<6)) {
1952 jgs 506 assert(sampleData[i]==i-2);
1953 jgs 508 } else if ((i>=6) && (i<9)) {
1954 jgs 506 assert(sampleData[i]==i-4);
1955 jgs 508 } else if ((i>=9) && (i<12)) {
1956 jgs 506 assert(sampleData[i]==i-6);
1957 jgs 508 } else if ((i>=12) && (i<15)) {
1958 jgs 506 assert(sampleData[i]==i-8);
1959 jgs 508 } else if ((i>=15) && (i<18)) {
1960 jgs 506 assert(sampleData[i]==i-10);
1961 jgs 508 } else {
1962 jgs 506 assert(sampleData[i]==i-12);
1963     }
1964     }
1965    
1966 jgs 501 }
1967    
1968     }
1969    
1970 jgs 502 void DataTaggedTestCase::testSetTaggedValue() {
1971    
1972     cout << endl;
1973    
1974     {
1975    
1976     cout << "\tTest setting key in DataTagged with three tags." << endl;
1977    
1978     DataTagged::TagListType keys;
1979     keys.push_back(1);
1980     keys.push_back(2);
1981     keys.push_back(3);
1982    
1983 jfenwick 1747 DataTagged::ValueBatchType values;
1984 jgs 502
1985 jfenwick 1697 DataTypes::ShapeType viewShape;
1986 jgs 502 viewShape.push_back(3);
1987    
1988     // default value
1989 jfenwick 1747 DataTypes::ValueType viewData(3*4);
1990 jgs 502 for (int i=0;i<viewShape[0];i++) {
1991     viewData[i]=i;
1992     }
1993 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
1994 jgs 502
1995     // value for tag "1"
1996 jfenwick 1747 // DataTypes::ValueType eOneData(viewData);
1997     // DataArrayView eOneView(eOneData, viewShape);
1998     for (int i=0;i<viewShape[0];i++) {
1999     viewData[viewShape[0]+i]=i+1.0;
2000 jgs 502 }
2001 jfenwick 1747 // values.push_back(eOneView);
2002 jgs 502
2003     // value for tag "2"
2004 jfenwick 1747 // DataTypes::ValueType eTwoData(viewData);
2005     // DataArrayView eTwoView(eTwoData, viewShape);
2006     for (int i=0;i<viewShape[0];i++) {
2007     // eTwoView(i)=i+2.0;
2008     viewData[2*viewShape[0]+i]=i+2.0;
2009 jgs 502 }
2010 jfenwick 1747 // values.push_back(eTwoView);
2011 jgs 502
2012     // value for tag "3"
2013 jfenwick 1747 // DataTypes::ValueType eThreeData(viewData);
2014     // DataArrayView eThreeView(eThreeData, viewShape);
2015     for (int i=0;i<viewShape[0];i++) {
2016     // eThreeView(i)=i+3.0;
2017     viewData[3*viewShape[0]+i]=i+3.0;
2018 jgs 502 }
2019 jfenwick 1747 // values.push_back(eThreeView);
2020 jgs 502
2021 jfenwick 1747 DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
2022 jgs 502
2023     // new value for tag "2"
2024 jfenwick 1747 ValueType tmp(viewShape[0]);
2025     for (int i=0;i<viewShape[0];i++) {
2026     tmp[i]=i+5.0;
2027 jgs 502 }
2028    
2029 jfenwick 1747 myData.setTaggedValue(2,viewShape,tmp);
2030 jgs 502
2031     assert(myData.isCurrentTag(2));
2032    
2033     assert(myData.getTagLookup().size()==3);
2034    
2035     assert(myData.getLength()==12);
2036    
2037 jfenwick 1747 assert(myData.getRank()==1);
2038     assert(myData.getNoValues()==3);
2039     assert(myData.getShape().size()==1);
2040     // DataArrayView myDataView = myData.getDataPointByTag(2);
2041     int offset=myData.getOffsetForTag(2);
2042     assert(offset==6);
2043     assert(getRef(myData,offset,0)==5);
2044     assert(getRef(myData,offset,1)==6);
2045     assert(getRef(myData,offset,2)==7);
2046    
2047 jgs 506 // use a non-existent tag so we get a pointer to
2048     // the first element of the data array
2049     double* sampleData=myData.getSampleDataByTag(9);
2050     for (int i=0; i<myData.getLength(); i++) {
2051     if (i<3) {
2052     assert(sampleData[i]==i);
2053 jgs 508 } else if ((i>=3) && (i<6)) {
2054 jgs 506 assert(sampleData[i]==i-2);
2055 jgs 508 } else if ((i>=6) && (i<9)) {
2056 jgs 506 assert(sampleData[i]==i-1);
2057 jgs 508 } else {
2058 jgs 506 assert(sampleData[i]==i-6);
2059     }
2060     }
2061    
2062 jgs 502 }
2063    
2064     }
2065    
2066 jgs 82 void DataTaggedTestCase::testAll() {
2067 jgs 121
2068 jgs 82 cout << endl;
2069 jgs 121
2070 jgs 82 {
2071 jgs 497
2072     cout << "\tTest default DataTagged." << endl;
2073 jgs 82 DataTagged myData;
2074 jgs 497
2075 jgs 499 //cout << myData.toString() << endl;
2076    
2077 jgs 497 assert(myData.getNumSamples()==1);
2078 jgs 82 assert(myData.getNumDPPSample()==1);
2079 jgs 497
2080     assert(myData.validSamplePointNo(0));
2081     assert(myData.validSampleNo(0));
2082     assert(!myData.validSamplePointNo(1));
2083     assert(!myData.validSampleNo(1));
2084    
2085 jgs 501 // data-point 0 has tag number 1 by default
2086 jgs 497 assert(myData.getTagNumber(0)==1);
2087    
2088     assert(!myData.isCurrentTag(1));
2089    
2090     assert(myData.getTagLookup().size()==0);
2091    
2092     assert(myData.getLength()==1);
2093    
2094     assert(myData.getPointOffset(0,0)==0);
2095    
2096 jfenwick 1747 assert(myData.getRank()==0);
2097     assert(myData.getNoValues()==1);
2098     assert(myData.getShape().size()==0);
2099 jgs 497
2100 jfenwick 1747
2101     // DataArrayView myDataView = myData.getDataPoint(0,0);
2102     int offset=myData.getPointOffset(0,0);
2103     assert(offset==0);
2104     assert(myData.getDataAtOffset(offset)==0.0);
2105    
2106 jgs 499 // Test non-existent tag returns the default value.
2107 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
2108     offset=myData.getOffsetForTag(1);
2109     assert(offset==0);
2110     assert(myData.getDataAtOffset(offset)==0.0);
2111 jgs 497
2112 jfenwick 1747 // myDataView = myData.getDefaultValue();
2113     offset=myData.getDefaultOffset();
2114     assert(offset==0);
2115     assert(myData.getDataAtOffset(offset)==0.0);
2116 jgs 497
2117 jgs 506 // use a non-existent tag so we get a pointer to
2118     // the first element of the data array
2119     double* sampleData=myData.getSampleDataByTag(9);
2120     for (int i=0; i<myData.getLength(); i++) {
2121     assert(sampleData[i]==i);
2122     }
2123 jgs 510 sampleData=myData.getSampleData(0);
2124 jfenwick 1747 for (int i=0; i<myData.getNoValues(); i++) {
2125 jgs 510 assert(sampleData[i]==i);
2126     }
2127 jgs 506
2128 jgs 82 }
2129 jgs 497
2130 jgs 82 {
2131 jgs 497
2132 jgs 499 cout << "\tTest DataTagged with default value only." << endl;
2133    
2134 jfenwick 1697 DataTypes::ShapeType viewShape;
2135 jgs 499 viewShape.push_back(3);
2136    
2137     DataTagged::TagListType keys;
2138    
2139 jfenwick 1747 DataTagged::ValueBatchType values;
2140 jgs 499
2141 jfenwick 1697 DataTypes::ValueType viewData(3);
2142 jgs 499 for (int i=0;i<viewShape[0];i++) {
2143     viewData[i]=i;
2144     }
2145 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
2146     DataTagged myData(FunctionSpace(),viewShape, viewData);
2147 jgs 499 //cout << myData.toString() << endl;
2148    
2149     assert(myData.getNumSamples()==1);
2150     assert(myData.getNumDPPSample()==1);
2151    
2152     assert(myData.validSamplePointNo(0));
2153     assert(myData.validSampleNo(0));
2154     assert(!myData.validSamplePointNo(1));
2155     assert(!myData.validSampleNo(1));
2156    
2157 jgs 501 // data-point 0 has tag number 1 by default
2158 jgs 499 assert(myData.getTagNumber(0)==1);
2159    
2160     assert(!myData.isCurrentTag(1));
2161    
2162     assert(myData.getTagLookup().size()==0);
2163    
2164     assert(myData.getLength()==3);
2165    
2166     assert(myData.getPointOffset(0,0)==0);
2167    
2168 jfenwick 1747 assert(myData.getRank()==1);
2169     assert(myData.getNoValues()==3);
2170     assert(myData.getShape().size()==1);
2171 jgs 499
2172 jfenwick 1747 // DataArrayView myDataView = myData.getDataPoint(0,0);
2173     int offset=myData.getPointOffset(0,0);
2174     assert(offset==0);
2175     assert(getRef(myData,offset,0)==0);
2176     assert(getRef(myData,offset,1)==1);
2177     assert(getRef(myData,offset,2)==2);
2178    
2179 jgs 499 // Test non-existent tag returns the default value.
2180 jfenwick 1747 // myDataView = myData.getDataPointByTag(1);
2181     offset=myData.getOffsetForTag(1);
2182     assert(offset==0);
2183     assert(getRef(myData,offset,0)==0);
2184     assert(getRef(myData,offset,1)==1);
2185     assert(getRef(myData,offset,2)==2);
2186 jgs 499
2187 jfenwick 1747 // myDataView = myData.getDefaultValue();
2188     offset=myData.getDefaultOffset();
2189     assert(offset==0);
2190     assert(getRef(myData,offset,0)==0);
2191     assert(getRef(myData,offset,1)==1);
2192     assert(getRef(myData,offset,2)==2);
2193 jgs 499
2194 jgs 506 // use a non-existent tag so we get a pointer to
2195     // the first element of the data array
2196     double* sampleData=myData.getSampleDataByTag(9);
2197     for (int i=0; i<myData.getLength(); i++) {
2198     assert(sampleData[i]==i);
2199     }
2200 jgs 510 sampleData=myData.getSampleDataByTag(0);
2201 jfenwick 1747 for (int i=0; i<myData.getNoValues(); i++) {
2202 jgs 510 assert(sampleData[i]==i);
2203     }
2204 jgs 506
2205 jgs 82 }
2206 jgs 497
2207 jgs 82 {
2208 jgs 497
2209 jgs 499 cout << "\tTest DataTagged with one tag." << endl;
2210    
2211     // the one data-point has tag value "1"
2212    
2213     DataTagged::TagListType keys;
2214     keys.push_back(1);
2215    
2216 jfenwick 1747 DataTagged::ValueBatchType values;
2217 jgs 499
2218 jfenwick 1697 DataTypes::ShapeType viewShape;
2219 jgs 499 viewShape.push_back(3);
2220    
2221     // default value
2222 jfenwick 1747 DataTypes::ValueType viewData(3*2);
2223 jgs 499 for (int i=0;i<viewShape[0];i++) {
2224     viewData[i]=i;
2225     }
2226 jfenwick 1747 // DataArrayView myView(viewData,viewShape);
2227 jgs 499
2228     // value for tag "1"
2229 jfenwick 1747 // DataTypes::ValueType eOneData(viewData);
2230     // DataArrayView eOneView(eOneData, viewShape);
2231     for (int i=0;i<viewShape[0];i++) {
2232     // eOneView(i)=i+1.0;
2233     viewData[viewShape[0]+i]=i+1.0;
2234 jgs 499 }
2235 jfenwick 1747 // values.push_back(eOneView);
2236 jfenwick 1751 DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
2237 jgs 499
2238     //cout << myData.toString() << endl;
2239    
2240     assert(myData.getNumSamples()==1);
2241     assert(myData.getNumDPPSample()==1);
2242    
2243     assert(myData.validSamplePointNo(0));
2244     assert(myData.validSampleNo(0));
2245     assert(!myData.validSamplePointNo(1));
2246     assert(!myData.validSampleNo(1));
2247    
2248 jgs 501 // data-point 0 has tag number 1 by default
2249 jgs 499 assert(myData.getTagNumber(0)==1);
2250    
2251     assert(!myData.isCurrentTag(0));
2252     assert(myData.isCurrentTag(1));