d3f_sss.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
 */
 
/*
 * Singular (point and line) sources and sinks in d3f.
 */
#ifndef __H__UG__PLUGINS__D3F__SINGULAR_SOURCES_AND_SINKS__
#define __H__UG__PLUGINS__D3F__SINGULAR_SOURCES_AND_SINKS__
 
#include <vector>
 
// ug4 headers
#include "bindings/lua/lua_user_data.h"
#include "lib_disc/spatial_disc/disc_util/fv1_sss.h"
#include "lib_disc/spatial_disc/user_data/user_data.h"
 
namespace ug {
namespace d3f {
 
template <int dim>
class dd_sss_data
{
  MathVector<2> m_values;
  
  SmartPtr<UserData<MathVector<2>, dim> > m_spData; 
  
public:
  
  dd_sss_data () {m_values [0] = 0; m_values [1] = 0;}
  
  number intensity () {return m_values [0];}
  
  number concentration () {return m_values [1];}
  
  void compute
  (
    const MathVector<dim>& x, 
    number time, 
    int si 
  )
  {
    if (m_spData.valid ())
      (* m_spData) (m_values, x, time, si);
  }
  
  void set (number intens, number c)
  {
    m_values[0] = intens;
    m_values[1] = c;
    m_spData = SPNULL;
  }
  
  void set (SmartPtr<UserData<MathVector<2>, dim> > spData)
  {
    m_spData = spData;
  }
  
  void set (LuaFunctionHandle func)
  {
    m_spData = make_sp (new LuaUserData<MathVector<2>, dim> (func));
  }
};
 
template <int dim>
class th_sss_data
{
  MathVector<3> m_values;
  
  SmartPtr<UserData<MathVector<3>, dim> > m_spData; 
  
public:
  
  th_sss_data () {m_values [0] = 0; m_values [1] = 0; m_values [2] = 0;}
  
  number intensity () {return m_values [0];}
  
  number concentration () {return m_values [1];}
  
  number temperature () {return m_values [2];}
  
  void compute
  (
    const MathVector<dim>& x, 
    number time, 
    int si 
  )
  {
    if (m_spData.valid ())
      (* m_spData) (m_values, x, time, si);
  }
  
  void set (number intens, number c, number T)
  {
    m_values[0] = intens;
    m_values[1] = c;
    m_values[2] = T;
    m_spData = SPNULL;
  }
  
  void set (SmartPtr<UserData<MathVector<3>, dim> > spData)
  {
    m_spData = spData;
  }
  
  void set (LuaFunctionHandle func)
  {
    m_spData = make_sp (new LuaUserData<MathVector<3>, dim> (func));
  }
};
 
  template <int dim>
  class river_sss_data
  {
    MathVector<3> m_values;
    number m_matrix_permeability;
    number m_exchange_flux;
    number m_width;
    number m_bottom_thickness;
    SmartPtr<UserData<MathVector<3>, dim> > m_spData; 
    Edge* m_edge;
  public:
 
    river_sss_data () : m_matrix_permeability(0), m_exchange_flux(0), m_width(1.0), m_bottom_thickness(1.0) {
      m_values[0] = 0;
      m_values[1] = 0;
      m_values[2] = 0;
    }
 
    number intensity () {return m_values [0];}
 
    number concentration () {return m_values [1];}
 
    number relative_bottom_permeability () {return m_values [2];}
 
    number width() const {return m_width;}
 
    number bottom_thickness() const {return m_bottom_thickness;}
 
    number& exchange_flux() {return m_exchange_flux;}
 
    void compute
    (
      const MathVector<dim>& x, 
      number time, 
      int si 
    )
    {
      if (m_spData.valid ())
        (* m_spData) (m_values, x, time, si);
    }
 
    void set (number intens, number c, number perm, number width = 1.0, number thickness = 1.0)
    {
      m_values[0] = intens;
      m_values[1] = c;
      m_values[2] = perm;
      m_width = width;
      m_bottom_thickness = thickness;
      m_spData = SPNULL;
    }
 
    void set_edge(Edge* edge) {m_edge = edge;}
    Edge* get_edge() const {return m_edge;}
    void set_matrix_permeability(number k){m_matrix_permeability = k;}
    number matrix_permeability() const {return m_matrix_permeability;}
 
    void set (SmartPtr<UserData<MathVector<3>, dim> > spData)
    {
      m_spData = spData;
    }
 
    void set (LuaFunctionHandle func)
    {
      m_spData = make_sp (new LuaUserData<MathVector<3>, dim> (func));
    }
  };
 
 
 
class point_sss_marker
{
  GridObject * m_elem; 
  size_t m_co; 
  
public:
 
  point_sss_marker () : m_elem (NULL), m_co (0) {};
  
  void init () {m_elem = NULL; m_co = 0;}
  
  bool marked_for (GridObject * elem, size_t co)
  {
    if (m_elem == NULL)
    {
      m_elem = elem; m_co = co;
      return true;
    }
    return m_elem == elem && m_co == co;
  }
};
 
class line_sss_marker
{
// All the members are used in the fractures only!
 
  struct t_fract_elem
  {
    IVertexGroup * fract_face;
    size_t fract_co;
    
    t_fract_elem (IVertexGroup * face, size_t co) : fract_face (face), fract_co (co) {};
  };
  
  std::vector<t_fract_elem> m_intersections;
  
public:
 
  line_sss_marker () {};
  
  void init () {m_intersections.clear ();}
  
  bool marked_for (IVertexGroup * elem, size_t co)
  {
  //  is the fracture already processed?
    for (size_t i = 0; i < m_intersections.size (); i++)
    {
    //  check if we have already registered this mark
      t_fract_elem& intersection = m_intersections[i];
      if (intersection.fract_face == elem)
        return intersection.fract_co == co;
      
    //  check if a different corner is meant (i.e. this is the same fracture)
      Vertex * vrt = elem->vertex (co);
      for (size_t j = 0; j < intersection.fract_face->num_vertices (); j++)
        if (vrt == intersection.fract_face->vertex (j))
          return false; // in this fracture, we use a different corner
    }
  // no, register this fracture, too
    m_intersections.push_back (t_fract_elem (elem, co));
    return true;
  }
};
 
template <int dim> class dd_point_sss_data : public dd_sss_data<dim>, public point_sss_marker {};
template <int dim> class dd_line_sss_data : public dd_sss_data<dim>, public line_sss_marker {};
template <int dim>
class DDSingularSourcesAndSinks
  : public FVSingularSourcesAndSinks<dim, dd_point_sss_data<dim>, dd_line_sss_data<dim> >
{};
 
template <int dim> class th_point_sss_data : public th_sss_data<dim>, public point_sss_marker {};
template <int dim> class th_line_sss_data : public th_sss_data<dim>, public line_sss_marker {};
template <int dim>
class THSingularSourcesAndSinks
  : public FVSingularSourcesAndSinks<dim, th_point_sss_data<dim>, th_line_sss_data<dim> >
{};
 
 
template <int dim> class river_point_sss_data : public river_sss_data<dim>, public point_sss_marker {};
template <int dim> class river_line_sss_data : public river_sss_data<dim>, public line_sss_marker {};
 
 
} // namespace d3f
} // end namespace ug
 
#endif // __H__UG__PLUGINS__D3F__SINGULAR_SOURCES_AND_SINKS__
 
/* End of File */