Intrepid
test_01.cpp
1 // @HEADER
2 // ************************************************************************
3 //
4 // Intrepid Package
5 // Copyright (2007) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Pavel Bochev (pbboche@sandia.gov)
38 // Denis Ridzal (dridzal@sandia.gov), or
39 // Kara Peterson (kjpeter@sandia.gov)
40 //
41 // ************************************************************************
42 // @HEADER
43 
44 
50 #include "Intrepid_FieldContainer.hpp"
51 #include "Teuchos_oblackholestream.hpp"
52 #include "Teuchos_RCP.hpp"
53 #include "Teuchos_GlobalMPISession.hpp"
54 
55 
56 using namespace Intrepid;
57 
58 int main(int argc, char *argv[]) {
59 
60  Teuchos::GlobalMPISession mpiSession(&argc, &argv);
61 
62  // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
63  int iprint = argc - 1;
64 
65  Teuchos::RCP<std::ostream> outStream;
66  Teuchos::oblackholestream bhs; // outputs nothing
67 
68  if (iprint > 0)
69  outStream = Teuchos::rcp(&std::cout, false);
70  else
71  outStream = Teuchos::rcp(&bhs, false);
72 
73  // Save the format state of the original std::cout.
74  Teuchos::oblackholestream oldFormatState;
75  oldFormatState.copyfmt(std::cout);
76 
77  *outStream \
78  << "===============================================================================\n" \
79  << "| |\n" \
80  << "| Unit Test FieldContainer |\n" \
81  << "| |\n" \
82  << "| 1) Value accesss by multi-index and enumeration, setting values |\n" \
83  << "| |\n" \
84  << "| Questions? Contact Pavel Bochev (pbboche@sandia.gov) or |\n" \
85  << "| Denis Ridzal (dridzal@sandia.gov). |\n" \
86  << "| |\n" \
87  << "| Intrepid's website: http://trilinos.sandia.gov/packages/intrepid |\n" \
88  << "| Trilinos website: http://trilinos.sandia.gov |\n" \
89  << "| |\n" \
90  << "===============================================================================\n";
91 
92  int errorFlag = 0;
93 
94  // Define variables to construct and use FieldContainer:
95  Teuchos::Array<double> dataArray;
96  Teuchos::Array<int> dimension;
97  Teuchos::Array<int> multiIndex;
98  int dim0, dim1, dim2, dim3, dim4;
99  int containerSize;
100  int containerRank;
101  int dataSize;
102  int counter;
103 
104 
105  *outStream \
106  << "\n"
107  << "===============================================================================\n"\
108  << "| TEST 1: Rank-1 FieldContainer |\n"\
109  << "===============================================================================\n";
110 
111  // Adjust for rank-1 containers
112  dimension.resize(1);
113  multiIndex.resize(1);
114  dim0 = 267;
115 
116  // Set dimensions
117  dimension[0] = dim0;
118 
119  // Define Teuchos::Array with dimension equal to FieldContainer capacity (determined from dimension)
120  dataSize = dimension[0];
121  dataArray.resize(dataSize);
122 
123  // Fill with data
124  counter = 0;
125  for(int i=0; i < dimension[0]; i++){
126  dataArray[counter] = (double)counter;
127  counter++;
128  }
129 
130  *outStream \
131  << "\n"
132  << "===============================================================================\n"\
133  << "| TEST 1-a: Compare constructors with array and list of dimensions |\n"\
134  << "===============================================================================\n";
135  try{
136 
137  // Using ctor with array of dimensions and array of data
138  FieldContainer<double> rank1Container(dimension, dataArray);
139 
140  // Using ctor with list of dimensions and no data
141  FieldContainer<double> rank1ContainerAlt(dim0);
142 
143  // Initialize variables
144  containerSize = rank1Container.size();
145  containerRank = rank1Container.rank();
146  multiIndex.resize(containerRank);
147 
148  if( rank1Container.size() != rank1ContainerAlt.size() ) {
149  errorFlag++;
150  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
151  *outStream << " Size using ctor with array of dimensions = " << rank1Container.size() << "\n";
152  *outStream << " Size using ctor with list of dimensions = " << rank1ContainerAlt.size() << "\n";
153  }
154 
155  if( rank1Container.rank() != rank1ContainerAlt.rank() ) {
156  errorFlag++;
157  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
158  *outStream << " Rank using ctor with array of dimensions = " << rank1Container.rank() << "\n";
159  *outStream << " Rank using ctor with list of dimensions = " << rank1ContainerAlt.rank() << "\n";
160  }
161 
162  for(int dim = 0; dim < rank1Container.rank(); dim ++ ) {
163  if( rank1Container.dimension(dim) != rank1ContainerAlt.dimension(dim) ) {
164  errorFlag++;
165  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
166  *outStream << " Dimension " << dim << " using ctor with array of dimensions = " << rank1Container.dimension(dim) << "\n";
167  *outStream << " Dimension " << dim << " using ctor with list of dimensions = " << rank1ContainerAlt.dimension(dim) << "\n";
168  }
169  }
170 
171  *outStream \
172  << "\n"
173  << "===============================================================================\n"\
174  << "| TEST 1-b: Access by enumeration, multi-index array and multi-index list |\n"\
175  << "===============================================================================\n";
176 
177  // Loop over container by enumeration
178  for(int enumeration = 0; enumeration < containerSize; enumeration++) {
179  int i0;
180 
181  // Convert enumeration to multi-index array and multi-index list and compare values
182  rank1Container.getMultiIndex(multiIndex, enumeration);
183  rank1Container.getMultiIndex(i0, enumeration);
184  if( (multiIndex[0] != i0) ) {
185  errorFlag++;
186  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
187  *outStream << " Multi-index as array = ["
188  << multiIndex[0] << "]\n";
189  *outStream << " Multi-index as list = (" << i0 << ")\n";
190  }
191 
192  // Check if access by enumeration gives the same value as access by multi-index array
193  if( rank1Container[enumeration] != rank1Container.getValue(multiIndex) ) {
194  errorFlag++;
195  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
196  *outStream << " Value by enumeration = " << rank1Container[enumeration] << "\n";
197  *outStream << " Value by multi-index array = " << rank1Container.getValue(multiIndex) << "\n";
198  }
199 
200  // Check if access by multi-index list gives the same value as access by multi-index array
201  if( rank1Container(i0) != rank1Container.getValue(multiIndex) ) {
202  errorFlag++;
203  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
204  *outStream << " Value by multi-index list = " << rank1Container(i0) << "\n";
205  *outStream << " Value by multi-index array = " << rank1Container.getValue(multiIndex) << "\n";
206  }
207 
208  // Check if access by multi-index list gives the same value as access by [] (only for rank-1!)
209  if( rank1Container(i0) != rank1Container[i0] ) {
210  errorFlag++;
211  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
212  *outStream << " Value by multi-index list = " << rank1Container(i0) << "\n";
213  *outStream << " Value by overloaded [] = " << rank1Container[i0] << "\n";
214  }
215  }
216 
217  *outStream \
218  << "\n"
219  << "===============================================================================\n"\
220  << "| TEST 1-c: Access by multi-index array and list & compare with data array |\n"\
221  << "===============================================================================\n";
222 
223  // Loop over container by multi-index
224  for(int i=0; i < dimension[0]; i++){
225  multiIndex[0] = i;
226 
227  // Method that takes array of multi-indices
228  int enumeration = rank1Container.getEnumeration(multiIndex);
229 
230  // Compare with method that takes a list of multi-indices
231  if( enumeration != rank1Container.getEnumeration(i) ) {
232  errorFlag++;
233  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
234  *outStream << " Enumeration from multi-index array = " << enumeration << "\n";
235  *outStream << " Enumeration from multi-index list = " << rank1Container.getEnumeration(i) << "\n";
236  }
237 
238  // Check if access by multi-index array matches values in original dataArray
239  if(dataArray[enumeration] != rank1Container.getValue(multiIndex)) {
240  errorFlag++;
241  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
242  *outStream << " Value by multi-index array = " << rank1Container.getValue(multiIndex) << "\n";
243  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
244  }
245 
246  // Check if access by multi-index list matches values in original dataArray
247  if(dataArray[enumeration] != rank1Container(i)) {
248  errorFlag++;
249  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
250  *outStream << " Value by multi-index list = " << rank1Container(i) << "\n";
251  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
252  }
253 
254  // Check if access by multi-index array matches access by multi-index list
255  if( rank1Container(i) != rank1Container.getValue(multiIndex)) {
256  errorFlag++;
257  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
258  *outStream << " Value by multi-index array = " << rank1Container.getValue(multiIndex) << "\n";
259  *outStream << " Value by multi-index list = " << rank1Container(i) << "\n";
260  }
261  }
262 
263  *outStream \
264  << "\n"
265  << "===============================================================================\n"\
266  << "| TEST 1-d: Store zeroes and empty container |\n"\
267  << "===============================================================================\n";
268 
269  rank1Container.initialize();
270  double sum = 0.0;
271  for (int i=0; i<rank1Container.size(); i++) {
272  sum += rank1Container[i];
273  }
274  if( (sum != 0.0) ) {
275  errorFlag++;
276  *outStream << " Container size = " << rank1Container.size() << "\n";
277  *outStream << " Container rank = " << rank1Container.rank() << "\n";
278  }
279 
280  rank1Container.clear();
281  if( !(rank1Container.size() == 0 && rank1Container.rank() == 0)) {
282  errorFlag++;
283  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
284  *outStream << " Container size = " << rank1Container.size() << "\n";
285  *outStream << " Container rank = " << rank1Container.rank() << "\n";
286  }
287  } //try
288 
289  catch (const std::logic_error & err) {
290  *outStream << err.what() << "\n";
291  errorFlag = -1000;
292  };
293 
294 
295  *outStream \
296  << "\n"
297  << "===============================================================================\n"\
298  << "| TEST 2: Rank-2 FieldContainer |\n"\
299  << "===============================================================================\n";
300 
301  // Adjust for rank-2 containers
302  dimension.resize(2);
303  multiIndex.resize(2);
304  dim0 = 1;
305  dim1 = 55;
306 
307  // Set dimensions
308  dimension[0] = dim0;
309  dimension[1] = dim1;
310 
311  // Define Teuchos::Array with dimension equal to FieldContainer capacity (determined from dimension)
312  dataSize = dimension[0];
313  for(int r = 1; r < (int)dimension.size(); r++){
314  dataSize *= dimension[r];
315  }
316  dataArray.resize(dataSize);
317 
318  // Fill with data
319  counter = 0;
320  for(int i=0; i < dimension[0]; i++){
321  for(int j=0; j < dimension[1]; j++){
322  dataArray[counter] = (double)counter;
323  counter++;
324  }
325  }
326 
327  *outStream \
328  << "\n"
329  << "===============================================================================\n"\
330  << "| TEST 2-a: Compare constructors with array and list of dimensions |\n"\
331  << "===============================================================================\n";
332  try{
333 
334  // Using ctor with array of dimensions and array of data
335  FieldContainer<double> rank2Container(dimension, dataArray);
336 
337  // Using ctor with list of dimensions and no data
338  FieldContainer<double> rank2ContainerAlt(dim0, dim1);
339 
340  // Initialize variables
341  containerSize = rank2Container.size();
342  containerRank = rank2Container.rank();
343  multiIndex.resize(containerRank);
344 
345  if( rank2Container.size() != rank2ContainerAlt.size() ) {
346  errorFlag++;
347  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
348  *outStream << " Size using ctor with array of dimensions = " << rank2Container.size() << "\n";
349  *outStream << " Size using ctor with list of dimensions = " << rank2ContainerAlt.size() << "\n";
350  }
351 
352  if( rank2Container.rank() != rank2ContainerAlt.rank() ) {
353  errorFlag++;
354  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
355  *outStream << " Rank using ctor with array of dimensions = " << rank2Container.rank() << "\n";
356  *outStream << " Rank using ctor with list of dimensions = " << rank2ContainerAlt.rank() << "\n";
357  }
358 
359  for(int dim = 0; dim < rank2Container.rank(); dim ++ ) {
360  if( rank2Container.dimension(dim) != rank2ContainerAlt.dimension(dim) ) {
361  errorFlag++;
362  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
363  *outStream << " Dimension " << dim << " using ctor with array of dimensions = " << rank2Container.dimension(dim) << "\n";
364  *outStream << " Dimension " << dim << " using ctor with list of dimensions = " << rank2ContainerAlt.dimension(dim) << "\n";
365  }
366  }
367 
368  *outStream \
369  << "\n"
370  << "===============================================================================\n"\
371  << "| TEST 2-b: Access by enumeration, multi-index array and multi-index list |\n"\
372  << "===============================================================================\n";
373 
374  // Loop over container by enumeration
375  for(int enumeration = 0; enumeration < containerSize; enumeration++) {
376  int i0,i1;
377 
378  // Convert enumeration to multi-index array and multi-index list and compare values
379  rank2Container.getMultiIndex(multiIndex, enumeration);
380  rank2Container.getMultiIndex(i0, i1, enumeration);
381  if( (multiIndex[0] != i0) ||
382  (multiIndex[1] != i1) ) {
383  errorFlag++;
384  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
385  *outStream << " Multi-index as array = ["
386  << multiIndex[0] << multiIndex[1] << "]\n";
387  *outStream << " Multi-index as list = (" << i0 << "," << i1 << ")\n";
388  }
389 
390  // Check if access by enumeration gives the same value as access by multi-index array
391  if( rank2Container[enumeration] != rank2Container.getValue(multiIndex) ) {
392  errorFlag++;
393  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
394  *outStream << " Value by enumeration = " << rank2Container[enumeration] << "\n";
395  *outStream << " Value by multi-index array = " << rank2Container.getValue(multiIndex) << "\n";
396  }
397 
398  // Check if access by multi-index list gives the same value as access by multi-index array
399  if( rank2Container(i0,i1) != rank2Container.getValue(multiIndex) ) {
400  errorFlag++;
401  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
402  *outStream << " Value by multi-index list = " << rank2Container(i0,i1) << "\n";
403  *outStream << " Value by multi-index array = " << rank2Container.getValue(multiIndex) << "\n";
404  }
405  }
406 
407  *outStream \
408  << "\n"
409  << "===============================================================================\n"\
410  << "| TEST 2-c: Access by multi-index array and list & compare with data array |\n"\
411  << "===============================================================================\n";
412 
413  // Loop over container by multi-index
414  for(int i=0; i < dimension[0]; i++){
415  multiIndex[0] = i;
416  for(int j=0; j < dimension[1]; j++){
417  multiIndex[1] = j;
418 
419  // Method that takes array of multi-indices
420  int enumeration = rank2Container.getEnumeration(multiIndex);
421 
422  // Compare with method that takes a list of multi-indices
423  if( enumeration != rank2Container.getEnumeration(i,j) ) {
424  errorFlag++;
425  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
426  *outStream << " Enumeration from multi-index array = " << enumeration << "\n";
427  *outStream << " Enumeration from multi-index list = " << rank2Container.getEnumeration(i,j) << "\n";
428  }
429 
430  // Check if access by multi-index array matches values in original dataArray
431  if(dataArray[enumeration] != rank2Container.getValue(multiIndex)) {
432  errorFlag++;
433  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
434  *outStream << " Value by multi-index array = " << rank2Container.getValue(multiIndex) << "\n";
435  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
436  }
437 
438  // Check if access by multi-index list matches values in original dataArray
439  if(dataArray[enumeration] != rank2Container(i,j)) {
440  errorFlag++;
441  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
442  *outStream << " Value by multi-index list = " << rank2Container(i,j) << "\n";
443  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
444  }
445 
446  // Check if access by multi-index array matches access by multi-index list
447  if( rank2Container(i,j) != rank2Container.getValue(multiIndex)) {
448  errorFlag++;
449  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
450  *outStream << " Value by multi-index array = " << rank2Container.getValue(multiIndex) << "\n";
451  *outStream << " Value by multi-index list = " << rank2Container(i,j) << "\n";
452  }
453  }
454  }
455 
456  *outStream \
457  << "\n"
458  << "===============================================================================\n"\
459  << "| TEST 2-d: Store zeroes and empty container |\n"\
460  << "===============================================================================\n";
461 
462  rank2Container.initialize();
463  double sum = 0.0;
464  for (int i=0; i<rank2Container.size(); i++) {
465  sum += rank2Container[i];
466  }
467  if( (sum != 0.0) ) {
468  errorFlag++;
469  *outStream << " Container size = " << rank2Container.size() << "\n";
470  *outStream << " Container rank = " << rank2Container.rank() << "\n";
471  }
472 
473  rank2Container.clear();
474  if( !(rank2Container.size() == 0 && rank2Container.rank() == 0)) {
475  errorFlag++;
476  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
477  *outStream << " Container size = " << rank2Container.size() << "\n";
478  *outStream << " Container rank = " << rank2Container.rank() << "\n";
479  }
480  } //try
481 
482  catch (const std::logic_error & err) {
483  *outStream << err.what() << "\n";
484  errorFlag = -1000;
485  };
486 
487 
488 
489  *outStream \
490  << "\n"
491  << "===============================================================================\n"\
492  << "| TEST 3: Rank-3 FieldContainer |\n"\
493  << "===============================================================================\n";
494 
495  // Adjust for rank-3 containers
496  dimension.resize(3);
497  multiIndex.resize(3);
498  dim0 = 17;
499  dim1 = 55;
500  dim2 = 10;
501 
502  // Set dimensions
503  dimension[0] = dim0;
504  dimension[1] = dim1;
505  dimension[2] = dim2;
506 
507  // Define Teuchos::Array with dimension equal to FieldContainer capacity (determined from dimension)
508  dataSize = dimension[0];
509  for(int r = 1; r < (int)dimension.size(); r++){
510  dataSize *= dimension[r];
511  }
512  dataArray.resize(dataSize);
513 
514  // Fill with data
515  counter = 0;
516  for(int i=0; i < dimension[0]; i++){
517  for(int j=0; j < dimension[1]; j++){
518  for(int k=0; k < dimension[2]; k++){
519  dataArray[counter] = (double)counter;
520  counter++;
521  }
522  }
523  }
524 
525  *outStream \
526  << "\n"
527  << "===============================================================================\n"\
528  << "| TEST 3-a: Compare constructors with array and list of dimensions |\n"\
529  << "===============================================================================\n";
530  try{
531 
532  // Using ctor with array of dimensions and array of data
533  FieldContainer<double> rank3Container(dimension, dataArray);
534 
535  // Using ctor with list of dimensions and no data
536  FieldContainer<double> rank3ContainerAlt(dim0, dim1, dim2);
537 
538  // Initialize variables
539  containerSize = rank3Container.size();
540  containerRank = rank3Container.rank();
541  multiIndex.resize(containerRank);
542 
543  if( rank3Container.size() != rank3ContainerAlt.size() ) {
544  errorFlag++;
545  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
546  *outStream << " Size using ctor with array of dimensions = " << rank3Container.size() << "\n";
547  *outStream << " Size using ctor with list of dimensions = " << rank3ContainerAlt.size() << "\n";
548  }
549 
550  if( rank3Container.rank() != rank3ContainerAlt.rank() ) {
551  errorFlag++;
552  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
553  *outStream << " Rank using ctor with array of dimensions = " << rank3Container.rank() << "\n";
554  *outStream << " Rank using ctor with list of dimensions = " << rank3ContainerAlt.rank() << "\n";
555  }
556 
557  for(int dim = 0; dim < rank3Container.rank(); dim ++ ) {
558  if( rank3Container.dimension(dim) != rank3ContainerAlt.dimension(dim) ) {
559  errorFlag++;
560  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
561  *outStream << " Dimension " << dim << " using ctor with array of dimensions = " << rank3Container.dimension(dim) << "\n";
562  *outStream << " Dimension " << dim << " using ctor with list of dimensions = " << rank3ContainerAlt.dimension(dim) << "\n";
563  }
564  }
565 
566  *outStream \
567  << "\n"
568  << "===============================================================================\n"\
569  << "| TEST 3-b: Access by enumeration, multi-index array and multi-index list |\n"\
570  << "===============================================================================\n";
571 
572  // Loop over container by enumeration
573  for(int enumeration = 0; enumeration < containerSize; enumeration++) {
574  int i0,i1,i2;
575 
576  // Convert enumeration to multi-index array and multi-index list and compare values
577  rank3Container.getMultiIndex(multiIndex, enumeration);
578  rank3Container.getMultiIndex(i0, i1, i2, enumeration);
579  if( (multiIndex[0] != i0) ||
580  (multiIndex[1] != i1) ||
581  (multiIndex[2] != i2) ) {
582  errorFlag++;
583  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
584  *outStream << " Multi-index as array = ["
585  << multiIndex[0] << multiIndex[1] << multiIndex[2] << "]\n";
586  *outStream << " Multi-index as list = (" << i0 << "," << i1 << "," << i2 << ")\n";
587  }
588 
589  // Check if access by enumeration gives the same value as access by multi-index array
590  if( rank3Container[enumeration] != rank3Container.getValue(multiIndex) ) {
591  errorFlag++;
592  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
593  *outStream << " Value by enumeration = " << rank3Container[enumeration] << "\n";
594  *outStream << " Value by multi-index array = " << rank3Container.getValue(multiIndex) << "\n";
595  }
596 
597  // Check if access by multi-index list gives the same value as access by multi-index array
598  if( rank3Container(i0,i1,i2) != rank3Container.getValue(multiIndex) ) {
599  errorFlag++;
600  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
601  *outStream << " Value by multi-index list = " << rank3Container(i0,i1,i2) << "\n";
602  *outStream << " Value by multi-index array = " << rank3Container.getValue(multiIndex) << "\n";
603  }
604  }
605 
606  *outStream \
607  << "\n"
608  << "===============================================================================\n"\
609  << "| TEST 3-c: Access by multi-index array and list & compare with data array |\n"\
610  << "===============================================================================\n";
611 
612  // Loop over container by multi-index
613  for(int i=0; i < dimension[0]; i++){
614  multiIndex[0] = i;
615  for(int j=0; j < dimension[1]; j++){
616  multiIndex[1] = j;
617  for(int k=0; k < dimension[2]; k++){
618  multiIndex[2] = k;
619 
620  // Method that takes array of multi-indices
621  int enumeration = rank3Container.getEnumeration(multiIndex);
622 
623  // Compare with method that takes a list of multi-indices
624  if( enumeration != rank3Container.getEnumeration(i,j,k) ) {
625  errorFlag++;
626  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
627  *outStream << " Enumeration from multi-index array = " << enumeration << "\n";
628  *outStream << " Enumeration from multi-index list = " << rank3Container.getEnumeration(i,j,k) << "\n";
629  }
630 
631  // Check if access by multi-index array matches values in original dataArray
632  if(dataArray[enumeration] != rank3Container.getValue(multiIndex)) {
633  errorFlag++;
634  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
635  *outStream << " Value by multi-index array = " << rank3Container.getValue(multiIndex) << "\n";
636  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
637  }
638 
639  // Check if access by multi-index list matches values in original dataArray
640  if(dataArray[enumeration] != rank3Container(i,j,k)) {
641  errorFlag++;
642  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
643  *outStream << " Value by multi-index list = " << rank3Container(i,j,k) << "\n";
644  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
645  }
646 
647  // Check if access by multi-index array matches access by multi-index list
648  if( rank3Container(i,j,k) != rank3Container.getValue(multiIndex)) {
649  errorFlag++;
650  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
651  *outStream << " Value by multi-index array = " << rank3Container.getValue(multiIndex) << "\n";
652  *outStream << " Value by multi-index list = " << rank3Container(i,j,k) << "\n";
653  }
654  }
655  }
656  }
657 
658  *outStream \
659  << "\n"
660  << "===============================================================================\n"\
661  << "| TEST 3-d: Store zeroes and empty container |\n"\
662  << "===============================================================================\n";
663 
664  rank3Container.initialize();
665  double sum = 0.0;
666  for (int i=0; i<rank3Container.size(); i++) {
667  sum += rank3Container[i];
668  }
669  if( (sum != 0.0) ) {
670  errorFlag++;
671  *outStream << " Container size = " << rank3Container.size() << "\n";
672  *outStream << " Container rank = " << rank3Container.rank() << "\n";
673  }
674 
675  rank3Container.clear();
676  if( !(rank3Container.size() == 0 && rank3Container.rank() == 0)) {
677  errorFlag++;
678  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
679  *outStream << " Container size = " << rank3Container.size() << "\n";
680  *outStream << " Container rank = " << rank3Container.rank() << "\n";
681  }
682  } //try
683 
684  catch (const std::logic_error & err) {
685  *outStream << err.what() << "\n";
686  errorFlag = -1000;
687  };
688 
689 
690 
691  *outStream \
692  << "\n"
693  << "===============================================================================\n"\
694  << "| TEST 4: Rank-4 FieldContainer |\n"\
695  << "===============================================================================\n";
696 
697  // Adjust for rank-4 containers
698  dimension.resize(4);
699  multiIndex.resize(4);
700  dim0 = 27;
701  dim1 = 4;
702  dim2 = 11;
703  dim3 = 6;
704 
705  // Set dimensions
706  dimension[0] = dim0;
707  dimension[1] = dim1;
708  dimension[2] = dim2;
709  dimension[3] = dim3;
710 
711  // Define Teuchos::Array with dimension equal to FieldContainer capacity (determined from dimension)
712  dataSize = dimension[0];
713  for(int r = 1; r < (int)dimension.size(); r++){
714  dataSize *= dimension[r];
715  }
716  dataArray.resize(dataSize);
717 
718  // Fill with data
719  counter = 0;
720  for(int i=0; i < dimension[0]; i++){
721  for(int j=0; j < dimension[1]; j++){
722  for(int k=0; k < dimension[2]; k++){
723  for(int l = 0; l < dimension[3]; l++){
724  dataArray[counter] = (double)counter;
725  counter++;
726  }
727  }
728  }
729  }
730 
731  *outStream \
732  << "\n"
733  << "===============================================================================\n"\
734  << "| TEST 4-a: Compare constructors with array and list of dimensions |\n"\
735  << "===============================================================================\n";
736  try{
737 
738  // Using ctor with array of dimensions and array of data
739  FieldContainer<double> rank4Container(dimension, dataArray);
740 
741  // Using ctor with list of dimensions and no data
742  FieldContainer<double> rank4ContainerAlt(dim0, dim1, dim2, dim3);
743 
744  // Initialize variables
745  containerSize = rank4Container.size();
746  containerRank = rank4Container.rank();
747  multiIndex.resize(containerRank);
748 
749  if( rank4Container.size() != rank4ContainerAlt.size() ) {
750  errorFlag++;
751  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
752  *outStream << " Size using ctor with array of dimensions = " << rank4Container.size() << "\n";
753  *outStream << " Size using ctor with list of dimensions = " << rank4ContainerAlt.size() << "\n";
754  }
755 
756  if( rank4Container.rank() != rank4ContainerAlt.rank() ) {
757  errorFlag++;
758  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
759  *outStream << " Rank using ctor with array of dimensions = " << rank4Container.rank() << "\n";
760  *outStream << " Rank using ctor with list of dimensions = " << rank4ContainerAlt.rank() << "\n";
761  }
762 
763  for(int dim = 0; dim < rank4Container.rank(); dim ++ ) {
764  if( rank4Container.dimension(dim) != rank4ContainerAlt.dimension(dim) ) {
765  errorFlag++;
766  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
767  *outStream << " Dimension " << dim << " using ctor with array of dimensions = " << rank4Container.dimension(dim) << "\n";
768  *outStream << " Dimension " << dim << " using ctor with list of dimensions = " << rank4ContainerAlt.dimension(dim) << "\n";
769  }
770  }
771 
772  *outStream \
773  << "\n"
774  << "===============================================================================\n"\
775  << "| TEST 4-b: Access by enumeration, multi-index array and multi-index list |\n"\
776  << "===============================================================================\n";
777 
778  // Loop over container by enumeration
779  for(int enumeration = 0; enumeration < containerSize; enumeration++) {
780  int i0,i1,i2,i3;
781 
782  // Convert enumeration to multi-index array and multi-index list and compare values
783  rank4Container.getMultiIndex(multiIndex, enumeration);
784  rank4Container.getMultiIndex(i0, i1, i2, i3, enumeration);
785  if( (multiIndex[0] != i0) ||
786  (multiIndex[1] != i1) ||
787  (multiIndex[2] != i2) ||
788  (multiIndex[3] != i3) ) {
789  errorFlag++;
790  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
791  *outStream << " Multi-index as array = ["
792  << multiIndex[0] << multiIndex[1] << multiIndex[2] << multiIndex[3] << "]\n";
793  *outStream << " Multi-index as list = (" << i0 << "," << i1 << "," << i2 << "," << i3 << ")\n";
794  }
795 
796  // Check if access by enumeration gives the same value as access by multi-index array
797  if( rank4Container[enumeration] != rank4Container.getValue(multiIndex) ) {
798  errorFlag++;
799  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
800  *outStream << " Value by enumeration = " << rank4Container[enumeration] << "\n";
801  *outStream << " Value by multi-index array = " << rank4Container.getValue(multiIndex) << "\n";
802  }
803 
804  // Check if access by multi-index list gives the same value as access by multi-index array
805  if( rank4Container(i0,i1,i2,i3) != rank4Container.getValue(multiIndex) ) {
806  errorFlag++;
807  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
808  *outStream << " Value by multi-index list = " << rank4Container(i0,i1,i2,i3) << "\n";
809  *outStream << " Value by multi-index array = " << rank4Container.getValue(multiIndex) << "\n";
810  }
811  }
812 
813  *outStream \
814  << "\n"
815  << "===============================================================================\n"\
816  << "| TEST 4-c: Access by multi-index array and list & compare with data array |\n"\
817  << "===============================================================================\n";
818 
819  // Loop over container by multi-index
820  for(int i=0; i < dimension[0]; i++){
821  multiIndex[0] = i;
822  for(int j=0; j < dimension[1]; j++){
823  multiIndex[1] = j;
824  for(int k=0; k < dimension[2]; k++){
825  multiIndex[2] = k;
826  for(int l = 0; l < dimension[3]; l++){
827  multiIndex[3] = l;
828 
829  // Method that takes array of multi-indices
830  int enumeration = rank4Container.getEnumeration(multiIndex);
831 
832  // Compare with method that takes a list of multi-indices
833  if( enumeration != rank4Container.getEnumeration(i,j,k,l) ) {
834  errorFlag++;
835  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
836  *outStream << " Enumeration from multi-index array = " << enumeration << "\n";
837  *outStream << " Enumeration from multi-index list = " << rank4Container.getEnumeration(i,j,k,l) << "\n";
838  }
839 
840  // Check if access by multi-index array matches values in original dataArray
841  if(dataArray[enumeration] != rank4Container.getValue(multiIndex)) {
842  errorFlag++;
843  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
844  *outStream << " Value by multi-index array = " << rank4Container.getValue(multiIndex) << "\n";
845  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
846  }
847 
848  // Check if access by multi-index list matches values in original dataArray
849  if(dataArray[enumeration] != rank4Container(i,j,k,l)) {
850  errorFlag++;
851  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
852  *outStream << " Value by multi-index list = " << rank4Container(i,j,k,l) << "\n";
853  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
854  }
855 
856  // Check if access by multi-index array matches access by multi-index list
857  if( rank4Container(i,j,k,l) != rank4Container.getValue(multiIndex)) {
858  errorFlag++;
859  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
860  *outStream << " Value by multi-index array = " << rank4Container.getValue(multiIndex) << "\n";
861  *outStream << " Value by multi-index list = " << rank4Container(i,j,k,l) << "\n";
862  }
863  }
864  }
865  }
866  }
867 
868  *outStream \
869  << "\n"
870  << "===============================================================================\n"\
871  << "| TEST 4-d: Store zeroes and empty container |\n"\
872  << "===============================================================================\n";
873 
874  rank4Container.initialize();
875  double sum = 0.0;
876  for (int i=0; i<rank4Container.size(); i++) {
877  sum += rank4Container[i];
878  }
879  if( (sum != 0.0) ) {
880  errorFlag++;
881  *outStream << " Container size = " << rank4Container.size() << "\n";
882  *outStream << " Container rank = " << rank4Container.rank() << "\n";
883  }
884 
885  rank4Container.clear();
886  if( !(rank4Container.size() == 0 && rank4Container.rank() == 0)) {
887  errorFlag++;
888  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
889  *outStream << " Container size = " << rank4Container.size() << "\n";
890  *outStream << " Container rank = " << rank4Container.rank() << "\n";
891  }
892  } //try
893 
894  catch (const std::logic_error & err) {
895  *outStream << err.what() << "\n";
896  errorFlag = -1000;
897  };
898 
899 
900  *outStream \
901  << "\n"
902  << "===============================================================================\n"\
903  << "| TEST 5: Rank-5 FieldContainer |\n"\
904  << "===============================================================================\n";
905 
906  // Adjust for rank-5 containers
907  dimension.resize(5);
908  multiIndex.resize(5);
909  dim0 = 3;
910  dim1 = 7;
911  dim2 = 11;
912  dim3 = 5;
913  dim4 = 6;
914 
915  // Set dimensions
916  dimension[0] = dim0;
917  dimension[1] = dim1;
918  dimension[2] = dim2;
919  dimension[3] = dim3;
920  dimension[4] = dim4;
921 
922  // Define Teuchos::Array with dimension equal to FieldContainer capacity (determined from dimension)
923  dataSize = dimension[0];
924  for(int r = 1; r < (int)dimension.size(); r++){
925  dataSize *= dimension[r];
926  }
927  dataArray.resize(dataSize);
928 
929  // Fill with data
930  counter = 0;
931  for(int i=0; i < dimension[0]; i++){
932  for(int j=0; j < dimension[1]; j++){
933  for(int k=0; k < dimension[2]; k++){
934  for(int l = 0; l < dimension[3]; l++){
935  for(int m = 0; m < dimension[4]; m++){
936  dataArray[counter] = (double)counter;
937  counter++;
938  }
939  }
940  }
941  }
942  }
943 
944  *outStream \
945  << "\n"
946  << "===============================================================================\n"\
947  << "| TEST 5-a: Compare constructors with array and list of dimensions |\n"\
948  << "===============================================================================\n";
949  try{
950 
951  // Using ctor with array of dimensions and array of data
952  FieldContainer<double> rank5Container(dimension, dataArray);
953 
954  // Using ctor with list of dimensions and no data
955  FieldContainer<double> rank5ContainerAlt(dim0, dim1, dim2, dim3, dim4);
956 
957  // Initialize variables
958  containerSize = rank5Container.size();
959  containerRank = rank5Container.rank();
960  multiIndex.resize(containerRank);
961 
962  if( rank5Container.size() != rank5ContainerAlt.size() ) {
963  errorFlag++;
964  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
965  *outStream << " Size using ctor with array of dimensions = " << rank5Container.size() << "\n";
966  *outStream << " Size using ctor with list of dimensions = " << rank5ContainerAlt.size() << "\n";
967  }
968 
969  if( rank5Container.rank() != rank5ContainerAlt.rank() ) {
970  errorFlag++;
971  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
972  *outStream << " Rank using ctor with array of dimensions = " << rank5Container.rank() << "\n";
973  *outStream << " Rank using ctor with list of dimensions = " << rank5ContainerAlt.rank() << "\n";
974  }
975 
976  for(int dim = 0; dim < rank5Container.rank(); dim ++ ) {
977  if( rank5Container.dimension(dim) != rank5ContainerAlt.dimension(dim) ) {
978  errorFlag++;
979  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
980  *outStream << " Dimension " << dim << " using ctor with array of dimensions = " << rank5Container.dimension(dim) << "\n";
981  *outStream << " Dimension " << dim << " using ctor with list of dimensions = " << rank5ContainerAlt.dimension(dim) << "\n";
982  }
983  }
984 
985  *outStream \
986  << "\n"
987  << "===============================================================================\n"\
988  << "| TEST 5-b: Access by enumeration, multi-index array and multi-index list |\n"\
989  << "===============================================================================\n";
990 
991  // Loop over container by enumeration
992  for(int enumeration = 0; enumeration < containerSize; enumeration++) {
993  int i0,i1,i2,i3,i4;
994 
995  // Convert enumeration to multi-index array and multi-index list and compare values
996  rank5Container.getMultiIndex(multiIndex, enumeration);
997  rank5Container.getMultiIndex(i0, i1, i2, i3, i4, enumeration);
998  if( (multiIndex[0] != i0) ||
999  (multiIndex[1] != i1) ||
1000  (multiIndex[2] != i2) ||
1001  (multiIndex[3] != i3) ||
1002  (multiIndex[4] != i4) ) {
1003  errorFlag++;
1004  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1005  *outStream << " Multi-index as array = ["
1006  << multiIndex[0] << multiIndex[1] << multiIndex[2] << multiIndex[3] << multiIndex[4] << "]\n";
1007  *outStream << " Multi-index as list = (" << i0 << "," << i1 << "," << i2 << "," << i3 << "," << i4 << ")\n";
1008  }
1009 
1010  // Check if access by enumeration gives the same value as access by multi-index array
1011  if( rank5Container[enumeration] != rank5Container.getValue(multiIndex) ) {
1012  errorFlag++;
1013  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1014  *outStream << " Value by enumeration = " << rank5Container[enumeration] << "\n";
1015  *outStream << " Value by multi-index array = " << rank5Container.getValue(multiIndex) << "\n";
1016  }
1017 
1018  // Check if access by multi-index list gives the same value as access by multi-index array
1019  if( rank5Container(i0,i1,i2,i3,i4) != rank5Container.getValue(multiIndex) ) {
1020  errorFlag++;
1021  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1022  *outStream << " Value by multi-index list = " << rank5Container(i0,i1,i2,i3,i4) << "\n";
1023  *outStream << " Value by multi-index array = " << rank5Container.getValue(multiIndex) << "\n";
1024  }
1025  }
1026 
1027  *outStream \
1028  << "\n"
1029  << "===============================================================================\n"\
1030  << "| TEST 5-c: Access by multi-index array and list & compare with data array |\n"\
1031  << "===============================================================================\n";
1032 
1033  // Loop over container by multi-index
1034  for(int i=0; i < dimension[0]; i++){
1035  multiIndex[0] = i;
1036  for(int j=0; j < dimension[1]; j++){
1037  multiIndex[1] = j;
1038  for(int k=0; k < dimension[2]; k++){
1039  multiIndex[2] = k;
1040  for(int l = 0; l < dimension[3]; l++){
1041  multiIndex[3] = l;
1042  for(int m = 0; m < dimension[4]; m++){
1043  multiIndex[4] = m;
1044 
1045  // Method that takes array of multi-indices
1046  int enumeration = rank5Container.getEnumeration(multiIndex);
1047 
1048  // Compare with method that takes a list of multi-indices
1049  if( enumeration != rank5Container.getEnumeration(i,j,k,l,m) ) {
1050  errorFlag++;
1051  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1052  *outStream << " Enumeration from multi-index array = " << enumeration << "\n";
1053  *outStream << " Enumeration from multi-index list = " << rank5Container.getEnumeration(i,j,k,l,m) << "\n";
1054  }
1055 
1056  // Check if access by multi-index array matches values in original dataArray
1057  if(dataArray[enumeration] != rank5Container.getValue(multiIndex)) {
1058  errorFlag++;
1059  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1060  *outStream << " Value by multi-index array = " << rank5Container.getValue(multiIndex) << "\n";
1061  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
1062  }
1063 
1064  // Check if access by multi-index list matches values in original dataArray
1065  if(dataArray[enumeration] != rank5Container(i,j,k,l,m)) {
1066  errorFlag++;
1067  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1068  *outStream << " Value by multi-index list = " << rank5Container(i,j,k,l,m) << "\n";
1069  *outStream << " Value from data array = " << dataArray[enumeration] << "\n";
1070  }
1071 
1072  // Check if access by multi-index array matches access by multi-index list
1073  if( rank5Container(i,j,k,l,m) != rank5Container.getValue(multiIndex)) {
1074  errorFlag++;
1075  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1076  *outStream << " Value by multi-index array = " << rank5Container.getValue(multiIndex) << "\n";
1077  *outStream << " Value by multi-index list = " << rank5Container(i,j,k,l,m) << "\n";
1078  }
1079  }
1080  }
1081  }
1082  }
1083  }
1084 
1085  *outStream \
1086  << "\n"
1087  << "===============================================================================\n"\
1088  << "| TEST 5-d: Store zeroes and empty container |\n"\
1089  << "===============================================================================\n";
1090 
1091  rank5Container.initialize();
1092  double sum = 0.0;
1093  for (int i=0; i<rank5Container.size(); i++) {
1094  sum += rank5Container[i];
1095  }
1096  if( (sum != 0.0) ) {
1097  errorFlag++;
1098  *outStream << " Container size = " << rank5Container.size() << "\n";
1099  *outStream << " Container rank = " << rank5Container.rank() << "\n";
1100  }
1101 
1102  rank5Container.clear();
1103  if( !(rank5Container.size() == 0 && rank5Container.rank() == 0)) {
1104  errorFlag++;
1105  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1106  *outStream << " Container size = " << rank5Container.size() << "\n";
1107  *outStream << " Container rank = " << rank5Container.rank() << "\n";
1108  }
1109  } //try
1110 
1111  catch (const std::logic_error & err) {
1112  *outStream << err.what() << "\n";
1113  errorFlag = -1000;
1114  };
1115 
1116  *outStream \
1117  << "\n"
1118  << "===============================================================================\n"\
1119  << "| TEST 6: Resize container based on another container |\n"\
1120  << "===============================================================================\n";
1121 
1122  try{
1123  FieldContainer<double> myContainer(1,2,3);
1124  FieldContainer<double> hisContainer(5,4,3,2);
1125 
1126  hisContainer.resize(myContainer);
1127  if ( hisContainer.rank() != myContainer.rank() ) {
1128  errorFlag++;
1129  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1130  *outStream << " Rank of target container = " << hisContainer.rank() << "\n";
1131  *outStream << " Rank of argument container = " << myContainer.rank() << "\n";
1132  }
1133 
1134  for(int dim = 0; dim < myContainer.rank(); dim++){
1135  if ( hisContainer.dimension(dim) != myContainer.dimension(dim) ) {
1136  errorFlag++;
1137  *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
1138  *outStream << " Dimension " << dim << " of target container = " << hisContainer.dimension(dim) << "\n";
1139  *outStream << " Dimension " << dim << " of argument container = " << myContainer.dimension(dim) << "\n";
1140  }
1141  }
1142  }// try
1143 
1144  catch (const std::logic_error & err) {
1145  *outStream << err.what() << "\n";
1146  errorFlag = -1000;
1147  };
1148 
1149 
1150 
1151 
1152 
1153 
1154  if (errorFlag != 0)
1155  std::cout << "End Result: TEST FAILED\n";
1156  else
1157  std::cout << "End Result: TEST PASSED\n";
1158 
1159  // reset format state of std::cout
1160  std::cout.copyfmt(oldFormatState);
1161 
1162  return errorFlag;
1163 }
Intrepid_FieldContainer.hpp
Header file for utility class to provide multidimensional containers.
Generated by   doxygen 1.8.5