FillBetweenPointVectorsTools.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "LinearInterpolation.h"
#include "SplineInterpolation.h"
#include "MooseException.h"
#include "libmesh/mesh_base.h"
#include "libmesh/mesh_modification.h"
 
namespace FillBetweenPointVectorsTools
{
void fillBetweenPointVectorsGenerator(MeshBase & mesh,
                                      const std::vector<Point> & boundary_points_vec_1,
                                      const std::vector<Point> & boundary_points_vec_2,
                                      const unsigned int num_layers,
                                      const subdomain_id_type transition_layer_id,
                                      const boundary_id_type input_boundary_1_id,
                                      const boundary_id_type input_boundary_2_id,
                                      const boundary_id_type begin_side_boundary_id,
                                      const boundary_id_type end_side_boundary_id,
                                      const std::string type,
                                      const std::string name,
                                      const bool quad_elem = false,
                                      const Real bias_parameter = 1.0,
                                      const Real sigma = 3.0);
 
void fillBetweenPointVectorsGenerator(MeshBase & mesh,
                                      const std::vector<Point> & boundary_points_vec_1,
                                      const std::vector<Point> & boundary_points_vec_2,
                                      const unsigned int num_layers,
                                      const subdomain_id_type transition_layer_id,
                                      const boundary_id_type external_boundary_id,
                                      const std::string type,
                                      const std::string name,
                                      const bool quad_elem = false);
 
void elementsCreationFromNodesVectorsQuad(MeshBase & mesh,
                                          const std::vector<std::vector<Node *>> & nodes,
                                          const unsigned int num_layers,
                                          const std::vector<unsigned int> & node_number_vec,
                                          const subdomain_id_type transition_layer_id,
                                          const boundary_id_type input_boundary_1_id,
                                          const boundary_id_type input_boundary_2_id,
                                          const boundary_id_type begin_side_boundary_id,
                                          const boundary_id_type end_side_boundary_id);
 
void elementsCreationFromNodesVectors(MeshBase & mesh,
                                      const std::vector<std::vector<Node *>> & nodes,
                                      const unsigned int num_layers,
                                      const std::vector<unsigned int> & node_number_vec,
                                      const subdomain_id_type transition_layer_id,
                                      const boundary_id_type input_boundary_1_id,
                                      const boundary_id_type input_boundary_2_id,
                                      const boundary_id_type begin_side_boundary_id,
                                      const boundary_id_type end_side_boundary_id);
 
void weightedInterpolator(const unsigned int vec_node_num,
                          const std::vector<Point> & boundary_points_vec,
                          std::vector<Real> & vec_index,
                          std::vector<Real> & wt,
                          std::vector<Real> & index,
                          const Real sigma,
                          std::unique_ptr<LinearInterpolation> & linear_vec_x,
                          std::unique_ptr<LinearInterpolation> & linear_vec_y,
                          std::unique_ptr<SplineInterpolation> & spline_vec_l);
 
void surrogateGenerator(std::vector<Real> & weighted_surrogate_index,
                        std::vector<Real> & unweighted_surrogate_index,
                        const std::vector<unsigned int> & node_number_vec,
                        const std::vector<Real> & index,
                        const std::vector<Real> & wt,
                        const unsigned int boundary_node_num,
                        const unsigned int i);
 
bool needFlip(const std::vector<Point> & vec_pts_1, const std::vector<Point> & vec_pts_2);
 
bool isBoundarySimpleClosedLoop(MeshBase & mesh,
                                Real & max_node_radius,
                                std::vector<dof_id_type> & boundary_ordered_node_list,
                                const Point origin_pt,
                                const boundary_id_type bid);
 
bool isBoundarySimpleClosedLoop(MeshBase & mesh,
                                Real & max_node_radius,
                                const Point origin_pt,
                                const boundary_id_type bid);
 
bool isBoundarySimpleClosedLoop(MeshBase & mesh, const Point origin_pt, const boundary_id_type bid);
 
bool isBoundaryOpenSingleSegment(MeshBase & mesh,
                                 Real & max_node_radius,
                                 std::vector<dof_id_type> & boundary_ordered_node_list,
                                 const Point origin_pt,
                                 const boundary_id_type bid);
 
bool isCurveSimpleClosedLoop(MeshBase & mesh,
                             Real & max_node_radius,
                             std::vector<dof_id_type> & ordered_node_list,
                             const Point origin_pt);
 
bool isCurveSimpleClosedLoop(MeshBase & mesh, Real & max_node_radius, const Point origin_pt);
 
bool isCurveSimpleClosedLoop(MeshBase & mesh, const Point origin_pt);
 
bool isCurveOpenSingleSegment(MeshBase & mesh,
                              Real & max_node_radius,
                              std::vector<dof_id_type> & ordered_node_list,
                              const Point origin_pt);
 
void isClosedLoop(MeshBase & mesh,
                  Real & max_node_radius,
                  std::vector<dof_id_type> & ordered_node_list,
                  std::vector<std::pair<dof_id_type, dof_id_type>> & node_assm,
                  std::vector<dof_id_type> & midpoint_node_list,
                  const Point origin_pt,
                  const std::string input_type,
                  bool & is_closed_loop,
                  const bool suppress_exception = false);
 
void isClosedLoop(MeshBase & mesh,
                  Real & max_node_radius,
                  std::vector<dof_id_type> & ordered_node_list,
                  std::vector<std::pair<dof_id_type, dof_id_type>> & node_assm,
                  const Point origin_pt,
                  const std::string input_type,
                  bool & is_closed_loop,
                  const bool suppress_exception = false);
 
bool isExternalBoundary(MeshBase & mesh, const boundary_id_type bid);
 
bool buildQuadElement(Elem * elem,
                      Node * nd_0,
                      Node * nd_1,
                      Node * nd_2,
                      Node * nd_3,
                      const subdomain_id_type transition_layer_id);
 
bool buildTriElement(Elem * elem,
                     Node * nd_0,
                     Node * nd_1,
                     Node * nd_2,
                     const subdomain_id_type transition_layer_id);
}