ModelEnt.hpp

Go to the documentation of this file.

#ifndef MESHKIT_MODELENT_HPP
#define MESHKIT_MODELENT_HPP

#include "meshkit/iGeom.hpp"
#include "meshkit/Types.hpp"
#include "moab/Interface.hpp"
#include <cassert>
#include <vector>
#include <set>
#include <map>

namespace MeshKit {

class ModelEnt;
class MKCore;
class IAVariable;

class ModelEnt
{
public:

  ModelEnt(MKCore *mk,
           iGeom::EntityHandle geom_ent,
           int geom_index,
           moab::EntityHandle mesh_ent = 0,
           int mesh_index = -1,
           int irel_index = -1,
           int sizing_index = -1);

  ModelEnt(MKCore *mk,
           iGeom::EntitySetHandle geom_set,
           int geom_index,
           moab::EntityHandle mesh_ent = 0,
           int mesh_index = -1,
           int irel_index = -1,
           int sizing_index = -1,
           IAVariable *ia_var = NULL);

  virtual ~ModelEnt();

  void children(std::vector<MEntVector> &child_ents) const;

  void children(std::vector<MEntVector> &child_ents);

  void children(std::vector<std::vector<moab::EntityHandle> > &child_ents) const;

  void children(std::vector<std::vector<iGeom::EntityHandle> > &child_ents) const;

  void get_adjacencies(int dim, MEntVector &adjs) const;

  void get_adjacencies(int dim, std::vector<iGeom::EntityHandle> &adjs) const;

  void get_adjacencies(int dim, std::vector<moab::EntityHandle> &adjs) const;

  void get_adjacencies(int dim, moab::Range &adjs) const;

  ModelEnt *shared_entity(ModelEnt *ent2, int to_dim);
  
  void get_adjs_bool(MEntVector &from_ents,
                     int to_dim,
                     MEntVector &to_ents,
                     BooleanType op_type,
                     bool only_to_ents = true);

  int dimension() const;
  
  double measure() const;
  
  double measure_discrete() const;
  
  void evaluate(double x, double y, double z, 
                double *close = NULL,
                double *direction = NULL,
                double *curvature1 = NULL,
                double *curvature2 = NULL) const;
  
  void evaluate_discrete(double x, double y, double z, 
                         double *close = NULL,
                         double *direction = NULL,
                         double *curvature1 = NULL,
                         double *curvature2 = NULL) const;
  
  int id() const;
  
  void create_mesh_set(int ordered_flag = -1);

  void commit_mesh(moab::Range &mesh_ents,
                   MeshedState mstate);
  
  void commit_mesh(moab::EntityHandle *mesh_ents,
                   int num_ents,
                   MeshedState mstate);

  void get_mesh(int dim,
                std::vector<moab::EntityHandle> &ments,
                bool bdy_too = false);

  void boundary(int dim,
                std::vector<moab::EntityHandle> &bdy,
                std::vector<int> *senses = NULL,
                std::vector<int> *group_sizes = NULL);

  void boundary(int dim,
                MEntVector &elements,
                std::vector<int> *senses,
                std::vector<int> *group_sizes = NULL);

  void boundary(int dim, 
                moab::Range &ents) const;

  void get_indexed_connect_coords(std::vector<moab::EntityHandle> &ents,
                                  std::vector<int> *senses,
                                  moab::Tag tagh,
                                  std::vector<int> &ents_as_ids,
                                  std::vector<double> &coords,
                                  moab::Range *verts_range = NULL,
                                  int start_index = 0);
  
  MeshedState get_meshed_state();

  void set_meshed_state(MeshedState mstate);

  int sizing_function_index() const;

  void sizing_function_index(int index, bool children_too = true);

  double mesh_interval_size() const;

  int mesh_intervals() const;

  void mesh_intervals(int ints);

  Firmness interval_firmness() const;

  void interval_firmness(Firmness firm);

  bool constrain_even() const;
  
  void constrain_even(bool flag);

  void add_meshop(MeshOp *meshop);
  
  void remove_meshop(MeshOp *meshop);
  
  void get_meshops(std::vector<MeshOp*> &meshops);

  bool is_meshops_list_empty()
  {
    return meshOps.empty();
  }


  MKCore *mk_core() const;
  
  iGeom::EntityHandle geom_handle() const;

  iGeom::EntityHandle geom_handle(moab::EntityHandle ment) const;

  iGeom * igeom_instance() const ;

  moab::Interface * moab_instance() const ;

  moab::EntityHandle mesh_handle() const;

  moab::EntityHandle mesh_handle(iGeom::EntityHandle gent) const;

  moab::EntityHandle mesh_handle(iGeom::EntitySetHandle gent) const;

  int iGeomIndex()
   {return igeomIndex;}

  int iRelPairIndex()
   {return irelIndex;}

  IAVariable *ia_var() {return iaVariable;}
  const IAVariable *ia_var() const {return iaVariable;}
  void ia_var(IAVariable *var) {iaVariable = var;}

private:

  ModelEnt *next_winding(ModelEnt *this_edge, 
                            int this_sense, 
                            MEntVector &tmp_adjs);
  
  void init_parents_children();

  void init_group_contents();
  
  void set_downward_senses();
  
  MKCore *mkCore;

  int igeomIndex;

  int meshIndex;

  int irelIndex;

  iGeom::EntityHandle iGeomEnt;
  
  iGeom::EntitySetHandle iGeomSet;
  
  moab::EntityHandle moabEntSet;
  
  int sizingFunctionIndex;
  
  int meshIntervals;
  
  Firmness intervalFirmness;

  bool constrainEven;
  
  MeshedState meshedState;

  std::vector<MeshOp*> meshOps;

  IAVariable *iaVariable;
};

inline MKCore *ModelEnt::mk_core() const
{
  return mkCore;
}

inline iGeom::EntityHandle ModelEnt::geom_handle() const
{
  return iGeomEnt;
}

inline moab::EntityHandle ModelEnt::mesh_handle() const
{
  return moabEntSet;
}

inline void ModelEnt::children(std::vector<std::vector<moab::EntityHandle> > &child_ents) const 
{
  std::vector<MEntVector> tmp_vec;
  children(tmp_vec);
  std::vector<moab::EntityHandle> tmp_vec2;
  for (std::vector<MEntVector>::iterator vit1 = tmp_vec.begin(); vit1 != tmp_vec.end(); vit1++) {
    tmp_vec2.clear();
    for (MEntVector::iterator vit2 = (*vit1).begin(); vit2 != (*vit1).end(); vit2++)
      tmp_vec2.push_back((*vit2)->mesh_handle());
    child_ents.push_back(tmp_vec2);
  }
}

inline void ModelEnt::children(std::vector<std::vector<iGeom::EntityHandle> > &child_ents) const
{
  std::vector<MEntVector> tmp_vec;
  children(tmp_vec);
  std::vector<iGeom::EntityHandle> tmp_vec2;
  for (std::vector<MEntVector>::iterator vit1 = tmp_vec.begin(); vit1 != tmp_vec.end(); vit1++) {
    tmp_vec2.clear();
    for (MEntVector::iterator vit2 = (*vit1).begin(); vit2 != (*vit1).end(); vit2++)
      tmp_vec2.push_back((*vit2)->geom_handle());
    child_ents.push_back(tmp_vec2);
  }
}

inline int ModelEnt::sizing_function_index() const 
{
  return sizingFunctionIndex;
}

inline int ModelEnt::mesh_intervals() const 
{
  return meshIntervals;
}

inline void ModelEnt::mesh_intervals(int ints)
{
  meshIntervals = ints;
}

inline Firmness ModelEnt::interval_firmness() const 
{
  return intervalFirmness;
}

inline void ModelEnt::interval_firmness(Firmness firm) 
{
  intervalFirmness = firm;
}

inline bool ModelEnt::constrain_even() const 
{
  return constrainEven;
}

inline void ModelEnt::constrain_even(bool flag) 
{
  constrainEven = flag;
}

inline MeshedState ModelEnt::get_meshed_state() 
{
  return meshedState;
}

inline void ModelEnt::set_meshed_state(MeshedState mstate) 
{
  meshedState = mstate;
}

inline void ModelEnt::evaluate_discrete(double x, double y, double z, 
                                        double *close,
                                        double *direction,
                                        double *curvature1,
                                        double *curvature2) const
{
  evaluate(x, y, z, close, direction, curvature1, curvature2);
}

inline void ModelEnt::add_meshop(MeshOp *meshop) 
{
  assert(std::find(meshOps.begin(), meshOps.end(), meshop) == meshOps.end());
  meshOps.push_back(meshop);
}
  
    /* \brief Remove a MeshOp that pointed to this ModelEnt
     * \param meshop MeshOp to remove
     */
inline void ModelEnt::remove_meshop(MeshOp *meshop)
{
  assert(std::find(meshOps.begin(), meshOps.end(), meshop) != meshOps.end());
  meshOps.erase(std::remove(meshOps.begin(), meshOps.end(), meshop), meshOps.end());
}
  
    /* \brief Get MeshOps pointing to this ModelEnt
     * \param meshop MeshOps returned
     */
inline void ModelEnt::get_meshops(std::vector<MeshOp*> &meshops) 
{
  meshops.resize(meshOps.size());
  std::copy(meshOps.begin(), meshOps.end(), meshops.begin());
}

// TODO: unimplemented functions (these are just here because SWIG expects some
// implementation!
inline void ModelEnt::get_adjacencies(int dim, std::vector<iGeom::EntityHandle> &adjs) const {}
inline void ModelEnt::get_adjacencies(int dim, std::vector<moab::EntityHandle> &adjs) const {}
inline void ModelEnt::get_adjacencies(int dim, moab::Range &adjs) const {}
inline void ModelEnt::children(std::vector<MEntVector> &child_ents) const {}
inline void ModelEnt::children(std::vector<MEntVector> &child_ents) {}

} // namespace meshkit

#endif