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 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
 };
 
 struct VolData
 {
 moab::EntityHandle vol;
 Sense sense;
 };
 
 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;
};