rayfire_mesh.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// GRINS - General Reacting Incompressible Navier-Stokes
//
// Copyright (C) 2014-2017 Paul T. Bauman, Roy H. Stogner
// Copyright (C) 2010-2013 The PECOS Development Team
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Version 2.1 GNU Lesser General
// Public License as published by the Free Software Foundation.
//
// 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
//
//-----------------------------------------------------------------------el-


#ifndef GRINS_RAYFIRE_MESH_H
#define GRINS_RAYFIRE_MESH_H

// libMesh
#include "libmesh/quadrature.h"
#include "libmesh/mesh.h"

// GRINS
#include "grins/qoi_base.h"
#include "grins/variable_name_defaults.h"

namespace GRINS
{


  class RayfireMesh
  {
  public:


    RayfireMesh(libMesh::Point& origin, libMesh::Real theta);


    RayfireMesh(libMesh::Point& origin, libMesh::Real theta, libMesh::Real phi);


    RayfireMesh(const GetPot & input, const std::string & qoi_string);


    RayfireMesh(const RayfireMesh & original);


    void init(const libMesh::MeshBase& mesh_base);

    const libMesh::Elem* map_to_rayfire_elem(const libMesh::dof_id_type elem_id);

    void elem_ids_in_rayfire(std::vector<libMesh::dof_id_type>& id_vector) const;

    void reinit(const libMesh::MeshBase& mesh_base);


  private:
    const unsigned int _dim;

    libMesh::Point _origin;

    libMesh::Real   _theta;

    libMesh::Real   _phi;

    libMesh::UniquePtr<libMesh::Mesh> _mesh;

    std::map<libMesh::dof_id_type,libMesh::dof_id_type> _elem_id_map;

    RayfireMesh();


    libMesh::Elem* get_rayfire_elem(const libMesh::dof_id_type elem_id);


    const libMesh::Elem* get_next_elem(const libMesh::Elem* cur_elem, libMesh::Point& start_point, libMesh::Point& end_point, bool same_parent = false);

    bool check_valid_point(libMesh::Point& intersection_point, libMesh::Point& start_point, const libMesh::Elem& edge_elem, libMesh::Point& next_point);

    const libMesh::Elem* get_correct_neighbor(libMesh::Point & start_point, libMesh::Point & end_point, const libMesh::Elem * cur_elem, unsigned int side, bool same_parent);

    void check_origin_on_boundary(const libMesh::Elem* start_elem);


    const libMesh::Elem* get_start_elem(const libMesh::MeshBase& mesh_base);

    bool validate_edge(const libMesh::Point & start_point, const libMesh::Point & end_point, const libMesh::Elem * side_elem, const libMesh::Elem * neighbor);

    bool rayfire_in_elem(const libMesh::Point& end_point, const libMesh::Elem* elem);


    bool newton_solve_intersection(libMesh::Point& initial_point, const libMesh::Elem* edge_elem, libMesh::Point& intersection_point);

    void refine(const libMesh::Elem* main_elem, libMesh::Elem* rayfire_elem);

    void coarsen(const libMesh::Elem* rayfire_elem);

  };

}
#endif //GRINS_RAYFIRE_MESH_H