MKCore.hpp

Go to the documentation of this file.

#ifndef MESHKIT_MKCORE_HPP
#define MESHKIT_MKCORE_HPP

#include "meshkit/Types.hpp"
#include "meshkit/Error.hpp"
#include "meshkit/MKGraph.hpp"
#include "meshkit/iGeom.hpp"
#include "moab/Interface.hpp"
#include "meshkit/iMesh.hpp"
#include "meshkit/iRel.hpp"
#include "lemon/list_graph.h"
#include <vector>

namespace MeshKit {

class SizingFunction;

class VertexMesher;

class EBMesher;

class MeshOpProxy;

class MKCore : public MKGraph
{
public:

  MKCore(iGeom *igeom = NULL, 
         moab::Interface *moab = NULL, 
         iMesh *imesh = NULL, 
         iRel *irel = NULL,
         bool construct_missing_ifaces = true);
  
  virtual ~MKCore();

  static void register_meshop(MeshOpProxy* proxy);
  
  static MeshOpProxy* meshop_proxy(const char *op_name);
  
  static MeshOpProxy* meshop_proxy(unsigned index);
  
  static unsigned num_meshops();
  
  static unsigned int meshop_index(const char *op_name);

  void set_default_meshop(const char *op_name, unsigned short dims);
  
  void set_default_meshop(unsigned op_index, unsigned short dims);
  
  void set_default_meshop(MeshOpProxy* mesh_op, unsigned short dims);
  
  MeshOpProxy* get_default_meshop( unsigned dimension );
  
  void meshop_by_mesh_type(moab::EntityType tp, std::vector<MeshOpProxy*> &ops);
    
  void meshop_by_dimension(int dim, std::vector<MeshOpProxy*> &ops);
    
  void meshop_by_modelent(ModelEnt * const ent, std::vector<MeshOpProxy*> &ops);
    
  MeshOp *construct_meshop(MeshOpProxy* op_info, const MEntVector &me_vec = MEntVector());
    
  MeshOp *construct_meshop(std::string op_name, const MEntVector &me_vec = MEntVector());
    
  MeshOp *construct_meshop(unsigned int dim, const MEntVector &me_vec = MEntVector());
    
  void load_geometry_mesh(const char *geom_filename, 
                          const char *mesh_filename, 
                          const char *geom_options = NULL, 
                          const char *mesh_options = NULL, 
                          int geom_index = 0,
                          int mesh_index = 0,
                          int irel_index = 0,
                          bool relate_too = true,
                          bool populate_too = true);

  void load_geometry(const char *filename, const char *options = NULL, 
                     int geom_index = 0,
                     int mesh_index = 0,
                     int irel_index = 0,
                     bool relate_too = false,
                     bool populate_too = true);

  void load_mesh(const char *filename, const char *options = NULL,
                 int geom_index = 0,
                 int mesh_index = 0,
                 int irel_index = 0,
                 bool relate_too = false,
                 bool populate_too = true);

  void save_geometry(const char *filename, const char *options = NULL,
                     int index = 0);

  void save_mesh(const char *filename, const char *options = NULL,
                 int index = 0);

  void save_mesh_from_model_ents(const char *filename, MEntVector & ments, const char *options = NULL,
                  int index = 0);

  void populate_model_ents(int geom_index = 0, 
                           int mesh_index = 0, 
                           int irel_index = 0, bool only_geom = false);

  void create_mbg_model_entities(moab::EntityHandle modelRootSet, bool geometry);

  void get_entities_by_dimension(int dim, MEntVector &model_ents,
      int igindx = -1);

  void get_entities_by_handle(MEntVector &model_ents);

  iGeom *igeom_instance(unsigned index = 0);
  
  unsigned int add_igeom_instance(iGeom * igeom);

  moab::Interface *moab_instance(unsigned index = 0);
  
  iMesh *imesh_instance(unsigned index = 0);
  
  iRel *irel_instance(unsigned index = 0);

  inline unsigned int add_irel_pair(iRel::PairHandle * pair);

  iRel::PairHandle *irel_pair(unsigned index = 0);

  iRel::PairHandle *group_set_pair(unsigned index = 0);

  iGeom::TagHandle igeom_model_tag(unsigned index = 0);

  moab::Tag moab_model_tag(unsigned index = 0);

  moab::Tag moab_geom_dim_tag(unsigned index = 0);

  moab::Tag moab_global_id_tag(unsigned index = 0);

  VertexMesher *vertex_mesher() const;
  
  void vertex_mesher(VertexMesher *vm);

  EBMesher *eb_mesher() const;
  
  void eb_mesher(EBMesher *ebm);

  SizingFunction *sizing_function(int index);
  
  SizingFunction *sizing_function(double size, bool create_if_missing);
  
  int add_sizing_function(SizingFunction *sf);

  void remove_sizing_function(int index, bool delete_too = true);
  
#if 1

  int initialize_mesh_based_geometry(iBase_EntitySetHandle modelSet);

  void remove_mesh_based_geometry(int index);
#endif

  int number_of_igeom_instances()
  {
    return (int)iGeomInstances.size();
  }
  void delete_model_entities();
  void delete_all();
private:
  void init(bool construct_missing_ifaces);

  void init_opsbydim();

  std::vector<iGeom *> iGeomInstances;
  
  std::vector<moab::Interface *> moabInstances;
  
  std::vector<iMesh *> iMeshInstances;
  
  std::vector<iRel *> iRelInstances;

  std::vector<iRel::PairHandle *> iRelPairs;
  
  std::vector<iRel::PairHandle *> groupSetPairs;
  
  std::vector<iGeom::TagHandle> iGeomModelTags;
  
  std::vector<moab::Tag> moabModelTags;

  std::vector<moab::Tag> moabGeomDimTags;

  std::vector<moab::Tag> moabIDTags;

  std::vector<bool> iCreatedIgeoms, iCreatedMoabs, iCreatedImeshs, iCreatedIrels;

  MEntVector modelEnts[5];
  
  VertexMesher *vertexMesher;

  EBMesher *ebMesher;
  
  MeshOpProxy* defaultMeshOps[4];
  
  std::vector<SizingFunction*> sizingFunctions;
};

inline iGeom *MKCore::igeom_instance(unsigned index) 
{
  if (iGeomInstances.size() <= index)
    throw Error(MK_BAD_INPUT, "No instance of that index.");
  
  return iGeomInstances[index];
}

inline moab::Interface *MKCore::moab_instance(unsigned index)
{
  if (moabInstances.size() <= index)
    throw Error(MK_BAD_INPUT, "No instance of that index.");
  
  return moabInstances[index];
}

inline iMesh *MKCore::imesh_instance(unsigned index) 
{
  if (iMeshInstances.size() <= index)
    throw Error(MK_BAD_INPUT, "No instance of that index.");
  
  return iMeshInstances[index];
}

inline iRel *MKCore::irel_instance(unsigned index)
{
  if (iRelInstances.size() <= index)
    throw Error(MK_BAD_INPUT, "No instance of that index.");

  return iRelInstances[index];
}

inline iRel::PairHandle *MKCore::irel_pair(unsigned index)
{
  if (iRelPairs.size() <= index)
    throw Error(MK_BAD_INPUT, "No pair of that index.");

  return iRelPairs[index];
}

inline unsigned int MKCore::add_irel_pair(iRel::PairHandle * pair)
{
  iRelPairs.push_back(pair);
  return iRelPairs.size()-1;
}

inline iRel::PairHandle *MKCore::group_set_pair(unsigned index)
{
  if (groupSetPairs.size() <= index)
    throw Error(MK_BAD_INPUT, "No pair of that index.");

  return groupSetPairs[index];
}

inline iGeom::TagHandle MKCore::igeom_model_tag(unsigned index)
{
  if (iGeomModelTags.size() <= index)
    throw Error(MK_BAD_INPUT, "No tag of that index.");

  return iGeomModelTags[index];
}

inline moab::Tag MKCore::moab_model_tag(unsigned index)
{
  if (moabModelTags.size() <= index)
    throw Error(MK_BAD_INPUT, "No tag of that index.");

  return moabModelTags[index];
}

inline moab::Tag MKCore::moab_geom_dim_tag(unsigned index)
{
  if (moabGeomDimTags.size() <= index)
    throw Error(MK_BAD_INPUT, "No tag of that index.");

  return moabGeomDimTags[index];
}

inline moab::Tag MKCore::moab_global_id_tag(unsigned index)
{
  if (moabIDTags.size() <= index)
    throw Error(MK_BAD_INPUT, "No tag of that index.");

  return moabIDTags[index];
}

inline void MKCore::vertex_mesher(VertexMesher *vm) 
{
  vertexMesher = vm;
}

inline VertexMesher *MKCore::vertex_mesher() const
{
  return vertexMesher;
}

inline EBMesher *MKCore::eb_mesher() const 
{
  return ebMesher;
}

inline void MKCore::eb_mesher(EBMesher *ebm) 
{
  ebMesher = ebm;
}

inline SizingFunction *MKCore::sizing_function(int index) 
{
    // don't check for NULL here 'cuz sometimes we just want to know there isn't one
    // with that index
  if (index >= (int)sizingFunctions.size())
    throw Error(MK_BAD_INPUT, "Sizing function index outside range of valid indices.");
  else if (index == -1)
    return NULL;

  return sizingFunctions[index];
}
  
} // namespace MeshKit

#endif