mesh.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 FE_MESH_H
#define FE_MESH_H
 
#include "util/point.h" // definition of struct Point
#include <cstdint> // uint8_t type
#include <cstring> // string and size_t type
#include <string>
#include <vector>
 
// forward declaration of geometry deck
namespace inp {
struct MeshDeck;
struct ModelDeck;
}
 
namespace mesh {
 
class Mesh {
 
public:
  explicit Mesh(size_t dim = 0);
 
  explicit Mesh(const inp::MeshDeck *meshDeck, const inp::ModelDeck *modelDeck);
 
  size_t getDimension() const { return d_dim; };
 
  size_t getNumNodes() const { return d_numNodes; };
 
  size_t getNumElements() const { return d_enc.size()/d_eNumVertex; };
 
  size_t getNumDofs() const { return d_numDofs; };
 
  size_t getElementType() const { return d_eType; };
 
  double getMeshSize() const { return d_h; };
 
  util::Point getNode(const size_t &i) const { return d_nodes[i]; };
 
  double getNodalVolume(const size_t &i) const { return d_vol[i]; };
 
  const std::vector<util::Point> &getNodes() const { return d_nodes; };
 
  std::vector<util::Point> &getNodes() { return d_nodes; };
 
  const std::vector<util::Point> *getNodesP() const { return &d_nodes; };
 
  std::vector<util::Point> *getNodesP() { return &d_nodes; };
 
  const std::vector<uint8_t> *getFixityP() const { return &d_fix; };
 
  std::vector<uint8_t> *getFixityP() { return &d_fix; };
 
  const std::vector<uint8_t> &getFixity() const { return d_fix; };
 
  std::vector<uint8_t> &getFixity() { return d_fix; };
 
  const std::vector<double> &getNodalVolumes() const { return d_vol; };
 
  std::vector<double> &getNodalVolumes() { return d_vol; };
 
  const std::vector<double> *getNodalVolumesP() const { return &d_vol; };
 
  std::vector<double> *getNodalVolumesP() { return &d_vol; };
 
  bool isNodeFree(const size_t &i, const unsigned int &dof) const {
 
    // below checks if d_fix has 1st bit (if dof=0), 2nd bit (if dof=1), 3rd
    // bit (if dof=2) is set to 1 or 0. If set to 1, then it means it is fixed,
    // and therefore it returns false
    return !(d_fix[i] >> dof & 1UL);
  };
 
  std::vector<size_t> getElementConnectivity(const size_t &i) const {
    return std::vector<size_t>(d_enc.begin() + d_eNumVertex * i,
                               d_enc.begin() + d_eNumVertex * i + d_eNumVertex);
  };
 
  std::vector<util::Point> getElementConnectivityNodes(const size_t
                                                              &i) const {
    std::vector<util::Point> nds;
    for (size_t k = 0; k < d_eNumVertex; k++)
      nds.emplace_back(d_nodes[d_enc[d_eNumVertex * i + k]]);
    return nds;
  };
 
  const std::vector<size_t> &getElementConnectivities() const {
    return d_enc;
  };
 
  std::vector<size_t> &getElementConnectivities() {
    return d_enc;
  };
 
  const std::vector<size_t> *getElementConnectivitiesP() const {
    return &d_enc;
  };
 
  std::vector<size_t> *getElementConnectivitiesP() {
    return &d_enc;
  };
 
  const std::pair<std::vector<double>, std::vector<double>> &getBoundingBox()
  const {
    return d_bbox;
  };
 
  std::pair<std::vector<double>, std::vector<double>> &getBoundingBox() {
    return d_bbox;
  };
 
  void setFixity(const size_t &i, const unsigned int &dof, const bool &flag);
 
  void clearElementData();
 
  std::string printStr(int nt = 0, int lvl = 0) const;
 
  void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); };
 
public:
  void createData(const std::string &filename, bool ref_config = false);
 
  void loadFromTriangleElements2D(std::vector<util::Point> nodes,
                                  std::vector<size_t> enc,
                                  const inp::MeshDeck *meshDeck,
                                  const inp::ModelDeck *modelDeck);
 
  void loadFromTetraElements3D(std::vector<util::Point> nodes,
                               std::vector<size_t> enc,
                               const inp::MeshDeck *meshDeck,
                               const inp::ModelDeck *modelDeck);
 
  bool readElementData(const std::string &filename);
 
  void computeVol();
 
  void setZCoordinateZero();
 
  void computeBBox();
 
  void computeMeshSize();
 
  size_t d_numNodes;
 
  size_t d_numElems;
 
  size_t d_eType;
 
  size_t d_eNumVertex;
 
  std::vector<util::Point> d_nodes;
 
  std::vector<size_t> d_enc;
 
  std::vector<std::vector<size_t>> d_nec;
 
  std::vector<uint8_t> d_fix;
 
  std::vector<double> d_vol;
 
  size_t d_nPart;
 
  std::string d_partitionMethod;
 
  std::vector<size_t> d_nodePartition;
 
  size_t d_dim;
 
  std::string d_spatialDiscretization;
 
  std::string d_filename;
 
  bool d_needEncData;
 
  bool d_encDataPopulated;
 
  size_t d_numDofs;
 
  std::vector<size_t> d_gMap;
 
  std::vector<int> d_gInvMap;
 
  std::pair<std::vector<double>, std::vector<double>> d_bbox;
 
  double d_h;
 
private:
  void finalizeMeshDerivedFieldsFromCurrentNodes(bool compute_vol_from_elements,
                                                 const std::string &volume_error_note);
};
 
} // namespace mesh
 
#endif // FE_MESH_H