MeshInfo.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "GeneralReporter.h"
 
#include "libmesh/enum_elem_type.h"
#include "libmesh/enum_elem_quality.h"
 
namespace libMesh
{
class EquationSystems;
class System;
class MeshBase;
}
 
class MeshInfo : public GeneralReporter
{
public:
  static InputParameters validParams();
 
  MeshInfo(const InputParameters & parameters);
 
  enum BoundType : int
  {
    MIN = 0,
    MAX = 1
  };
 
  struct DomainElemQuality : public std::pair<libMesh::ElemQuality, BoundType>
  {
    DomainElemQuality() = default;
    DomainElemQuality(const libMesh::ElemQuality elem_quality, const BoundType bound_type);
 
    libMesh::ElemQuality & elemQuality() { return this->first; }
    const libMesh::ElemQuality & elemQuality() const { return this->first; }
 
    BoundType & boundType() { return this->second; }
    const BoundType & boundType() const { return this->second; }
 
    std::string itemName() const;
    void updateValue(std::map<DomainElemQuality, Real> & quality_map, const Real value) const;
  };
 
  static const std::vector<DomainElemQuality> domain_elem_qualities;
  static const std::vector<libMesh::ElemQuality> elem_qualities;
 
  template <typename IDType>
  struct InfoBase
  {
    using id_type = IDType;
 
    InfoBase() = default;
    InfoBase(const IDType id) : id(id) {}
 
    IDType id;
  };
 
  template <typename IDType>
  struct ElemContainingInfo : public InfoBase<IDType>
  {
    ElemContainingInfo() = default;
    ElemContainingInfo(const IDType id) : InfoBase<IDType>(id) {}
 
    // Bounding box
    BoundingBox bounding_box;
    // Total volume
    Real volume = 0;
  };
 
  template <typename IDType, typename ElemsType>
  struct DomainInfo : public ElemContainingInfo<IDType>
  {
    DomainInfo() = default;
    DomainInfo(const IDType id) : ElemContainingInfo<IDType>(id) {}
 
    std::string name;
    std::map<DomainElemQuality, Real> elem_qualities;
    std::vector<ElemsType> elems;
    std::set<libMesh::ElemType> elem_types;
    Real min_volume = std::numeric_limits<Real>::max();
    Real max_volume = 0;
    std::size_t num_elems = 0;
    std::set<processor_id_type> processor_ids;
  };
  using SidesetInfo = DomainInfo<BoundaryID, std::pair<dof_id_type, unsigned int>>;
  using SubdomainInfo = DomainInfo<SubdomainID, dof_id_type>;
 
  struct ElemInfo : public ElemContainingInfo<dof_id_type>
  {
    ElemInfo() = default;
    ElemInfo(const dof_id_type id, const SubdomainID subdomain_id)
      : ElemContainingInfo<dof_id_type>(id), subdomain_id(subdomain_id)
    {
    }
 
    SubdomainID subdomain_id;
    std::vector<std::pair<libMesh::ElemQuality, Real>> elem_qualities;
    unsigned short dim;
    libMesh::ElemMappingType elem_mapping_type;
    libMesh::ElemType elem_type;
    Real hmax;
    Real hmin;
    std::vector<dof_id_type> neighbor_ids;
    std::vector<dof_id_type> node_ids;
    unsigned int num_sides;
    std::vector<Point> points;
    processor_id_type processor_id;
    unique_id_type unique_id;
  };
 
  struct ElemContainingInfoItems
  {
    ElemContainingInfoItems() = default;
    ElemContainingInfoItems(const MultiMooseEnum & items);
 
    bool bounding_box = false;
    bool volume = false;
  };
 
  struct DomainInfoItems : public ElemContainingInfoItems
  {
    DomainInfoItems() = default;
    DomainInfoItems(const MultiMooseEnum & items, const MultiMooseEnum & elem_qualities);
 
    bool elems = false;
    bool elem_types = false;
    bool max_volume = false;
    bool min_volume = false;
    bool num_elems = false;
    bool processor_ids = false;
 
    std::vector<DomainElemQuality> elem_qualities;
  };
 
  struct ElemInfoItems : public ElemContainingInfoItems
  {
    ElemInfoItems() = default;
    ElemInfoItems(const MultiMooseEnum & items, const MultiMooseEnum & elem_qualities);
 
    bool dim = false;
    bool elem_mapping_type = false;
    bool elem_type = false;
    bool hmax = false;
    bool hmin = false;
    bool neighbor_ids = false;
    bool node_ids = false;
    bool num_sides = false;
    bool points = false;
    bool processor_id = false;
    bool unique_id = false;
    std::vector<libMesh::ElemQuality> elem_qualities;
  };
 
  template <class InfoType, class ItemsType>
  struct InfoMap
  {
    using id_type = typename InfoType::id_type;
    using info_type = InfoType;
    using map_type = std::map<id_type, InfoType>;
 
    InfoMap() = default;
    InfoMap(const ItemsType & items) : items(items) {}
 
    map_type map;
    ItemsType items;
  };
  using ElemInfoMap = InfoMap<ElemInfo, ElemInfoItems>;
  using SidesetInfoMap = InfoMap<SidesetInfo, DomainInfoItems>;
  using SubdomainInfoMap = InfoMap<SubdomainInfo, DomainInfoItems>;
 
  template <class InfoMapType, class ItemsType>
  struct CombinedInfos
  {
    using info_map_type = InfoMapType;
    using id_type = typename InfoMapType::id_type;
    using info_type = typename InfoMapType::info_type;
    using map_type = typename info_map_type::map_type;
    using items_type = ItemsType;
 
    CombinedInfos(info_map_type * local, info_map_type * global, const ItemsType & items);
 
    InfoMapType * const local;
    InfoMapType * const global;
    const ItemsType items;
  };
  using ElemInfos = CombinedInfos<ElemInfoMap, ElemInfoItems>;
  using SidesetInfos = CombinedInfos<SidesetInfoMap, DomainInfoItems>;
  using SubdomainInfos = CombinedInfos<SubdomainInfoMap, DomainInfoItems>;
 
  virtual void initialize() override {}
  virtual void finalize() override {}
  virtual void execute() override;
 
  static bool hasItem(const std::string & name, const MultiMooseEnum & items);
 
protected:
  const MultiMooseEnum & _items;
  const MultiMooseEnum & _elem_items;
  const MultiMooseEnum & _sideset_items;
  const MultiMooseEnum & _subdomain_items;
  const MultiMooseEnum & _elem_qualities;
  const MultiMooseEnum & _sideset_elem_qualities;
  const MultiMooseEnum & _subdomain_elem_qualities;
 
  template <typename T, typename... Args>
  T * declareHelper(const std::string & name, const ReporterMode mode, Args &&... args);
 
private:
  template <class CombinedInfosType>
  CombinedInfosType initCombinedInfos(const std::string & name,
                                      const MultiMooseEnum & items,
                                      const MultiMooseEnum & qualities);
 
  void possiblyAddElemInfo();
 
  template <class CombinedInfosType>
  void possiblyAddDomainInfo(CombinedInfosType & infos);
 
  unsigned int * const _num_dofs;
  unsigned int * const _num_dofs_nl;
  unsigned int * const _num_dofs_aux;
  unsigned int * const _num_dofs_constrained;
  unsigned int * const _num_elem;
  unsigned int * const _num_node;
  unsigned int * const _num_local_dofs;
  unsigned int * const _num_local_dofs_nl;
  unsigned int * const _num_local_dofs_aux;
  unsigned int * const _num_local_elem;
  unsigned int * const _num_local_node;
 
  ElemInfos _elem_infos;
  SidesetInfos _sideset_infos;
  SubdomainInfos _subdomain_infos;
 
  const libMesh::EquationSystems & _equation_systems;
  const libMesh::System & _nonlinear_system;
  const libMesh::System & _aux_system;
  const libMesh::MeshBase & _mesh;
};
 
template <typename T, typename... Args>
T *
MeshInfo::declareHelper(const std::string & name, const ReporterMode mode, Args &&... args)
{
  return hasItem(name, _items) ? &declareValueByName<T>(name, mode, args...) : nullptr;
}
 
void to_json(nlohmann::json &, const MeshInfo::ElemInfoMap &);
void to_json(nlohmann::json &, const MeshInfo::SidesetInfoMap &);
void to_json(nlohmann::json &, const MeshInfo::SubdomainInfoMap &);
 
void dataStore(std::ostream &, MeshInfo::DomainElemQuality &, void *);
void dataLoad(std::istream &, MeshInfo::DomainElemQuality &, void *);
 
void dataStore(std::ostream &, MeshInfo::ElemInfo &, void *);
void dataStore(std::ostream &, MeshInfo::SidesetInfo &, void *);
void dataStore(std::ostream &, MeshInfo::SubdomainInfo &, void *);
void dataLoad(std::istream &, MeshInfo::ElemInfo &, void *);
void dataLoad(std::istream &, MeshInfo::SidesetInfo &, void *);
void dataLoad(std::istream &, MeshInfo::SubdomainInfo &, void *);
 
void dataStore(std::ostream &, MeshInfo::ElemInfoMap &, void *);
void dataStore(std::ostream &, MeshInfo::SidesetInfoMap &, void *);
void dataStore(std::ostream &, MeshInfo::SubdomainInfoMap &, void *);
void dataLoad(std::istream &, MeshInfo::ElemInfoMap &, void *);
void dataLoad(std::istream &, MeshInfo::SidesetInfoMap &, void *);
void dataLoad(std::istream &, MeshInfo::SubdomainInfoMap &, void *);