inout_bnd.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
 */
 
 
/*
 * Implementation of the outflow and inflow/outflow boundary conditions
 */
#ifndef __H__UG__PLUGINS__D3F__INOUT_BND__
#define __H__UG__PLUGINS__D3F__INOUT_BND__
 
#include <map>
#include <vector>
 
// ug4 headers
#include "common/common.h"
 
// library-specific headers
#include "lib_grid/lg_base.h"
#include "lib_disc/common/function_group.h"
#include "lib_disc/common/groups_util.h"
#include "lib_disc/spatial_disc/domain_disc_interface.h"
#include "lib_disc/function_spaces/approximation_space.h"
#include "lib_grid/tools/subset_handler_interface.h"
#ifdef UG_FOR_LUA
#include "bindings/lua/lua_user_data.h"
#endif
 
// d3f headers
#include "extravol.h"
 
namespace ug {
namespace d3f {
 
template <typename TDomain, typename TAlgebra>
class OutFlowBC
  : public IDomainConstraint<TDomain, TAlgebra>
{
  typedef OutFlowBC<TDomain, TAlgebra> this_type;
  
public:
  typedef IDomainConstraint<TDomain, TAlgebra> base_type;
    
  typedef TDomain domain_type;
 
  static const int dim = domain_type::dim;
 
  typedef TAlgebra algebra_type;
 
  typedef typename algebra_type::matrix_type matrix_type;
 
  typedef typename algebra_type::vector_type vector_type;
    
private:
  typedef DoFDistribution::traits<Vertex>::const_iterator t_vert_iterator;
  
  typedef std::map<std::string, std::vector<std::string> > bc_data_map_type;
  
  typedef std::map<std::string, number> fct_name_scaling_map_type;
  
public:
//  Management
 
  OutFlowBC () {};
  
  void set_volume_stabilization
  (
    SmartPtr<FlowVolStabData<domain_type> > spVolStabData 
  )
  {
    m_spVolStabData = spVolStabData;
    if (spVolStabData.valid ())
      spVolStabData->activate_flux ();
  }
 
  void add
  (
    std::string ss_names, 
    std::string fct_names 
  );
  
  void scale
  (
    std::string fct_names, 
    number scaling 
  );
  
public:
// The interface:
  
  void adjust_jacobian
  (
    matrix_type & J,
    const vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0,
    ConstSmartPtr<VectorTimeSeries<vector_type> > vSol = SPNULL,
    const number s_a0 = 1.0
  );
 
  void adjust_defect
  (
    vector_type & d,
    const vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0,
    ConstSmartPtr<VectorTimeSeries<vector_type> > vSol = SPNULL,
    const std::vector<number> * vScaleMass = NULL,
    const std::vector<number> * vScaleStiff = NULL
  );
 
  void adjust_solution
  (
    vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  )
  {}; // nothing to do for this boundary condition
 
  void adjust_linear
  (
    matrix_type & A,
    vector_type & b,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  )
  {
    this_type::adjust_jacobian (A, b, dd, time); // the 2nd arg. is dummy: A does not depend on u
  };
 
  void adjust_rhs
  (
    vector_type & b,
    const vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  )
  {}; // nothing to do for this boundary condition
 
  int type () const {return CT_DIRICHLET;}
  
private:
  void names_to_ids_in_scaling
  (
    const FunctionPattern * fct_pattern, 
    std::vector<number> & v_scaling 
  ) const;
  
private:
  
  SmartPtr<FlowVolStabData<domain_type> > m_spVolStabData;
  
  bc_data_map_type m_mStoF;
  
  fct_name_scaling_map_type m_mFtoM;
};
 
template <typename TDomain, typename TAlgebra>
class InOutFlowBC
  : public IDomainConstraint<TDomain, TAlgebra>
{
  typedef InOutFlowBC<TDomain, TAlgebra> this_type;
  
public:
  typedef IDomainConstraint<TDomain, TAlgebra> base_type;
    
  typedef TDomain domain_type;
 
  static const int dim = domain_type::dim;
 
  typedef TAlgebra algebra_type;
 
  typedef typename algebra_type::matrix_type matrix_type;
 
  typedef typename algebra_type::vector_type vector_type;
    
private:
  typedef DoFDistribution::traits<Vertex>::const_iterator t_vert_iterator;
  
  struct t_inDirichlet
  {
    number val; 
    SmartPtr<UserData<number, dim> > func; 
  };
  
  typedef std::map<std::string, std::map<std::string, t_inDirichlet> > bc_data_map_type;
  
  typedef std::map<std::string, number> fct_name_scaling_map_type;
  
  void add_spec
  (
    std::string ss_names, 
    std::string fct_names, 
    number val, 
    SmartPtr<UserData<number, dim> > func 
  );
  
public:
//  Management
 
  InOutFlowBC () {};
  
  void set_volume_stabilization
  (
    SmartPtr<FlowVolStabData<domain_type> > spVolStabData 
  )
  {
    m_spVolStabData = spVolStabData;
    if (spVolStabData.valid ())
    {
      spVolStabData->activate_flux ();
      spVolStabData->activate_flags ();
    }
  }
 
  void add
  (
    std::string ss_names, 
    std::string fct_names, 
    number value 
  )
  {
    add_spec (ss_names, fct_names, value, SPNULL);
  }
  
  void add
  (
    std::string ss_names, 
    std::string fct_names, 
    SmartPtr<UserData<number, dim> > func 
  )
  {
    add_spec (ss_names, fct_names, 0 /* dummy value */, func);
  }
 
  #ifdef UG_FOR_LUA
  void add
  (
    std::string ss_names, 
    std::string fct_names, 
    const char* fctName 
  )
  {
    add(ss_names, fct_names, LuaUserDataFactory<number,dim>::create(fctName));
  }
 
  void add
  (
    std::string ss_names, 
    std::string fct_names, 
    LuaFunctionHandle fct 
  )
  {
    add(ss_names, fct_names, make_sp(new LuaUserData<number,dim>(fct)));
  }
  #endif
 
  void scale
  (
    std::string fct_names, 
    number scaling 
  );
  
public:
// The interface:
  
  void adjust_jacobian
  (
    matrix_type & J,
    const vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0,
    ConstSmartPtr<VectorTimeSeries<vector_type> > vSol = SPNULL,
    const number s_a0 = 1.0
  );
 
  void adjust_defect
  (
    vector_type & d,
    const vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0,
    ConstSmartPtr<VectorTimeSeries<vector_type> > vSol = SPNULL,
    const std::vector<number> * vScaleMass = NULL,
    const std::vector<number> * vScaleStiff = NULL
  );
 
  void adjust_solution
  (
    vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  );
 
  void adjust_linear
  (
    matrix_type & A,
    vector_type & b,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  )
  {
    this_type::adjust_jacobian (A, b, dd, time); // the 2nd arg. is dummy: A does not depend on u
    this_type::adjust_solution (b, dd, time);
  };
 
  void adjust_rhs
  (
    vector_type & b,
    const vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  )
  {
    this_type::adjust_solution (b, dd, time);
  };
 
  int type () const {return CT_DIRICHLET;}
  
private:
  void names_to_ids_in_scaling
  (
    const FunctionPattern * fct_pattern, 
    std::vector<number> & v_scaling 
  ) const;
  
private:
  
  SmartPtr<FlowVolStabData<domain_type> > m_spVolStabData;
  
  bc_data_map_type m_mStoF;
  
  fct_name_scaling_map_type m_mFtoM;
};
 
} // namespace d3f
} // end namespace ug
 
#include "inout_bnd_impl.h"
 
#endif // __H__UG__PLUGINS__D3F__INOUT_BND__
 
/* End of File */