meshDeck.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2026 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#ifndef INP_MESHDECK_H
#define INP_MESHDECK_H
 
#include "deckField.h"
#include "util/io.h"
#include <stdexcept>
#include "util/json.h"
#include <string>
 
namespace inp {
 
struct MeshDeck {
 
  std::string d_filename;
 
  double d_hMeshing;
 
  bool d_createMesh;
 
  std::string d_createMeshInfo;
 
  bool d_writeMeshFile;
 
  std::vector<std::vector<double>> d_voidRegions;
 
  MeshDeck(const json &j = json({})) : d_hMeshing(0.), d_createMesh(false), d_writeMeshFile(true) {
    readFromJson(j);
  };
 
  MeshDeck(std::string filename, double h_meshing = -1.)
      : d_filename(std::move(filename)), d_hMeshing(h_meshing > 0. ? h_meshing : 0.),
        d_createMesh(false), d_writeMeshFile(true) {}
 
  static json getExampleJson(const json &given = json::object()) {
    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;
  }
 
  static json getExampleJson(const std::string &) = delete;
  static json getExampleJson(const char *) = delete;
 
  static const std::vector<Field<MeshDeck>> &fields() {
    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;
  }
 
  static const std::vector<Field<MeshDeck>> &createMeshFields() {
    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;
  }
 
  void readFromJson(const json &j) {
    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.");
    }
  }
 
  std::string printStr(int nt = 0, int lvl = 0) const {
 
    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();
  }
 
  void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); }
};
 
} // namespace inp
 
#endif // INP_MESHDECK_H