fract_pf_fv1.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
 */
 
 
 
/*
 * fract_pf_fv1.h - discretization of the pressure driven flow in porous media
 * with fractures.
 */
#ifndef __H__UG__LIB_DISC__PRESSURE_DRIVEN_FLOW__FRACT_PF_FV1_
#define __H__UG__LIB_DISC__PRESSURE_DRIVEN_FLOW__FRACT_PF_FV1_
 
// other ug4 modules
#include "common/common.h"
#include "lib_grid/lg_base.h"
#include "lib_grid/algorithms/deg_layer_mngr.h"
 
#include "lib_disc/spatial_disc/elem_disc/elem_disc_interface.h"
#include "lib_disc/spatial_disc/user_data/data_export.h"
#include "lib_disc/spatial_disc/user_data/data_import.h"
#include "lib_disc/spatial_disc/user_data/const_user_data.h"
#ifdef UG_FOR_LUA
#include "bindings/lua/lua_user_data.h"
#endif
 
#include "lib_disc/spatial_disc/disc_util/conv_shape_interface.h"
#include "lib_disc/spatial_disc/disc_util/consistent_gravity.h"
 
namespace ug{
namespace d3f{
 
 
 
template <typename TDomain>
class FractPF_FV1
  : public IElemDisc<TDomain>
{
private:
  typedef IElemDisc<TDomain> base_type;
 
  typedef FractPF_FV1<TDomain> this_type;
 
  typedef typename base_type::domain_type domain_type;
 
  typedef typename base_type::position_type position_type;
  
  static const int dim = base_type::dim;
 
  static const int low_dim = dim - 1;
  
  typedef DimFV1Geometry<low_dim, dim> TFractFVGeom;
  
  typedef typename domain_traits<dim>::DimElemList AssembleElemList;
  
  typedef DegeneratedLayerManager<dim> fract_manager_type;
  
  typedef typename fract_manager_type::side_type side_type;
  
  static const size_t maxFractSideCorners = fract_manager_type::maxLayerSideCorners;
  
  static const size_t _P_ = 0;
  
public:
 
  FractPF_FV1
  (
    const char* functions, 
    const char* subsets, 
    bool condensed_FV 
  );
  
  FractPF_FV1
  (
    const char* functions, 
    const char* subsets 
  );
  
//---- Settings: ----
public:
  
  void set_fract_manager (SmartPtr<fract_manager_type> fract_manager)
  {
    m_spFractManager = fract_manager;
  }
 
  void set_density (number density) {m_density = density;}
  void set_viscosity (number viscosity) {m_viscosity = viscosity;}
  void set_gravity (SmartPtr<CplUserData<MathVector<dim>, dim> > user)
  {
    m_imConstGravity.set_data (user);
  }
  void set_gravity (const std::vector<number>& vGravity)
  {
    set_gravity (SmartPtr<ConstUserVector<dim> > (new ConstUserVector<dim> (vGravity)));
  }
  
  void set_permeability (SmartPtr<CplUserData<MathMatrix<dim, dim>, dim> > user)
  {
    m_imPermeability.set_data(user);
  }
  void set_permeability (number val)
  {
    set_permeability (make_sp (new ConstUserMatrix<dim> (val)));
  }
#ifdef UG_FOR_LUA
  void set_permeability (const char* fctName)
  {
    set_permeability (LuaUserDataFactory<MathMatrix<dim,dim>, dim>::create (fctName));
  }
  void set_permeability (LuaFunctionHandle fct)
  {
    set_permeability (make_sp (new LuaUserData<MathMatrix<dim,dim>, dim> (fct)));
  }
#endif
  
 
  void set_aperture (SmartPtr<CplUserData<number, dim> > user)
  {
    m_spApertureData = user; 
  }
  void set_aperture (number val)
  {
    set_aperture (make_sp (new ConstUserNumber<dim> (val)));
  }
#ifdef UG_FOR_LUA
  void set_aperture (const char* fctName)
  {
    set_aperture (LuaUserDataFactory<number, dim>::create (fctName));
  }
  void set_aperture (LuaFunctionHandle fct)
  {
    set_aperture (make_sp (new LuaUserData<number, dim> (fct)));
  }
#endif
  
  void set_fract_permeability (SmartPtr<CplUserData<number, dim> > user)
  {
    m_spFractPermeabilityData = user;
  }
  void set_fract_permeability (number val)
  {
    set_fract_permeability (make_sp (new ConstUserNumber<dim> (val)));
  }
#ifdef UG_FOR_LUA
  void set_fract_permeability (const char* fctName)
  {
    set_fract_permeability (LuaUserDataFactory<number, dim>::create (fctName));
  }
  void set_fract_permeability (LuaFunctionHandle fct)
  {
    set_fract_permeability (make_sp(new LuaUserData<number, dim> (fct)));
  }
#endif
  
  void set_orthofract_permeability (SmartPtr<CplUserData<number, dim> > user)
  {
    m_spOrthoPermeabilityData = user;
  }
  void set_orthofract_permeability (number val)
  {
    set_orthofract_permeability (make_sp (new ConstUserNumber<dim> (val)));
  }
#ifdef UG_FOR_LUA
  void set_orthofract_permeability (const char* fctName)
  {
    set_orthofract_permeability (LuaUserDataFactory<number, dim>::create (fctName));
  }
  void set_orthofract_permeability (LuaFunctionHandle fct)
  {
    set_orthofract_permeability (make_sp(new LuaUserData<number, dim> (fct)));
  }
#endif
  
  bool condensed_FV () {return m_bCondensedFV;}
  
//---- Local discretization interface: ----
protected:
  
  virtual void prepare_setting
  (
    const std::vector<LFEID> & vLfeID,
    bool bNonRegular
  );
 
//---- Assembling functions: ----
protected:
  
  template <typename TElem, typename TBulkFVGeom>
  void prepare_element_loop (ReferenceObjectID roid, int si);
 
  template <typename TElem, typename TBulkFVGeom>
  void prepare_element (const LocalVector& u, GridObject* elem, ReferenceObjectID roid, const position_type vCornerCoords[]);
 
  template <typename TElem, typename TBulkFVGeom>
  void finish_element_loop ();
 
  template <typename TElem, typename TBulkFVGeom>
  void ass_JA_elem (LocalMatrix& J, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
  template <typename TElem, typename TBulkFVGeom>
  void ass_JM_elem (LocalMatrix& J, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
  template <typename TElem, typename TBulkFVGeom>
  void ass_dA_elem (LocalVector& d, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
  template <typename TElem, typename TBulkFVGeom>
  void ass_dM_elem (LocalVector& d, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
  template <typename TElem, typename TBulkFVGeom>
  void ass_rhs_elem (LocalVector& d, GridObject* elem, const position_type vCornerCoords[]);
  
//---- Assembling functions for bulk medium: ----
private:
 
  template <typename TElem, typename TBulkFVGeom>
  inline void bulk_prepare_element_loop (ReferenceObjectID roid, int si);
 
  template <typename TElem, typename TBulkFVGeom>
  inline void bulk_prepare_element (const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
  template <typename TElem, typename TBulkFVGeom>
  inline void bulk_ass_JA_elem (LocalMatrix& J, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
  template <typename TElem, typename TBulkFVGeom>
  inline void bulk_ass_dA_elem (LocalVector& d, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
  template <typename TElem, typename TBulkFVGeom>
  inline void bulk_ass_rhs_elem (LocalVector& d, TElem* elem, const position_type vCornerCoords[]);
  
//---- Assembling functions for fractures: ----
private:
 
  template <typename TElem>
  inline void fract_prepare_element_loop (ReferenceObjectID roid, int si);
 
  template <typename TElem>
  inline void fract_prepare_element (const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
  template <typename TElem>
  inline void fract_ass_JA_elem (LocalMatrix& J, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
  template <typename TElem>
  inline void fract_bulk_ass_JA_elem (LocalMatrix& J, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
  template <typename TElem>
  inline void fract_ass_dA_elem (LocalVector& d, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
  template <typename TElem>
  inline void fract_bulk_ass_dA_elem (LocalVector& d, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
  template <typename TElem>
  inline void fract_ass_rhs_elem (LocalVector& d, TElem* elem, const position_type vCornerCoords[]);
 
//---- Computation of the Darcy velocity: ----
private:
  
  template<typename TFVGeom>
  inline void compute_ip_velocity
  (
    MathVector<dim>& Vel, 
    size_t ip, 
    const TFVGeom& bulk_geo, 
    number vPressure[] 
  );
 
  template<typename TFVGeom>
  inline void compute_J_ip_velocity
  (
    MathVector<dim> Vel_p[], 
    size_t ip, 
    const TFVGeom& geo 
  );
  
//---- Registration of the template functions: ----
private:
  
  bool m_bCondensedFV;
 
  struct RegisterLocalDiscr {
      RegisterLocalDiscr(this_type * pThis) : m_pThis(pThis){}
      this_type * m_pThis;
      template< typename TElem > void operator() (TElem &)
      {m_pThis->register_loc_discr_func<TElem> ();}
  };
 
  template <typename TElem, typename TBulkFVGeom>
  void register_loc_discr_func_with_fvgeom ();
  
  template <typename TElem>
  void register_loc_discr_func ();
  
  void register_discr_and_param
  (
    bool condensed 
  );
 
private:
  
//  Global parameters (for all subdomains):
  number m_density; 
  number m_viscosity; 
  DataImport<MathVector<dim>, dim> m_imConstGravity; 
  
//  Specific parameters for full-dimensional subdomains:
  DataImport<MathMatrix<dim, dim>, dim> m_imPermeability; 
  
//  Specific parameters for low-dimensional subdomains (fractures):
  DataImport<number, dim> m_imAperture; 
  DataImport<number, dim> m_imFractPermeability; 
  DataImport<number, dim> m_imOrthoPermeability; 
  /* If OrthoPermeability is not specified, the tensor Permeability parameter is used. */
//  Note that the data for the fracture parameters are kept permanently not in the DataImports, but here:
  SmartPtr<CplUserData<number, dim> > m_spApertureData;
  SmartPtr<CplUserData<number, dim> > m_spFractPermeabilityData;
  SmartPtr<CplUserData<number, dim> > m_spOrthoPermeabilityData;
  /* The purpose of these pointers is to prevend evaluation of the fracture parameters
   * in the full-dimensional (non-degenerated) elements.
   */
  
//  Parameters of the numerical methods of the discretization:
  SmartPtr<fract_manager_type> m_spFractManager; 
  
  SmartPtr<DataExport<number, dim> > m_exBrine;
 
private:
  MathVector<dim> m_Gravity; 
  
//  Temporary data used in the assembling
  bool m_isFracture; 
  
  TFractFVGeom * m_pFractGeo; 
  size_t m_numFractCo; 
  side_type * m_innerFractSide; 
  side_type * m_outerFractSide; 
  size_t m_innerFractSideIdx; 
  size_t m_outerFractSideIdx; 
  size_t m_innerSideCo[maxFractSideCorners]; 
  size_t m_outerSideCo[maxFractSideCorners]; 
  size_t m_assCo [2 * maxFractSideCorners]; 
  MathVector<dim> m_unitOuterNormal; 
  MathVector<dim> m_elem_loc_coe; 
  MathVector<dim> m_elem_loc_scvf [TFractFVGeom::maxNumSCVF]; 
};
 
 
} // namespace d3f
} // end namespace ug
 
#include "fract_pf_fv1_impl.h"
 
#endif /* __H__UG__LIB_DISC__PRESSURE_DRIVEN_FLOW__FRACT_PF_FV1_ */
 
/* End of File */