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());
  }
  virtual unsigned int getSubdomainBin(const Elem * const elem) const {…}
 
  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:
  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;
 
  const bool & _use_displaced;
 
  Real _scaling;
 
  unsigned int _n_write;
 
  bool _standalone;
 
  enum Sense
  {
    BACKWARDS = -1,
    FORWARDS = 1
  };
  enum Sense {…};
 
  struct VolData
  {
    moab::EntityHandle vol;
    Sense sense;
  };
  struct VolData {…};
 
  MooseMesh & getMooseMesh();
  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);
 
  void createSurfaces(moab::Range & reversed, VolData & voldata, unsigned int & surf_id);
 
  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();
 
  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;
 
  moab::EntityHandle offset;
 
  std::string _density_name;
 
  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;
};
class MoabSkinner : public GeneralUserObject {…};