TestPlasCom2Viscous.C

Go to the documentation of this file.

#include "Testing.H"
#include "PlasCom2.H"
#include "Simulation.H"
#include "RKTestFixtures.H"
#include "EulerRHS.H"
#include "Stencil.H"
#include "PCPPCommUtil.H"
#include "PCPPReport.H"
#include "PCPPIntervalUtils.H"
#include "TestFixtures.H"
#include "EulerTestFixtures.H"
#include "PC2Util.H"

#include <cmath>

using pcpp::comm::CheckResult;

typedef plascom2::application::domainvector        DomainVector;
typedef simulation::grid::parallel_blockstructured pbsgrid_t;
typedef simulation::state::base                    state_t;


void TestPlasCom2_ViscousShock2DX_Regression(ix::test::results &parallelUnitResults,
                                            pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_ViscousShock2DX");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock2DX");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  testComm.Barrier();

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","shock.test.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimenPC1X");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock2d_nd2_1000.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock2d_nd_1000.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0)
      ix::sys::Remove("PlasCom2_000001000.h5");

    if(myRank == 0)
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;
    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000001000.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000001000.h5",
                                               "accepted/accepted_shock2d_nd2_1000.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:Shock2DXRegression",viscousShockTestResult);
  }
  
  return;
  
}

void TestPlasCom2_VSCurvilinear2DX_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_VSCurvilinear2DX_Regression");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock2DX");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  testComm.Barrier();
  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  testComm.Barrier();

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimenPC1X");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock2d_nd2_1000.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock2d_nd_1000.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");


  testComm.Barrier();
  if(myRank == 0)
    if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5"))
      ix::sys::Remove("PlasCom2_000001000.h5");
  testComm.Barrier();

  if(myRank == 0)
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    testComm.Barrier();
    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000001000.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000001000.h5",
                                               "accepted/accepted_shock2d_nd2_1000.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:CurvilinearVS2DX",viscousShockTestResult);
  }
  
  testComm.Barrier();
  return;
  
}

void TestPlasCom2_VSRectilinear2DX_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_VSRectilinear2DX_Regression");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock2DX");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  testComm.Barrier();
  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  testComm.Barrier();

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimenPC1X");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock2d_nd2_1000.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock2d_nd_1000.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

  testComm.Barrier();
  if(myRank == 0)
    if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5"))
      ix::sys::Remove("PlasCom2_000001000.h5");

  testComm.Barrier();
  if(myRank == 0)
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    testComm.Barrier();
    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000001000.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000001000.h5",
                                               "accepted/accepted_shock2d_nd2_1000.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:RectilinearVS2DX",viscousShockTestResult);
  }
  
  testComm.Barrier();
  return;
  
}

void TestPlasCom2_Poiseuille2DX_Regression(ix::test::results &parallelUnitResults,
                               pcpp::CommunicatorType &testComm)
{

  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_Poiseuille2DX");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille2DX");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","cartesian.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimenPC1");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille2d_nonDimenPC1_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille2d_nonDimenPC1_100.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");
    if(myRank == 0)
      ix::sys::Remove("PlasCom2_000000100.h5");

    if(myRank == 0)
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_poiseuille2d_nonDimenPC1_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:Poiseuille2DXRegression",poiseulleTestResult);
  }
  return;
}

void TestPlasCom2_PFRectilinear2DX_Regression(ix::test::results &parallelUnitResults,
                               pcpp::CommunicatorType &testComm)
{

  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_Poiseuille2DXRM_Regression");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille2DX");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimenPC1");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille2d_nonDimenPC1_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille2d_nonDimenPC1_100.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
        ix::sys::Remove("PlasCom2_000000100.h5");
      }
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;
    }
    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");


    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_poiseuille2d_nonDimenPC1_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:PF2DXRectilinear",poiseulleTestResult);
  }

  testComm.Barrier();

  return;
}

void TestPlasCom2_PFCurvilinear2DX_Regression(ix::test::results &parallelUnitResults,
                               pcpp::CommunicatorType &testComm)
{

  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_Poiseuille2DXCM_Regression");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille2DX");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimenPC1");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille2d_nonDimenPC1_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille2d_nonDimenPC1_100.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
        ix::sys::Remove("PlasCom2_000000100.h5");
      }
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;
    }
    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");


    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_poiseuille2d_nonDimenPC1_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:PF2DXCurvilinear",poiseulleTestResult);
  }

  testComm.Barrier();

  return;
}


void TestPlasCom2_Poiseuille2DY_Regression(ix::test::results &parallelUnitResults,
                                            pcpp::CommunicatorType &testComm)
{

  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_Poiseuille2DY");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille2DY");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  testComm.Barrier();

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","cartesian.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("dimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille2d_dimen_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille2d_dimen_100.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0)
      ix::sys::Remove("PlasCom2_000000100.h5");

    if(myRank == 0)
      std::cout << "Running dimensional PlasCom2..." << std::endl;

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running dimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_poiseuille2d_dimen_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:Poiseuille2DYRegression",poiseulleTestResult);
  }
  
  return;
  
}

void TestPlasCom2_PFRectilinear2DY_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_PFRectilinear2DY");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille2DY");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  testComm.Barrier();

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("dimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille2d_dimen_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille2d_dimen_100.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000000100.h5"))
        ix::sys::Remove("PlasCom2_000000100.h5");
      std::cout << "Running dimensional PlasCom2..." << std::endl;
    }
    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running dimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    

    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_poiseuille2d_dimen_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:PF2DYRectilinear",poiseulleTestResult);
  }
  
  testComm.Barrier();

  return;  
}

void TestPlasCom2_PFCurvilinear2DY_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_PFCurvilinear2DY");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille2DY");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  testComm.Barrier();

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("dimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille2d_dimen_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille2d_dimen_100.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000000100.h5"))
        ix::sys::Remove("PlasCom2_000000100.h5");
      std::cout << "Running dimensional PlasCom2..." << std::endl;
    }
    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running dimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    

    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_poiseuille2d_dimen_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:PF2DYCurvilinear",poiseulleTestResult);
  }
  
  testComm.Barrier();

  return;  
}

void TestPlasCom2_Poiseuille3DZ_Regression(ix::test::results &parallelUnitResults,
                                            pcpp::CommunicatorType &testComm)
{

  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_Poiseuille3DZ");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille3DZ");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","cartesian.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille3d_nonDimen_10.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille3d_nonDimen_10.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0)
      ix::sys::Remove("PlasCom2_000000010.h5");

    if(myRank == 0)
      std::cout << "Running dimensional PlasCom2..." << std::endl;

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running dimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000010.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000010.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000010.h5",
                                               "accepted/accepted_poiseuille3d_nonDimen_10.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:Poiseuille3DZRegression",poiseulleTestResult);
  }
  
  return;
  
}

void TestPlasCom2_PFRectilinear3DZ_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{
  
  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_PF3DZRectilinear");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille3DZ");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;
  pcpp::CommunicatorType pc2Comm(testComm);

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       pc2Comm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille3d_nonDimen_10.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille3d_nonDimen_10.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000000010.h5"))
        ix::sys::Remove("PlasCom2_000000010.h5");
      std::cout << "Running dimensional PlasCom2..." << std::endl;
    }
    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running dimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000010.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000010.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000010.h5",
                                               "accepted/accepted_poiseuille3d_nonDimen_10.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:PF3DZRectilinear",poiseulleTestResult);
  }

  testComm.Barrier();
  return;
  
}

void TestPlasCom2_PFCurvilinear3DZ_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool poiseulleTestResult = true;

  const std::string testFunctionName("TestPlasCom2_PF3DZCurvilinear");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("Poiseuille3DZ");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    poiseulleTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_poiseuille3d_nonDimen_10.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_poiseuille3d_nonDimen_10.h5) not found."
                  << " Aborting test." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000000010.h5"))
        ix::sys::Remove("PlasCom2_000000010.h5");
      std::cout << "Running dimensional PlasCom2..." << std::endl;
    }
    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running dimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000010.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000010.h5). Test failed." << std::endl;
      poiseulleTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000010.h5",
                                               "accepted/accepted_poiseuille3d_nonDimen_10.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        poiseulleTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  poiseulleTestResult = CheckResult(poiseulleTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:PF3DZCurvilinear",poiseulleTestResult);
  }

  testComm.Barrier();
  return;
  
}

void TestPlasCom2_ViscousShock2DY_Regression(ix::test::results &parallelUnitResults,
                                            pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_ViscousShock2DY");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock2DY");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","shock.test.config",NULL};

  //   plascom2::application simulationApplicationDimen(argc,const_cast<char **>(argv),
  //                                                    testComm.Comm());

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock2d_nd_1000.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock2d_nd_1000.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0)
      ix::sys::Remove("PlasCom2_000001000.h5");

    if(myRank == 0)
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;
    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);
    
    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000001000.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000001000.h5",
                                               "accepted/accepted_shock2d_nd_1000.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:Shock2DYRegression",viscousShockTestResult);
  }
  
  return;
  
}

void TestPlasCom2_VSRectilinear2DY_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_VSRectilinear2DY");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock2DY");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock2d_nd_1000.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock2d_nd_1000.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5"))
        ix::sys::Remove("PlasCom2_000001000.h5");
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;
    }

    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);

    testComm.Barrier();

    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000001000.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000001000.h5",
                                               "accepted/accepted_shock2d_nd_1000.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:VSRectilinear2DY",viscousShockTestResult);
  }

  testComm.Barrier();

  return;
  
}

void TestPlasCom2_VSCurvilinear2DY_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_VSCurvilinear2DY");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock2DY");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};

  plascom2::application simulationApplicationNonDimen2(argc,const_cast<char **>(argv),
                                                       testComm.Comm());
  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock2d_nd_1000.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock2d_nd_1000.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000001000.h5"))
        ix::sys::Remove("PlasCom2_000001000.h5");
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;
    }

    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplicationNonDimen2);

    testComm.Barrier();

    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
  
    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000001000.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000001000.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000001000.h5",
                                               "accepted/accepted_shock2d_nd_1000.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }
    ix::sys::ChDir("../");
  }
  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

  endTest:
  {
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:VSCurvilinear2DY",viscousShockTestResult);
  }

  testComm.Barrier();

  return;
  
}

void TestPlasCom2_ViscousShock3DZ_Regression(ix::test::results &parallelUnitResults,
                                            pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_ViscousShock3DZ");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock3DZ");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","shock.test.config",NULL};

  pcpp::CommunicatorType pc2Comm(testComm);
  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());

  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock3d_nd_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock3d_nd_100.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0)
      ix::sys::Remove("PlasCom2_000000100.h5");
    testComm.Barrier();
    if(myRank == 0)
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;

    returnValue = application::ApplicationDriver(simulationApplication);
    
    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
    
    testComm.Barrier();

    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
    }

    viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

    if(!viscousShockTestResult)
      goto endTest;
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_shock3d_nd_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }

    ix::sys::ChDir("../");
  }

  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);
  
  endTest:
  {
    
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:Shock3DZRegression",viscousShockTestResult);
  }
  
  return;
  
}

void TestPlasCom2_VSRectilinear3DZ_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_VSRectilinear3DZ");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock3DZ");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","rectilinear.config",NULL};

  pcpp::CommunicatorType pc2Comm(testComm);
  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());

  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock3d_nd_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock3d_nd_100.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000000100.h5"))
        ix::sys::Remove("PlasCom2_000000100.h5");
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;
    }

    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplication);
    
    testComm.Barrier();

    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
    
    testComm.Barrier();

    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
    }

    viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

    if(!viscousShockTestResult)
      goto endTest;
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_shock3d_nd_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }

    ix::sys::ChDir("../");
  }

  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);
  
  endTest:
  {
    
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:VSRectilinear3DZ",viscousShockTestResult);
  }
  
  testComm.Barrier();
  return;
  
}

void TestPlasCom2_VSCurvilinear3DZ_Regression(ix::test::results &parallelUnitResults,
                                              pcpp::CommunicatorType &testComm)
{

  bool viscousShockTestResult = true;

  const std::string testFunctionName("TestPlasCom2_VSCurvilinear3DZ");
  const std::string testSuiteName("ViscidTest");
  const std::string testCaseName("ViscousShock3DZ");
  const std::string testDirectory(testSuiteName+"/"+testCaseName);
  const std::string originalDirectory(ix::sys::CWD());
  std::ostringstream compareStream;
  double errorTolerance = 5e-14;

  int myRank = testComm.Rank();

  if(myRank == 0)
    std::cout << "Executing " << testFunctionName << std::endl;

  int argc = 4;
  const char *argv[] = {"plascom2x","-c","curvilinear.config",NULL};

  pcpp::CommunicatorType pc2Comm(testComm);
  plascom2::application simulationApplication(argc,const_cast<char **>(argv),pc2Comm.Comm());

  int returnValue = 0;

  if(!ix::sys::FILEEXISTS(testDirectory)){
    viscousShockTestResult = false;
    if(myRank == 0){
      std::cout << testFunctionName << ": testing directory (" 
                << testDirectory << ") did not exist. Aborting test."
                << std::endl;
    }
    goto endTest;
  }

  ix::sys::ChDir(testDirectory);

  // nonDimensional run using PlasComCM non-dimensionalization
  {
    ix::sys::ChDir("nonDimen");
    
    if(!ix::sys::FILEEXISTS("accepted/accepted_shock3d_nd_100.h5")){
      if(myRank == 0)
        std::cout << testFunctionName << ": Accepted solution file ("
                  << "accepted/accepted_shock3d_nd_100.h5) not found."
                  << " Aborting test." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }

    ix::sys::ChDir("regression");

    if(myRank == 0){
      if(ix::sys::FILEEXISTS("PlasCom2_000000100.h5"))
        ix::sys::Remove("PlasCom2_000000100.h5");
      std::cout << "Running nonDimensional PlasCom2..." << std::endl;
    }

    testComm.Barrier();

    returnValue = application::ApplicationDriver(simulationApplication);
    
    testComm.Barrier();

    if(myRank == 0)
      std::cout << "Done running nonDimensional PlasCom2." << std::endl;
    
    testComm.Barrier();

    if(returnValue > 0){
      std::cout << testFunctionName << ": PlasCom2 returned error code ("
                << returnValue << "). Test failed." << std::endl;
      viscousShockTestResult = false;
    }

    viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);

    if(!viscousShockTestResult)
      goto endTest;
    
    if(!ix::sys::FILEEXISTS("PlasCom2_000000100.h5")){
      std::cout << testFunctionName << ": PlasCom2 failed to produce expected" 
                << std::endl
                << "output file (PlasCom2_000000100.h5). Test failed." << std::endl;
      viscousShockTestResult = false;
      goto endTest;
    }
    
    ix::sys::ChDir("../");
    
    if(myRank == 0){
      std::cout << "Comparing results to expected result...";
      returnValue = plascom2::util::PC2Compare("regression/PlasCom2_000000100.h5",
                                               "accepted/accepted_shock3d_nd_100.h5",
                                               errorTolerance,compareStream);
      if(returnValue == 0)
        std::cout << "passed." << std::endl;
      else {
        std::cout << "failed." << std::endl;
        viscousShockTestResult = false;
        std::cout << testFunctionName << ": Resulting state "
                  << "comparison yielded negative result:"
                  << std::endl
                  << compareStream.str()
                  << std::endl;
      }
    }

    ix::sys::ChDir("../");
  }

  viscousShockTestResult = CheckResult(viscousShockTestResult,testComm);
  
  endTest:
  {
    
    ix::sys::ChDir(originalDirectory);
    parallelUnitResults.UpdateResult("PlasCom2:Viscid:VSCurvilinear3DZ",viscousShockTestResult);
  }
  
  testComm.Barrier();
  return;
  
}