anonymous_namespace{testMeshGen.cpp} Namespace Reference

Functions
size_t	meshDimForBuiltin (const std::string &deckName, const std::shared_ptr< geom::GeomObject > &obj)
	Model dimension for mesh deck (annulus deck names map to annulus_object with d_dim set).
bool	testCircleMeshWritesFiles ()
	Circle: write .msh and .vtk via the built-in Gmsh path (file I/O check).
bool	builtinMeshCheckForGeometry (const std::string &geomName, double s)
	For one acceptable geometry name: exampleGeomParams → mesh in memory → non-empty nodes, every node inside geom::box() (loose tolerance).

Function Documentation

builtinMeshCheckForGeometry()

bool anonymous_namespace{testMeshGen.cpp}::builtinMeshCheckForGeometry	(	const std::string &	geomName,
		double	s
	)

For one acceptable geometry name: exampleGeomParams → mesh in memory → non-empty nodes, every node inside geom::box() (loose tolerance).

Definition at line 81 of file testMeshGen.cpp.

                                                                      {
  try {
    auto geom = geom::makeExampleGeomObject(geomName, util::Point(0., 0., 0.), s);
    const double meshSize = s / 5.0;
 
    inp::MeshDeck meshDeck;
    meshDeck.d_hMeshing = meshSize;
    meshDeck.d_filename = std::string("mesh_") + geomName + ".msh";
 
    const size_t dim = meshDimForBuiltin(geomName, geom);
    const auto modelJson =
        inp::ModelDeck::getExampleJson(dim, 0.001, 10, "finite_difference", "central_difference", true,
                                       2, "Multi_Particle", 0);
    inp::ModelDeck modelDeck(modelJson);
 
    mesh::Mesh mesh;
    mesh_gen::generateBuiltinParticleMeshGmsh(geom, meshSize, "", false, false, &mesh, &meshDeck,
                                              &modelDeck);
 
    if (mesh.getNodes().empty()) {
      util::io::log(std::format("Error: mesh check: {} produced zero nodes.\n", geomName));
      return false;
    }
 
    const auto box = geom->box();
    const double tol = 4.0 * meshSize;
    for (const auto &p : mesh.getNodes()) {
      if (p.d_x < box.first.d_x - tol || p.d_y < box.first.d_y - tol || p.d_z < box.first.d_z - tol ||
          p.d_x > box.second.d_x + tol || p.d_y > box.second.d_y + tol || p.d_z > box.second.d_z + tol) {
        util::io::log(std::format(
            "Error: mesh check {}: node ({},{},{}) outside geometry box (tol {}).\n", geomName, p.d_x,
            p.d_y, p.d_z, tol));
        return false;
      }
    }
 
    util::io::log(std::format("  mesh check [ {} ] passed.\n", geomName));
    return true;
  } catch (const std::exception &e) {
    util::io::log(std::format("Error: mesh check {}: {}\n", geomName, e.what()));
    return false;
  }
}

References builtinMeshCheckForGeometry(), inp::MeshDeck::d_filename, inp::MeshDeck::d_hMeshing, mesh_gen::generateBuiltinParticleMeshGmsh(), inp::ModelDeck::getExampleJson(), util::io::log(), geom::makeExampleGeomObject(), and meshDimForBuiltin().

Referenced by builtinMeshCheckForGeometry(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

meshDimForBuiltin()

size_t anonymous_namespace{testMeshGen.cpp}::meshDimForBuiltin	(	const std::string &	deckName,
		const std::shared_ptr< geom::GeomObject > &	obj
	)

Model dimension for mesh deck (annulus deck names map to annulus_object with d_dim set).

Definition at line 33 of file testMeshGen.cpp.

                                                                                              {
  if (obj->d_name == "annulus_object")
    return static_cast<const geom::AnnulusGeomObject &>(*obj).d_dim;
  return geom::getGeomTypeToDim(deckName);
}

References geom::AnnulusGeomObject::d_dim, geom::getGeomTypeToDim(), and meshDimForBuiltin().

Referenced by builtinMeshCheckForGeometry(), and meshDimForBuiltin().

Here is the call graph for this function:

Here is the caller graph for this function:

testCircleMeshWritesFiles()

bool anonymous_namespace{testMeshGen.cpp}::testCircleMeshWritesFiles

(

)

Circle: write .msh and .vtk via the built-in Gmsh path (file I/O check).

Definition at line 42 of file testMeshGen.cpp.

                                 {
  util::io::log("Testing circle mesh file output (gmsh_builtin_mesh)...\n");
 
  const std::vector<double> center = {0.0, 0.0, 0.0};
  const double radius = 0.001;
  const double meshSize = radius / 5.0;
 
  const fs::path outputDir = "test_output/mesh_gen";
  fs::create_directories(outputDir);
 
  try {
    auto circle =
        std::make_shared<geom::Circle>(radius, util::Point(center[0], center[1], center[2]));
    mesh_gen::generateBuiltinParticleMeshGmsh(circle, meshSize, (outputDir / "circle").string(),
                                              true, true, nullptr, nullptr, nullptr);
 
    const bool mshOk = fs::exists(outputDir / "circle.msh");
    const bool vtkOk = fs::exists(outputDir / "circle.vtk");
    if (!mshOk || !vtkOk) {
      util::io::log("Error: Expected circle.msh and circle.vtk under test_output/mesh_gen.\n");
      if (!mshOk)
        util::io::log("Missing: circle.msh\n");
      if (!vtkOk)
        util::io::log("Missing: circle.vtk\n");
      return false;
    }
 
    util::io::log("Circle mesh file output test passed.\n");
    return true;
  } catch (const std::exception &e) {
    util::io::log(std::format("Error in mesh generation: {}\n", e.what()));
    return false;
  }
}

References mesh_gen::generateBuiltinParticleMeshGmsh(), util::io::log(), and testCircleMeshWritesFiles().

Referenced by main(), and testCircleMeshWritesFiles().

Here is the call graph for this function:

Here is the caller graph for this function: