level_set_intersection.h

Go to the documentation of this file.

/*
 * MAST: Multidisciplinary-design Adaptation and Sensitivity Toolkit
 * Copyright (C) 2013-2020  Manav Bhatia and MAST authors
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __mast_level_set_intersection_h__
#define __mast_level_set_intersection_h__

// C++ includes
#include <vector>

// MAST includes
#include "base/mast_data_types.h"

// libMesh includes
#include "libmesh/elem.h"


namespace MAST {

    enum LevelSet2DIntersectionMode {
        
        THROUGH_NODE,           // level set passes through node
        COLINEAR_EDGE,          // level set coliniear with edge of element
        ADJACENT_EDGES,         // level set passes through two adjacent edges
        OPPOSITE_EDGES,         // level set passes through two opposite edges
        OPPOSITE_NODES,         // level set passes through diagonally opposite nodes
        NODE_AND_EDGE,          // level set passes through a node and edge
        TWO_ADJACENT_EDGES,     // level set passes through four edges
        NODE_AND_TWO_EDGES,     // level set passes through a node and two edges
        NO_INTERSECTION
    };
    

    // Forward declerations
    template <typename ValType> class FieldFunction;
    
    
    
    class LevelSetIntersection {
        
    public:
        
        LevelSetIntersection();
        
        virtual ~LevelSetIntersection();

        void init(const MAST::FieldFunction<Real>& phi,
                  const libMesh::Elem& e,
                  const Real t,
                  unsigned int max_elem_id,
                  unsigned int max_node_id);

        void clear();
        
        const libMesh::Elem& elem() const;
        
        MAST::LevelSet2DIntersectionMode
        get_intersection_mode() const;

        unsigned int node_on_boundary() const;

        unsigned int edge_on_boundary() const;


        Real get_positive_phi_volume_fraction() const;
        
        Real get_node_phi_value(const libMesh::Node* n) const;
        

        bool if_hanging_node(const libMesh::Node* n) const;
        
        bool if_elem_has_boundary() const;
        
        bool if_intersection_through_elem() const;

        bool if_elem_on_positive_phi() const;

        bool if_elem_on_negative_phi() const;

        bool if_elem_has_positive_phi_region() const;

        
        bool if_elem_has_negative_phi_region() const;

        const std::vector<const libMesh::Elem*>&
        get_sub_elems_positive_phi() const;
        
        const std::vector<const libMesh::Elem*>&
        get_sub_elems_negative_phi() const;

        void
        get_corner_nodes_on_negative_phi(std::set<const libMesh::Node*>& nodes) const;
        
        unsigned int
        get_side_on_interface(const libMesh::Elem& e) const;

        bool
        has_side_on_interface(const libMesh::Elem& e) const;

        const libMesh::Point&
        get_nondimensional_coordinate_for_node(const libMesh::Node& n) const;


        bool if_node_is_new(const libMesh::Node& node) const;

        
        bool if_interior_node(const libMesh::Node& node) const;

        
        std::pair<const libMesh::Node*, const libMesh::Node*>
        get_bounding_nodes_for_node(const libMesh::Node& node) const;
        
        
        void
        get_material_sides_without_intersection(std::set<unsigned int>& sides) const;

        
        void get_nearest_intersection_point(const libMesh::Point& p,
                                            libMesh::Point& pt);
        
    protected:
        
        std::unique_ptr<libMesh::Elem>
        _first_order_elem(const libMesh::Elem& e);
        
        void _init_on_first_order_ref_elem(const MAST::FieldFunction<Real>& phi,
                                           const libMesh::Elem& e,
                                           const Real t);

        
        void _add_node_local_coords
        ( const libMesh::Elem& e,
         std::vector<std::pair<libMesh::Point, libMesh::Point> >& side_nondim_points,
         std::map<const libMesh::Node*, libMesh::Point>& node_coord_map);
        
        void
        _find_quad4_intersections(const MAST::FieldFunction<Real>& phi,
                                  const libMesh::Elem& e,
                                  const Real t,
                                  const std::map<const libMesh::Node*, std::pair<Real, bool> >&
                                  node_phi_vals);

        Real
        _find_intersection_on_straight_edge(const libMesh::Point& p0,
                                            const libMesh::Point& p1,
                                            const MAST::FieldFunction<Real>& phi,
                                            const Real t);
        
        Real                                         _tol;
        
        unsigned int                                 _max_iters;
        unsigned int                                 _max_mesh_elem_id;
        unsigned int                                 _max_mesh_node_id;
        const unsigned int                           _max_elem_divs;
        const libMesh::Elem*                         _elem;
        bool                                         _initialized;

        const MAST::FieldFunction<Real>*             _phi;
        
        bool                                         _if_elem_on_positive_phi;
        
        bool                                         _if_elem_on_negative_phi;
        
        MAST::LevelSet2DIntersectionMode             _mode;
        
        unsigned int                                 _node_num_on_boundary;
        
        unsigned int                                 _edge_num_on_boundary;
        
        std::vector<const libMesh::Elem*>            _positive_phi_elems;
        
        std::vector<const libMesh::Elem*>            _negative_phi_elems;
        
        std::map<const libMesh::Elem*, int>          _elem_sides_on_interface;
        
        std::vector<libMesh::Node*>                  _new_nodes;
        std::vector<libMesh::Elem*>                  _new_elems;
        std::map<const libMesh::Node*, libMesh::Point> _node_local_coords;
        std::map<const libMesh::Node*, std::pair<Real, bool> > _node_phi_vals;
        std::set<const libMesh::Node*>               _interior_nodes;
        std::map<const libMesh::Node*, std::pair<const libMesh::Node*, const libMesh::Node*>> _bounding_nodes;
        std::set<const libMesh::Node*>               _hanging_node;
    };
    
}




#endif // __mast_level_set_intersection_h__