gmsh_file_v4.h

 
#ifndef INCG0eae50bb4868430ebde754b70d7f7f47
#define INCG0eae50bb4868430ebde754b70d7f7f47
 
#include <lf/mesh/mesh.h>
 
#include <optional>
 
namespace lf::io {
 
struct GMshFileV4 {
  std::string version_number = "4.1";
  bool is_binary = false;
  int size_t_size = 8;
  struct PhysicalName {
    int dimension = 0;
    int physical_tag = 0;
    std::string name;
  };
 
  std::vector<PhysicalName> physical_names;
 
  struct PointEntity {
    int tag = -1;
    Eigen::Vector3d coord;
    std::vector<int> physical_tags;
  };
 
  struct Entity {
    int tag = -1;
    Eigen::Vector3d min_coord;
    Eigen::Vector3d max_coord;
 
    std::vector<int> physical_tags;
    std::vector<int> bounding_entities;
  };
 
  std::tuple<std::vector<PointEntity>, std::vector<Entity>, std::vector<Entity>,
             std::vector<Entity>>
      entities;
 
  struct GhostEntity {
    int tag;
 
    int partition;
  };
 
  struct PartitionedPointEntity {
    int tag = -1;
 
    int parent_dim = -1;
 
    int parent_tag = -1;
 
    std::vector<int> partitions;
 
    Eigen::Vector3d coord;
 
    std::vector<int> physical_tags;
  };
 
  struct PartitionedEntity {
    int tag = -1;
 
    int parent_dim = -1;
 
    int parent_tag = -1;
 
    std::vector<int> partitions;
 
    Eigen::Vector3d min_coord;
 
    Eigen::Vector3d max_coord;
 
    std::vector<int> physical_tags;
 
    std::vector<int> bounding_entities;
  };
 
  struct PartitionedEntities {
    std::size_t num_partitions = 0;
 
    std::vector<GhostEntity> ghost_entities;
 
    std::tuple<std::vector<PartitionedPointEntity>,
               std::vector<PartitionedEntity>, std::vector<PartitionedEntity>,
               std::vector<PartitionedEntity>>
        partitioned_entities;
  };
 
  PartitionedEntities partitioned_entities;
 
  struct NodeBlock {
    int entity_dim = -1;
 
    int entity_tag = -1;
 
    bool parametric = false;
 
    std::vector<std::pair<std::size_t, Eigen::Vector3d>> nodes;
  };
 
  struct Nodes {
    std::size_t num_nodes = -1;
 
    std::size_t min_node_tag = 0;
 
    std::size_t max_node_tag = 0;
 
    std::vector<NodeBlock> node_blocks;
  };
 
  Nodes nodes;
 
  enum class ElementType : int {
    EDGE2 = 1,     
    TRIA3 = 2,     
    QUAD4 = 3,     
    TET4 = 4,      
    HEX8 = 5,      
    PRISM6 = 6,    
    PYRAMID5 = 7,  
    EDGE3 = 8,     
    TRIA6 = 9,     
    QUAD9 = 10,    
    TET10 = 11,    
    HEX27 = 12,    
    PRISM18 = 13,  
    PYRAMID14 = 14,  
    POINT = 15,      
    QUAD8 = 16,      
    HEX20 = 17,      
    PRISM15 = 18,    
    PYRAMID13 = 19,  
    TRIA9 = 20,      
    TRIA10 = 21,     
    TRIA12 = 22,     
    TRIA15 = 23,     
    TRIA15_5 = 24,   
    TRIA21 = 25,  
    EDGE4 = 26,   
    EDGE5 = 27,   
    EDGE6 = 28,   
    TET20 = 29,   
    TET35 = 30,   
    TET56 = 31,   
    HEX64 = 92,   
    HEX125 = 93   
  };
 
  static const std::vector<ElementType> AllElementTypes;
 
  struct ElementBlock {
    int dimension = -1;
 
    int entity_tag = -1;
 
    ElementType element_type = ElementType::EDGE2;
 
    std::vector<std::pair<std::size_t, std::vector<std::size_t>>> elements;
  };
 
  struct Elements {
    std::size_t num_elements = 0;
 
    std::size_t min_element_tag = 0;
 
    std::size_t max_element_tag = 0;
 
    std::vector<ElementBlock> element_blocks;
  };
 
  Elements elements;
 
  struct PeriodicLink {
    int dimension = 0;
    int entity_tag_slave = 0;
    int entity_tag_master = 0;
 
    std::optional<Eigen::Matrix4d> affine_transform;
 
    std::vector<std::pair<std::size_t, std::size_t>> node_mapping;
  };
 
  std::vector<PeriodicLink> periodic_links;
 
  struct GhostElement {
    std::size_t element_tag = 0;
 
    int partition_tag = -1;
 
    std::vector<int> ghost_partition_tags;
  };
 
  std::vector<GhostElement> ghost_elements;
};
 
base::RefEl RefElOf(GMshFileV4::ElementType et);
 
int DimOf(GMshFileV4::ElementType et);
 
int NumNodes(GMshFileV4::ElementType et);
 
std::ostream& operator<<(std::ostream& stream, GMshFileV4::ElementType et);
 
GMshFileV4 ReadGmshFileV4(std::string::const_iterator begin,
                          std::string::const_iterator end,
                          const std::string& version, bool is_binary,
                          int size_t_size, int one,
                          const std::string& filename);
 
}  // namespace lf::io
 
 
template <>
struct fmt::formatter<lf::io::GMshFileV4::ElementType> : ostream_formatter {};
 
#endif  // INCG0eae50bb4868430ebde754b70d7f7f47