anonymous_namespace{testDeckRoundTrip.cpp} Namespace Reference

Functions
void	check (bool ok, const std::string &what)
void	checkClose (double got, double want, const std::string &what, double tol=1.0e-12)
void	checkIsObject (const json &j, const std::string &key)
void	testModelDeck ()
void	testOutputDeck ()
void	testMaterialDeck ()
void	testMeshDeck ()
void	testContactPairDeck ()
void	testContactDeck ()
void	testNeighborAndGenDecks ()
void	testTestDeck ()
void	testBCBaseDeck ()
void	testBCDeck ()
void	run (void(*fn)(), const std::string &name)

Variables
int	g_failures = 0
int	g_checks = 0

Function Documentation

check()

void anonymous_namespace{testDeckRoundTrip.cpp}::check	(	bool	ok,
		const std::string &	what
	)

Definition at line 39 of file testDeckRoundTrip.cpp.

                                           {
  ++g_checks;
  if (!ok) {
    ++g_failures;
    std::cerr << "  FAIL: " << what << "\n";
  }
}

References g_checks, and g_failures.

Referenced by checkClose(), checkIsObject(), testBCBaseDeck(), testBCDeck(), testContactDeck(), testContactPairDeck(), testMaterialDeck(), testMeshDeck(), testModelDeck(), testNeighborAndGenDecks(), testOutputDeck(), and testTestDeck().

Here is the caller graph for this function:

checkClose()

void anonymous_namespace{testDeckRoundTrip.cpp}::checkClose	(	double	got,
		double	want,
		const std::string &	what,
		double	tol = 1.0e-12
	)

Definition at line 47 of file testDeckRoundTrip.cpp.

                                      {
  check(std::abs(got - want) <= tol * std::max(1.0, std::abs(want)),
        what + " (got " + std::to_string(got) + ", want " +
            std::to_string(want) + ")");
}

References check().

Referenced by testBCBaseDeck(), testContactPairDeck(), testMaterialDeck(), testMeshDeck(), testModelDeck(), and testNeighborAndGenDecks().

Here is the call graph for this function:

Here is the caller graph for this function:

checkIsObject()

void anonymous_namespace{testDeckRoundTrip.cpp}::checkIsObject	(	const json &	j,
		const std::string &	key
	)

The readers call at() and value() on these blocks, so each is an object.

Definition at line 55 of file testDeckRoundTrip.cpp.

                                                        {
  check(j.contains(key), key + " present");
  if (j.contains(key))
    check(j.at(key).is_object(), key + " is an object, not an array");
}

References check().

Referenced by testBCBaseDeck(), testBCDeck(), and testTestDeck().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

void anonymous_namespace{testDeckRoundTrip.cpp}::run	(	void(*)()	fn,
		const std::string &	name
	)

A malformed block makes the reader throw. Recording that as a failed check rather than letting it propagate lets the remaining decks run, so one report names every deck that disagrees.

Definition at line 357 of file testDeckRoundTrip.cpp.

                                              {
  try {
    fn();
  } catch (const std::exception &e) {
    ++g_checks;
    ++g_failures;
    std::cerr << "  FAIL: " << name << " threw: " << e.what() << "\n";
  }
}

References g_checks, and g_failures.

testBCBaseDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck

(

)

Definition at line 281 of file testDeckRoundTrip.cpp.

                      {
  std::cout << "BCBaseDeck\n";
  geom::GeomData region;
  region.d_geomName = "rectangle";
  region.d_geomParams = {0., 0., 0., 1.0e-3, 1.0e-3, 0.};
  geom::createGeomObject(region);
 
  // Region plus both function blocks: all three used to come out as arrays.
  auto j = inp::BCBaseDeck::getExampleJson(
      json{{"Type", "Displacement_BC"},
           {"Particle_List", {0, 1}},
           {"Particle_Exclude_List", {2}},
           {"Direction", {1, 2}},
           {"Zero_Displacement", true},
           {"Time_Function",
            json{{"Type", "linear"},
                 {"Parameters", std::vector<double>{0.5}}}},
           {"Spatial_Function",
            json{{"Type", "constant"},
                 {"Parameters", std::vector<double>{}}}}},
      &region);
  checkIsObject(j, "Region");
  if (j.contains("Region"))
    checkIsObject(j.at("Region"), "Geometry");
  checkIsObject(j, "Time_Function");
  checkIsObject(j, "Spatial_Function");
  check(j.at("Time_Function").contains("Type"),
        "Time_Function.Type survives alongside Parameters");
  check(j.at("Time_Function").contains("Parameters"),
        "Time_Function.Parameters present");
 
  inp::BCBaseDeck d;
  d.readFromJson(j, "Displacement_BC");
  check(d.d_isRegionActive, "Region is picked up by the reader");
  check(d.d_regionGeomData.d_geomName == "rectangle",
        "Region geometry round-trips");
  check(d.d_timeFnType == "linear", "Time_Function.Type round-trips");
  check(d.d_timeFnParams.size() == 1, "Time_Function.Parameters round-trip");
  check(d.d_spatialFnType == "constant", "Spatial_Function.Type round-trips");
  check(d.d_pList.size() == 2, "Particle_List round-trips");
  check(d.d_pNotList.size() == 1, "Particle_Exclude_List round-trips");
  check(d.d_direction.size() == 2, "Direction round-trips");
  check(d.d_isDisplacementZero, "Zero_Displacement round-trips");
 
  // Initial condition shape.
  auto jic = inp::BCBaseDeck::getExampleJson(
      json{{"Type", "IC"},
           {"Particle_List", {1}},
           {"IC_Type", "Constant_Velocity"},
           {"IC_Vector", {0., -2.5, 0.}}});
  checkIsObject(jic, "Constant_Velocity");
  inp::BCBaseDeck dic;
  dic.readFromJson(jic, "IC");
  check(dic.d_icType == "Constant_Velocity", "IC type round-trips");
  checkClose(dic.d_icVec.d_y, -2.5, "IC velocity round-trips");
}

References check(), checkClose(), checkIsObject(), geom::createGeomObject(), inp::BCBaseDeck::d_direction, geom::GeomData::d_geomName, geom::GeomData::d_geomParams, inp::BCBaseDeck::d_icType, inp::BCBaseDeck::d_icVec, inp::BCBaseDeck::d_isDisplacementZero, inp::BCBaseDeck::d_isRegionActive, inp::BCBaseDeck::d_pList, inp::BCBaseDeck::d_pNotList, inp::BCBaseDeck::d_regionGeomData, inp::BCBaseDeck::d_spatialFnType, inp::BCBaseDeck::d_timeFnParams, inp::BCBaseDeck::d_timeFnType, util::Point::d_y, inp::BCBaseDeck::getExampleJson(), and inp::BCBaseDeck::readFromJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testBCDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testBCDeck

(

)

Definition at line 338 of file testDeckRoundTrip.cpp.

                  {
  std::cout << "BCDeck\n";
  auto j = inp::BCDeck::getExampleJson(
      json{{"Displacement_BC_Sets", 1},
           {"IC_Sets", 1},
           {"Gravity", util::Point(0., -10., 0.).toVec()}});
  checkIsObject(j, "Force_BC");
  check(j.at("Force_BC").contains("Gravity"), "Gravity present");
  checkIsObject(j, "Displacement_BC");
  checkIsObject(j, "IC");
}

References check(), checkIsObject(), inp::BCDeck::getExampleJson(), and util::Point::toVec().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testContactDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testContactDeck

(

)

Definition at line 224 of file testDeckRoundTrip.cpp.

                       {
  std::cout << "ContactDeck\n";
  auto j = inp::ContactDeck::getExampleJson(json{{"Sets", 2}});
  check(j.at("Sets") == 2, "Sets count");
  for (const auto &key : {"Set_1_1", "Set_1_2", "Set_2_2"})
    check(j.contains(key), std::string("pair ") + key + " present");
  check(j.contains("Damping_Law"), "Damping_Law present");
  check(j.contains("Correct_Volume"), "Correct_Volume present");
}

References check(), and inp::ContactDeck::getExampleJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testContactPairDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testContactPairDeck

(

)

Definition at line 184 of file testDeckRoundTrip.cpp.

                           {
  std::cout << "ContactPairDeck\n";
  auto j = inp::ContactPairDeck::getExampleJson(
          json{{"Contact_Radius_Factor", 0.95},
               {"Kn", 1.0e12},
               {"Damping_On", true},
               {"Epsilon", 0.9},
               {"Friction_On", true},
               {"Friction_Coeff", 0.5},
               {"Kn_Factor", 2.0},
               {"Beta_n_Factor", 100.},
               {"K", 2.16e7}});
  inp::ContactPairDeck d;
  d.readFromJson(j);
  check(d.d_computeContactR, "Contact_Radius_Factor round-trips");
  checkClose(d.d_contactR, 0.95, "contact radius factor value");
  checkClose(d.d_Kn, 1.0e12, "Kn round-trips");
  checkClose(d.d_eps, 0.9, "Epsilon round-trips");
  check(d.d_frictionOn, "Friction_On round-trips");
  checkClose(d.d_mu, 0.5, "Friction_Coeff round-trips");
  checkClose(d.d_KnFactor, 2.0, "Kn_Factor round-trips");
  checkClose(d.d_betanFactor, 100., "Beta_n_Factor round-trips");
 
  // Damping off must zero the damping factor, not carry it.
  auto j2 = inp::ContactPairDeck::getExampleJson(
          json{{"Contact_Radius_Factor", 0.95},
               {"Kn", 1.0e12},
               {"Damping_On", false},
               {"Epsilon", 0.9},
               {"Friction_On", false},
               {"Friction_Coeff", 0.},
               {"Kn_Factor", 1.},
               {"Beta_n_Factor", 100.},
               {"K", 2.16e7}});
  inp::ContactPairDeck d2;
  d2.readFromJson(j2);
  check(!d2.d_dampingOn, "Damping_On false round-trips");
  checkClose(d2.d_betanFactor, 0., "Beta_n_Factor zeroed when damping is off");
}

References check(), checkClose(), inp::ContactPairDeck::getExampleJson(), and inp::ContactPairDeck::readFromJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testMaterialDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testMaterialDeck

(

)

Definition at line 112 of file testDeckRoundTrip.cpp.

                        {
  std::cout << "MaterialDeck\n";
  // Plane strain on: the writer key and the reader key must agree.
  auto j = inp::MaterialDeck::getExampleJson(
      json{{"Type", "PMBBond"},
           {"Is_Plane_Strain", true},
           {"Horizon", 6.0e-4},
           {"Density", 1200.},
           {"K", 2.16e7},
           {"G", 1.296e7},
           {"Gc", 50.},
           {"E", 3.24e7},
           {"Compute_From_Classical", true},
           {"Influence_Function", json{{"Type", 1}}}});
  inp::MaterialDeck d;
  d.readFromJson(j);
  check(d.d_materialType == "PMBBond", "Type round-trips");
  check(d.d_isPlaneStrain, "Is_Plane_Strain round-trips (writer/reader key)");
  checkClose(d.d_horizon, 6.0e-4, "Horizon round-trips");
  checkClose(d.d_density, 1200., "Density round-trips");
  check(d.d_influenceFnType == 1, "Influence_Function.Type round-trips");
 
  // Plane strain off must also survive.
  auto j2 = inp::MaterialDeck::getExampleJson(
      json{{"Type", "PDState"},
           {"Is_Plane_Strain", false},
           {"Horizon", 6.0e-4},
           {"Density", 1200.},
           {"K", 2.16e7},
           {"G", 1.296e7},
           {"Gc", 50.},
           {"Compute_From_Classical", true},
           {"Influence_Function", json{{"Type", 0}}}});
  inp::MaterialDeck d2;
  d2.readFromJson(j2);
  check(!d2.d_isPlaneStrain, "Is_Plane_Strain false round-trips");
}

References check(), checkClose(), inp::MaterialDeck::getExampleJson(), and inp::MaterialDeck::readFromJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testMeshDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testMeshDeck

(

)

Definition at line 150 of file testDeckRoundTrip.cpp.

                    {
  std::cout << "MeshDeck\n";
  // A mesh size with no filename requests generation.
  auto j = inp::MeshDeck::getExampleJson(json{{"Mesh_Size", 1.0e-4}});
  inp::MeshDeck d;
  d.readFromJson(j);
  check(d.d_createMesh, "bare Mesh_Size still means CreateMesh");
  checkClose(d.d_hMeshing, 1.0e-4, "Mesh_Size round-trips");
 
  // File only.
  auto j2 = inp::MeshDeck::getExampleJson(json{{"File", "mesh.msh"}});
  inp::MeshDeck d2;
  d2.readFromJson(j2);
  check(d2.d_filename == "mesh.msh", "File round-trips");
  check(!d2.d_createMesh, "a plain File does not request mesh creation");
 
  // File plus generation, which is what the examples need.
  auto j3 = inp::MeshDeck::getExampleJson(
      json{{"File", "mesh.msh"},
           {"Mesh_Size", 2.0e-4},
           {"Create_Mesh", true},
           {"Info", "uniform"},
           {"Write_Mesh_File", false},
           {"Void_Regions", {{0., 0., 0., 1., 1., 1.}}}});
  inp::MeshDeck d3;
  d3.readFromJson(j3);
  check(d3.d_filename == "mesh.msh", "File round-trips with CreateMesh");
  check(d3.d_createMesh, "CreateMesh.Flag round-trips");
  check(d3.d_createMeshInfo == "uniform", "CreateMesh.Info round-trips");
  check(!d3.d_writeMeshFile, "Write_Mesh_File round-trips");
  checkClose(d3.d_hMeshing, 2.0e-4, "CreateMesh.Mesh_Size round-trips");
  check(d3.d_voidRegions.size() == 1, "Void_Regions round-trip");
}

References check(), checkClose(), inp::MeshDeck::getExampleJson(), and inp::MeshDeck::readFromJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testModelDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testModelDeck

(

)

Definition at line 61 of file testDeckRoundTrip.cpp.

                     {
  std::cout << "ModelDeck\n";
  auto j = inp::ModelDeck::getExampleJson(
      json{{"Dimension", 3},
           {"Final_Time", 0.25},
           {"Time_Steps", 500},
           {"Discretization_Type", json{{"Spatial", "finite_difference"}, {"Time", "central_difference"}}},
           {"Populate_ElementNodeConnectivity", false},
           {"Quad_Approximation_Order", 3},
           {"Particle_Sim_Type", "Single_Particle"},
           {"Seed", 7}});
  inp::ModelDeck d;
  d.readFromJson(j);
  check(d.d_dim == 3, "Dimension round-trips");
  checkClose(d.d_tFinal, 0.25, "Final_Time round-trips");
  check(d.d_Nt == 500, "Time_Steps round-trips");
  check(!d.d_populateElementNodeConnectivity,
        "Populate_ElementNodeConnectivity round-trips");
  check(d.d_quadOrder == 3, "Quad_Approximation_Order round-trips");
  check(d.d_particleSimType == "Single_Particle",
        "Particle_Sim_Type round-trips");
  check(d.d_seed == 7, "Seed round-trips");
  checkClose(d.d_dt, 0.25 / 500., "dt derived from Final_Time / Time_Steps");
}

References check(), checkClose(), inp::ModelDeck::getExampleJson(), and inp::ModelDeck::readFromJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testNeighborAndGenDecks()

void anonymous_namespace{testDeckRoundTrip.cpp}::testNeighborAndGenDecks

(

)

Definition at line 234 of file testDeckRoundTrip.cpp.

                               {
  std::cout << "PNeighborDeck / PGenDeck\n";
  auto j = inp::PNeighborDeck::getExampleJson(
          json{{"Update_Criteria", "simple_all"},
               {"Search_Factor", 8.},
               {"Search_Interval", 5},
               {"Near_Bd_Nodes_Tol", 0.25}});
  inp::PNeighborDeck d;
  d.readFromJson(j);
  check(d.d_updateCriteria == "simple_all", "Update_Criteria round-trips");
  checkClose(d.d_sFactor, 8., "Search_Factor round-trips");
  check(d.d_neighUpdateInterval == 5, "Search_Interval round-trips");
  checkClose(d.d_nearBdNodesTol, 0.25, "Near_Bd_Nodes_Tol round-trips");
 
  auto jg = inp::PGenDeck::getExampleJson(json{{"Method", "From_File"}});
  check(jg.at("Method") == "From_File", "Method present");
}

References check(), checkClose(), inp::PGenDeck::getExampleJson(), inp::PNeighborDeck::getExampleJson(), and inp::PNeighborDeck::readFromJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testOutputDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testOutputDeck

(

)

Definition at line 86 of file testDeckRoundTrip.cpp.

                      {
  std::cout << "OutputDeck\n";
  auto j = inp::OutputDeck::getExampleJson(
      json{{"File_Format", "vtu"},
           {"Path", "out/"},
           {"Tags", std::vector<std::string>({"Displacement", "Damage_Z"})},
           {"Output_Interval", 25},
           {"Debug", 1},
           {"Perform_FE_Out", false},
           {"Compress_Type", "zlib"},
           {"Perform_Out", true},
           {"Test_Output_Interval", 5},
           {"Tag_PP", "3"},
           {"PVD_Collection", true}});
  inp::OutputDeck d;
  d.readFromJson(j);
  check(d.d_path == "out/", "Path round-trips");
  check(d.d_dtOut == 25, "Output_Interval round-trips");
  check(d.d_debug == 1, "Debug round-trips");
  check(!d.d_performFEOut, "Perform_FE_Out round-trips");
  check(d.d_dtTestOut == 5, "Test_Output_Interval round-trips");
  check(d.d_tagPPFile == "3", "Tag_PP round-trips");
  check(d.d_pvdCollection, "PVD_Collection round-trips");
  check(d.d_outTags.size() == 2, "Tags round-trip");
}

References check(), inp::OutputDeck::getExampleJson(), and inp::OutputDeck::readFromJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testTestDeck()

void anonymous_namespace{testDeckRoundTrip.cpp}::testTestDeck

(

)

Definition at line 252 of file testDeckRoundTrip.cpp.

                    {
  std::cout << "TestDeck\n";
  // An empty name yields an empty block, which the reader ignores.
  auto empty = inp::TestDeck::getExampleJson(json{{"Test_Name", ""}});
  check(empty.empty(), "an unnamed test yields an empty block");
 
  // A plain test name. This used to be emitted as a JSON array.
  auto j = inp::TestDeck::getExampleJson(json{{"Test_Name", "two_particle"}});
  check(j.is_object(), "Test block is an object, not an array");
  inp::TestDeck d;
  d.readFromJson(j);
  check(d.d_testName == "two_particle", "Test_Name round-trips");
 
  // readFromJson requires the sub-block for both spellings of the name.
  for (const std::string name : {"Compressive_Test", "compressive_test"}) {
    auto jc = inp::TestDeck::getExampleJson(
        json{{"Test_Name", name},
             {"Compressive_Test",
              json{{"Wall_Id", 13}, {"Wall_Force_Direction", 2}}}});
    checkIsObject(jc, "Compressive_Test");
    inp::TestDeck dc;
    dc.readFromJson(jc);
    check(dc.d_testName == name, name + ": Test_Name round-trips");
    check(dc.d_particleIdCompressiveTest == 13, name + ": Wall_Id round-trips");
    check(dc.d_particleForceDirectionCompressiveTest == 2,
          name + ": Wall_Force_Direction round-trips");
  }
}

References check(), checkIsObject(), inp::TestDeck::d_particleForceDirectionCompressiveTest, inp::TestDeck::d_particleIdCompressiveTest, inp::TestDeck::d_testName, inp::TestDeck::getExampleJson(), and inp::TestDeck::readFromJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_checks

int anonymous_namespace{testDeckRoundTrip.cpp}::g_checks = 0

Definition at line 37 of file testDeckRoundTrip.cpp.

Referenced by check(), main(), and run().

g_failures

int anonymous_namespace{testDeckRoundTrip.cpp}::g_failures = 0

Definition at line 36 of file testDeckRoundTrip.cpp.

Referenced by check(), main(), and run().