fract_dimadapt.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: Sabine Stichel
 * 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
 */
 
/*
 * A tool for the dimension-adaptive fracture representation
 */
#ifndef __H__UG__PLUGINS__D3F__FRACT_DIMADAPT__
#define __H__UG__PLUGINS__D3F__FRACT_DIMADAPT__
 
#include <map>
#include <vector>
 
// ug4 headers
#include "common/common.h"
#include "common/util/smart_pointer.h"
#include "lib_grid/tools/subset_group.h"
#include "lib_grid/algorithms/subset_dim_util.h"
#include "lib_grid/algorithms/deg_layer_mngr.h"
#include "lib_disc/domain_traits.h"
 
namespace ug {
namespace d3f {
 
template <typename TDomain,typename TAlgebra>
class FractDimadapt
{
public:
    typedef TDomain domain_type;
  
    typedef typename domain_type::subset_handler_type subset_handler_type;
 
    static const int dim = domain_type::dim;
    
    static const int low_dim = dim - 1;
 
    typedef DimFV1Geometry<low_dim, dim> TFractFVGeom;
 
    typedef Attachment<signed char> mark_attachment_type;
    typedef Attachment<MathVector<dim> > shift_attachment_type;
    
    typedef typename domain_traits<dim>::grid_base_object element_type;
    
    typedef typename domain_traits<dim>::side_type side_type;
 
    typedef DegeneratedLayerManager<TDomain::dim> fract_manager_type;
 
    typedef typename domain_type::position_accessor_type position_accessor_type;
 
    static const size_t maxElemCorners = domain_traits<dim>::MaxNumVerticesOfElem;
    
    static const size_t maxLayerSideCorners = maxElemCorners / 2;
  
    enum t_grid_object_mark
    {
      F_NONE = -1, //only auxilliary
      F_OUTER = 0, //only auxilliary
      F_INNER = 1, //only auxilliary
      F_MID = 2,
      F_BND = 3,
      F_VERT = 4,
      F_CORNER = 5 //short end of the fracture (triangle end point)
    };
 
public:
    FractDimadapt
    (
      SmartPtr<domain_type> domain, 
      const char* ss_name, 
      const std::vector<number> normal, 
      number aperture, 
      bool shift  
    );
    
    virtual ~FractDimadapt ();
 
    void add_density (
        number rho_pw,
        number rho_pb,
        const char* density_type
        ){
      m_density_type = density_type;
      m_rho_pw = rho_pw;
      m_rho_pb = rho_pb;
    }
 
    void add_viscosity (
        number zero_viscosity,
        const char* viscosity_type
        ){
      m_viscosity_type = viscosity_type;
      m_zero_viscosity = zero_viscosity;
    }
 
    void add_gravity (const std::vector<number> gravity){
      for (int d=0;d < dim;d++)
        m_Gravity[d] = gravity[d];
    }
    void add_permeability (
        number perm_f,
        number perm_m
        ){
      m_permeability_f = perm_f;
      m_permeability_m = perm_m;
    }
 
    template <typename TGridFunction> void get_ave_val (
        const std::vector<number> eval_point, 
        TGridFunction& u, 
        number time 
        );
    
    template <typename TGridFunction> number evaluate_criterion(
        TGridFunction& u,
        DegeneratedLayerManager<TDomain::dim>* fractManager,
        number omega_theta,
        number time
        );
 
    template <typename TGridFunction> void check_transfer(
        TGridFunction& u,
        DegeneratedLayerManager<TDomain::dim>* fractManager,
        number omega_theta,
        number delta,
        number time
        );
 
    void grid_transfer_full_to_low ();
 
    void grid_transfer_low_to_full ();
 
    template <typename TGridFunction> void transfer_full_to_low (
        TGridFunction& u 
        );
    template <typename TGridFunction> void transfer_low_to_full (
        TGridFunction& u 
        );
 
    template <typename TGridFunction> void convert_end_triangles_to_quadris (
        TGridFunction& u, 
        DegeneratedLayerManager<TDomain::dim>* fractManager
        );
 
    void convert_end_quadris_to_triangles (
        DegeneratedLayerManager<TDomain::dim>* fractManager
        );
 
 
protected:
    void mark_vertices ();
  
    void grid_adaption_callback (const GridMessage_Adaption& msg);
 
    void grid_distribution_callback (const GridMessage_Distribution& msg);
 
    void calculate_interpolation (
        double bnd[2][2],
        double mid[2],
        MathVector<dim> bndpoint[2],
        number param[2][3]  //return value
        );
    void density_func (
      number c, 
      number &rho, 
      number &d_rho 
      );
 
    void viscosity_func (
      number c, 
      number &mu, 
      number &d_mu 
      );
 
      int vert_mark (Vertex * vrt) {return m_aaVertAuxMarks [vrt];};
 
      int edge_mark (Edge * edge) {return m_aaEdgeAuxMarks [edge];};
 
      MathVector<dim> vert_shift (Vertex * vrt) {return m_aaVertexShift [vrt];};
 
  
private:
    SmartPtr<subset_handler_type> m_spSH;
 
    SmartPtr<position_accessor_type> m_posAcc;
 
    SmartPtr<domain_type> m_dom;
 
    SubsetGroup m_fractSsGrp;
 
    bool m_shift;
 
    static const size_t max_number_levels = 100;
    static const size_t max_number_fracture_midnodes = 10000;
    static const size_t max_number_fracture_layers = 100;
 
    int NumberFractNodes[max_number_levels];
    int NumberFractVertNodes[max_number_levels][max_number_fracture_midnodes];
    int m_NumberLevels;
    int m_FirstFullLevel;
    Vertex* FractNode[max_number_levels][max_number_fracture_midnodes][max_number_fracture_layers];
    element_type * CornerTriangleList[max_number_levels][4];
    int m_FractureIsFullDimensional; //1 for full, 0 for low
 
    MathVector<dim> m_fractNormal;
    number m_aperture;
    MathVector<dim> m_Gravity;
    number m_rho_pw,m_rho_pb;
    const char* m_density_type;
    number m_zero_viscosity;
    const char* m_viscosity_type;
    number m_permeability_f;
    number m_permeability_m;
  
    mark_attachment_type m_aVertexAuxMarks;
    mark_attachment_type m_aEdgeAuxMarks;
    //todo: for 3d add FaceMarks
 
    shift_attachment_type m_aVertexShift;
 
    MultiGrid::AttachmentAccessor<Vertex, mark_attachment_type> m_aaVertAuxMarks;
    MultiGrid::AttachmentAccessor<Edge, mark_attachment_type> m_aaEdgeAuxMarks;
    MultiGrid::AttachmentAccessor<Vertex, shift_attachment_type> m_aaVertexShift;
    
    
  //  Message hub callback id's for the notifications of the changes of the grid:
    MessageHub::SPCallbackId m_spGridAdaptionCallbackID;
    MessageHub::SPCallbackId m_spGridDistributionCallbackID;
};
 
} // namespace d3f
} // end namespace ug
 
#include "fract_dimadapt_impl.h"
 
#endif // __H__UG__PLUGINS__D3F__FRACT_DIMADAPT__
 
/* End of File */