MoabSkinner.h

Go to the documentation of this file.

#pragma once
 
#include "GeneralUserObject.h"
#include "MaterialBase.h"
#include "MooseMesh.h"
 
#include "moab/Core.hpp"
#include "moab/Skinner.hpp"
#include "moab/GeomTopoTool.hpp"
#include "MBTagConventions.hpp"
 
struct BinnedField
{
  std::string name;
  unsigned int var_num;
  Real min;
  Real max;
  Real width;
  unsigned int n_bins;
  std::vector<Real> bounds;
};
 
class MoabSkinner : public GeneralUserObject
{
public:
  MoabSkinner(const InputParameters & parameters);
 
  static InputParameters validParams();
 
  virtual void execute() override;
 
  virtual void initialize() override;
 
  virtual void finalize() override;
 
  virtual void threadJoin(const UserObject & /* uo */) override {}
 
  virtual moab::ErrorCode check(const moab::ErrorCode input) const;
 
  std::string materialName(const unsigned int & block) const;
 
  virtual void update();
 
  virtual void setMaterialNames(std::vector<std::string> names) { _material_names = names; }
 
  unsigned int nBins() const;
 
  virtual unsigned int getFieldBin(const unsigned int & field_index, const Elem * const elem) const;
 
  virtual unsigned int getFieldBin(const std::string & name, const Elem * const elem) const;
 
  bool binsByField(const std::string & name) const;
 
  std::vector<std::string> binnedFieldNames() const;
 
  virtual unsigned int getSubdomainBin(const Elem * const elem) const
  {
    return _blocks.at(elem->subdomain_id());
  }
 
  void setUseDisplacedMesh(const bool & use);
 
  virtual void setScaling(const Real & scale) { _scaling = scale; }
 
  virtual void setVerbosity(const bool & verbose) { _verbose = verbose; }
 
  virtual void makeDependentOnExternalAction() { _standalone = false; }
 
  unsigned int getAuxiliaryVariableNumber(const std::string & name,
                                          const std::string & param_name) const;
 
  void reset();
 
  virtual unsigned int getBin(const Elem * const elem) const;
 
  virtual const bool & hasGraveyard() const { return _build_graveyard; }
 
  void setGraveyard(bool build);
 
  const std::shared_ptr<moab::Interface> & moabPtr() const { return _moab; }
 
protected:
  enum class BoundaryConditionType
  {
    Transmission,
    Vacuum,
    Reflective
  };
 
  virtual unsigned int getFieldBin(const BinnedField & field, const Elem * const elem) const;
 
  void readFieldParameters();
 
  std::unique_ptr<NumericVector<Number>> _serialized_solution;
 
  std::shared_ptr<moab::Interface> _moab;
 
  bool _verbose;
 
  std::vector<BinnedField> _fields;
 
  std::vector<std::string> _material_names;
 
  const Real & _faceting_tol;
 
  const Real & _geom_tol;
 
  const Real & _graveyard_scale_inner;
 
  const Real & _graveyard_scale_outer;
 
  const bool & _output_skins;
 
  const bool & _output_full;
 
  bool _build_graveyard;
 
  bool _set_implicit_complement_material = false;
 
  std::string _implicit_complement_group_name;
 
  bool _use_displaced;
 
  Real _scaling;
 
  unsigned int _n_write;
 
  bool _standalone;
 
  bool _tet_mesh_built;
 
  std::unique_ptr<MeshBase> _tet_mesh;
 
  enum Sense
  {
    BACKWARDS = -1,
    FORWARDS = 1
  };
 
  struct VolData
  {
    moab::EntityHandle vol;
    Sense sense;
  };
 
  MooseMesh & getMooseMesh();
 
  MeshBase & getDAGMCGeometryMesh();
 
  void buildTetMesh();
 
  void createMOABElems();
 
  virtual void createTags();
 
  void
  createGroup(const unsigned int & id, const std::string & name, moab::EntityHandle & group_set);
 
  void
  createVol(const unsigned int & id, moab::EntityHandle & volume_set, moab::EntityHandle group_set);
 
  void createSurf(const unsigned int & id,
                  moab::EntityHandle & surface_set,
                  moab::Range & faces,
                  const std::vector<VolData> & voldata,
                  BoundaryConditionType bc_type = BoundaryConditionType::Transmission);
 
  void createSurfaces(moab::Range & faces,
                      VolData & voldata,
                      unsigned int & surf_id,
                      BoundaryConditionType bc_type = BoundaryConditionType::Transmission);
 
  void createSurfaceFromBox(const BoundingBox & box,
                            const VolData & voldata,
                            unsigned int & surf_id,
                            bool normalout,
                            const Real & factor);
 
  std::vector<moab::EntityHandle> createNodesFromBox(const BoundingBox & box,
                                                     const Real & factor) const;
 
  void createCornerTris(const std::vector<moab::EntityHandle> & verts,
                        unsigned int corner,
                        unsigned int v1,
                        unsigned int v2,
                        unsigned int v3,
                        bool normalout,
                        moab::Range & surface_tris);
 
  moab::EntityHandle createTri(const std::vector<moab::EntityHandle> & vertices,
                               unsigned int v1,
                               unsigned int v2,
                               unsigned int v3);
 
  void updateSurfData(moab::EntityHandle surface_set, const VolData & data);
 
  void
  setTags(moab::EntityHandle ent, std::string name, std::string category, unsigned int id, int dim);
 
  void setTagData(moab::Tag tag, moab::EntityHandle ent, std::string data, unsigned int SIZE);
 
  void setTagData(moab::Tag tag, moab::EntityHandle ent, void * data);
 
  const std::vector<std::vector<unsigned int>> & getTetSets(ElemType type) const;
 
  void buildGraveyard(unsigned int & vol_id, unsigned int & surf_id);
 
  virtual void findBlocks();
 
  virtual void sortElemsByResults();
 
  void findSurfaces();
 
  std::set<BoundaryID> boundaryNamesToIDs(const std::vector<BoundaryName> & names,
                                          const std::string & param_name);
 
  void checkBoundaryConditionOverlap() const;
 
  BoundaryConditionType boundaryConditionType(const Elem * const elem,
                                              const unsigned int side,
                                              const libMesh::BoundaryInfo & boundary_info) const;
 
  void splitSkinByBoundaryCondition(const moab::Range & region,
                                    const moab::Range & skin,
                                    moab::Range & transmission_tris,
                                    moab::Range & vacuum_tris,
                                    moab::Range & reflective_tris);
 
  void createSurfacesFromSkin(const moab::Range & region,
                              moab::Range & skin,
                              VolData & voldata,
                              unsigned int & surf_id);
 
  void recordBoundaryConditionSurface(moab::EntityHandle surface_set,
                                      BoundaryConditionType bc_type);
 
  BoundaryConditionType recordedBoundaryCondition(moab::EntityHandle surface_set) const;
 
  unsigned int firstBoundaryConditionGroupID() const;
 
  void createBoundaryConditionGroups();
 
  std::string boundaryConditionGroupName(BoundaryConditionType bc_type) const;
 
  void groupLocalElems(std::set<dof_id_type> elems, std::vector<moab::Range> & localElems);
 
  bool resetMOAB();
 
  void findSurface(const moab::Range & region,
                   moab::EntityHandle group,
                   unsigned int & vol_id,
                   unsigned int & surf_id,
                   moab::EntityHandle & volume_set);
 
  virtual void write();
 
  std::unique_ptr<moab::Skinner> skinner;
 
  std::unique_ptr<moab::GeomTopoTool> gtt;
 
  std::map<dof_id_type, std::vector<moab::EntityHandle>> _id_to_elem_handles;
 
  std::unordered_map<dof_id_type, moab::EntityHandle> _node_id_to_handle;
 
  moab::EntityHandle offset;
 
  std::set<BoundaryID> _vacuum_bcs_surface_ids;
 
  std::set<BoundaryID> _reflective_bcs_surface_ids;
 
  std::map<moab::EntityHandle, BoundaryConditionType> _surface_bc_types;
 
  std::unordered_map<moab::EntityHandle, dof_id_type> _elem_handle_to_id;
 
  bool _set_bcs;
 
  unsigned int _n_block_bins;
 
  std::vector<std::set<dof_id_type>> _elem_bins;
 
  std::map<SubdomainID, unsigned int> _blocks;
 
  moab::EntityHandle _all_tets;
 
  std::map<moab::EntityHandle, std::vector<VolData>> surfsToVols;
 
  moab::Tag geometry_dimension_tag;
 
  moab::Tag id_tag;
 
  moab::Tag faceting_tol_tag;
 
  moab::Tag geometry_resabs_tag;
 
  moab::Tag category_tag;
 
  moab::Tag name_tag;
 
  std::vector<std::vector<unsigned int>> _tet4_nodes;
 
  std::vector<std::vector<unsigned int>> _tet10_nodes;
 
  const unsigned int NODES_PER_MOAB_TET = 4;
 
  const Real BIN_TOLERANCE = 1e-6;
 
  std::map<SubdomainID, std::string> _block_id_to_material_name;
};