PlasCom2  1.0
XPACC Multi-physics simluation application
TestPlasCom2.C
Go to the documentation of this file.
1 #include "Testing.H"
2 #include "PlasCom2.H"
3 #include "Simulation.H"
4 #include "RKTestFixtures.H"
5 #include "EulerRHS.H"
6 #include "Stencil.H"
7 #include "PCPPCommUtil.H"
8 #include "PCPPReport.H"
9 #include "PCPPIntervalUtils.H"
10 #include "TestFixtures.H"
11 #include "EulerTestFixtures.H"
12 #include "PC2Util.H"
13 
14 #include <cmath>
15 
16 using pcpp::comm::CheckResult;
17 
18 typedef plascom2::application::domainvector DomainVector;
19 typedef simulation::grid::parallel_blockstructured pbsgrid_t;
20 typedef simulation::state::base state_t;
21 
22 void TestPlasCom2_AcousticPulsePeriodic2D(ix::test::results &parallelUnitResults,
23  pcpp::CommunicatorType &testComm)
24 {
25  bool acousticTestResult = true;
26 
27  int myRank = testComm.Rank();
28  int numProc = testComm.NProc();
29 
30  const std::string testFunctionName("TestPlasCom2_AcousticPulsePeriodic2D");
31  const std::string testSuiteName("InviscidTests");
32  const std::string testCaseName("AcousticPulsePeriodic2D");
33  const std::string testDirectory(testSuiteName+"/"+testCaseName);
34  const std::string originalDirectory(ix::sys::CWD());
35  std::ostringstream compareStream;
36  double errorTolerance = 5e-14;
37 
38  testComm.Barrier();
39  if(myRank == 0)
40  std::cout << "TestFunction: " << testFunctionName << std::endl;
41 
42  int argc = 4;
43  const char *argv[] = {"plascom2x","-c","acousticPulse.config",NULL};
44 
45  int returnValue = 0;
46 
47  pcpp::CommunicatorType pc2Comm(testComm);
48  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
49 
50  if(!ix::sys::FILEEXISTS(testDirectory)){
51  acousticTestResult = false;
52  std::cout << "TestPlasCom2_AcousticPulsePeriodic2D: testing directory ("
53  << testDirectory << ") did not exist. Aborting test."
54  << std::endl;
55  goto endTest;
56  }
57 
58  ix::sys::ChDir(testDirectory);
59  ix::sys::ChDir("PlasCom2");
60  if(myRank == 0)
61  ix::sys::Remove("PlasCom2_000001000.h5");
62 
63  testComm.Barrier();
64 
65  if(myRank == 0)
66  std::cout << "Running PlasCom2..." << std::endl;
67  returnValue = application::ApplicationDriver(simulationApplication);
68  testComm.Barrier();
69  if(myRank == 0)
70  std::cout << "Done running PlasCom2." << std::endl;
71 
72  testComm.Barrier();
73 
74  if(returnValue > 0){
75  std::cout << "TestPlasCom2_AcousticPulsePeriodic2D: PlasCom2 returned error code ("
76  << returnValue << "). Test failed." << std::endl;
77  acousticTestResult = false;
78  goto endTest;
79  }
80 
81  ix::sys::ChDir("../");
82 
83 
84  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
85  std::cout << "TestPlasCom2_AcousticPulsePeriodic2D: PlasCom2 failed to "
86  << "produce expected output file (PlasCom2/PlasCom2_000001000.h5)."
87  << " Test failed." << std::endl;
88  acousticTestResult = false;
89  goto endTest;
90  }
91 
92  testComm.Barrier();
93  if(myRank == 0){
94  std::cout << "Comparing results to expected result...";
95  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
96  "CM/flocm_acousticpulse_1000.h5",
97  errorTolerance,compareStream);
98  if(returnValue == 0)
99  std::cout << "passed." << std::endl;
100  else
101  std::cout << "failed." << std::endl;
102  }
103  testComm.Barrier();
104 
105  if(returnValue > 0){
106  std::cout << "TestPlasCom2_AcousticPulsePeriodic2D: Resulting state "
107  << "comparison yielded negative result:"
108  << std::endl
109  << compareStream.str()
110  << std::endl;
111  acousticTestResult = false;
112  }
113 
114  testComm.Barrier();
115 
116  endTest:
117  {
118  ix::sys::ChDir(originalDirectory);
119  parallelUnitResults.UpdateResult("PlasCom2:Euler:AcousticPulsePeriodic2D",
120  acousticTestResult);
121  }
122 
123  testComm.Barrier();
124  return;
125 }
126 
127 void TestPlasCom2_APRectilinearPeriodic2D(ix::test::results &parallelUnitResults,
128  pcpp::CommunicatorType &testComm)
129 {
130  bool acousticTestResult = true;
131 
132  int myRank = testComm.Rank();
133  int numProc = testComm.NProc();
134 
135  const std::string testFunctionName("TestPlasCom2_APRectilinearPeriodic2D");
136  const std::string testSuiteName("InviscidTests");
137  const std::string testCaseName("AcousticPulsePeriodic2D");
138  const std::string testDirectory(testSuiteName+"/"+testCaseName);
139  const std::string originalDirectory(ix::sys::CWD());
140  std::ostringstream compareStream;
141  double errorTolerance = 5e-14;
142 
143  testComm.Barrier();
144  if(myRank == 0)
145  std::cout << "TestFunction: " << testFunctionName << std::endl;
146 
147  int argc = 4;
148  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};
149 
150  int returnValue = 0;
151 
152  pcpp::CommunicatorType pc2Comm(testComm);
153  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
154 
155  if(!ix::sys::FILEEXISTS(testDirectory)){
156  acousticTestResult = false;
157  std::cout << testFunctionName << ": testing directory ("
158  << testDirectory << ") did not exist. Aborting test."
159  << std::endl;
160  goto endTest;
161  }
162 
163  ix::sys::ChDir(testDirectory);
164  ix::sys::ChDir("PlasCom2");
165 
166  if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
167  ix::sys::Remove("PlasCom2_000001000.h5");
168  }
169 
170  testComm.Barrier();
171  if(myRank == 0)
172  std::cout << "Running PlasCom2..." << std::endl;
173  returnValue = application::ApplicationDriver(simulationApplication);
174  testComm.Barrier();
175  if(myRank == 0)
176  std::cout << "Done running PlasCom2." << std::endl;
177 
178  testComm.Barrier();
179 
180  if(returnValue > 0){
181  std::cout << testFunctionName << ": PlasCom2 returned error code ("
182  << returnValue << "). Test failed." << std::endl;
183  acousticTestResult = false;
184  goto endTest;
185  }
186 
187  ix::sys::ChDir("../");
188 
189 
190  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
191  std::cout << testFunctionName << ": PlasCom2 failed to "
192  << "produce expected output file (PlasCom2/PlasCom2_000001000.h5)."
193  << " Test failed." << std::endl;
194  acousticTestResult = false;
195  goto endTest;
196  }
197 
198  if(myRank == 0){
199  std::cout << "Comparing results to expected result...";
200  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
201  "CM/flocm_acousticpulse_1000.h5",
202  errorTolerance,compareStream);
203  if(returnValue == 0)
204  std::cout << "passed." << std::endl;
205  else
206  std::cout << "failed." << std::endl;
207  }
208 
209  if(returnValue > 0){
210  std::cout << testFunctionName << ": Resulting state "
211  << "comparison yielded negative result:"
212  << std::endl
213  << compareStream.str()
214  << std::endl;
215  acousticTestResult = false;
216  }
217 
218  testComm.Barrier();
219 
220  endTest:
221  {
222  ix::sys::ChDir(originalDirectory);
223  parallelUnitResults.UpdateResult("PlasCom2:Euler:RectilinearPeriodic2D",
224  acousticTestResult);
225  }
226 
227  testComm.Barrier();
228  return;
229 }
230 
231 void TestPlasCom2_APCurvilinearPeriodic2D(ix::test::results &parallelUnitResults,
232  pcpp::CommunicatorType &testComm)
233 {
234  bool acousticTestResult = true;
235 
236  int myRank = testComm.Rank();
237  int numProc = testComm.NProc();
238 
239  const std::string testFunctionName("TestPlasCom2_APCurvilinearPeriodic2D");
240  const std::string testSuiteName("InviscidTests");
241  const std::string testCaseName("AcousticPulsePeriodic2D");
242  const std::string testDirectory(testSuiteName+"/"+testCaseName);
243  const std::string originalDirectory(ix::sys::CWD());
244  std::ostringstream compareStream;
245  double errorTolerance = 5e-14;
246 
247  testComm.Barrier();
248  if(myRank == 0){
249  std::cout << "TestFunction: " << testFunctionName << std::endl;
250  std::cout << "CWD: " << ix::sys::CWD() << std::endl;
251  }
252  int argc = 4;
253  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};
254 
255  int returnValue = 0;
256 
257  pcpp::CommunicatorType pc2Comm(testComm);
258  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
259 
260  if(!ix::sys::FILEEXISTS(testDirectory)){
261  acousticTestResult = false;
262  std::cout << testFunctionName << ": testing directory ("
263  << testDirectory << ") did not exist. Aborting test."
264  << std::endl;
265  goto endTest;
266  }
267 
268  ix::sys::ChDir(testDirectory);
269  ix::sys::ChDir("PlasCom2");
270 
271  if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
272  ix::sys::Remove("PlasCom2_000001000.h5");
273  }
274 
275  testComm.Barrier();
276  if(myRank == 0)
277  std::cout << "Running PlasCom2..." << std::endl;
278  returnValue = application::ApplicationDriver(simulationApplication);
279  testComm.Barrier();
280  if(myRank == 0)
281  std::cout << "Done running PlasCom2." << std::endl;
282 
283  testComm.Barrier();
284 
285  if(returnValue > 0){
286  std::cout << testFunctionName << ": PlasCom2 returned error code ("
287  << returnValue << "). Test failed." << std::endl;
288  acousticTestResult = false;
289  goto endTest;
290  }
291 
292  ix::sys::ChDir("../");
293 
294 
295  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
296  std::cout << testFunctionName << ": PlasCom2 failed to "
297  << "produce expected output file (PlasCom2/PlasCom2_000001000.h5)."
298  << " Test failed." << std::endl;
299  acousticTestResult = false;
300  goto endTest;
301  }
302 
303  if(myRank == 0){
304  std::cout << "Comparing results to expected result...";
305  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
306  "CM/flocm_acousticpulse_1000.h5",
307  errorTolerance,compareStream);
308  if(returnValue == 0)
309  std::cout << "passed." << std::endl;
310  else
311  std::cout << "failed." << std::endl;
312  }
313 
314  if(returnValue > 0){
315  std::cout << testFunctionName << ": Resulting state "
316  << "comparison yielded negative result:"
317  << std::endl
318  << compareStream.str()
319  << std::endl;
320  acousticTestResult = false;
321  }
322 
323  testComm.Barrier();
324 
325  endTest:
326  {
327  ix::sys::ChDir(originalDirectory);
328  parallelUnitResults.UpdateResult("PlasCom2:Euler:CurvilinearPeriodic2D",
329  acousticTestResult);
330  }
331 
332  testComm.Barrier();
333  return;
334 }
335 
336 void TestPlasCom2_AcousticPulseFarfield2D(ix::test::results &parallelUnitResults,
337  pcpp::CommunicatorType &testComm)
338 {
339  bool acousticTestResult = true;
340 
341  int myRank = testComm.Rank();
342  int numProc = testComm.NProc();
343 
344  const std::string testFunctionName("TestPlasCom2_AcousticPulseFarfield2D");
345  const std::string testSuiteName("InviscidTests");
346  const std::string testCaseName("AcousticPulseFarfield2D");
347  const std::string testDirectory(testSuiteName+"/"+testCaseName);
348  const std::string originalDirectory(ix::sys::CWD());
349  std::ostringstream compareStream;
350  double errorTolerance = 5e-14;
351 
352  testComm.Barrier();
353  if(myRank == 0)
354  std::cout << "TestFunction: " << testFunctionName << std::endl;
355 
356  int argc = 4;
357  const char *argv[] = {"plascom2x","-c","acousticPulse.config",NULL};
358 
359  int returnValue = 0;
360  pcpp::CommunicatorType pc2Comm(testComm);
361  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
362 
363  if(!ix::sys::FILEEXISTS(testDirectory)){
364  acousticTestResult = false;
365  std::cout << testFunctionName << ": testing directory ("
366  << testDirectory << ") did not exist. Aborting test."
367  << std::endl;
368  goto endTest;
369  }
370 
371  ix::sys::ChDir(testDirectory);
372  ix::sys::ChDir("PlasCom2");
373 
374  if(myRank == 0){
375  if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
376  ix::sys::Remove("PlasCom2_000001000.h5");
377  }
378  }
379 
380  testComm.Barrier();
381  if(myRank == 0)
382  std::cout << "Running PlasCom2..." << std::endl;
383  returnValue = application::ApplicationDriver(simulationApplication);
384  testComm.Barrier();
385  if(myRank == 0)
386  std::cout << "Done running PlasCom2." << std::endl;
387 
388  if(returnValue > 0){
389  std::cout << testFunctionName << ": PlasCom2 returned error code ("
390  << returnValue << "). Test failed." << std::endl;
391  acousticTestResult = false;
392  goto endTest;
393  }
394 
395  ix::sys::ChDir("../");
396 
397 
398  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
399  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
400  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
401  acousticTestResult = false;
402  goto endTest;
403  }
404 
405  if(testComm.Rank() == 0){
406  std::cout << "Comparing results to expected....";
407  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
408  "CM/flocm_acousticpulse_1000.h5",
409  errorTolerance,compareStream);
410  std::cout << (returnValue == 0 ? "passed." : "failed.")
411  << std::endl;
412  }
413 
414  if(returnValue > 0){
415  std::cout << testFunctionName << ": Resulting state comparison "
416  << "yielded negative result:"
417  << std::endl
418  << compareStream.str()
419  << std::endl;
420  acousticTestResult = false;
421  goto endTest;
422  }
423 
424  endTest:
425  {
426  ix::sys::ChDir(originalDirectory);
427  parallelUnitResults.UpdateResult("PlasCom2:Euler:AcousticPulseFarfield2D",
428  acousticTestResult);
429  }
430 
431  testComm.Barrier();
432  return;
433 }
434 
435 void TestPlasCom2_APRectilinearFarfield2D(ix::test::results &parallelUnitResults,
436  pcpp::CommunicatorType &testComm)
437 {
438  bool acousticTestResult = true;
439 
440  int myRank = testComm.Rank();
441  int numProc = testComm.NProc();
442 
443  const std::string testFunctionName("TestPlasCom2_APRectilinearFarfield2D");
444  const std::string testSuiteName("InviscidTests");
445  const std::string testCaseName("AcousticPulseFarfield2D");
446  const std::string testDirectory(testSuiteName+"/"+testCaseName);
447  const std::string originalDirectory(ix::sys::CWD());
448  std::ostringstream compareStream;
449  double errorTolerance = 5e-14;
450 
451  testComm.Barrier();
452  if(myRank == 0)
453  std::cout << "TestFunction: " << testFunctionName << std::endl;
454 
455  int argc = 4;
456  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};
457 
458  int returnValue = 0;
459  pcpp::CommunicatorType pc2Comm(testComm);
460  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
461 
462  if(!ix::sys::FILEEXISTS(testDirectory)){
463  acousticTestResult = false;
464  std::cout << testFunctionName << ": testing directory ("
465  << testDirectory << ") did not exist. Aborting test."
466  << std::endl;
467  goto endTest;
468  }
469 
470  ix::sys::ChDir(testDirectory);
471  ix::sys::ChDir("PlasCom2");
472 
473  if(myRank == 0){
474  if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
475  ix::sys::Remove("PlasCom2_000001000.h5");
476  }
477  }
478 
479  testComm.Barrier();
480  if(myRank == 0)
481  std::cout << "Running PlasCom2..." << std::endl;
482  returnValue = application::ApplicationDriver(simulationApplication);
483  testComm.Barrier();
484  if(myRank == 0)
485  std::cout << "Done running PlasCom2." << std::endl;
486 
487  if(returnValue > 0){
488  std::cout << testFunctionName << ": PlasCom2 returned error code ("
489  << returnValue << "). Test failed." << std::endl;
490  acousticTestResult = false;
491  goto endTest;
492  }
493 
494  ix::sys::ChDir("../");
495 
496 
497  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
498  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
499  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
500  acousticTestResult = false;
501  goto endTest;
502  }
503 
504  if(testComm.Rank() == 0){
505  std::cout << "Comparing results to expected....";
506  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
507  "CM/flocm_acousticpulse_1000.h5",
508  errorTolerance,compareStream);
509  std::cout << (returnValue == 0 ? "passed." : "failed.")
510  << std::endl;
511  }
512 
513  if(returnValue > 0){
514  std::cout << testFunctionName << ": Resulting state comparison "
515  << "yielded negative result:"
516  << std::endl
517  << compareStream.str()
518  << std::endl;
519  acousticTestResult = false;
520  goto endTest;
521  }
522 
523  endTest:
524  {
525  ix::sys::ChDir(originalDirectory);
526  parallelUnitResults.UpdateResult("PlasCom2:Euler:RectilinearFarfield2D",
527  acousticTestResult);
528  }
529 
530  testComm.Barrier();
531  return;
532 }
533 
534 void TestPlasCom2_APCurvilinearFarfield2D(ix::test::results &parallelUnitResults,
535  pcpp::CommunicatorType &testComm)
536 {
537  bool acousticTestResult = true;
538 
539  int myRank = testComm.Rank();
540  int numProc = testComm.NProc();
541 
542  const std::string testFunctionName("TestPlasCom2_APCurvilinearFarfield2D");
543  const std::string testSuiteName("InviscidTests");
544  const std::string testCaseName("AcousticPulseFarfield2D");
545  const std::string testDirectory(testSuiteName+"/"+testCaseName);
546  const std::string originalDirectory(ix::sys::CWD());
547  std::ostringstream compareStream;
548  double errorTolerance = 5e-14;
549 
550  testComm.Barrier();
551  if(myRank == 0)
552  std::cout << "TestFunction: " << testFunctionName << std::endl;
553 
554  int argc = 4;
555  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};
556 
557  int returnValue = 0;
558  pcpp::CommunicatorType pc2Comm(testComm);
559  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
560 
561  if(!ix::sys::FILEEXISTS(testDirectory)){
562  acousticTestResult = false;
563  std::cout << testFunctionName << ": testing directory ("
564  << testDirectory << ") did not exist. Aborting test."
565  << std::endl;
566  goto endTest;
567  }
568 
569  ix::sys::ChDir(testDirectory);
570  ix::sys::ChDir("PlasCom2");
571 
572  if(myRank == 0) {
573  if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
574  ix::sys::Remove("PlasCom2_000001000.h5");
575  }
576  }
577 
578  testComm.Barrier();
579  if(myRank == 0)
580  std::cout << "Running PlasCom2..." << std::endl;
581  returnValue = application::ApplicationDriver(simulationApplication);
582  testComm.Barrier();
583  if(myRank == 0)
584  std::cout << "Done running PlasCom2." << std::endl;
585 
586  if(returnValue > 0){
587  std::cout << testFunctionName << ": PlasCom2 returned error code ("
588  << returnValue << "). Test failed." << std::endl;
589  acousticTestResult = false;
590  goto endTest;
591  }
592 
593  ix::sys::ChDir("../");
594 
595 
596  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
597  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
598  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
599  acousticTestResult = false;
600  goto endTest;
601  }
602 
603  if(testComm.Rank() == 0){
604  std::cout << "Comparing results to expected....";
605  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
606  "CM/flocm_acousticpulse_1000.h5",
607  errorTolerance,compareStream);
608  std::cout << (returnValue == 0 ? "passed." : "failed.")
609  << std::endl;
610  }
611 
612  if(returnValue > 0){
613  std::cout << testFunctionName << ": Resulting state comparison "
614  << "yielded negative result:"
615  << std::endl
616  << compareStream.str()
617  << std::endl;
618  acousticTestResult = false;
619  goto endTest;
620  }
621 
622  endTest:
623  {
624  ix::sys::ChDir(originalDirectory);
625  parallelUnitResults.UpdateResult("PlasCom2:Euler:CurvilinearFarfield2D",
626  acousticTestResult);
627  }
628 
629  testComm.Barrier();
630  return;
631 }
632 
633 void TestPlasCom2_AcousticPulseFarfield3D(ix::test::results &parallelUnitResults,
634  pcpp::CommunicatorType &testComm)
635 {
636  bool acousticTestResult = true;
637 
638  int myRank = testComm.Rank();
639  int numProc = testComm.NProc();
640 
641  const std::string testFunctionName("TestPlasCom2_AcousticPulseFarfield3D");
642  const std::string testSuiteName("InviscidTests");
643  const std::string testCaseName("AcousticPulseFarfield3D");
644  const std::string testDirectory(testSuiteName+"/"+testCaseName);
645  const std::string originalDirectory(ix::sys::CWD());
646  std::ostringstream compareStream;
647  double errorTolerance = 5e-14;
648 
649  testComm.Barrier();
650  if(myRank == 0)
651  std::cout << "TestFunction: " << testFunctionName << std::endl;
652 
653  int argc = 4;
654  const char *argv[] = {"plascom2x","-c","acousticPulse.config",NULL};
655 
656  int returnValue = 0;
657  pcpp::CommunicatorType pc2Comm(testComm);
658  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
659 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
660 // testComm.Comm());
661 
662  if(!ix::sys::FILEEXISTS(testDirectory)){
663  acousticTestResult = false;
664  std::cout << testFunctionName << ": testing directory ("
665  << testDirectory << ") did not exist. Aborting test."
666  << std::endl;
667  goto endTest;
668  }
669 
670  ix::sys::ChDir(testDirectory);
671  ix::sys::ChDir("PlasCom2");
672 
673  if(myRank == 0){
674  if(ix::sys::FILEEXISTS("PlasCom2_000000005.h5")){
675  ix::sys::Remove("PlasCom2_000000005.h5");
676  }
677  }
678 
679  testComm.Barrier();
680  if(myRank == 0)
681  std::cout << "Running PlasCom2..." << std::endl;
682  returnValue = application::ApplicationDriver(simulationApplication);
683  testComm.Barrier();
684  if(myRank == 0)
685  std::cout << "Done running PlasCom2." << std::endl;
686 
687  if(returnValue > 0){
688  std::cout << testFunctionName << ": PlasCom2 returned error code ("
689  << returnValue << "). Test failed." << std::endl;
690  acousticTestResult = false;
691  goto endTest;
692  }
693 
694  ix::sys::ChDir("../");
695 
696 
697  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000005.h5")){
698  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
699  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
700  acousticTestResult = false;
701  goto endTest;
702  }
703 
704  if(testComm.Rank() == 0){
705  std::cout << "Comparing results to expected....";
706 
707  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000005.h5",
708  "CM/flocm_acousticpulse_5.h5",
709  errorTolerance,compareStream);
710 
711  std::cout << (returnValue == 0 ? "passed." : "failed.")
712  << std::endl;
713  }
714  if(returnValue != 0){
715  std::cout << testFunctionName << ": Resulting state comparison "
716  << "yielded negative result:"
717  << std::endl
718  << compareStream.str()
719  << std::endl;
720  acousticTestResult = false;
721  goto endTest;
722  }
723 
724  endTest:
725  {
726  ix::sys::ChDir(originalDirectory);
727  parallelUnitResults.UpdateResult("PlasCom2:Euler:AcousticPulseFarfield3D",
728  acousticTestResult);
729  }
730 
731  testComm.Barrier();
732  return;
733 }
734 
735 void TestPlasCom2_APRectilinearFarfield3D(ix::test::results &parallelUnitResults,
736  pcpp::CommunicatorType &testComm)
737 {
738  bool acousticTestResult = true;
739 
740  int myRank = testComm.Rank();
741  int numProc = testComm.NProc();
742 
743  const std::string testFunctionName("TestPlasCom2_APRectilinearFarfield3D");
744  const std::string testSuiteName("InviscidTests");
745  const std::string testCaseName("AcousticPulseFarfield3D");
746  const std::string testDirectory(testSuiteName+"/"+testCaseName);
747  const std::string originalDirectory(ix::sys::CWD());
748  std::ostringstream compareStream;
749  double errorTolerance = 5e-14;
750 
751  testComm.Barrier();
752  if(myRank == 0)
753  std::cout << "TestFunction: " << testFunctionName << std::endl;
754 
755  int argc = 4;
756  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};
757 
758  int returnValue = 0;
759  pcpp::CommunicatorType pc2Comm(testComm);
760  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
761 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
762 // testComm.Comm());
763 
764  if(!ix::sys::FILEEXISTS(testDirectory)){
765  acousticTestResult = false;
766  std::cout << testFunctionName << ": testing directory ("
767  << testDirectory << ") did not exist. Aborting test."
768  << std::endl;
769  goto endTest;
770  }
771 
772  ix::sys::ChDir(testDirectory);
773  ix::sys::ChDir("PlasCom2");
774 
775  if(myRank == 0){
776  if(ix::sys::FILEEXISTS("PlasCom2_000000005.h5")){
777  ix::sys::Remove("PlasCom2_000000005.h5");
778  }
779  }
780 
781  testComm.Barrier();
782  if(myRank == 0)
783  std::cout << "Running PlasCom2..." << std::endl;
784  returnValue = application::ApplicationDriver(simulationApplication);
785  testComm.Barrier();
786  if(myRank == 0)
787  std::cout << "Done running PlasCom2." << std::endl;
788 
789  if(returnValue > 0){
790  std::cout << testFunctionName << ": PlasCom2 returned error code ("
791  << returnValue << "). Test failed." << std::endl;
792  acousticTestResult = false;
793  goto endTest;
794  }
795 
796  ix::sys::ChDir("../");
797 
798 
799  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000005.h5")){
800  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
801  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
802  acousticTestResult = false;
803  goto endTest;
804  }
805 
806  if(testComm.Rank() == 0){
807  std::cout << "Comparing results to expected....";
808 
809  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000005.h5",
810  "CM/flocm_acousticpulse_5.h5",
811  errorTolerance,compareStream);
812 
813  std::cout << (returnValue == 0 ? "passed." : "failed.")
814  << std::endl;
815  }
816  if(returnValue != 0){
817  std::cout << testFunctionName << ": Resulting state comparison "
818  << "yielded negative result:"
819  << std::endl
820  << compareStream.str()
821  << std::endl;
822  acousticTestResult = false;
823  goto endTest;
824  }
825 
826  endTest:
827  {
828  ix::sys::ChDir(originalDirectory);
829  parallelUnitResults.UpdateResult("PlasCom2:Euler:RectilinearFarfield3D",
830  acousticTestResult);
831  }
832 
833  testComm.Barrier();
834  return;
835 }
836 
837 void TestPlasCom2_APCurvilinearFarfield3D(ix::test::results &parallelUnitResults,
838  pcpp::CommunicatorType &testComm)
839 {
840  bool acousticTestResult = true;
841 
842  int myRank = testComm.Rank();
843  int numProc = testComm.NProc();
844 
845  const std::string testFunctionName("TestPlasCom2_APCurvilinearFarfield3D");
846  const std::string testSuiteName("InviscidTests");
847  const std::string testCaseName("AcousticPulseFarfield3D");
848  const std::string testDirectory(testSuiteName+"/"+testCaseName);
849  const std::string originalDirectory(ix::sys::CWD());
850  std::ostringstream compareStream;
851  double errorTolerance = 5e-14;
852 
853  testComm.Barrier();
854  if(myRank == 0)
855  std::cout << "TestFunction: " << testFunctionName << std::endl;
856 
857  int argc = 4;
858  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};
859 
860  int returnValue = 0;
861  pcpp::CommunicatorType pc2Comm(testComm);
862  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
863 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
864 // testComm.Comm());
865 
866  if(!ix::sys::FILEEXISTS(testDirectory)){
867  acousticTestResult = false;
868  std::cout << testFunctionName << ": testing directory ("
869  << testDirectory << ") did not exist. Aborting test."
870  << std::endl;
871  goto endTest;
872  }
873 
874  ix::sys::ChDir(testDirectory);
875  ix::sys::ChDir("PlasCom2");
876 
877  if(myRank == 0){
878  if(ix::sys::FILEEXISTS("PlasCom2_000000005.h5")){
879  ix::sys::Remove("PlasCom2_000000005.h5");
880  }
881  }
882 
883  testComm.Barrier();
884  if(myRank == 0)
885  std::cout << "Running PlasCom2..." << std::endl;
886  returnValue = application::ApplicationDriver(simulationApplication);
887  testComm.Barrier();
888  if(myRank == 0)
889  std::cout << "Done running PlasCom2." << std::endl;
890 
891  if(returnValue > 0){
892  std::cout << testFunctionName << ": PlasCom2 returned error code ("
893  << returnValue << "). Test failed." << std::endl;
894  acousticTestResult = false;
895  goto endTest;
896  }
897 
898  ix::sys::ChDir("../");
899 
900 
901  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000005.h5")){
902  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
903  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
904  acousticTestResult = false;
905  goto endTest;
906  }
907 
908  if(testComm.Rank() == 0){
909  std::cout << "Comparing results to expected....";
910 
911  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000005.h5",
912  "CM/flocm_acousticpulse_5.h5",
913  errorTolerance,compareStream);
914 
915  std::cout << (returnValue == 0 ? "passed." : "failed.")
916  << std::endl;
917  }
918  if(returnValue != 0){
919  std::cout << testFunctionName << ": Resulting state comparison "
920  << "yielded negative result:"
921  << std::endl
922  << compareStream.str()
923  << std::endl;
924  acousticTestResult = false;
925  goto endTest;
926  }
927 
928  endTest:
929  {
930  ix::sys::ChDir(originalDirectory);
931  parallelUnitResults.UpdateResult("PlasCom2:Euler:CurvilinearFarfield3D",
932  acousticTestResult);
933  }
934 
935  testComm.Barrier();
936  return;
937 }
938 
939 void TestPlasCom2_AcousticPulseSlipwall2D(ix::test::results &parallelUnitResults,
940  pcpp::CommunicatorType &testComm)
941 {
942  bool acousticTestResult = true;
943 
944  int myRank = testComm.Rank();
945  int numProc = testComm.NProc();
946 
947  const std::string testFunctionName("TestPlasCom2_AcousticPulseSlipWall2D");
948  const std::string testSuiteName("InviscidTests");
949  const std::string testCaseName("AcousticPulseSlipwall2D");
950  const std::string testDirectory(testSuiteName+"/"+testCaseName);
951  const std::string originalDirectory(ix::sys::CWD());
952  std::ostringstream compareStream;
953  double errorTolerance = 5e-14;
954 
955  testComm.Barrier();
956  if(myRank == 0)
957  std::cout << "TestFunction: " << testFunctionName << std::endl;
958 
959  int argc = 4;
960  const char *argv[] = {"plascom2x","-c","acousticPulse.config",NULL};
961 
962  int returnValue = 0;
963  pcpp::CommunicatorType pc2Comm(testComm);
964  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
965 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
966 // testComm.Comm());
967 
968  if(!ix::sys::FILEEXISTS(testDirectory)){
969  acousticTestResult = false;
970  std::cout << testFunctionName << ": testing directory ("
971  << testDirectory << ") did not exist. Aborting test."
972  << std::endl;
973  goto endTest;
974  }
975 
976  ix::sys::ChDir(testDirectory);
977  ix::sys::ChDir("PlasCom2");
978 
979  testComm.Barrier();
980  if(myRank == 0){
981  if(ix::sys::FILEEXISTS("PlasCom2_000002000.h5")){
982  ix::sys::Remove("PlasCom2_000002000.h5");
983  }
984  }
985  testComm.Barrier();
986  if(myRank == 0)
987  std::cout << "Running PlasCom2..." << std::endl;
988  returnValue = application::ApplicationDriver(simulationApplication);
989  testComm.Barrier();
990  if(myRank == 0)
991  std::cout << "Done running PlasCom2." << std::endl;
992 
993  if(returnValue > 0){
994  std::cout << testFunctionName << ": PlasCom2 returned error code ("
995  << returnValue << "). Test failed." << std::endl;
996  acousticTestResult = false;
997  goto endTest;
998  }
999 
1000  ix::sys::ChDir("../");
1001 
1002 
1003  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000002000.h5")){
1004  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1005  << "output file (PlasCom2/PlasCom2_000002000.h5). Test failed." << std::endl;
1006  acousticTestResult = false;
1007  goto endTest;
1008  }
1009 
1010  if(testComm.Rank() == 0){
1011  std::cout << "Comparing results to expected....";
1012 
1013  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000002000.h5",
1014  "CM/flocm_acousticpulse_2000.h5",
1015  errorTolerance,compareStream);
1016 
1017  std::cout << (returnValue == 0 ? "passed." : "failed.")
1018  << std::endl;
1019  }
1020  if(returnValue != 0){
1021  std::cout << testFunctionName << ": Resulting state comparison "
1022  << "yielded negative result:"
1023  << std::endl
1024  << compareStream.str()
1025  << std::endl;
1026  acousticTestResult = false;
1027  goto endTest;
1028  }
1029 
1030  endTest:
1031  {
1032  ix::sys::ChDir(originalDirectory);
1033  parallelUnitResults.UpdateResult("PlasCom2:Euler:AcousticPulseSlipwall2D",
1034  acousticTestResult);
1035  }
1036 
1037  testComm.Barrier();
1038  return;
1039 }
1040 
1041 
1042 void TestPlasCom2_APRectilinearSlipwall2D(ix::test::results &parallelUnitResults,
1043  pcpp::CommunicatorType &testComm)
1044 {
1045  bool acousticTestResult = true;
1046 
1047  int myRank = testComm.Rank();
1048  int numProc = testComm.NProc();
1049 
1050  const std::string testFunctionName("TestPlasCom2_APRectilinearSlipwall2D");
1051  const std::string testSuiteName("InviscidTests");
1052  const std::string testCaseName("AcousticPulseSlipwall2D");
1053  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1054  const std::string originalDirectory(ix::sys::CWD());
1055  std::ostringstream compareStream;
1056  double errorTolerance = 5e-14;
1057 
1058  testComm.Barrier();
1059  if(myRank == 0)
1060  std::cout << "TestFunction: " << testFunctionName << std::endl;
1061 
1062  int argc = 4;
1063  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};
1064 
1065  int returnValue = 0;
1066  pcpp::CommunicatorType pc2Comm(testComm);
1067  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1068 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1069 // testComm.Comm());
1070 
1071  if(!ix::sys::FILEEXISTS(testDirectory)){
1072  acousticTestResult = false;
1073  std::cout << testFunctionName << ": testing directory ("
1074  << testDirectory << ") did not exist. Aborting test."
1075  << std::endl;
1076  goto endTest;
1077  }
1078 
1079  ix::sys::ChDir(testDirectory);
1080  ix::sys::ChDir("PlasCom2");
1081 
1082  testComm.Barrier();
1083  if(myRank == 0){
1084  if(ix::sys::FILEEXISTS("PlasCom2_000002000.h5")){
1085  ix::sys::Remove("PlasCom2_000002000.h5");
1086  }
1087  }
1088  testComm.Barrier();
1089  if(myRank == 0)
1090  std::cout << "Running PlasCom2..." << std::endl;
1091  returnValue = application::ApplicationDriver(simulationApplication);
1092  testComm.Barrier();
1093  if(myRank == 0)
1094  std::cout << "Done running PlasCom2." << std::endl;
1095 
1096  if(returnValue > 0){
1097  std::cout << testFunctionName << ": PlasCom2 returned error code ("
1098  << returnValue << "). Test failed." << std::endl;
1099  acousticTestResult = false;
1100  goto endTest;
1101  }
1102 
1103  ix::sys::ChDir("../");
1104 
1105 
1106  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000002000.h5")){
1107  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1108  << "output file (PlasCom2/PlasCom2_000002000.h5). Test failed." << std::endl;
1109  acousticTestResult = false;
1110  goto endTest;
1111  }
1112 
1113  if(testComm.Rank() == 0){
1114  std::cout << "Comparing results to expected....";
1115 
1116  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000002000.h5",
1117  "CM/flocm_acousticpulse_2000.h5",
1118  errorTolerance,compareStream);
1119 
1120  std::cout << (returnValue == 0 ? "passed." : "failed.")
1121  << std::endl;
1122  }
1123  if(returnValue != 0){
1124  std::cout << testFunctionName << ": Resulting state comparison "
1125  << "yielded negative result:"
1126  << std::endl
1127  << compareStream.str()
1128  << std::endl;
1129  acousticTestResult = false;
1130  goto endTest;
1131  }
1132 
1133  endTest:
1134  {
1135  ix::sys::ChDir(originalDirectory);
1136  parallelUnitResults.UpdateResult("PlasCom2:Euler:RectilinearSlipwall2D",
1137  acousticTestResult);
1138  }
1139 
1140  testComm.Barrier();
1141  return;
1142 }
1143 
1144 void TestPlasCom2_APCurvilinearSlipwall2D(ix::test::results &parallelUnitResults,
1145  pcpp::CommunicatorType &testComm)
1146 {
1147  bool acousticTestResult = true;
1148 
1149  int myRank = testComm.Rank();
1150  int numProc = testComm.NProc();
1151 
1152  const std::string testFunctionName("TestPlasCom2_APCurvilinearSlipwall2D");
1153  const std::string testSuiteName("InviscidTests");
1154  const std::string testCaseName("AcousticPulseSlipwall2D");
1155  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1156  const std::string originalDirectory(ix::sys::CWD());
1157  std::ostringstream compareStream;
1158  double errorTolerance = 5e-14;
1159 
1160  testComm.Barrier();
1161  if(myRank == 0)
1162  std::cout << "TestFunction: " << testFunctionName << std::endl;
1163 
1164  int argc = 4;
1165  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};
1166 
1167  int returnValue = 0;
1168  pcpp::CommunicatorType pc2Comm(testComm);
1169  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1170 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1171 // testComm.Comm());
1172 
1173  if(!ix::sys::FILEEXISTS(testDirectory)){
1174  acousticTestResult = false;
1175  std::cout << testFunctionName << ": testing directory ("
1176  << testDirectory << ") did not exist. Aborting test."
1177  << std::endl;
1178  goto endTest;
1179  }
1180 
1181  ix::sys::ChDir(testDirectory);
1182  ix::sys::ChDir("PlasCom2");
1183 
1184  testComm.Barrier();
1185  if(myRank == 0)
1186  if(ix::sys::FILEEXISTS("PlasCom2_000002000.h5")){
1187  ix::sys::Remove("PlasCom2_000002000.h5");
1188  }
1189 
1190  testComm.Barrier();
1191  if(myRank == 0)
1192  std::cout << "Running PlasCom2..." << std::endl;
1193  returnValue = application::ApplicationDriver(simulationApplication);
1194  testComm.Barrier();
1195  if(myRank == 0)
1196  std::cout << "Done running PlasCom2." << std::endl;
1197 
1198  if(returnValue > 0){
1199  std::cout << testFunctionName << ": PlasCom2 returned error code ("
1200  << returnValue << "). Test failed." << std::endl;
1201  acousticTestResult = false;
1202  goto endTest;
1203  }
1204 
1205  ix::sys::ChDir("../");
1206 
1207 
1208  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000002000.h5")){
1209  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1210  << "output file (PlasCom2/PlasCom2_000002000.h5). Test failed." << std::endl;
1211  acousticTestResult = false;
1212  goto endTest;
1213  }
1214 
1215  if(testComm.Rank() == 0){
1216  std::cout << "Comparing results to expected....";
1217 
1218  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000002000.h5",
1219  "CM/flocm_acousticpulse_2000.h5",
1220  errorTolerance,compareStream);
1221 
1222  std::cout << (returnValue == 0 ? "passed." : "failed.")
1223  << std::endl;
1224  }
1225  if(returnValue != 0){
1226  std::cout << testFunctionName << ": Resulting state comparison "
1227  << "yielded negative result:"
1228  << std::endl
1229  << compareStream.str()
1230  << std::endl;
1231  acousticTestResult = false;
1232  goto endTest;
1233  }
1234 
1235  endTest:
1236  {
1237  ix::sys::ChDir(originalDirectory);
1238  parallelUnitResults.UpdateResult("PlasCom2:Euler:CurvilinearSlipwall2D",
1239  acousticTestResult);
1240  }
1241 
1242  testComm.Barrier();
1243  return;
1244 }
1245 
1246 void TestPlasCom2_AcousticPulseSlipwall3D(ix::test::results &parallelUnitResults,
1247  pcpp::CommunicatorType &testComm)
1248 {
1249  bool acousticTestResult = true;
1250 
1251  int myRank = testComm.Rank();
1252  int numProc = testComm.NProc();
1253 
1254  const std::string testFunctionName("TestPlasCom2_AcousticPulseSlipWall3D");
1255  const std::string testSuiteName("InviscidTests");
1256  const std::string testCaseName("AcousticPulseSlipwall3D");
1257  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1258  const std::string originalDirectory(ix::sys::CWD());
1259  std::ostringstream compareStream;
1260  double errorTolerance = 5e-14;
1261 
1262  testComm.Barrier();
1263  if(myRank == 0)
1264  std::cout << "TestFunction: " << testFunctionName << std::endl;
1265 
1266  int argc = 4;
1267  const char *argv[] = {"plascom2x","-c","acousticPulse.config",NULL};
1268 
1269  int returnValue = 0;
1270  pcpp::CommunicatorType pc2Comm(testComm);
1271  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1272 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1273 // testComm.Comm());
1274 
1275  if(!ix::sys::FILEEXISTS(testDirectory)){
1276  acousticTestResult = false;
1277  std::cout << testFunctionName << ": testing directory ("
1278  << testDirectory << ") did not exist. Aborting test."
1279  << std::endl;
1280  goto endTest;
1281  }
1282 
1283  ix::sys::ChDir(testDirectory);
1284  ix::sys::ChDir("PlasCom2");
1285 
1286  testComm.Barrier();
1287  if(myRank == 0)
1288  if(ix::sys::FILEEXISTS("PlasCom2_000000010.h5")){
1289  ix::sys::Remove("PlasCom2_000000010.h5");
1290  }
1291 
1292  testComm.Barrier();
1293  if(myRank == 0)
1294  std::cout << "Running PlasCom2..." << std::endl;
1295  returnValue = application::ApplicationDriver(simulationApplication);
1296  testComm.Barrier();
1297  if(myRank == 0)
1298  std::cout << "Done running PlasCom2." << std::endl;
1299 
1300  if(returnValue > 0){
1301  std::cout << testFunctionName << ": PlasCom2 returned error code ("
1302  << returnValue << "). Test failed." << std::endl;
1303  acousticTestResult = false;
1304  goto endTest;
1305  }
1306 
1307  ix::sys::ChDir("../");
1308 
1309 
1310  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000010.h5")){
1311  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1312  << "output file (PlasCom2/PlasCom2_000000010.h5). Test failed." << std::endl;
1313  acousticTestResult = false;
1314  goto endTest;
1315  }
1316 
1317  if(testComm.Rank() == 0){
1318  std::cout << "Comparing results to expected....";
1319 
1320  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000010.h5",
1321  "CM/flocm_acousticpulse_10.h5",
1322  errorTolerance,compareStream);
1323 
1324  std::cout << (returnValue == 0 ? "passed." : "failed.")
1325  << std::endl;
1326  }
1327  if(returnValue != 0){
1328  std::cout << testFunctionName << ": Resulting state comparison "
1329  << "yielded negative result:"
1330  << std::endl
1331  << compareStream.str()
1332  << std::endl;
1333  acousticTestResult = false;
1334  goto endTest;
1335  }
1336 
1337  endTest:
1338  {
1339  ix::sys::ChDir(originalDirectory);
1340  parallelUnitResults.UpdateResult("PlasCom2:Euler:AcousticPulseSlipwall3D",
1341  acousticTestResult);
1342  }
1343 
1344  testComm.Barrier();
1345  return;
1346 }
1347 
1348 void TestPlasCom2_APRectilinearSlipwall3D(ix::test::results &parallelUnitResults,
1349  pcpp::CommunicatorType &testComm)
1350 {
1351  bool acousticTestResult = true;
1352 
1353  int myRank = testComm.Rank();
1354  int numProc = testComm.NProc();
1355 
1356  const std::string testFunctionName("TestPlasCom2_APRectilinearSlipWall3D");
1357  const std::string testSuiteName("InviscidTests");
1358  const std::string testCaseName("AcousticPulseSlipwall3D");
1359  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1360  const std::string originalDirectory(ix::sys::CWD());
1361  std::ostringstream compareStream;
1362  double errorTolerance = 5e-14;
1363 
1364  testComm.Barrier();
1365  if(myRank == 0)
1366  std::cout << "TestFunction: " << testFunctionName << std::endl;
1367 
1368  int argc = 4;
1369  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};
1370 
1371  int returnValue = 0;
1372  pcpp::CommunicatorType pc2Comm(testComm);
1373  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1374 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1375 // testComm.Comm());
1376 
1377  if(!ix::sys::FILEEXISTS(testDirectory)){
1378  acousticTestResult = false;
1379  std::cout << testFunctionName << ": testing directory ("
1380  << testDirectory << ") did not exist. Aborting test."
1381  << std::endl;
1382  goto endTest;
1383  }
1384 
1385  ix::sys::ChDir(testDirectory);
1386  ix::sys::ChDir("PlasCom2");
1387 
1388 
1389  testComm.Barrier();
1390  if(myRank == 0)
1391  if(ix::sys::FILEEXISTS("PlasCom2_000000010.h5")){
1392  ix::sys::Remove("PlasCom2_000000010.h5");
1393  }
1394 
1395  testComm.Barrier();
1396  if(myRank == 0)
1397  std::cout << "Running PlasCom2..." << std::endl;
1398  returnValue = application::ApplicationDriver(simulationApplication);
1399  testComm.Barrier();
1400  if(myRank == 0)
1401  std::cout << "Done running PlasCom2." << std::endl;
1402 
1403  if(returnValue > 0){
1404  std::cout << testFunctionName << ": PlasCom2 returned error code ("
1405  << returnValue << "). Test failed." << std::endl;
1406  acousticTestResult = false;
1407  goto endTest;
1408  }
1409 
1410  ix::sys::ChDir("../");
1411 
1412 
1413  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000010.h5")){
1414  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1415  << "output file (PlasCom2/PlasCom2_000000010.h5). Test failed." << std::endl;
1416  acousticTestResult = false;
1417  goto endTest;
1418  }
1419 
1420  if(testComm.Rank() == 0){
1421  std::cout << "Comparing results to expected....";
1422 
1423  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000010.h5",
1424  "CM/flocm_acousticpulse_10.h5",
1425  errorTolerance,compareStream);
1426 
1427  std::cout << (returnValue == 0 ? "passed." : "failed.")
1428  << std::endl;
1429  }
1430  if(returnValue != 0){
1431  std::cout << testFunctionName << ": Resulting state comparison "
1432  << "yielded negative result:"
1433  << std::endl
1434  << compareStream.str()
1435  << std::endl;
1436  acousticTestResult = false;
1437  goto endTest;
1438  }
1439 
1440  endTest:
1441  {
1442  ix::sys::ChDir(originalDirectory);
1443  parallelUnitResults.UpdateResult("PlasCom2:Euler:RectilinearSlipwall3D",
1444  acousticTestResult);
1445  }
1446 
1447  testComm.Barrier();
1448  return;
1449 }
1450 
1451 
1452 void TestPlasCom2_APCurvilinearSlipwall3D(ix::test::results &parallelUnitResults,
1453  pcpp::CommunicatorType &testComm)
1454 {
1455  bool acousticTestResult = true;
1456 
1457  int myRank = testComm.Rank();
1458  int numProc = testComm.NProc();
1459 
1460  const std::string testFunctionName("TestPlasCom2_APCurvilinearSlipWall3D");
1461  const std::string testSuiteName("InviscidTests");
1462  const std::string testCaseName("AcousticPulseSlipwall3D");
1463  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1464  const std::string originalDirectory(ix::sys::CWD());
1465  std::ostringstream compareStream;
1466  double errorTolerance = 5e-14;
1467 
1468  testComm.Barrier();
1469  if(myRank == 0)
1470  std::cout << "TestFunction: " << testFunctionName << std::endl;
1471 
1472  int argc = 4;
1473  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};
1474 
1475  int returnValue = 0;
1476  pcpp::CommunicatorType pc2Comm(testComm);
1477  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1478 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1479 // testComm.Comm());
1480 
1481  if(!ix::sys::FILEEXISTS(testDirectory)){
1482  acousticTestResult = false;
1483  std::cout << testFunctionName << ": testing directory ("
1484  << testDirectory << ") did not exist. Aborting test."
1485  << std::endl;
1486  goto endTest;
1487  }
1488 
1489  ix::sys::ChDir(testDirectory);
1490  ix::sys::ChDir("PlasCom2");
1491 
1492 
1493  testComm.Barrier();
1494  if(myRank == 0)
1495  if(ix::sys::FILEEXISTS("PlasCom2_000000010.h5")){
1496  ix::sys::Remove("PlasCom2_000000010.h5");
1497  }
1498 
1499  testComm.Barrier();
1500  if(myRank == 0)
1501  std::cout << "Running PlasCom2..." << std::endl;
1502  returnValue = application::ApplicationDriver(simulationApplication);
1503  testComm.Barrier();
1504  if(myRank == 0)
1505  std::cout << "Done running PlasCom2." << std::endl;
1506 
1507  if(returnValue > 0){
1508  std::cout << testFunctionName << ": PlasCom2 returned error code ("
1509  << returnValue << "). Test failed." << std::endl;
1510  acousticTestResult = false;
1511  goto endTest;
1512  }
1513 
1514  ix::sys::ChDir("../");
1515 
1516 
1517  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000010.h5")){
1518  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1519  << "output file (PlasCom2/PlasCom2_000000010.h5). Test failed." << std::endl;
1520  acousticTestResult = false;
1521  goto endTest;
1522  }
1523 
1524  if(testComm.Rank() == 0){
1525  std::cout << "Comparing results to expected....";
1526 
1527  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000010.h5",
1528  "CM/flocm_acousticpulse_10.h5",
1529  errorTolerance,compareStream);
1530 
1531  std::cout << (returnValue == 0 ? "passed." : "failed.")
1532  << std::endl;
1533  }
1534  if(returnValue != 0){
1535  std::cout << testFunctionName << ": Resulting state comparison "
1536  << "yielded negative result:"
1537  << std::endl
1538  << compareStream.str()
1539  << std::endl;
1540  acousticTestResult = false;
1541  goto endTest;
1542  }
1543 
1544  endTest:
1545  {
1546  ix::sys::ChDir(originalDirectory);
1547  parallelUnitResults.UpdateResult("PlasCom2:Euler:CurvilinearSlipwall3D",
1548  acousticTestResult);
1549  }
1550 
1551  testComm.Barrier();
1552  return;
1553 }
1554 
1555 void TestPlasCom2_AcousticPulsePeriodic3D(ix::test::results &parallelUnitResults,
1556  pcpp::CommunicatorType &testComm)
1557 {
1558  bool acousticTestResult = true;
1559 
1560  int myRank = testComm.Rank();
1561  int numProc = testComm.NProc();
1562 
1563  const std::string testFunctionName("TestPlasCom2_AcousticPulsePeriodic3D");
1564  const std::string testSuiteName("InviscidTests");
1565  const std::string testCaseName("AcousticPulsePeriodic3D");
1566  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1567  const std::string originalDirectory(ix::sys::CWD());
1568  std::ostringstream compareStream;
1569  double errorTolerance = 5e-14;
1570 
1571  testComm.Barrier();
1572  if(myRank == 0)
1573  std::cout << "TestFunction: " << testFunctionName << std::endl;
1574 
1575  int argc = 4;
1576  const char *argv[] = {"plascom2x","-c","acousticPulse.config",NULL};
1577 
1578  int returnValue = 0;
1579  pcpp::CommunicatorType pc2Comm(testComm);
1580  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1581 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1582 // testComm.Comm());
1583 
1584  if(!ix::sys::FILEEXISTS(testDirectory)){
1585  acousticTestResult = false;
1586  std::cout << "TestPlasCom2_AcousticPulsePeriodic3D: testing directory ("
1587  << testDirectory << ") did not exist. Aborting test."
1588  << std::endl;
1589  goto endTest;
1590  }
1591 
1592  ix::sys::ChDir(testDirectory);
1593  ix::sys::ChDir("PlasCom2");
1594  if(myRank == 0)
1595  ix::sys::Remove("PlasCom2_000000005.h5");
1596 
1597  testComm.Barrier();
1598 
1599  if(myRank == 0)
1600  std::cout << "Running PlasCom2..." << std::endl;
1601  returnValue = application::ApplicationDriver(simulationApplication);
1602  testComm.Barrier();
1603  if(myRank == 0)
1604  std::cout << "Done running PlasCom2." << std::endl;
1605 
1606  if(returnValue > 0){
1607  std::cout << "TestPlasCom2_AcousticPulsePeriodic3D: PlasCom2 returned error code ("
1608  << returnValue << "). Test failed." << std::endl;
1609  acousticTestResult = false;
1610  goto endTest;
1611  }
1612 
1613  ix::sys::ChDir("../");
1614 
1615  testComm.Barrier();
1616 
1617  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000005.h5")){
1618  std::cout << "TestPlasCom2_AcousticPulsePeriodic3D: PlasCom2 failed to produce expected" << std::endl
1619  << "output file (PlasCom2/PlasCom2_000000005.h5). Test failed." << std::endl;
1620  acousticTestResult = false;
1621  goto endTest;
1622  }
1623 
1624  if(myRank == 0){
1625  std::cout << "Comparing results to expected.....";
1626  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000005.h5",
1627  "CM/flocm_acousticpulse_5.h5",
1628  errorTolerance,compareStream);
1629  if(returnValue == 0)
1630  std::cout << "passed." << std::endl;
1631  else
1632  std::cout << "failed." << std::endl;
1633  }
1634 
1635  if(returnValue > 0){
1636  std::cout << "TestPlasCom2_AcousticPulsePeriodic3D: Resulting state comparison yielded negative result:"
1637  << std::endl
1638  << compareStream.str()
1639  << std::endl;
1640  acousticTestResult = false;
1641  goto endTest;
1642  }
1643 
1644  endTest:
1645  {
1646  ix::sys::ChDir(originalDirectory);
1647  parallelUnitResults.UpdateResult("PlasCom2:Euler:AcousticPulsePeriodic3D",
1648  acousticTestResult);
1649  }
1650 
1651  testComm.Barrier();
1652  return;
1653 }
1654 
1655 void TestPlasCom2_APRectilinearPeriodic3D(ix::test::results &parallelUnitResults,
1656  pcpp::CommunicatorType &testComm)
1657 {
1658  bool acousticTestResult = true;
1659 
1660  int myRank = testComm.Rank();
1661  int numProc = testComm.NProc();
1662 
1663  const std::string testFunctionName("TestPlasCom2_APRectilinearPeriodic3D");
1664  const std::string testSuiteName("InviscidTests");
1665  const std::string testCaseName("AcousticPulsePeriodic3D");
1666  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1667  const std::string originalDirectory(ix::sys::CWD());
1668  std::ostringstream compareStream;
1669  double errorTolerance = 5e-14;
1670 
1671  testComm.Barrier();
1672  if(myRank == 0)
1673  std::cout << "TestFunction: " << testFunctionName << std::endl;
1674 
1675  int argc = 4;
1676  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};
1677 
1678  int returnValue = 0;
1679  pcpp::CommunicatorType pc2Comm(testComm);
1680  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1681 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1682 // testComm.Comm());
1683 
1684  if(!ix::sys::FILEEXISTS(testDirectory)){
1685  acousticTestResult = false;
1686  std::cout << testFunctionName << ": testing directory ("
1687  << testDirectory << ") did not exist. Aborting test."
1688  << std::endl;
1689  goto endTest;
1690  }
1691 
1692  ix::sys::ChDir(testDirectory);
1693  ix::sys::ChDir("PlasCom2");
1694 
1695  testComm.Barrier();
1696  if(myRank == 0)
1697  if(ix::sys::FILEEXISTS("PlasCom2_000000005.h5")){
1698  ix::sys::Remove("PlasCom2_000000005.h5");
1699  }
1700 
1701  testComm.Barrier();
1702  if(myRank == 0)
1703  std::cout << "Running PlasCom2..." << std::endl;
1704  returnValue = application::ApplicationDriver(simulationApplication);
1705  testComm.Barrier();
1706  if(myRank == 0)
1707  std::cout << "Done running PlasCom2." << std::endl;
1708 
1709  if(returnValue > 0){
1710  std::cout << testFunctionName << ": PlasCom2 returned error code ("
1711  << returnValue << "). Test failed." << std::endl;
1712  acousticTestResult = false;
1713  goto endTest;
1714  }
1715 
1716  ix::sys::ChDir("../");
1717 
1718  testComm.Barrier();
1719 
1720  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000005.h5")){
1721  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1722  << "output file (PlasCom2/PlasCom2_000000005.h5). Test failed." << std::endl;
1723  acousticTestResult = false;
1724  goto endTest;
1725  }
1726 
1727  if(myRank == 0){
1728  std::cout << "Comparing results to expected.....";
1729  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000005.h5",
1730  "CM/flocm_acousticpulse_5.h5",
1731  errorTolerance,compareStream);
1732  if(returnValue == 0)
1733  std::cout << "passed." << std::endl;
1734  else
1735  std::cout << "failed." << std::endl;
1736  }
1737 
1738  if(returnValue > 0){
1739  std::cout << testFunctionName << ": Resulting state comparison yielded negative result:"
1740  << std::endl
1741  << compareStream.str()
1742  << std::endl;
1743  acousticTestResult = false;
1744  goto endTest;
1745  }
1746 
1747  endTest:
1748  {
1749  ix::sys::ChDir(originalDirectory);
1750  parallelUnitResults.UpdateResult("PlasCom2:Euler:RectilinearPeriodic3D",
1751  acousticTestResult);
1752  }
1753 
1754  testComm.Barrier();
1755  return;
1756 }
1757 
1758 void TestPlasCom2_APCurvilinearPeriodic3D(ix::test::results &parallelUnitResults,
1759  pcpp::CommunicatorType &testComm)
1760 {
1761  bool acousticTestResult = true;
1762 
1763  int myRank = testComm.Rank();
1764  int numProc = testComm.NProc();
1765 
1766  const std::string testFunctionName("TestPlasCom2_APCurvilinearPeriodic3D");
1767  const std::string testSuiteName("InviscidTests");
1768  const std::string testCaseName("AcousticPulsePeriodic3D");
1769  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1770  const std::string originalDirectory(ix::sys::CWD());
1771  std::ostringstream compareStream;
1772  double errorTolerance = 5e-14;
1773 
1774  testComm.Barrier();
1775  if(myRank == 0)
1776  std::cout << "TestFunction: " << testFunctionName << std::endl;
1777 
1778  int argc = 4;
1779  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};
1780 
1781  int returnValue = 0;
1782  pcpp::CommunicatorType pc2Comm(testComm);
1783  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1784 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1785 // testComm.Comm());
1786 
1787  if(!ix::sys::FILEEXISTS(testDirectory)){
1788  acousticTestResult = false;
1789  std::cout << testFunctionName << ": testing directory ("
1790  << testDirectory << ") did not exist. Aborting test."
1791  << std::endl;
1792  goto endTest;
1793  }
1794 
1795  ix::sys::ChDir(testDirectory);
1796  ix::sys::ChDir("PlasCom2");
1797 
1798  testComm.Barrier();
1799  if(myRank == 0)
1800  if(ix::sys::FILEEXISTS("PlasCom2_000000005.h5")){
1801  ix::sys::Remove("PlasCom2_000000005.h5");
1802  }
1803 
1804  testComm.Barrier();
1805  if(myRank == 0)
1806  std::cout << "Running PlasCom2..." << std::endl;
1807  returnValue = application::ApplicationDriver(simulationApplication);
1808  testComm.Barrier();
1809  if(myRank == 0)
1810  std::cout << "Done running PlasCom2." << std::endl;
1811 
1812  if(returnValue > 0){
1813  std::cout << testFunctionName << ": PlasCom2 returned error code ("
1814  << returnValue << "). Test failed." << std::endl;
1815  acousticTestResult = false;
1816  goto endTest;
1817  }
1818 
1819  ix::sys::ChDir("../");
1820 
1821  testComm.Barrier();
1822 
1823  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000005.h5")){
1824  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1825  << "output file (PlasCom2/PlasCom2_000000005.h5). Test failed." << std::endl;
1826  acousticTestResult = false;
1827  goto endTest;
1828  }
1829 
1830  if(myRank == 0){
1831  std::cout << "Comparing results to expected.....";
1832  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000005.h5",
1833  "CM/flocm_acousticpulse_5.h5",
1834  errorTolerance,compareStream);
1835  if(returnValue == 0)
1836  std::cout << "passed." << std::endl;
1837  else
1838  std::cout << "failed." << std::endl;
1839  }
1840 
1841  if(returnValue > 0){
1842  std::cout << testFunctionName << ": Resulting state comparison yielded negative result:"
1843  << std::endl
1844  << compareStream.str()
1845  << std::endl;
1846  acousticTestResult = false;
1847  goto endTest;
1848  }
1849 
1850  endTest:
1851  {
1852  ix::sys::ChDir(originalDirectory);
1853  parallelUnitResults.UpdateResult("PlasCom2:Euler:CurvilinearPeriodic3D",
1854  acousticTestResult);
1855  }
1856 
1857  testComm.Barrier();
1858  return;
1859 }
1860 
1861 void TestPlasCom2_AcousticPulseSponge2D(ix::test::results &parallelUnitResults,
1862  pcpp::CommunicatorType &testComm)
1863 {
1864  bool acousticTestResult = true;
1865 
1866  int myRank = testComm.Rank();
1867  int numProc = testComm.NProc();
1868 
1869  const std::string testFunctionName("TestPlasCom2_AcousticPulseSponge2D");
1870  const std::string testSuiteName("InviscidTests");
1871  const std::string testCaseName("AcousticPulseSponge2D");
1872  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1873  const std::string originalDirectory(ix::sys::CWD());
1874  std::ostringstream compareStream;
1875  double errorTolerance = 5e-14;
1876 
1877  testComm.Barrier();
1878  if(myRank == 0)
1879  std::cout << "TestFunction: " << testFunctionName << std::endl;
1880 
1881  int argc = 4;
1882  const char *argv[] = {"plascom2x","-c","acousticPulse.config",NULL};
1883 
1884  int returnValue = 0;
1885  pcpp::CommunicatorType pc2Comm(testComm);
1886  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1887 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1888 // testComm.Comm());
1889 
1890  if(!ix::sys::FILEEXISTS(testDirectory)){
1891  acousticTestResult = false;
1892  std::cout << testFunctionName << ": testing directory ("
1893  << testDirectory << ") did not exist. Aborting test."
1894  << std::endl;
1895  goto endTest;
1896  }
1897 
1898  ix::sys::ChDir(testDirectory);
1899  ix::sys::ChDir("PlasCom2");
1900 
1901  if(myRank == 0)
1902  ix::sys::Remove("PlasCom2_000001000.h5");
1903 
1904  testComm.Barrier();
1905  if(myRank == 0)
1906  std::cout << "Running PlasCom2..." << std::endl;
1907  returnValue = application::ApplicationDriver(simulationApplication);
1908  testComm.Barrier();
1909  if(myRank == 0)
1910  std::cout << "Done running PlasCom2." << std::endl;
1911 
1912  if(returnValue > 0){
1913  std::cout << testFunctionName << ": PlasCom2 returned error code ("
1914  << returnValue << "). Test failed." << std::endl;
1915  acousticTestResult = false;
1916  goto endTest;
1917  }
1918 
1919  ix::sys::ChDir("../");
1920 
1921  testComm.Barrier();
1922 
1923  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
1924  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
1925  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
1926  acousticTestResult = false;
1927  goto endTest;
1928  }
1929 
1930  if(!ix::sys::FILEEXISTS("CM/flocm_acousticpulse_1000.h5")){
1931  std::cout << testFunctionName << ": Missing expected result ("
1932  << "CM/flocm_acousticpulse_1000.h5)" << std::endl;
1933  acousticTestResult = false;
1934  goto endTest;
1935  }
1936  testComm.Barrier();
1937 
1938  if(testComm.Rank() == 0){
1939  std::cout << "Comparing results to expected....";
1940  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
1941  "CM/flocm_acousticpulse_1000.h5",
1942  errorTolerance,compareStream);
1943  std::cout << (returnValue == 0 ? "passed." : "failed.")
1944  << std::endl;
1945  }
1946 
1947  testComm.Barrier();
1948 
1949  if(returnValue > 0){
1950  std::cout << testFunctionName << ": Resulting state comparison "
1951  << "yielded negative result:"
1952  << std::endl
1953  << compareStream.str()
1954  << std::endl;
1955  acousticTestResult = false;
1956  goto endTest;
1957  }
1958 
1959  endTest:
1960  {
1961  ix::sys::ChDir(originalDirectory);
1962  parallelUnitResults.UpdateResult("PlasCom2:Euler:AcousticPulseSponge2D",
1963  acousticTestResult);
1964  }
1965 
1966  testComm.Barrier();
1967  return;
1968 }
1969 
1970 void TestPlasCom2_APRectilinearSponge2D(ix::test::results &parallelUnitResults,
1971  pcpp::CommunicatorType &testComm)
1972 {
1973  bool acousticTestResult = true;
1974 
1975  int myRank = testComm.Rank();
1976  int numProc = testComm.NProc();
1977 
1978  const std::string testFunctionName("TestPlasCom2_RectilinearSponge2D");
1979  const std::string testSuiteName("InviscidTests");
1980  const std::string testCaseName("AcousticPulseSponge2D");
1981  const std::string testDirectory(testSuiteName+"/"+testCaseName);
1982  const std::string originalDirectory(ix::sys::CWD());
1983  std::ostringstream compareStream;
1984  double errorTolerance = 5e-14;
1985 
1986  testComm.Barrier();
1987  if(myRank == 0)
1988  std::cout << "TestFunction: " << testFunctionName << std::endl;
1989 
1990  int argc = 4;
1991  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};
1992 
1993  int returnValue = 0;
1994  pcpp::CommunicatorType pc2Comm(testComm);
1995  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
1996 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
1997 // testComm.Comm());
1998 
1999  if(!ix::sys::FILEEXISTS(testDirectory)){
2000  acousticTestResult = false;
2001  std::cout << testFunctionName << ": testing directory ("
2002  << testDirectory << ") did not exist. Aborting test."
2003  << std::endl;
2004  goto endTest;
2005  }
2006 
2007  ix::sys::ChDir(testDirectory);
2008  ix::sys::ChDir("PlasCom2");
2009 
2010  testComm.Barrier();
2011  if(myRank == 0)
2012  if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
2013  ix::sys::Remove("PlasCom2_000001000.h5");
2014  }
2015 
2016  testComm.Barrier();
2017  if(myRank == 0)
2018  std::cout << "Running PlasCom2..." << std::endl;
2019  returnValue = application::ApplicationDriver(simulationApplication);
2020  testComm.Barrier();
2021  if(myRank == 0)
2022  std::cout << "Done running PlasCom2." << std::endl;
2023 
2024  if(returnValue > 0){
2025  std::cout << testFunctionName << ": PlasCom2 returned error code ("
2026  << returnValue << "). Test failed." << std::endl;
2027  acousticTestResult = false;
2028  goto endTest;
2029  }
2030 
2031  ix::sys::ChDir("../");
2032 
2033  if(myRank == 0)
2034  ix::sys::Remove("PlasCom2_000001000.h5");
2035 
2036  testComm.Barrier();
2037 
2038  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
2039  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
2040  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
2041  acousticTestResult = false;
2042  goto endTest;
2043  }
2044 
2045  if(!ix::sys::FILEEXISTS("CM/flocm_acousticpulse_1000.h5")){
2046  std::cout << testFunctionName << ": Missing expected result ("
2047  << "CM/flocm_acousticpulse_1000.h5)" << std::endl;
2048  acousticTestResult = false;
2049  goto endTest;
2050  }
2051  testComm.Barrier();
2052 
2053  if(testComm.Rank() == 0){
2054  std::cout << "Comparing results to expected....";
2055  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
2056  "CM/flocm_acousticpulse_1000.h5",
2057  errorTolerance,compareStream);
2058  std::cout << (returnValue == 0 ? "passed." : "failed.")
2059  << std::endl;
2060  }
2061 
2062  testComm.Barrier();
2063 
2064  if(returnValue > 0){
2065  std::cout << testFunctionName << ": Resulting state comparison "
2066  << "yielded negative result:"
2067  << std::endl
2068  << compareStream.str()
2069  << std::endl;
2070  acousticTestResult = false;
2071  goto endTest;
2072  }
2073 
2074  endTest:
2075  {
2076  ix::sys::ChDir(originalDirectory);
2077  parallelUnitResults.UpdateResult("PlasCom2:Euler:RectilinearSponge2D",
2078  acousticTestResult);
2079  }
2080 
2081  testComm.Barrier();
2082  return;
2083 }
2084 
2085 void TestPlasCom2_APCurvilinearSponge2D(ix::test::results &parallelUnitResults,
2086  pcpp::CommunicatorType &testComm)
2087 {
2088  bool acousticTestResult = true;
2089 
2090  int myRank = testComm.Rank();
2091  int numProc = testComm.NProc();
2092 
2093  const std::string testFunctionName("TestPlasCom2_CurvilinearSponge2D");
2094  const std::string testSuiteName("InviscidTests");
2095  const std::string testCaseName("AcousticPulseSponge2D");
2096  const std::string testDirectory(testSuiteName+"/"+testCaseName);
2097  const std::string originalDirectory(ix::sys::CWD());
2098  std::ostringstream compareStream;
2099  double errorTolerance = 5e-14;
2100 
2101  testComm.Barrier();
2102  if(myRank == 0)
2103  std::cout << "TestFunction: " << testFunctionName << std::endl;
2104 
2105  int argc = 4;
2106  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};
2107 
2108  int returnValue = 0;
2109  pcpp::CommunicatorType pc2Comm(testComm);
2110  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
2111 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),
2112 // testComm.Comm());
2113 
2114  if(!ix::sys::FILEEXISTS(testDirectory)){
2115  acousticTestResult = false;
2116  std::cout << testFunctionName << ": testing directory ("
2117  << testDirectory << ") did not exist. Aborting test."
2118  << std::endl;
2119  goto endTest;
2120  }
2121 
2122  ix::sys::ChDir(testDirectory);
2123  ix::sys::ChDir("PlasCom2");
2124 
2125  testComm.Barrier();
2126  if(myRank == 0)
2127  if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
2128  ix::sys::Remove("PlasCom2_000001000.h5");
2129  }
2130 
2131  testComm.Barrier();
2132  if(myRank == 0)
2133  std::cout << "Running PlasCom2..." << std::endl;
2134  returnValue = application::ApplicationDriver(simulationApplication);
2135  testComm.Barrier();
2136  if(myRank == 0)
2137  std::cout << "Done running PlasCom2." << std::endl;
2138 
2139  if(returnValue > 0){
2140  std::cout << testFunctionName << ": PlasCom2 returned error code ("
2141  << returnValue << "). Test failed." << std::endl;
2142  acousticTestResult = false;
2143  goto endTest;
2144  }
2145 
2146  ix::sys::ChDir("../");
2147 
2148  testComm.Barrier();
2149 
2150  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000001000.h5")){
2151  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
2152  << "output file (PlasCom2/PlasCom2_000001000.h5). Test failed." << std::endl;
2153  acousticTestResult = false;
2154  goto endTest;
2155  }
2156 
2157  if(!ix::sys::FILEEXISTS("CM/flocm_acousticpulse_1000.h5")){
2158  std::cout << testFunctionName << ": Missing expected result ("
2159  << "CM/flocm_acousticpulse_1000.h5)" << std::endl;
2160  acousticTestResult = false;
2161  goto endTest;
2162  }
2163  testComm.Barrier();
2164 
2165  if(testComm.Rank() == 0){
2166  std::cout << "Comparing results to expected....";
2167  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000001000.h5",
2168  "CM/flocm_acousticpulse_1000.h5",
2169  errorTolerance,compareStream);
2170  std::cout << (returnValue == 0 ? "passed." : "failed.")
2171  << std::endl;
2172  }
2173 
2174  testComm.Barrier();
2175 
2176  if(returnValue > 0){
2177  std::cout << testFunctionName << ": Resulting state comparison "
2178  << "yielded negative result:"
2179  << std::endl
2180  << compareStream.str()
2181  << std::endl;
2182  acousticTestResult = false;
2183  goto endTest;
2184  }
2185 
2186  endTest:
2187  {
2188  ix::sys::ChDir(originalDirectory);
2189  parallelUnitResults.UpdateResult("PlasCom2:Euler:CurvilinearSponge2D",
2190  acousticTestResult);
2191  }
2192 
2193  testComm.Barrier();
2194  return;
2195 }
2196 
2197 void TestPlasCom2_Restart(ix::test::results &parallelUnitResults,
2198  pcpp::CommunicatorType &testComm)
2199 {
2200  bool acousticTestResult = true;
2201 
2202  int myRank = testComm.Rank();
2203  int numProc = testComm.NProc();
2204 
2205  const std::string testFunctionName("TestPlasCom2_Restart");
2206  const std::string testSuiteName("InviscidTests");
2207  const std::string testCaseName("AcousticPulseSponge2D");
2208  const std::string testDirectory(testSuiteName+"/"+testCaseName);
2209  const std::string originalDirectory(ix::sys::CWD());
2210  std::ostringstream compareStream;
2211  double errorTolerance = 5e-14;
2212 
2213  testComm.Barrier();
2214  if(myRank == 0)
2215  std::cout << "TestFunction: " << testFunctionName << std::endl;
2216 
2217  int argc1 = 4;
2218  const char *argv1[] = {"plascom2x","-c","curvilinear2.config",NULL};
2219 
2220  int returnValue = 0;
2221  pcpp::CommunicatorType pc2Comm(testComm);
2222  plascom2::application simulationApplication(argc1,const_cast<char **>(argv1),pc2Comm.Comm());
2223 
2224  int argc2 = 4;
2225  const char *argv2[] = {"plascom2x","PlasCom2_000001000.h5","PlasCom2_000000000.h5",NULL};
2226 
2227  pcpp::CommunicatorType pc2Comm2(testComm);
2228  plascom2::application simulationApplication2(argc2,const_cast<char **>(argv2),pc2Comm2.Comm());
2229 
2230  if(!ix::sys::FILEEXISTS(testDirectory)){
2231  acousticTestResult = false;
2232  std::cout << testFunctionName << ": testing directory ("
2233  << testDirectory << ") did not exist. Aborting test."
2234  << std::endl;
2235  goto endTest;
2236  }
2237 
2238  ix::sys::ChDir(testDirectory);
2239  ix::sys::ChDir("PlasCom2");
2240 
2241  testComm.Barrier();
2242  if(myRank == 0){
2243  if(ix::sys::FILEEXISTS("PlasCom2_000002000.h5")){
2244  ix::sys::Remove("PlasCom2_000002000.h5");
2245  }
2246  if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
2247  ix::sys::Remove("PlasCom2_000001000.h5");
2248  }
2249  if(!ix::sys::FILEEXISTS("original"))
2250  ix::sys::CreateDirectory("original");
2251  }
2252 
2253  testComm.Barrier();
2254 
2255  if(myRank == 0)
2256  std::cout << "Running PlasCom2..." << std::endl;
2257  returnValue = application::ApplicationDriver(simulationApplication);
2258  testComm.Barrier();
2259  if(myRank == 0)
2260  std::cout << "Done running PlasCom2." << std::endl;
2261 
2262  if(returnValue > 0){
2263  std::cout << testFunctionName << ": PlasCom2 returned error code ("
2264  << returnValue << "). Test failed." << std::endl;
2265  acousticTestResult = false;
2266  goto endTest;
2267  }
2268 
2269  // ix::sys::ChDir("../");
2270 
2271  testComm.Barrier();
2272 
2273  if(!ix::sys::FILEEXISTS("PlasCom2_000002000.h5")){
2274  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
2275  << "output file (PlasCom2_000002000.h5). Test failed." << std::endl;
2276  acousticTestResult = false;
2277  goto endTest;
2278  } else {
2279  if(myRank == 0){
2280  ix::sys::Rename("PlasCom2_000002000.h5","original/PlasCom2_000002000.h5");
2281  }
2282  }
2283 
2284  testComm.Barrier();
2285 
2286  // Now restart PlasCom2
2287  if(myRank == 0)
2288  std::cout << "Restarting PlasCom2..." << std::endl;
2289  returnValue = application::ApplicationDriver(simulationApplication2);
2290  testComm.Barrier();
2291  if(myRank == 0)
2292  std::cout << "Done running PlasCom2." << std::endl;
2293 
2294  if(returnValue > 0){
2295  std::cout << testFunctionName << ": PlasCom2 returned error code ("
2296  << returnValue << "). Test failed." << std::endl;
2297  acousticTestResult = false;
2298  goto endTest;
2299  }
2300 
2301  if(!ix::sys::FILEEXISTS("PlasCom2_000002000.h5")){
2302  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
2303  << "output file (PlasCom2_000002000.h5). Test failed." << std::endl;
2304  acousticTestResult = false;
2305  goto endTest;
2306  }
2307 
2308  if(myRank == 0){
2309  errorTolerance = 0; // do not tolerate errors for restarted vs. original
2310  std::cout << "Comparing results to expected....";
2311  returnValue = plascom2::util::PC2Compare("PlasCom2_000002000.h5",
2312  "original/PlasCom2_000002000.h5",
2313  errorTolerance,compareStream);
2314  std::cout << (returnValue == 0 ? "passed." : "failed.")
2315  << std::endl;
2316  }
2317 
2318  testComm.Barrier();
2319 
2320  if(returnValue > 0){
2321  std::cout << testFunctionName << ": Resulting state comparison "
2322  << "yielded negative result:"
2323  << std::endl
2324  << compareStream.str()
2325  << std::endl;
2326  acousticTestResult = false;
2327  goto endTest;
2328  }
2329 
2330  endTest:
2331  {
2332  ix::sys::ChDir(originalDirectory);
2333  parallelUnitResults.UpdateResult("PlasCom2:Restart",
2334  acousticTestResult);
2335  }
2336 
2337  testComm.Barrier();
2338  return;
2339 }
2340 
2341 void TestPlasCom2_AcousticPulseSponge3D(ix::test::results &parallelUnitResults,
2342  pcpp::CommunicatorType &testComm)
2343 {
2344  bool acousticTestResult = true;
2345 
2346  int myRank = testComm.Rank();
2347  int numProc = testComm.NProc();
2348 
2349  const std::string testFunctionName("TestPlasCom2_AcousticPulseSponge3D");
2350  const std::string testSuiteName("InviscidTests");
2351  const std::string testCaseName("AcousticPulseSponge3D");
2352  const std::string testDirectory(testSuiteName+"/"+testCaseName);
2353  const std::string originalDirectory(ix::sys::CWD());
2354  std::ostringstream compareStream;
2355  double errorTolerance = 5e-14;
2356 
2357  testComm.Barrier();
2358  if(myRank == 0)
2359  std::cout << "TestFunction: " << testFunctionName << std::endl;
2360 
2361  int argc = 4;
2362  const char *argv[] = {"plascom2x","-c","acousticPulse.config",NULL};
2363 
2364  int returnValue = 0;
2365  pcpp::CommunicatorType pc2Comm(testComm);
2366  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
2367 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),testComm.Comm());
2368 
2369  if(!ix::sys::FILEEXISTS(testDirectory)){
2370  acousticTestResult = false;
2371  std::cout << testFunctionName << ": testing directory ("
2372  << testDirectory << ") did not exist. Aborting test."
2373  << std::endl;
2374  goto endTest;
2375  }
2376 
2377  ix::sys::ChDir(testDirectory);
2378  ix::sys::ChDir("PlasCom2");
2379 
2380  if(myRank == 0)
2381  ix::sys::Remove("PlasCom2_000000010.h5");
2382 
2383  testComm.Barrier();
2384  if(myRank == 0)
2385  std::cout << "Running PlasCom2..." << std::endl;
2386  returnValue = application::ApplicationDriver(simulationApplication);
2387  testComm.Barrier();
2388  if(myRank == 0)
2389  std::cout << "Done running PlasCom2." << std::endl;
2390 
2391  if(returnValue > 0){
2392  std::cout << testFunctionName << ": PlasCom2 returned error code ("
2393  << returnValue << "). Test failed." << std::endl;
2394  acousticTestResult = false;
2395  goto endTest;
2396  }
2397 
2398  ix::sys::ChDir("../");
2399 
2400 
2401  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000010.h5")){
2402  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
2403  << "output file (PlasCom2/PlasCom2_000000010.h5). Test failed." << std::endl;
2404  acousticTestResult = false;
2405  goto endTest;
2406  }
2407 
2408  if(testComm.Rank() == 0){
2409  std::cout << "Comparing results to expected....";
2410  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000010.h5",
2411  "CM/flocm_acousticpulse_10.h5",
2412  errorTolerance,compareStream);
2413  std::cout << (returnValue == 0 ? "passed." : "failed.")
2414  << std::endl;
2415  }
2416 
2417  if(returnValue > 0){
2418  std::cout << testFunctionName << ": Resulting state comparison "
2419  << "yielded negative result:"
2420  << std::endl
2421  << compareStream.str()
2422  << std::endl;
2423  acousticTestResult = false;
2424  goto endTest;
2425  }
2426 
2427  endTest:
2428  {
2429  ix::sys::ChDir(originalDirectory);
2430  parallelUnitResults.UpdateResult("PlasCom2:Euler:AcousticPulseSponge3D",
2431  acousticTestResult);
2432  }
2433 
2434  testComm.Barrier();
2435  return;
2436 }
2437 
2438 void TestPlasCom2_APRectilinearSponge3D(ix::test::results &parallelUnitResults,
2439  pcpp::CommunicatorType &testComm)
2440 {
2441  bool acousticTestResult = true;
2442 
2443  int myRank = testComm.Rank();
2444  int numProc = testComm.NProc();
2445 
2446  const std::string testFunctionName("TestPlasCom2_APRectilinearSponge3D");
2447  const std::string testSuiteName("InviscidTests");
2448  const std::string testCaseName("AcousticPulseSponge3D");
2449  const std::string testDirectory(testSuiteName+"/"+testCaseName);
2450  const std::string originalDirectory(ix::sys::CWD());
2451  std::ostringstream compareStream;
2452  double errorTolerance = 5e-14;
2453 
2454  testComm.Barrier();
2455  if(myRank == 0)
2456  std::cout << "TestFunction: " << testFunctionName << std::endl;
2457 
2458  int argc = 4;
2459  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};
2460 
2461  int returnValue = 0;
2462  pcpp::CommunicatorType pc2Comm(testComm);
2463  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
2464 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),testComm.Comm());
2465 
2466  if(!ix::sys::FILEEXISTS(testDirectory)){
2467  acousticTestResult = false;
2468  std::cout << testFunctionName << ": testing directory ("
2469  << testDirectory << ") did not exist. Aborting test."
2470  << std::endl;
2471  goto endTest;
2472  }
2473 
2474  ix::sys::ChDir(testDirectory);
2475  ix::sys::ChDir("PlasCom2");
2476 
2477  testComm.Barrier();
2478  if(myRank == 0)
2479  if(ix::sys::FILEEXISTS("PlasCom2_000000010.h5")){
2480  ix::sys::Remove("PlasCom2_000000010.h5");
2481  }
2482 
2483  testComm.Barrier();
2484  if(myRank == 0)
2485  std::cout << "Running PlasCom2..." << std::endl;
2486  returnValue = application::ApplicationDriver(simulationApplication);
2487  testComm.Barrier();
2488  if(myRank == 0)
2489  std::cout << "Done running PlasCom2." << std::endl;
2490 
2491  if(returnValue > 0){
2492  std::cout << testFunctionName << ": PlasCom2 returned error code ("
2493  << returnValue << "). Test failed." << std::endl;
2494  acousticTestResult = false;
2495  goto endTest;
2496  }
2497 
2498  ix::sys::ChDir("../");
2499 
2500 
2501  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000010.h5")){
2502  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
2503  << "output file (PlasCom2/PlasCom2_000000010.h5). Test failed." << std::endl;
2504  acousticTestResult = false;
2505  goto endTest;
2506  }
2507 
2508  if(testComm.Rank() == 0){
2509  std::cout << "Comparing results to expected....";
2510  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000010.h5",
2511  "CM/flocm_acousticpulse_10.h5",
2512  errorTolerance,compareStream);
2513  std::cout << (returnValue == 0 ? "passed." : "failed.")
2514  << std::endl;
2515  }
2516 
2517  if(returnValue > 0){
2518  std::cout << testFunctionName << ": Resulting state comparison "
2519  << "yielded negative result:"
2520  << std::endl
2521  << compareStream.str()
2522  << std::endl;
2523  acousticTestResult = false;
2524  goto endTest;
2525  }
2526 
2527  endTest:
2528  {
2529  ix::sys::ChDir(originalDirectory);
2530  parallelUnitResults.UpdateResult("PlasCom2:Euler:RectilinearSponge3D",
2531  acousticTestResult);
2532  }
2533 
2534  testComm.Barrier();
2535  return;
2536 }
2537 
2538 
2539 void TestPlasCom2_APCurvilinearSponge3D(ix::test::results &parallelUnitResults,
2540  pcpp::CommunicatorType &testComm)
2541 {
2542  bool acousticTestResult = true;
2543 
2544  int myRank = testComm.Rank();
2545  int numProc = testComm.NProc();
2546 
2547  const std::string testFunctionName("TestPlasCom2_APCurvilinearSponge3D");
2548  const std::string testSuiteName("InviscidTests");
2549  const std::string testCaseName("AcousticPulseSponge3D");
2550  const std::string testDirectory(testSuiteName+"/"+testCaseName);
2551  const std::string originalDirectory(ix::sys::CWD());
2552  std::ostringstream compareStream;
2553  double errorTolerance = 5e-14;
2554 
2555  testComm.Barrier();
2556  if(myRank == 0)
2557  std::cout << "TestFunction: " << testFunctionName << std::endl;
2558 
2559  int argc = 4;
2560  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};
2561 
2562  int returnValue = 0;
2563  pcpp::CommunicatorType pc2Comm(testComm);
2564  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());
2565 // plascom2::application simulationApplication(argc,const_cast<char **>(argv),testComm.Comm());
2566 
2567  if(!ix::sys::FILEEXISTS(testDirectory)){
2568  acousticTestResult = false;
2569  std::cout << testFunctionName << ": testing directory ("
2570  << testDirectory << ") did not exist. Aborting test."
2571  << std::endl;
2572  goto endTest;
2573  }
2574 
2575  ix::sys::ChDir(testDirectory);
2576  ix::sys::ChDir("PlasCom2");
2577 
2578  testComm.Barrier();
2579  if(myRank == 0)
2580  if(ix::sys::FILEEXISTS("PlasCom2_000000010.h5")){
2581  ix::sys::Remove("PlasCom2_000000010.h5");
2582  }
2583 
2584  testComm.Barrier();
2585  if(myRank == 0)
2586  std::cout << "Running PlasCom2..." << std::endl;
2587  returnValue = application::ApplicationDriver(simulationApplication);
2588  testComm.Barrier();
2589  if(myRank == 0)
2590  std::cout << "Done running PlasCom2." << std::endl;
2591 
2592  if(returnValue > 0){
2593  std::cout << testFunctionName << ": PlasCom2 returned error code ("
2594  << returnValue << "). Test failed." << std::endl;
2595  acousticTestResult = false;
2596  goto endTest;
2597  }
2598 
2599  ix::sys::ChDir("../");
2600 
2601 
2602  if(!ix::sys::FILEEXISTS("PlasCom2/PlasCom2_000000010.h5")){
2603  std::cout << testFunctionName << ": PlasCom2 failed to produce expected" << std::endl
2604  << "output file (PlasCom2/PlasCom2_000000010.h5). Test failed." << std::endl;
2605  acousticTestResult = false;
2606  goto endTest;
2607  }
2608 
2609  if(testComm.Rank() == 0){
2610  std::cout << "Comparing results to expected....";
2611  returnValue = plascom2::util::PC2Compare("PlasCom2/PlasCom2_000000010.h5",
2612  "CM/flocm_acousticpulse_10.h5",
2613  errorTolerance,compareStream);
2614  std::cout << (returnValue == 0 ? "passed." : "failed.")
2615  << std::endl;
2616  }
2617 
2618  if(returnValue > 0){
2619  std::cout << testFunctionName << ": Resulting state comparison "
2620  << "yielded negative result:"
2621  << std::endl
2622  << compareStream.str()
2623  << std::endl;
2624  acousticTestResult = false;
2625  goto endTest;
2626  }
2627 
2628  endTest:
2629  {
2630  ix::sys::ChDir(originalDirectory);
2631  parallelUnitResults.UpdateResult("PlasCom2:Euler:CurvilinearSponge3D",
2632  acousticTestResult);
2633  }
2634 
2635  testComm.Barrier();
2636  return;
2637 }
2638 
TestPlasCom2_APCurvilinearFarfield3D
void TestPlasCom2_APCurvilinearFarfield3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:837
TestPlasCom2_AcousticPulseFarfield3D
void TestPlasCom2_AcousticPulseFarfield3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:633
TestPlasCom2_AcousticPulsePeriodic3D
void TestPlasCom2_AcousticPulsePeriodic3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1555
application::ApplicationDriver
int ApplicationDriver(ApplicationType &simulationApplication)
Definition: include/Application.H:18
TestPlasCom2_AcousticPulseFarfield2D
void TestPlasCom2_AcousticPulseFarfield2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:336
TestPlasCom2_APCurvilinearSlipwall2D
void TestPlasCom2_APCurvilinearSlipwall2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1144
ix::sys::Remove
int Remove(const std::string &fname)
Definition: UnixUtils.C:141
TestPlasCom2_APRectilinearPeriodic3D
void TestPlasCom2_APRectilinearPeriodic3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1655
simulation::application::domainvector
std::vector< DomainBaseType > domainvector
Definition: Simulation.H:32
TestPlasCom2_APCurvilinearSlipwall3D
void TestPlasCom2_APCurvilinearSlipwall3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1452
TestPlasCom2_APRectilinearFarfield3D
void TestPlasCom2_APRectilinearFarfield3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:735
plascom2::util::PC2Compare
int PC2Compare(const std::string &redFileName, const std::string &blueFileName, double errTolerance, std::ostream &outStream)
Read two HDF5 files and compare the state data therein.
Definition: PC2Util.C:30
TestPlasCom2_APRectilinearSponge3D
void TestPlasCom2_APRectilinearSponge3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:2438
TestPlasCom2_Restart
void TestPlasCom2_Restart(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:2197
pcpp::comm::CheckResult
bool CheckResult(bool &localResult, pcpp::CommunicatorType &testComm)
Definition: PCPPCommUtil.C:176
ix::sys::ChDir
int ChDir(const std::string &path)
Definition: UnixUtils.C:297
TestPlasCom2_AcousticPulsePeriodic2D
void TestPlasCom2_AcousticPulsePeriodic2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:22
ix::test::results
Encapsulating class for collections of test results.
Definition: Testing.H:18
state_t
simulation::state::base state_t
Definition: TestPlasCom2.C:20
ix::sys::CreateDirectory
int CreateDirectory(const std::string &fname)
Definition: UnixUtils.C:217
TestPlasCom2_AcousticPulseSponge3D
void TestPlasCom2_AcousticPulseSponge3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:2341
ix::sys::FILEEXISTS
bool FILEEXISTS(const std::string &fname)
Definition: UnixUtils.C:189
TestPlasCom2_APCurvilinearPeriodic2D
void TestPlasCom2_APCurvilinearPeriodic2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:231
ix::comm::CommunicatorObject
Main encapsulation of MPI.
Definition: COMM.H:62
TestPlasCom2_AcousticPulseSlipwall2D
void TestPlasCom2_AcousticPulseSlipwall2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:939
Testing.H
Testing constructs for unit testing.
ix::sys::Rename
int Rename(const std::string &source_file, const std::string &target_file)
Definition: UnixUtils.C:132
TestPlasCom2_APCurvilinearSponge3D
void TestPlasCom2_APCurvilinearSponge3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:2539
TestPlasCom2_APRectilinearSlipwall3D
void TestPlasCom2_APRectilinearSlipwall3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1348
TestPlasCom2_APCurvilinearSponge2D
void TestPlasCom2_APCurvilinearSponge2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:2085
ix::sys::CWD
const std::string CWD()
Definition: UnixUtils.C:291
TestPlasCom2_APRectilinearSlipwall2D
void TestPlasCom2_APRectilinearSlipwall2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1042
ix::test::results::UpdateResult
void UpdateResult(const std::string &name, const ValueType &result)
Updates an existing test result.
Definition: Testing.H:55
TestPlasCom2_APRectilinearFarfield2D
void TestPlasCom2_APRectilinearFarfield2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:435
DomainVector
plascom2::application::domainvector DomainVector
Definition: TestPlasCom2.C:18
TestPlasCom2_APRectilinearSponge2D
void TestPlasCom2_APRectilinearSponge2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1970
TestPlasCom2_APRectilinearPeriodic2D
void TestPlasCom2_APRectilinearPeriodic2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:127
pbsgrid_t
simulation::grid::parallel_blockstructured pbsgrid_t
Definition: TestPlasCom2.C:19
TestPlasCom2_AcousticPulseSponge2D
void TestPlasCom2_AcousticPulseSponge2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1861
TestPlasCom2_AcousticPulseSlipwall3D
void TestPlasCom2_AcousticPulseSlipwall3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1246
TestPlasCom2_APCurvilinearFarfield2D
void TestPlasCom2_APCurvilinearFarfield2D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:534
TestPlasCom2_APCurvilinearPeriodic3D
void TestPlasCom2_APCurvilinearPeriodic3D(ix::test::results &parallelUnitResults, pcpp::CommunicatorType &testComm)
Definition: TestPlasCom2.C:1758
simulation::grid::parallel_blockstructured
Definition: Grid.H:387