inp::MeshDeck Struct Reference

Structure to read and store mesh related input data. More...

#include <meshDeck.h>

Collaboration diagram for inp::MeshDeck:

Public Member Functions
	MeshDeck (const json &j=json({}))
	Constructor.
	MeshDeck (std::string filename, double h_meshing=-1.)
	Constructor for programmatic use (optional meshing size for tests).
void	readFromJson (const json &j)
std::string	printStr (int nt=0, int lvl=0) const
	Returns the string containing printable information about the object.
void	print (int nt=0, int lvl=0) const
	Prints the information about the object.

Static Public Member Functions
static json	getExampleJson (const json &given=json::object())
	Returns example JSON object for ModelDeck configuration.
static json	getExampleJson (const std::string &)=delete
	Rejects a value given where a set of named values is expected.
static json	getExampleJson (const char *)=delete
	Rejects a value given where a set of named values is expected.
static const std::vector< Field< MeshDeck > > &	fields ()
	Reads from json object.
static const std::vector< Field< MeshDeck > > &	createMeshFields ()
	The fields of the CreateMesh sub-block.

Data Fields
std::string	d_filename
	Filename to read mesh data.
double	d_hMeshing
	Target spacing for in-built meshers only (Gmsh uniform / uniform rectangle grid).
bool	d_createMesh
	Specify if we create mesh using in-built gmsh or in-built routine for uniform discretization of rectangle/cuboid.
std::string	d_createMeshInfo
	Selector for in-built mesh creation (e.g. uniform rectangle, gmsh_builtin_mesh for built-in geometries meshed in-process with Gmsh).
bool	d_writeMeshFile
	If true (default), Gmsh-based create-mesh paths write a .msh file; set false for in-memory only.
std::vector< std::vector< double > >	d_voidRegions
	Axis-aligned boxes emptied from an in-built uniform grid (CreateMesh.Void_Regions: [xlo,ylo,zlo,xhi,yhi,zhi]).

Detailed Description

Structure to read and store mesh related input data.

Definition at line 28 of file meshDeck.h.

Constructor & Destructor Documentation

MeshDeck() [1/2]

inp::MeshDeck::MeshDeck ( const json &  j = json({}) )

inline

Constructor.

Definition at line 66 of file meshDeck.h.

                                {})) : d_hMeshing(0.), d_createMesh(false), d_writeMeshFile(true) {
    readFromJson(j);
  };

MeshDeck() [2/2]

inp::MeshDeck::MeshDeck ( std::string  filename, double  h_meshing = -1.  )

inline

Constructor for programmatic use (optional meshing size for tests).

Definition at line 73 of file meshDeck.h.

      : d_filename(std::move(filename)), d_hMeshing(h_meshing > 0. ? h_meshing : 0.),
        d_createMesh(false), d_writeMeshFile(true) {}

Member Function Documentation

createMeshFields()

static const std::vector< Field< MeshDeck > > & inp::MeshDeck::createMeshFields ( )

inlinestatic

The fields of the CreateMesh sub-block.

The sub-block has a table of its own. Its members are members of this deck, so the two tables write into the same object.

Returns

fields The field table

Definition at line 163 of file meshDeck.h.

                                                              {
    static const std::vector<Field<MeshDeck>> f = {
        field(&MeshDeck::d_createMesh, "Flag", false,
              "Generate the mesh rather than read it"),
        field(&MeshDeck::d_createMeshInfo, "Info", std::string("uniform"),
              "Mesh generator used",
              {{"uniform", "gmsh_builtin_mesh"}, {}, {}}),
        field(&MeshDeck::d_hMeshing, "Mesh_Size", 0.,
              "Element size the generator is asked for"),
        field(&MeshDeck::d_writeMeshFile, "Write_Mesh_File", true,
              "Write the generated mesh to File"),
    };
    return f;
  }

References d_createMesh, d_createMeshInfo, d_hMeshing, d_writeMeshFile, and inp::field().

Referenced by getExampleJson(), printStr(), and readFromJson().

Here is the call graph for this function:

Here is the caller graph for this function:

fields()

static const std::vector< Field< MeshDeck > > & inp::MeshDeck::fields ( )

inlinestatic

Reads from json object.

The fields of the block itself

Returns

fields The field table

Definition at line 147 of file meshDeck.h.

                                                    {
    static const std::vector<Field<MeshDeck>> f = {
        field(&MeshDeck::d_filename, "File", std::string(),
              "Mesh file read, or written when one is generated"),
    };
    return f;
  }

References d_filename, and inp::field().

Referenced by printStr(), and readFromJson().

Here is the call graph for this function:

Here is the caller graph for this function:

getExampleJson() [1/3]

static json inp::MeshDeck::getExampleJson ( const char *  )

staticdelete

Rejects a value given where a set of named values is expected.

A file name passed on its own would convert to a JSON string and be read as a set with no keys, so such a call is rejected when compiling.

getExampleJson() [2/3]

static json inp::MeshDeck::getExampleJson ( const json &  given = json::object() )

inlinestatic

Returns example JSON object for ModelDeck configuration.

Returns

JSON object with example configuration

Definition at line 81 of file meshDeck.h.

                                                               {
    const std::vector<std::string> names = {
        "File",  "Mesh_Size",       "Create_Mesh",
        "Info",  "Write_Mesh_File", "Void_Regions"};
    checkNames(given, names);
 
    const auto filename = given.value("File", std::string());
    const auto h_meshing = given.value("Mesh_Size", -1.);
    const auto createMeshInfo =
        given.value("Info", std::string("gmsh_builtin_mesh"));
    const auto writeMeshFile = given.value("Write_Mesh_File", true);
    const auto voidRegions = given.value(
        "Void_Regions", std::vector<std::vector<double>>());
 
    auto j = json({});
    if (!filename.empty())
      j["File"] = filename;
 
    // A mesh size with no filename requests generation. Create_Mesh lets a
    // set both generate a mesh and name the file it is written to or read
    // back from.
    const bool create = given.value("Create_Mesh", false) ||
                        (filename.empty() && h_meshing > 0.);
    if (create) {
      if (!(h_meshing > 0.))
        throw std::runtime_error(
            "MeshDeck::getExampleJson: mesh creation needs a positive "
            "Mesh_Size.");
      auto cm = applyGiven(json{{"Flag", true},
                                {"Info", createMeshInfo},
                                {"Mesh_Size", h_meshing},
                                {"Write_Mesh_File", writeMeshFile}},
                           createMeshFields(), {"Void_Regions"});
      for (const auto &r : voidRegions) {
        if (r.size() != 6)
          throw std::runtime_error(
              "MeshDeck::getExampleJson: each Void_Regions entry needs 6 "
              "values [xlo, ylo, zlo, xhi, yhi, zhi].");
      }
      if (!voidRegions.empty())
        cm["Void_Regions"] = voidRegions;
      j["CreateMesh"] = cm;
    } else if (filename.empty()) {
      throw std::runtime_error(
          "MeshDeck::getExampleJson: a mesh set needs a File or a Mesh_Size.");
    }
    return j;
  }

References inp::applyGiven(), inp::checkNames(), and createMeshFields().

Referenced by inp::ParticleDeck::getParticleMeshExampleJson(), and anonymous_namespace{testDeckRoundTrip.cpp}::testMeshDeck().

Here is the call graph for this function:

Here is the caller graph for this function:

getExampleJson() [3/3]

static json inp::MeshDeck::getExampleJson ( const std::string &  )

staticdelete

Rejects a value given where a set of named values is expected.

A file name passed on its own would convert to a JSON string and be read as a set with no keys, so such a call is rejected when compiling.

print()

void inp::MeshDeck::print ( int  nt = 0, int  lvl = 0  ) const

inline

Prints the information about the object.

Parameters

nt	Number of tabs to append before printing
lvl	Information level (higher means more information)

Definition at line 244 of file meshDeck.h.

{ std::cout << printStr(nt, lvl); }

References printStr().

Here is the call graph for this function:

printStr()

std::string inp::MeshDeck::printStr ( int  nt = 0, int  lvl = 0  ) const

inline

Returns the string containing printable information about the object.

Parameters

nt	Number of tabs to append before printing
lvl	Information level (higher means more information)

Returns

string String containing printable information about the object

Definition at line 223 of file meshDeck.h.

                                                    {
 
    auto tabS = util::io::getTabS(nt);
    std::ostringstream oss;
    oss << tabS << "------- MeshDeck --------" << std::endl << std::endl;
    printFields(*this, oss, fields(), tabS);
    printFields(*this, oss, createMeshFields(), tabS + "  ");
    oss << tabS << "Void_Regions count = " << d_voidRegions.size() << std::endl;
    oss << tabS << "The geometry of a generated mesh is Particle.Set_i at the "
        << "same index." << std::endl;
    oss << tabS << std::endl;
 
    return oss.str();
  }

References createMeshFields(), d_voidRegions, fields(), util::io::getTabS(), and inp::printFields().

Referenced by print().

Here is the call graph for this function:

Here is the caller graph for this function:

readFromJson()

void inp::MeshDeck::readFromJson ( const json &  j )

inline

Definition at line 178 of file meshDeck.h.

                                   {
    if (j.empty())
      return;
 
    readFields(*this, j, fields());
    // Defaults of the sub-block apply whether or not it is present.
    readFields(*this, json::object(), createMeshFields());
 
    if (j.find("CreateMesh") != j.end()) {
      const auto &cm = j.at("CreateMesh");
      readFields(*this, cm, createMeshFields());
 
      // A mesh size written beside the block rather than inside it.
      if (cm.find("Mesh_Size") == cm.end() && d_createMesh &&
          j.find("Mesh_Size") != j.end())
        d_hMeshing = j.at("Mesh_Size").get<double>();
 
      d_voidRegions.clear();
      if (cm.find("Void_Regions") != cm.end()) {
        for (const auto &r : cm.at("Void_Regions")) {
          auto box = r.get<std::vector<double>>();
          if (box.size() != 6)
            throw std::runtime_error(
                "CreateMesh.Void_Regions entries need 6 values [xlo,ylo,zlo,xhi,yhi,zhi].");
          d_voidRegions.push_back(std::move(box));
        }
      }
    }
 
    if (d_createMesh && d_hMeshing <= 0.)
      throw std::runtime_error(
          "In-built mesh creation requires CreateMesh.Mesh_Size (or legacy top-level Mesh_Size).");
 
    if (d_filename.empty() && !d_createMesh) {
      throw std::runtime_error("Mesh filename can not be empty unless CreateMesh is enabled.");
    }
  }

References createMeshFields(), d_createMesh, d_filename, d_hMeshing, d_voidRegions, fields(), and inp::readFields().

Referenced by anonymous_namespace{testDeckRoundTrip.cpp}::testMeshDeck().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

d_createMesh

bool inp::MeshDeck::d_createMesh

Specify if we create mesh using in-built gmsh or in-built routine for uniform discretization of rectangle/cuboid.

Definition at line 46 of file meshDeck.h.

Referenced by createMeshFields(), mesh_gen::createParticleMesh(), and readFromJson().

d_createMeshInfo

std::string inp::MeshDeck::d_createMeshInfo

Selector for in-built mesh creation (e.g. uniform rectangle, gmsh_builtin_mesh for built-in geometries meshed in-process with Gmsh).

Definition at line 52 of file meshDeck.h.

Referenced by createMeshFields(), and mesh_gen::createParticleMesh().

d_filename

std::string inp::MeshDeck::d_filename

Filename to read mesh data.

Definition at line 31 of file meshDeck.h.

Referenced by anonymous_namespace{testMeshGen.cpp}::builtinMeshCheckForGeometry(), mesh_gen::createParticleMesh(), fields(), mesh::Mesh::loadFromTetraElements3D(), mesh::Mesh::loadFromTriangleElements2D(), anonymous_namespace{particleMesh.cpp}::maybeWriteMeshFile(), and readFromJson().

d_hMeshing

double inp::MeshDeck::d_hMeshing

Target spacing for in-built meshers only (Gmsh uniform / uniform rectangle grid).

Read from CreateMesh.Mesh_Size in JSON. It drives mesh generation only; the characteristic length stored on mesh::Mesh is always computed from the generated nodes (same as for meshes read from file).

Definition at line 40 of file meshDeck.h.

Referenced by anonymous_namespace{testMeshGen.cpp}::builtinMeshCheckForGeometry(), createMeshFields(), mesh_gen::createParticleMesh(), and readFromJson().

d_voidRegions

std::vector<std::vector<double> > inp::MeshDeck::d_voidRegions

Axis-aligned boxes emptied from an in-built uniform grid (CreateMesh.Void_Regions: [xlo,ylo,zlo,xhi,yhi,zhi]).

Definition at line 61 of file meshDeck.h.

Referenced by mesh_gen::createParticleMesh(), printStr(), and readFromJson().

d_writeMeshFile

bool inp::MeshDeck::d_writeMeshFile

If true (default), Gmsh-based create-mesh paths write a .msh file; set false for in-memory only.

Definition at line 55 of file meshDeck.h.

Referenced by createMeshFields(), mesh_gen::createParticleMesh(), and anonymous_namespace{particleMesh.cpp}::maybeWriteMeshFile().

---

The documentation for this struct was generated from the following file:

• /home/user/project/src/inp/meshDeck.h