SCDMesh.hpp

Go to the documentation of this file.

//-----------------------------------C++-------------------------------------//
// File: algs/SCDMesh.hpp
// Author: Stuart R. Slattery
// Wednesday February 2 16:15:8 2011
// Brief: SCDMesh class definition 
//---------------------------------------------------------------------------//

#ifndef MESHKIT_SCDMESH_HPP
#define MESHKIT_SCDMESH_HPP

#include <vector>

#include "meshkit/Types.hpp"
#include "meshkit/Error.hpp"
#include "meshkit/MeshScheme.hpp"
#include "meshkit/ModelEnt.hpp"
#include "meshkit/iGeom.hpp"

#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/Interface.hpp"
#include "moab/ScdInterface.hpp"
#include "moab/GeomTopoTool.hpp"

namespace MeshKit
{

//===========================================================================//
//===========================================================================//


  class SCDMesh : public MeshScheme
  {
  public:

    // 2 different interface types
    // full - full element and vertex representation in moab
    // scd - minimal structured mesh represenation using ScdInterface in MOAB
    enum InterfaceSchemeType { full, scd};

    // 2 different grid scheme types
    // cfMesh - provide a coarse number of i, j, k cells and a number of fine
    //          sub-cells in a given coarse division
    // vtxMesh - provide an exact list of the vertex coordinates to be used
    //           in each direction
    enum GridSchemeType { cfMesh, vtxMesh};

    // 2 different axis scheme types
    // cartesian - i, j, k directions are parallel to the x, y, z axes
    // oriented - i, j, k directions oriented with the primary geometric axes
    enum AxisSchemeType { cartesian, oriented};

    // Set how the geometry volumes will be meshed
    // all - A single structured grid is created for all geometric volumes specified
    // individual - Every geometric volume specified gets its own structured grid
    enum GeomSchemeType { all, individual};

  private:

    // enum types defining the mesh generation
    InterfaceSchemeType interfaceType;
    GridSchemeType gridType;
    AxisSchemeType axisType;
    GeomSchemeType geomType;

    // MOAB ScdInterface instance - generated when InterfaceSchemeType set to scd
    moab::ScdInterface *scdIface;

    // number of coarse divisions in each direction
    unsigned int coarse_i;
    unsigned int coarse_j;
    unsigned int coarse_k;

    // array of fine divisions in each division
    std::vector<int> fine_i;
    std::vector<int> fine_j;
    std::vector<int> fine_k;

    // vertex arrays in each direction
    std::vector<double> i_arr;
    std::vector<double> j_arr;
    std::vector<double> k_arr;

    // error codes
    iGeom::Error gerr;
    moab::ErrorCode rval;

    // bounding box min, max coordiantes
    double minCoord[3], maxCoord[3];

    // number of ijk vertices
    int num_i;
    int num_j;
    int num_k;
    int num_verts;

    // box size increasement ratio, default is 0.0
    double boxIncrease;

    // vertex coordinates
    std::vector<double> full_coords;

    // created vertex and hex ranges
    moab::Range vtx_range;
    moab::Range hex_range;

    moab::Tag bb_tag;

    bool useMeshGeom;

  public:

    SCDMesh(MKCore *mkcore, const MEntVector &me_vec);

    virtual ~SCDMesh();

    virtual void setup_this();

    virtual void execute_this();

    static const char* name() 
      { return "SCDMesh"; }
      
    static bool can_mesh(iBase_EntityType dim)
      { return iBase_REGION == dim; }
  
    static bool can_mesh(ModelEnt* ent) 
      { return canmesh_region(ent); }
    
    static const moab::EntityType* output_types();
  
    virtual const moab::EntityType* mesh_types_arr() const
      { return output_types(); }

    void set_interface_scheme(InterfaceSchemeType scheme);

    InterfaceSchemeType get_interface_scheme() const;

    void set_grid_scheme(GridSchemeType scheme);

    GridSchemeType get_grid_scheme() const;

    void set_axis_scheme(AxisSchemeType scheme);

    AxisSchemeType get_axis_scheme() const;

    void set_geometry_scheme(GeomSchemeType scheme);

    GeomSchemeType get_geometry_scheme() const;

    void set_coarse_i_grid(int coarse_i_);

    void set_coarse_j_grid(int coarse_j_);

    void set_coarse_k_grid(int coarse_k_);

    void set_fine_i_grid(std::vector<int> fine_i_);

    void set_fine_j_grid(std::vector<int> fine_j_);

    void set_fine_k_grid(std::vector<int> fine_k_);

    void get_box_dimension(double* min, double* max);

    void set_box_increase_ratio(double box_increase = .03);

    void use_mesh_geometry(bool use);

    void set_cart_box_min_max(double* min, double* max, double box_increase);


  private:

    void set_cart_box_all();

    void set_cart_box_individual(ModelEnt *this_me);
    
    void create_cart_edges();

    void create_vertex_coords();

    void create_full_mesh(moab::Range& me_range);

    void create_light_mesh(moab::Range& me_range);
    
  }; // end class SCDMesh


  /* Inline Functions */

  inline SCDMesh::~SCDMesh()
  {
  }

  inline void SCDMesh::set_interface_scheme(SCDMesh::InterfaceSchemeType scheme)
  {
    interfaceType = scheme;
  }

  inline SCDMesh::InterfaceSchemeType SCDMesh::get_interface_scheme() const
  {
    return interfaceType;
  }

  inline void SCDMesh::set_grid_scheme(SCDMesh::GridSchemeType scheme)
  {
    gridType = scheme;
  }

  inline SCDMesh::GridSchemeType SCDMesh::get_grid_scheme() const
  {
    return gridType;
  }

  inline void SCDMesh::set_axis_scheme(SCDMesh::AxisSchemeType scheme)
  {
    axisType = scheme;
  }

  inline SCDMesh::AxisSchemeType SCDMesh::get_axis_scheme() const
  {
    return axisType;
  }

  inline void SCDMesh::set_geometry_scheme(SCDMesh::GeomSchemeType scheme)
  {
    geomType = scheme;
  }

  inline SCDMesh::GeomSchemeType SCDMesh::get_geometry_scheme() const
  {
    return geomType;
  }

  inline void SCDMesh::set_coarse_i_grid(int coarse_i_)
  {
    coarse_i = coarse_i_;
  }

  inline void SCDMesh::set_coarse_j_grid(int coarse_j_)
  {
    coarse_j = coarse_j_;
  }

  inline void SCDMesh::set_coarse_k_grid(int coarse_k_)
  {
    coarse_k = coarse_k_;
  }

  inline void SCDMesh::set_fine_i_grid(std::vector<int> fine_i_)
  {
    fine_i = fine_i_;
  }

  inline void SCDMesh::set_fine_j_grid(std::vector<int> fine_j_)
  {
    fine_j = fine_j_;
  }

  inline void SCDMesh::set_fine_k_grid(std::vector<int> fine_k_)
  {
    fine_k = fine_k_;
  }

  inline void SCDMesh::get_box_dimension(double* min, double* max)
  {
    for (int i = 0; i < 3; i++) {
      min[i] = minCoord[i];
      max[i] = maxCoord[i];
    }
  }

  inline void SCDMesh::set_box_increase_ratio(double box_increase) 
  { 
    boxIncrease = box_increase; 
  }

  inline void SCDMesh::use_mesh_geometry(bool use) 
  { 
    useMeshGeom = use;
  }

} // end namespace MeshKit

#endif // end if __SCDMESH_HPP

//---------------------------------------------------------------------------//
// end algs/SCDMesh.hpp
//---------------------------------------------------------------------------//