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"

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 unsigned int & density,
                           const unsigned int & temp) const;

  virtual void update();

  virtual void setMaterialNames(std::vector<std::string> names) { _material_names = names; }

  unsigned int nBins() const;

  virtual unsigned int getTemperatureBin(const Elem * const elem) const;

  virtual unsigned int getDensityBin(const Elem * const elem) 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 unsigned int & temp_bin,
                              const unsigned int & density_bin,
                              const unsigned int & subdomain_bin) const;

  virtual const bool & hasGraveyard() const { return _build_graveyard; }

  void setGraveyard(bool build);

  virtual unsigned int nDensityBins() const { return _n_density_bins; }

  virtual bool hasDensitySkinning() const { return _bin_by_density; }

  const std::shared_ptr<moab::Interface> & moabPtr() const { return _moab; }

protected:
  enum class BoundaryConditionType
  {
    Transmission,
    Vacuum,
    Reflective
  };

  std::unique_ptr<NumericVector<Number>> _serialized_solution;

  std::shared_ptr<moab::Interface> _moab;

  bool _verbose;

  const std::string & _temperature_name;

  const Real & _temperature_min;

  const Real & _temperature_max;

  const unsigned int & _n_temperature_bins;

  const Real _temperature_bin_width;

  const bool _bin_by_density;

  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::string _density_name;

  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;

  Real _density_min;

  Real _density_max;

  Real _density_bin_width;

  unsigned int _n_density_bins;

  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<Real> _temperature_bin_bounds;

  std::vector<Real> _density_bin_bounds;

  std::vector<std::vector<unsigned int>> _tet4_nodes;

  std::vector<std::vector<unsigned int>> _tet10_nodes;

  unsigned int _temperature_var_num;

  unsigned int _density_var_num;

  const unsigned int NODES_PER_MOAB_TET = 4;

  const Real BIN_TOLERANCE = 1e-6;

  std::map<SubdomainID, std::string> _block_id_to_material_name;
};