TestOverkit.C

Go to the documentation of this file.

#include "Testing.H"
#include "Simulation.H"
#include "OperatorKernels.H"
#include "Stencil.H"
#include "PCPPCommUtil.H"
#include "PCPPReport.H"
#include "PCPPIntervalUtils.H"
#include "PlasCom2.H"
#include "overkit.h"

using pcpp::comm::CheckResult;

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

  std::ostringstream messageStream;

  fixtures::ConfigurationType testConfig;

  bool AssertValue;

  // Set up application
  std::vector<std::string> args;
  args.push_back("plascom2x");
  args.push_back("-c");
  args.push_back("plascom2.test.config");

  std::vector<char *> argv(args.size()+1);
  for (int i = 0; i < args.size(); ++i) {
    argv[i] = const_cast<char *>(args[i].c_str());
  }
  argv[args.size()] = NULL;

  plascom2::application simulationApplication(args.size(),&argv[0],testComm.GetCommunicator());

  int returnValue;

  returnValue = simulationApplication.InitializeApplication();

  // Check that initialization successfully completed
  AssertValue = returnValue == 0;
  parallelUnitResults.UpdateResult("Overkit:Config:ApplicationInitialized",AssertValue);

  returnValue = simulationApplication.ConfigureApplication();

  // Check that configuration successfully completed
  AssertValue = returnValue == 0;
  parallelUnitResults.UpdateResult("Overkit:Config:ApplicationConfigured",AssertValue);

  plascom2::overkit_data *OverkitData = simulationApplication.GetOverkitData();

  ovk_context *Context = OverkitData->context;
  ovk_domain *Domain = OverkitData->domains[0];

  const ovk_context_properties *ContextProperties;
  ovkGetContextProperties(Context, &ContextProperties);

  // Check context comm
  // Overkit duplicates comm interally, but groups should match
  MPI_Comm ContextComm;
  ovkGetContextPropertyComm(ContextProperties, &ContextComm);
  MPI_Comm_compare(ContextComm, testComm.GetCommunicator(), &returnValue);
  AssertValue = returnValue == MPI_CONGRUENT;
  parallelUnitResults.UpdateResult("Overkit:Config:CorrectContextComm",AssertValue);

  const ovk_domain_properties *DomainProperties;
  ovkGetDomainProperties(Domain, &DomainProperties);

  // Check domain name
  char DomainName[64];
  ovkGetDomainPropertyName(DomainProperties, DomainName);
  AssertValue = std::string(DomainName) == "euler3d-test";
  parallelUnitResults.UpdateResult("Overkit:Config:CorrectDomainName",AssertValue);

  // Check domain comm
  // Overkit duplicates comm interally, but groups should match
  MPI_Comm DomainComm;
  ovkGetDomainPropertyComm(DomainProperties, &DomainComm);
  MPI_Comm_compare(DomainComm, testComm.GetCommunicator(), &returnValue);
  AssertValue = returnValue == MPI_CONGRUENT;
  parallelUnitResults.UpdateResult("Overkit:Config:CorrectDomainComm",AssertValue);

  // Check domain dimension
  int NumDims;
  ovkGetDomainPropertyDimension(DomainProperties, &NumDims);
  AssertValue = NumDims == 3;
  parallelUnitResults.UpdateResult("Overkit:Config:CorrectDomainDimension",AssertValue);

  // Check number of grids
  int NumGrids;
  ovkGetDomainPropertyGridCount(DomainProperties, &NumGrids);
  AssertValue = NumGrids == 1;
  parallelUnitResults.UpdateResult("Overkit:Config:CorrectDomainGridCount",AssertValue);

  const ovk_grid *Grid;
  ovkGetGrid(Domain, 1, &Grid);

  const ovk_grid_properties *GridProperties;
  ovkGetGridProperties(Grid, &GridProperties);

  // Check grid name
  char GridName[64];
  ovkGetGridPropertyName(GridProperties, GridName);
  AssertValue = std::string(GridName) == "box:grid1";
  parallelUnitResults.UpdateResult("Overkit:Config:CorrectDomainName",AssertValue);

  // Check grid comm
  // Overkit duplicates comm interally, but groups should match
  MPI_Comm GridComm;
  ovkGetGridPropertyComm(GridProperties, &GridComm);
  MPI_Comm_compare(GridComm, testComm.GetCommunicator(), &returnValue);
  AssertValue = returnValue == MPI_CONGRUENT;
  parallelUnitResults.UpdateResult("Overkit:Config:CorrectGridComm",AssertValue);

  // Check grid size
  int GridSize[3];
  ovkGetGridPropertySize(GridProperties, GridSize);
  AssertValue = GridSize[0] == 101 && GridSize[1] == 101 && GridSize[2] == 101;
  parallelUnitResults.UpdateResult("Overkit:Config:CorrectGridSize",AssertValue);

  returnValue = simulationApplication.FinalizeApplication();

  // Check that finalization successfully completed
  AssertValue = returnValue == 0;
  parallelUnitResults.UpdateResult("Overkit:Config:ApplicationFinalized",AssertValue);

  // Check that Overkit data was cleaned up
  AssertValue = OverkitData->context == NULL;
  parallelUnitResults.UpdateResult("Overkit:Config:DestroyedContext",AssertValue);

}