FBEngine.hpp

Go to the documentation of this file.

#ifndef FBENGINE_HPP_
#define FBENGINE_HPP_
#include <cstdlib>
 
#include <vector>
#include <map>
 
#include "moab/Types.hpp"
#include "moab/Interface.hpp"
#include "moab/Range.hpp"
#include "moab/CartVect.hpp"
 
namespace moab
{
class GeomTopoTool;
 
// some forward declarations
class SmoothFace;
class SmoothCurve;
 
/*
 *  Facet Based engine class for mesh-based geometry
 */
class FBEngine
{
  public:
    FBEngine( Interface* impl, GeomTopoTool* geomTopoTool = NULL, const bool smooth = false );
 
    ~FBEngine();
 
    ErrorCode Init();
 
    ErrorCode getRootSet( EntityHandle* root_set );
 
    ErrorCode getNumEntSets( EntityHandle set, int num_hops, int* all_sets );
 
    ErrorCode createEntSet( int isList, EntityHandle* pSet );
 
    ErrorCode addEntSet( EntityHandle entity_set_to_add, EntityHandle entity_set_handle );
 
    ErrorCode getEntities( EntityHandle root_set, int ent_type, Range& gentities );
 
    ErrorCode addEntArrToSet( const Range& entities, EntityHandle set );
 
    ErrorCode getNumOfType( EntityHandle set, int ent_type, int* pNum );
 
    ErrorCode getEntType( EntityHandle gent, int* type );
 
    ErrorCode getEntBoundBox( EntityHandle this_gent,
                              double* x0,
                              double* y0,
                              double* z0,
                              double* x1,
                              double* y1,
                              double* z1 );
    ErrorCode getEntClosestPt( EntityHandle this_gent,
                               double x,
                               double y,
                               double z,
                               double* x1,
                               double* y1,
                               double* y3 );
 
    ErrorCode getVtxCoord( EntityHandle this_gent, double* x0, double* y0, double* z0 );
 
    ErrorCode gsubtract( EntityHandle entity_set_1, EntityHandle entity_set_2, EntityHandle result_entity_set );
 
    ErrorCode getEntNrmlXYZ( EntityHandle entity_handle,
                             double x,
                             double y,
                             double z,
                             double* nrml_i,
                             double* nrml_j,
                             double* nrml_k );
 
    ErrorCode getPntRayIntsct( double x,
                               double y,
                               double z,
                               double dir_x,
                               double dir_y,
                               double dir_z,
                               std::vector< EntityHandle >& intersect_entity_handles,
                               /* int storage_order,*/
                               std::vector< double >& intersect_coords,
                               std::vector< double >& param_coords );
 
    // some new methods, that are needed
 
    ErrorCode createTag( const char* tag_name, int tag_num_type_values, int tag_type, Tag& tag_handle_out );
 
    Interface* moab_instance()
    {
        return _mbImpl;
    }
 
    ErrorCode getArrData( const moab::EntityHandle* entity_handles,
                          int entity_handles_size,
                          Tag tag_handle,
                          void* tag_values_out );
 
    ErrorCode setArrData( const EntityHandle* entity_handles,
                          int entity_handles_size,
                          Tag tag_handle,
                          const void* tag_values );
 
    ErrorCode getEntAdj( EntityHandle handle, int type_requested, Range& adjEnts );
 
    ErrorCode getEgFcSense( EntityHandle mbedge, EntityHandle mbface, int& sense );
 
    ErrorCode measure( const EntityHandle* moab_entities, int entities_size, double* measures );
 
    // to do
    ErrorCode getEntNrmlSense( EntityHandle face, EntityHandle region, int& sense );
 
    ErrorCode getEgEvalXYZ( EntityHandle edge,
                            double x,
                            double y,
                            double z,
                            double& on_x,
                            double& on_y,
                            double& on_z,
                            double& tngt_i,
                            double& tngt_j,
                            double& tngt_k,
                            double& cvtr_i,
                            double& cvtr_j,
                            double& cvtr_k );
    ErrorCode getFcEvalXYZ( EntityHandle face,
                            double x,
                            double y,
                            double z,
                            double& on_x,
                            double& on_y,
                            double& on_z,
                            double& nrml_i,
                            double& nrml_j,
                            double& nrml_k,
                            double& cvtr1_i,
                            double& cvtr1_j,
                            double& cvtr1_k,
                            double& cvtr2_i,
                            double& cvtr2_j,
                            double& cvtr2_k );
 
    ErrorCode getEgVtxSense( EntityHandle edge, EntityHandle vtx1, EntityHandle vtx2, int& sense );
 
    ErrorCode getEntURange( EntityHandle edge, double& u_min, double& u_max );
 
    ErrorCode getEntUtoXYZ( EntityHandle edge, double u, double& x, double& y, double& z );
 
    ErrorCode getEntTgntU( EntityHandle edge, double u, double& i, double& j, double& k );
 
    ErrorCode isEntAdj( EntityHandle entity1, EntityHandle entity2, bool& adjacent_out );
 
    ErrorCode split_surface_with_direction( EntityHandle face,
                                            std::vector< double >& xyz,
                                            double* direction,
                                            int closed,
                                            double min_dot,
                                            EntityHandle& oNewFace );
    // these new points will be on edges or triangles, if in interior of triangles
    ErrorCode split_surface( EntityHandle face,
                             std::vector< EntityHandle >& chainedEdges,
                             std::vector< EntityHandle >& splittingNodes,
                             EntityHandle& newFace );
 
    ErrorCode split_edge_at_point( EntityHandle edge, CartVect& point, EntityHandle& new_edge );
 
    ErrorCode split_edge_at_mesh_node( EntityHandle edge, EntityHandle node, EntityHandle& new_edge );
 
    ErrorCode split_bedge_at_new_mesh_node( EntityHandle b_edge,
                                            EntityHandle atNode,
                                            EntityHandle brokenEdge,
                                            EntityHandle& new_edge );
    // helper for cleaning the stuff
    // will be called if the topology is modified
    void clean();
 
    void delete_smooth_tags();
 
    // access to the geom topo tool
    // be careful what you do with it
    GeomTopoTool* get_gtt()
    {
        return this->_my_geomTopoTool;
    }
 
    ErrorCode create_volume_with_direction( EntityHandle newFace1,
                                            EntityHandle newFace2,
                                            double* direction,
                                            EntityHandle& volume );
 
    // get nodes from edge in order
    ErrorCode get_nodes_from_edge( EntityHandle gedge, std::vector< EntityHandle >& nodes );
 
    ErrorCode weave_lateral_face_from_edges( EntityHandle bEdge,
                                             EntityHandle tEdge,
                                             double* direction,
                                             EntityHandle& newLatFace );
 
    // chain "chain"-able edges
    // this could be useful if there are too many points / edges in the splitting
    // polyline
    // 2 edges are "chain"-able if
    /*
     *  1. they have the same adjacent faces
     *  2. their orientation is such as the end of one is the start of the other
     *  3. at meeting point, their tangents make an angle smaller then something
     *   (cos(angle) > cos (max_angle) = min_dot)
     */
    ErrorCode chain_edges( double min_dot );
 
    // 2 edges will be chained, along with modification of the topology
    ErrorCode chain_two_edges( EntityHandle edge, EntityHandle next_edge );
 
    ErrorCode get_vert_edges( EntityHandle edge, EntityHandle& v1, EntityHandle& v2 );
 
    void set_smooth()
    {
        _smooth = true;
    }
 
  private:
    ErrorCode initializeSmoothing();
 
    ErrorCode getAdjacentEntities( const EntityHandle from, const int to_dim, Range& adj_ents );
 
    ErrorCode compute_intersection_points( EntityHandle& face,
                                           EntityHandle from,
                                           EntityHandle to,
                                           CartVect& Dir,
                                           std::vector< CartVect >& points,
                                           std::vector< EntityHandle >& entities,
                                           std::vector< EntityHandle >& triangles );
 
    ErrorCode BreakTriangle( EntityHandle tri,
                             EntityHandle e1,
                             EntityHandle e3,
                             EntityHandle n1,
                             EntityHandle n2,
                             EntityHandle n3 );  // nodesAlongPolyline are on entities!
 
    ErrorCode BreakTriangle2( EntityHandle tri,
                              EntityHandle e1,
                              EntityHandle e2,
                              EntityHandle n1,
                              EntityHandle n2 );  // nodesAlongPolyline are on entities!
 
    void print_debug_triangle( EntityHandle triangle );
 
    ErrorCode create_new_gedge( std::vector< EntityHandle >& nodesAlongPolyline, EntityHandle& new_geo_edge );
 
    // used for splitting surfaces
    ErrorCode separate( EntityHandle face, std::vector< EntityHandle >& chainedEdges, Range& first, Range& second );
 
    ErrorCode smooth_new_intx_points( EntityHandle face, std::vector< EntityHandle >& chainedEdges );
 
    // having a node, split boundary along that node
    ErrorCode split_boundary( EntityHandle face, EntityHandle atNode );
 
    // see if the node is already part of a vertex set, do not create another one
    bool find_vertex_set_for_node( EntityHandle iNode, EntityHandle& oVertexSet );
 
    // if the splitting edge is not a loop, the original boundary edges will belong to
    // either original face, or new face
    // only the new geo edge (splitting) will be part of both, with the
    // orientation already decided
    //
    ErrorCode redistribute_boundary_edges_to_faces( EntityHandle face,
                                                    EntityHandle newFace,
                                                    std::vector< EntityHandle >& chainedEdges );
 
    // used as a way to isolate the faces after splitting
    ErrorCode set_neumann_tags( EntityHandle face, EntityHandle newFace );
 
    // split the quads if needed; it will create a new gtt, which will
    // contain triangles instead of quads
    ErrorCode split_quads();
 
    ErrorCode boundary_nodes_on_face( EntityHandle face, std::vector< EntityHandle >& boundary_nodes );
 
    ErrorCode boundary_mesh_edges_on_face( EntityHandle face, Range& boundary_mesh_edges );
 
    // used for splitting an edge
    ErrorCode split_internal_edge( EntityHandle& edge, EntityHandle& newVertex );
    // triangle split
    ErrorCode divide_triangle( EntityHandle triangle, EntityHandle& newVertex );
    Interface* _mbImpl;
 
    // this will be used during volume creation
    ErrorCode set_default_neumann_tags();
 
    ErrorCode chain_able_edge( EntityHandle edge, double min_dot, EntityHandle& next_edge, bool& chainable );
 
    GeomTopoTool* _my_geomTopoTool;
    bool _t_created;
    bool _smooth;
    bool _initialized;
    // these are initial ranges, that should not change during geometry gimmicks
    // those that are added are changing gtt ranges, but they are not yet "smoothed"
    // when new geometry is created, these ranges are not yet updated
    Range _my_gsets[5];
    // these are used only for smooth evaluations
    // these smooth faces and edges will be initialized after reading the file
    // the maps keep the link between EH in moab (geom sets) and
    //   their corresponding smooth counterparts
    std::map< EntityHandle, SmoothFace* > _faces;
    std::map< EntityHandle, SmoothCurve* > _edges;
    SmoothFace** _smthFace;
    SmoothCurve** _smthCurve;
 
    Range _piercedTriangles;  // triangles to delete
    Range _newTriangles;
    Range _piercedEdges;                                  // edges to delete
    std::map< EntityHandle, EntityHandle > _brokenEdges;  // this is a map between splitting nodes and edges that
    // are broken on the boundary, by the polyline; the edges will be deleted in the end
    // new edges?
};
 
}  // namespace moab
#endif /* FBENGINE_HPP_ */