fract_eval.h

Go to the documentation of this file.

/* 
 * SPDX-FileCopyrightText: 2025 Gesellschaft fuer Anlagen- und Reaktorsicherheit gGmbH
 * SPDX-License-Identifier: EUPL-1.2
 * SPDX-FileContributor: Dmitry Logashenko
 * SPDX-FileContributor: Goethe Universität Frankfurt
 * SPDX-FileType: SOURCE
 * 
 * This file is part of d3f++.
 * d3f++ is an extension for UG4. Licensing information and citation requirements of UG4 are provided in LICENSES/UG4-LGPL_2.1
 */
 
/*
 * Evaluation of values of functions at fractures.
 */
#ifndef __H__UG__PLUGINS__D3F__FRACT_EVAL__
#define __H__UG__PLUGINS__D3F__FRACT_EVAL__
 
#include <vector>
#include <map>
#include <ostream>
#include <sstream>
 
// ug4 headers
#include "common/common.h"
#include "lib_grid/algorithms/deg_layer_mngr.h"
#include "lib_disc/function_spaces/grid_function.h"
 
namespace ug {
namespace d3f {
 
template <typename TGridFunc>
class FractGFEval
{
public:
 
  typedef typename TGridFunc::domain_type domain_type;
  
  typedef typename TGridFunc::algebra_type algebra_type;
  
  typedef TGridFunc grid_func_type;
 
  static const int dim = domain_type::dim;
 
  typedef typename domain_type::grid_type grid_type;
  
  typedef typename domain_type::position_type position_type;
 
  typedef typename domain_type::position_accessor_type position_accessor_type;
  
  typedef DegeneratedLayerManager<dim> deg_layer_mngr_type;
  
  typedef typename deg_layer_mngr_type::element_type element_type;
  
  typedef typename deg_layer_mngr_type::side_type side_type;
  
  static const size_t maxElemCorners = deg_layer_mngr_type::maxElemCorners;
  
  static const size_t maxLayerSideCorners = deg_layer_mngr_type::maxLayerSideCorners;
  
private:
  
  struct t_fract_pnt_data
  {
    const side_type * face; 
    
    position_type intersection; 
    
    number fract_val; 
    number side_val[2]; 
    
    bool closed; 
    
    t_fract_pnt_data
    (
      const side_type * the_face,
      const position_type & the_intersection,
      number the_fract_val,
      number the_side_val
    )
    : face (the_face), intersection (the_intersection), fract_val (the_fract_val), closed (false)
    {
      side_val[0] = the_side_val;
    }
    
    t_fract_pnt_data (const t_fract_pnt_data& op)
    : face (op.face), intersection (op.intersection), fract_val (op.fract_val), closed (op.closed)
    {
      side_val[0] = op.side_val[0]; side_val[1] = op.side_val[1];
    }
  };
  
public:
 
  FractGFEval
  (
    SmartPtr<grid_func_type> spGridFunc, 
    const char * cmp_name, 
    SmartPtr<deg_layer_mngr_type> spDegLayerMngr, 
    const position_type & point_0, 
    const position_type & point_1 
  );
 
#ifdef UG_FOR_LUA
  FractGFEval
  (
    SmartPtr<grid_func_type> spGridFunc, 
    const char * cmp_name, 
    SmartPtr<deg_layer_mngr_type> spDegLayerMngr, 
    const std::vector<number> & point_0, 
    const std::vector<number> & point_1 
  );
#endif
 
  void get_all_values ();
  
  size_t num_intersections () const {return m_values.size ();}
  
  position_type position (size_t i) const {return m_values[i].intersection;}
  
  number fract_value (size_t i) const {return m_values[i].fract_val;}
  
  number side_value_1 (size_t i) const {return m_values[i].side_val[0];}
  
  number side_value_2 (size_t i) const {return m_values[i].side_val[1];}
  
  void write
  (
    std::ostream & out, 
    const char * inner_sep, 
    const char * outer_sep 
  ) const;
  
  void get_and_write
  (
    std::ostream & out, 
    const char * inner_sep, 
    const char * outer_sep 
  )
  {
    get_all_values ();
    write (out, inner_sep, outer_sep);
  }
  
  std::string get_as_string
  (
    const char * inner_sep, 
    const char * outer_sep 
  )
  {
    std::ostringstream str;
    get_and_write (str, inner_sep, outer_sep);
    return str.str ();
  }
  
private:
 
  void init_and_check
  (
    const char * cmp_name 
  );
  
  bool is_intersected
  (
    element_type * elem, 
    Grid & grid, 
    position_accessor_type & aaPos, 
    position_type & intersection, 
    size_t & num_fract_co, 
    side_type * & inner_side, 
    size_t inner_side_corners [], 
    size_t ass_co [] 
  );
  
  void get_local_coord
  (
    side_type * side, 
    size_t num_co, 
    position_accessor_type & aaPos, 
    position_type & global, 
    MathVector<dim-1> & local 
  );
  
  void get_co_values
  (
    element_type * elem, 
    side_type * side, 
    size_t num_fract_co, 
    size_t inner_side_corners [], 
    size_t ass_co [], 
    MathVector<dim-1> & local, 
    number & inner_val, 
    number & outer_val 
  );
  
  void append_values
  (
    const side_type * side, 
    const position_type & intersection, 
    number inner_val, 
    number outer_val 
  );
  
  void check_values ();
  
private:
 
  SmartPtr<grid_func_type> m_spGridFunc; 
  size_t m_fct; 
  LFEID m_lfeID; 
  SmartPtr<deg_layer_mngr_type> m_spDegLayerMngr; 
  position_type m_point_0; 
  position_type m_point_1; 
  
  std::vector<t_fract_pnt_data> m_values; 
  
};
 
} // namespace d3f
} // end namespace ug
 
#include "fract_eval_impl.h"
 
#endif // __H__UG__PLUGINS__D3F__FRACT_EVAL__
 
/* End of File */