mesh.h

//  Copyright (c) 2019 Prashant K. Jha
//  Copyright (c) 2019 Patrick Diehl
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
#ifndef FE_MESH_H
#define FE_MESH_H
 
#include "util/point.h" // definition of struct Point3
#include <hpx/config.hpp>
#include <string>
#include <vector>
 
// forward declaration of geometry deck
namespace inp {
struct MeshDeck;
}
 
namespace fe {
 
class Mesh {
 
public:
 
  Mesh();
 
  explicit Mesh(size_t dim = 0);
 
  explicit Mesh(inp::MeshDeck *deck);
 
  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::Point3 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::Point3> &getNodes() const { return d_nodes; };
  std::vector<util::Point3> &getNodes() { return d_nodes; };
 
  const std::vector<util::Point3> *getNodesP() const { return &d_nodes; };
  std::vector<util::Point3> *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; };
 
  const std::vector<size_t> getPrescribedNodes() const {return d_prescribed_nodes;};
  std::vector<size_t> getPrescribedNodes() {return d_prescribed_nodes;};
 
  const std::vector<util::Point3> getPrescribedValues() const {return d_prescribed_values;};
  std::vector<util::Point3> getPrescribedValues() {return d_prescribed_values;};
 
  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::Point3> getElementConnectivityNodes(const size_t
                                                              &i) const {
    std::vector<util::Point3> 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;
  };
 
 
  void setMeshData(const size_t &dim, std::vector<util::Point3> &nodes,
                   std::vector<double> &volumes);
 
  void setNodes(std::vector<util::Point3> &nodes);
 
  void setNodalVolumes(std::vector<double> &volumes);
 
  void setFixity(std::vector<uint8_t> &fixity);
 
  void setFixity(const size_t &i, const unsigned int &dof, const bool &flag);
 
  void setMeshSize(const double &h);
 
  void readFromFile(inp::MeshDeck *deck, const std::string &filename);
 
  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); };
 
private:
  void createData(const std::string &filename, bool ref_config, bool is_centroid_based, bool has_coupling_data);
 
  void nodesAtCentroid();
 
  void computeVol();
 
  void computeBBox();
 
  void computeMeshSize();
 
  size_t d_numNodes;
 
  size_t d_numElems;
 
  size_t d_eType;
 
  size_t d_eNumVertex;
 
  std::vector<util::Point3> 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;
 
  std::vector<size_t> d_prescribed_nodes;
 
 
  std::vector<util::Point3> d_prescribed_values;
 
  size_t d_dim;
 
  std::string d_spatialDiscretization;
 
  std::string d_filename;
 
  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;
 
  bool d_keepElementConn;
};
 
} // namespace fe
 
#endif // FE_MESH_H