PostBL.hpp

Go to the documentation of this file.

#ifndef MESHKIT_PostBL_HPP
#define MESHKIT_PostBL_HPP

#include <cassert>
#include <string>
#include <vector>
#include <set>
#include <math.h>
#include <iomanip>

#include "meshkit/Types.hpp"
#include "meshkit/Error.hpp"
#include "meshkit/MeshScheme.hpp"
#include "meshkit/ModelEnt.hpp"
#include "meshkit/MKCore.hpp"
#include "meshkit/SizingFunction.hpp"
#include "meshkit/RegisterMeshOp.hpp"

#include "meshkit/LocalSet.hpp"
#include "meshkit/LocalTag.hpp"
#include "meshkit/Matrix.hpp"

#include "meshkit/iMesh.hpp"
#include "meshkit/iGeom.hpp"
#include "MBCN.h"

#include "meshkit/SimpleArray.hpp"
#include "meshkit/parser.hpp"
#include "meshkit/clock.hpp"
#include "meshkit/mstream.hpp"

#include "MBiMesh.hpp"
#include "moab/Interface.hpp"
#include "moab/Range.hpp"
#include "moab/CartVect.hpp"


#include "moab/Skinner.hpp"
#include "moab/AdaptiveKDTree.hpp"
#include "moab/Matrix3.hpp"
#include "moab/verdict/VerdictWrapper.hpp"
#include "moab/ReadUtilIface.hpp"


namespace MeshKit {

#define DEFAULT_TEST_POSTBL  "test_postbl.inp"

  class MKCore;

  class PostBL : public MeshScheme
  {
  public:
    /* \brief Constructor
     *
     * Create a new PostBL instance
     * \param impl the iGeom instance handle for the Geom
     */
    PostBL(MKCore *mk, const MEntVector &me_vec);

    /* \brief Destructor
     */
    virtual ~PostBL();

    static const char* name();

    static bool can_mesh(iBase_EntityType dim);

    static bool can_mesh(ModelEnt *me);

    static const moab::EntityType* output_types();

    virtual const moab::EntityType* mesh_types_arr() const;

    virtual bool add_modelent(ModelEnt *model_ent);

    virtual void setup_this();

    virtual void execute_this();


    void Algo2 ();

    void PrepareIO (int argc, char *argv[], std::string TestDir);

    void get_normal_quad (std::vector<moab::EntityHandle>conn, moab::CartVect &v)   ;

    void get_normal_edge (std::vector<moab::EntityHandle>conn, moab::CartVect AB, moab::CartVect &v);

    void get_det_jacobian (std::vector<moab::EntityHandle> conn, int offset, double &detJ);

    void find_min_edge_length (moab::Range, moab::EntityHandle, moab::Range, double &e_len);
    
    int push_bulk_mesh(VerdictWrapper vw);
    
    int compute_normals();
    
    int create_bl_elements(VerdictWrapper vw);

  private:
    iGeom *igeom;

    iMesh *imesh;

    moab::Interface *mb;
    moab::Tag GDTag, GIDTag, NTag, MTag, STag, FTag, MNTag, MatIDTag, BLNodeIDTag;
    std::vector<moab::EntityHandle> old_hex, new_vert, conn, qconn, tri_conn, tet_conn;
    std::vector<moab::EntityHandle> adj_qconn, 
            old_hex_conn, adj_hex_nodes1;
    moab::CartVect surf_normal;
    moab::Range quads, nodes,edges, fixmat_ents;
    double coords_new_quad[3];
    double coords_old_quad[3];    
    moab::EntityHandle hex, hex1, hex2;
    moab::Range::iterator mset_it, set_it;
    moab::EntityHandle mthis_set, geom_set;
    moab::Range sets, n_sets, m_sets;
    
    
    // ! parser related
    bool debug, hybrid, check_bl_edge_length;
    // !! file Input
    std::ifstream m_FileInput;
    mstream m_LogFile;
    std::string szInputString;
    std::string szComment;
    int MAXCHARS, m_nLineNumber;
    // all_bl is the vector storing the number of materials a particular boundary layer node is attached to
    std::vector<int> blmaterial_id, all_bl;
    
    // ! variables to parse
    std::string m_InputFile, m_MeshFile, m_OutFile, m_LogName, m_MeshType;
    int m_SurfId, m_NeumannSet, m_Material, m_HConn, hex27;
    double m_Thickness, m_MinEdgeLength;
    int m_Intervals, m_JacCalls, tri_sch, fixmat;
    double m_Bias, m_JLo, m_JHi;
    // ! variable for hex and tet meshes
    int m_Conn, m_BElemNodes;
    int m_GD, m_BLDim;
    std::string m_Card;
    int err;

    // ! error handlers
    enum ErrorStates { INVALIDINPUT};
    void IOErrorHandler (ErrorStates) const;
  };

  inline const char* PostBL::name()
  {
    return "PostBL";
  }

  inline bool PostBL::can_mesh(iBase_EntityType)
  {
    return false;
  }

  inline bool PostBL::can_mesh(ModelEnt *)
  {
    return true;
  }

  inline const moab::EntityType* PostBL::mesh_types_arr() const
  {
    return output_types();
  }

} // namespace MeshKit
#endif