dom_disc_embb.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020:  G-CSC, Goethe University Frankfurt
 * Author: Dmitry Logashenko
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
/*
 * Global assembling of the problems with the embedded boundary.
 */
#ifndef __H__UG__PLUGINS__D3F__EMBASS__
#define __H__UG__PLUGINS__D3F__EMBASS__
 
#include <vector>
 
// ug4 headers
#include "common/common.h"
#include "common/util/smart_pointer.h"
#include "lib_disc/domain_traits.h"
#include "lib_disc/spatial_disc/domain_disc.h"
#include "lib_disc/operator/linear_operator/std_injection.h"
#include "bridge/util_algebra_dependent.h"
#ifdef UG_FOR_LUA
#include "bindings/lua/lua_user_data.h"
#endif
 
namespace ug {
 
 
template <typename TDomain, typename TAlgebra>
class IInterfaceExtrapolation
{
public:
 
  typedef TDomain domain_type;
  
  typedef TAlgebra algebra_type;
  
  typedef typename algebra_type::vector_type vector_type;
  
  typedef typename algebra_type::matrix_type matrix_type;
  
  static const int dim = domain_type::dim;
  
  IInterfaceExtrapolation () {}
  
  virtual ~IInterfaceExtrapolation () {}
 
  virtual int check_elem_lsf
  (
    size_t n_co, 
    GridObject * pElem, 
    int si, 
    int g_level, 
    bool use_hanging, 
    const MathVector<dim> vCornerCoords [], 
    number time 
  )
  {UG_THROW ("IInterfaceExtrapolation: Virtual functions are not implemented in the base class.");}
  virtual int check_elem_lsf {…}
  
  virtual int check_elem_lsf
  (
    size_t n_co, 
    GridObject * pElem, 
    int si, 
    bool use_hanging, 
    const MathVector<dim> vCornerCoords [], 
    number time 
  )
  {UG_THROW ("IInterfaceExtrapolation: Virtual functions are not implemented in the base class.");}
  virtual int check_elem_lsf {…}
  
  virtual void extrapolate_by_lsf
  (
    size_t num_co, 
    size_t base_co, 
    number * u, 
    size_t fct 
  ) const
  {UG_THROW ("IInterfaceExtrapolation: Virtual functions are not implemented in the base class.");}
  virtual void extrapolate_by_lsf {…}
  
  virtual void extrapolate_by_lsf
  (
    size_t num_co, 
    number * u, 
    size_t fct 
  ) const
  {UG_THROW ("IInterfaceExtrapolation: Virtual functions are not implemented in the base class.");}
  virtual void extrapolate_by_lsf {…}
  
  virtual bool corner_inside
  (
    size_t co 
  ) const
  {UG_THROW ("IInterfaceExtrapolation: Virtual functions are not implemented in the base class.");}
  virtual bool corner_inside {…}
  
  virtual number lsf_at
  (
    size_t co 
  ) const
  {UG_THROW ("IInterfaceExtrapolation: Virtual functions are not implemented in the base class.");}
  virtual number lsf_at {…}
 
}; // class IInterfaceExtrapolation
class IInterfaceExtrapolation {…};
 
 
template <typename TDomain, typename TAlgebra, typename TExtrapolation>
class LSGFGlobAssembler
{
public:
 
  typedef TDomain domain_type;
  
  typedef TAlgebra algebra_type;
  
  typedef ApproximationSpace<domain_type> approx_space_type;
  
  typedef typename algebra_type::vector_type vector_type;
  
  typedef typename algebra_type::matrix_type matrix_type;
  
  typedef TExtrapolation extrapolation_type;
  
  typedef typename extrapolation_type::ls_grid_func_type ls_grid_func_type;
  
  static const int dim = TDomain::dim;
  
// Constructor/destructor
 
public:
 
  LSGFGlobAssembler () : m_bAssembleOnlyCut(false) {};
  
  virtual ~LSGFGlobAssembler () {};
 
// Assembling tools
 
public:
 
  template <typename TElem, typename TIterator>
  void
  AssembleStiffnessMatrix(  const std::vector<IElemDisc<domain_type>*>& vElemDisc,
                ConstSmartPtr<domain_type> spDomain,
                ConstSmartPtr<DoFDistribution> dd,
                TIterator iterBegin,
                TIterator iterEnd,
                int si, bool bNonRegularGrid,
                matrix_type& A,
                const vector_type& u,
                ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
  template <typename TElem, typename TIterator>
  void
  AssembleMassMatrix( const std::vector<IElemDisc<domain_type>*>& vElemDisc,
            ConstSmartPtr<domain_type> spDomain,
            ConstSmartPtr<DoFDistribution> dd,
            TIterator iterBegin,
            TIterator iterEnd,
            int si, bool bNonRegularGrid,
            matrix_type& M,
            const vector_type& u,
            ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
  template <typename TElem, typename TIterator>
  void
  AssembleJacobian( const std::vector<IElemDisc<domain_type>*>& vElemDisc,
            ConstSmartPtr<domain_type> spDomain,
            ConstSmartPtr<DoFDistribution> dd,
            TIterator iterBegin,
            TIterator iterEnd,
            int si, bool bNonRegularGrid,
            matrix_type& J,
            const vector_type& u,
            ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
  template <typename TElem, typename TIterator>
  void
  AssembleJacobian( const std::vector<IElemDisc<domain_type>*>& vElemDisc,
            ConstSmartPtr<domain_type> spDomain,
            ConstSmartPtr<DoFDistribution> dd,
            TIterator iterBegin,
            TIterator iterEnd,
            int si, bool bNonRegularGrid,
            matrix_type& J,
            ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
            number s_a0,
            ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
  template <typename TElem, typename TIterator>
  void
  AssembleDefect( const std::vector<IElemDisc<domain_type>*>& vElemDisc,
          ConstSmartPtr<domain_type> spDomain,
          ConstSmartPtr<DoFDistribution> dd,
          TIterator iterBegin,
          TIterator iterEnd,
          int si, bool bNonRegularGrid,
          vector_type& d,
          const vector_type& u,
          ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
  template <typename TElem, typename TIterator>
  void
  AssembleDefect( const std::vector<IElemDisc<domain_type>*>& vElemDisc,
          ConstSmartPtr<domain_type> spDomain,
          ConstSmartPtr<DoFDistribution> dd,
          TIterator iterBegin,
          TIterator iterEnd,
          int si, bool bNonRegularGrid,
          vector_type& d,
          ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
          const std::vector<number>& vScaleMass,
          const std::vector<number>& vScaleStiff,
          ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
  template <typename TElem, typename TIterator>
  void
  AssembleLinear( const std::vector<IElemDisc<domain_type>*>& vElemDisc,
          ConstSmartPtr<domain_type> spDomain,
          ConstSmartPtr<DoFDistribution> dd,
          TIterator iterBegin,
          TIterator iterEnd,
          int si, bool bNonRegularGrid,
          matrix_type& A,
          vector_type& rhs,
          ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
  template <typename TElem, typename TIterator>
  void
  AssembleLinear( const std::vector<IElemDisc<domain_type>*>& vElemDisc,
          ConstSmartPtr<domain_type> spDomain,
          ConstSmartPtr<DoFDistribution> dd,
          TIterator iterBegin,
          TIterator iterEnd,
          int si, bool bNonRegularGrid,
          matrix_type& A,
          vector_type& rhs,
          ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
          const std::vector<number>& vScaleMass,
          const std::vector<number>& vScaleStiff,
          ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
// Assemble Rhs: it cannot be done for the ghost-fluid method independently of the matrix
 
public:
 
  template <typename TElem, typename TIterator>
  static void
  AssembleRhs(  const std::vector<IElemDisc<domain_type>*>& vElemDisc,
          ConstSmartPtr<domain_type> spDomain,
          ConstSmartPtr<DoFDistribution> dd,
          TIterator iterBegin,
          TIterator iterEnd,
          int si, bool bNonRegularGrid,
          vector_type& rhs,
          const vector_type& u,
          ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner)
  {
    UG_THROW ("LSGFGlobAssembler::AssembleRhs: Cannot assemble the RHS in GF independently of the matrix");
  }
  AssembleRhs(  const std::vector<IElemDisc<domain_type>*>& vElemDisc, {…}
 
  template <typename TElem, typename TIterator>
  static void
  AssembleRhs(  const std::vector<IElemDisc<domain_type>*>& vElemDisc,
          ConstSmartPtr<domain_type> spDomain,
          ConstSmartPtr<DoFDistribution> dd,
          TIterator iterBegin,
          TIterator iterEnd,
          int si, bool bNonRegularGrid,
          vector_type& rhs,
          ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
          const std::vector<number>& vScaleMass,
          const std::vector<number>& vScaleStiff,
          ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner)
  {
    UG_THROW ("LSGFGlobAssembler::AssembleRhs: Cannot assemble the RHS in GF independently of the matrix");
  }
  AssembleRhs(  const std::vector<IElemDisc<domain_type>*>& vElemDisc, {…}
 
// Prepare and Finish Timestep: these version merely skip the outer elements
 
public:
  void PrepareTimestep
  (
    const std::vector<IElemDisc<domain_type>*>& vElemDisc,
    ConstSmartPtr<DoFDistribution> dd,
    bool bNonRegularGrid,
    ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
    number future_time,
    ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner
  );
 
  template <typename TElem, typename TIterator>
  void
  PrepareTimestepElem(const std::vector<IElemDisc<domain_type>*>& vElemDisc,
          ConstSmartPtr<domain_type> spDomain,
          ConstSmartPtr<DoFDistribution> dd,
          TIterator iterBegin,
          TIterator iterEnd,
          int si, bool bNonRegularGrid,
          ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
          ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
  void FinishTimestep
  (
    const std::vector<IElemDisc<domain_type>*>& vElemDisc,
    ConstSmartPtr<DoFDistribution> dd,
    bool bNonRegularGrid,
    ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
    ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner
  );
 
  template <typename TElem, typename TIterator>
  void
  FinishTimestepElem(const std::vector<IElemDisc<domain_type>*>& vElemDisc,
           ConstSmartPtr<domain_type> spDomain,
           ConstSmartPtr<DoFDistribution> dd,
           TIterator iterBegin,
           TIterator iterEnd,
           int si, bool bNonRegularGrid,
           ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
           ConstSmartPtr<AssemblingTuner<TAlgebra> > spAssTuner);
 
  template <typename TElem, typename TIterator>
  void
  InitAllExports(const std::vector<IElemDisc<domain_type>*>& vElemDisc,
           ConstSmartPtr<DoFDistribution> dd,
           TIterator iterBegin,
           TIterator iterEnd,
           int si, bool bNonRegularGrid, bool bAsTimeDependent);
 
// Error estimators: Not implemented for the ghost-fluid method
 
public:
 
  template <typename TElem, typename TIterator>
  static void
  AssembleErrorEstimator
  (
    const std::vector<IElemError<domain_type>*>& vElemDisc,
    ConstSmartPtr<domain_type> spDomain,
    ConstSmartPtr<DoFDistribution> dd,
    TIterator iterBegin,
    TIterator iterEnd,
    int si,
    bool bNonRegularGrid,
    const vector_type& u
  )
  {
    UG_THROW ("AssembleErrorEstimator: No error estimator implemented for the Ghost-Fluid method.");
  }
  AssembleErrorEstimator {…}
 
  template <typename TElem, typename TIterator>
  static void
  AssembleErrorEstimator
  (
    const std::vector<IElemError<domain_type>*>& vElemDisc,
    ConstSmartPtr<domain_type> spDomain,
    ConstSmartPtr<DoFDistribution> dd,
    TIterator iterBegin,
    TIterator iterEnd,
    int si,
    bool bNonRegularGrid,
    std::vector<number> vScaleMass,
    std::vector<number> vScaleStiff,
    ConstSmartPtr<VectorTimeSeries<vector_type> > vSol
  )
  {
    UG_THROW ("AssembleErrorEstimator: No error estimator implemented for the Ghost-Fluid method.");
  }
  AssembleErrorEstimator {…}
  
// Data
 
private:
 
  extrapolation_type m_extrapol; 
  
   bool m_bAssembleOnlyCut;
 
public:
 
  void set_LSF
  (
    SmartPtr<ls_grid_func_type> spLSF 
  )
  {
    m_extrapol.set_LSF (spLSF);
  }
  void set_LSF {…}
  
  void prepare_interface_bc
  (
    SmartPtr<approx_space_type> spApproxSpace 
  )
  {
    m_extrapol.prepare_interface_bc (spApproxSpace);
  }
  void prepare_interface_bc {…}
  
  void set_Dirichlet_on_if_for
  (
    SmartPtr<approx_space_type> spApproxSpace, 
    const char* fct_name, 
    number value 
  )
  {
    m_extrapol.set_Dirichlet_for (spApproxSpace, fct_name, value);
  }
  void set_Dirichlet_on_if_for {…}
  
  void set_Dirichlet_on_if_for
  (
    SmartPtr<approx_space_type> spApproxSpace, 
    const char* fct_name, 
    SmartPtr<CplUserData<number, dim> > func 
  )
  {
    m_extrapol.set_Dirichlet_for (spApproxSpace, fct_name, func);
  }
  void set_Dirichlet_on_if_for {…}
  
  void set_plain_Dirichlet_on_if_for
  (
    SmartPtr<approx_space_type> spApproxSpace, 
    const char* fct_name, 
    SmartPtr<CplUserData<number, dim> > func 
  )
  {
    m_extrapol.set_plain_Dirichlet_for (spApproxSpace, fct_name, func);
  }
  void set_plain_Dirichlet_on_if_for {…}
  
  void set_plain_Dirichlet_on_if_for
  (
    SmartPtr<approx_space_type> spApproxSpace, 
    const char* fct_name, 
    number value 
  )
  {
    m_extrapol.set_plain_Dirichlet_for (spApproxSpace, fct_name, value);
  }
  void set_plain_Dirichlet_on_if_for {…}
  
  void set_Neumann0_on_if_for
  (
    SmartPtr<approx_space_type> spApproxSpace, 
    const char* fct_name 
  )
  {
    m_extrapol.set_Neumann0_for (spApproxSpace, fct_name);
  }
  void set_Neumann0_on_if_for {…}
  
  void exclude_subsets
  (
    SmartPtr<approx_space_type> spApproxSpace, 
    const char* subset_names 
  )
  {
    m_extrapol.exclude_subsets (spApproxSpace, subset_names);
  }
  void exclude_subsets {…}
  
  void set_assemble_only_cut (bool b)
  {
    m_bAssembleOnlyCut = b;
  }
  void set_assemble_only_cut (bool b) {…}
  
  void project_LSF ()
  {
    m_extrapol.project_LSF ();
  }
  void project_LSF () {…}
  
  extrapolation_type & extrapolation () {return m_extrapol;}
  
  int check_elem_lsf
  (
    size_t n_co, 
    GridObject * pElem, 
    int si, 
    int g_level, 
    bool use_hanging, 
    const MathVector<dim> vCornerCoords [], 
    number time 
  )
  {
    return m_extrapol.check_elem_lsf (n_co, pElem, si, g_level, use_hanging, vCornerCoords, time);
  }
  int check_elem_lsf {…}
  
  void extrapolate_by_lsf
  (
    size_t num_co, 
    size_t base_co, 
    number * u, 
    size_t fct 
  ) const
  {
    m_extrapol.extrapolate_by_lsf (num_co, base_co, u, fct);
  }
  void extrapolate_by_lsf {…}
  
  void extrapolate_by_lsf
  (
    size_t num_co, 
    number * u, 
    size_t fct 
  ) const
  {
    m_extrapol.extrapolate_by_lsf (num_co, u, fct);
  }
  void extrapolate_by_lsf {…}
  
  bool corner_inside
  (
    size_t co 
  ) const
  {return m_extrapol.corner_inside (co);}
  bool corner_inside {…}
  
  number lsf_at
  (
    size_t co 
  ) const
  {return m_extrapol.lsf_at (co);}
  number lsf_at {…}
  
  virtual void clear_outer_values
  (
    vector_type & d, 
    const DoFDistribution * dd 
  ) const
  {m_extrapol.clear_outer_values (d, dd);}
  virtual void clear_outer_values {…}
  
  virtual void set_outer_values
  (
    vector_type & u, 
    const DoFDistribution * dd, 
    number time 
  )
  {m_extrapol.set_outer_values (u, dd, time);}
  virtual void set_outer_values {…}
  
  virtual void set_outer_matrices
  (
    matrix_type & A, 
    const DoFDistribution * dd 
  ) const
  {m_extrapol.set_outer_matrices (A, dd);}
  virtual void set_outer_matrices {…}
  
}; // class LSGFGlobAssembler
class LSGFGlobAssembler {…};
 
 
template <typename TDomain, typename TAlgebra, typename TExtrapolation>
class LSGFConstraint
: public IDomainConstraint<TDomain, TAlgebra>
{
public:
 
  typedef TDomain domain_type;
  
  typedef TAlgebra algebra_type;
  
  typedef typename algebra_type::vector_type vector_type;
  
  typedef typename algebra_type::matrix_type matrix_type;
  
  typedef TExtrapolation extrapolation_type;
  
  LSGFConstraint
  (
    extrapolation_type & rExtrapolation 
  )
  : m_rExtrapolation (rExtrapolation)
  {}
  LSGFConstraint {…}
 
  virtual ~LSGFConstraint () {};
 
  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
  )
  {
    m_rExtrapolation.set_outer_matrices (J, dd.get ());
  }
  void adjust_jacobian {…}
 
  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
  )
  {
    m_rExtrapolation.clear_outer_values (d, dd.get ());
  }
  void adjust_defect {…}
 
  void adjust_solution
  (
    vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  )
  {
    m_rExtrapolation.set_outer_values (u, dd.get (), time);
  }
  void adjust_solution {…}
 
  void adjust_linear
  (
    matrix_type & A,
    vector_type & b,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  )
  { // Note that this function is not really used, so it needs not to be optimal.
    m_rExtrapolation.set_outer_matrices (A, dd.get ());
    m_rExtrapolation.clear_outer_values (b, dd.get ());
  }
  void adjust_linear {…}
 
  void adjust_rhs
  (
    vector_type & b,
    const vector_type & u,
    ConstSmartPtr<DoFDistribution> dd,
    int type,
    number time = 0.0
  )
  {
    m_rExtrapolation.clear_outer_values (b, dd.get ());
  }
  void adjust_rhs {…}
 
  int type () const {return CT_DIRICHLET;}
  
private:
  
  extrapolation_type & m_rExtrapolation;
};
class LSGFConstraint {…};
 
 
template <typename TDomain, typename TAlgebra, typename TExtrapolation>
class LSGFDomainDiscretization
: public DomainDiscretizationBase<TDomain, TAlgebra, LSGFGlobAssembler<TDomain, TAlgebra, TExtrapolation> >,
  public IInterfaceExtrapolation<TDomain, TAlgebra>
{
  typedef LSGFGlobAssembler<TDomain, TAlgebra, TExtrapolation> gass_type;
  
  typedef DomainDiscretizationBase<TDomain, TAlgebra, gass_type> base_type;
 
  typedef LSGFConstraint<TDomain, TAlgebra, TExtrapolation> ls_constraint_type;
  
public:
  typedef TDomain domain_type;
 
  typedef TAlgebra algebra_type;
 
  typedef typename TDomain::grid_type grid_type;
 
  typedef typename algebra_type::matrix_type matrix_type;
 
  typedef typename algebra_type::vector_type vector_type;
 
  typedef ApproximationSpace<TDomain> approx_space_type;
  
  typedef typename gass_type::ls_grid_func_type ls_grid_func_type;
  
  static const int dim = TDomain::dim;
  
public:
  LSGFDomainDiscretization (SmartPtr<approx_space_type> pApproxSpace)
  :   DomainDiscretizationBase<domain_type, algebra_type, gass_type> (pApproxSpace),
    m_spLSFGFConstraint (new ls_constraint_type (this->extrapolation ()))
  {
  //  register the constraint
    this->add (SmartPtr<IDomainConstraint<domain_type, algebra_type> > (m_spLSFGFConstraint));
  //  set the default the boundary condtions at the interface
    gass_type::prepare_interface_bc (pApproxSpace);
  }
  LSGFDomainDiscretization (SmartPtr<approx_space_type> pApproxSpace) {…}
 
  virtual ~LSGFDomainDiscretization () {};
  
  void set_LSF
  (
    SmartPtr<ls_grid_func_type> spLSF 
  )
  {
    gass_type::set_LSF (spLSF);
  }
  void set_LSF {…}
  
  void set_Dirichlet_on_if_for
  (
    const char* fct_name, 
    number value 
  )
  {
    gass_type::set_Dirichlet_on_if_for (base_type::m_spApproxSpace, fct_name, value);
  }
  void set_Dirichlet_on_if_for {…}
  
  void set_Dirichlet_on_if_for
  (
    const char* fct_name, 
    SmartPtr<CplUserData<number, dim> > func 
  )
  {
    gass_type::set_Dirichlet_on_if_for (base_type::m_spApproxSpace, fct_name, func);
  }
  void set_Dirichlet_on_if_for {…}
  
  void set_plain_Dirichlet_on_if_for
  (
    const char* fct_name, 
    number value 
  )
  {
    gass_type::set_plain_Dirichlet_on_if_for (base_type::m_spApproxSpace, fct_name, value);
  }
  void set_plain_Dirichlet_on_if_for {…}
  
  void set_plain_Dirichlet_on_if_for
  (
    const char* fct_name, 
    SmartPtr<CplUserData<number, dim> > func 
  )
  {
    gass_type::set_plain_Dirichlet_on_if_for (base_type::m_spApproxSpace, fct_name, func);
  }
  void set_plain_Dirichlet_on_if_for {…}
  
#ifdef UG_FOR_LUA
  
  void set_Dirichlet_on_if_for
  (
    const char* fct_name, 
    const char* func_name 
  )
  {
    set_Dirichlet_on_if_for (fct_name, LuaUserDataFactory<number,dim>::create(func_name));
  }
  
  void set_Dirichlet_on_if_for
  (
    const char* fct_name, 
    LuaFunctionHandle func 
  )
  {
    set_Dirichlet_on_if_for (fct_name, make_sp(new LuaUserData<number,dim>(func)));
  }
  
  void set_plain_Dirichlet_on_if_for
  (
    const char* fct_name, 
    const char* func_name 
  )
  {
    set_plain_Dirichlet_on_if_for (fct_name, LuaUserDataFactory<number,dim>::create(func_name));
  }
  
  void set_plain_Dirichlet_on_if_for
  (
    const char* fct_name, 
    LuaFunctionHandle func 
  )
  {
    set_plain_Dirichlet_on_if_for (fct_name, make_sp(new LuaUserData<number,dim>(func)));
  }
  
#endif
  
  void set_Neumann0_on_if_for
  (
    const char* fct_name 
  )
  {
    gass_type::set_Neumann0_on_if_for (base_type::m_spApproxSpace, fct_name);
  }
  void set_Neumann0_on_if_for {…}
  
  void exclude_subsets
  (
    const char* subset_names 
  )
  {
    gass_type::exclude_subsets (base_type::m_spApproxSpace, subset_names);
  }
  void exclude_subsets {…}
  
  void set_assemble_only_cut (bool b)
  {
    gass_type::set_assemble_only_cut (b);
  }
  void set_assemble_only_cut (bool b) {…}
  
  void project_LSF ()
  {
    gass_type::project_LSF ();
  }
  void project_LSF () {…}
  
  virtual int check_elem_lsf
  (
    size_t n_co, 
    GridObject * pElem, 
    int si, 
    int g_level, 
    bool use_hanging, 
    const MathVector<dim> vCornerCoords [], 
    number time 
  )
  {
    return gass_type::check_elem_lsf (n_co, pElem, si, g_level, use_hanging, vCornerCoords, time);
  }
  virtual int check_elem_lsf {…}
  
  virtual int check_elem_lsf
  (
    size_t n_co, 
    GridObject * pElem, 
    int si, 
    bool use_hanging, 
    const MathVector<dim> vCornerCoords [], 
    number time 
  )
  {
    ConstSmartPtr<grid_type> mg = base_type::m_spApproxSpace->domain()->grid ();
    int g_level = mg->get_level (pElem);
    UG_ASSERT (g_level >= 0, "LSGFDomainDiscretization: Grid element without grid level.");
    return gass_type::check_elem_lsf (n_co, pElem, si, g_level, use_hanging, vCornerCoords, time);
  }
  virtual int check_elem_lsf {…}
  
  virtual void extrapolate_by_lsf
  (
    size_t num_co, 
    size_t base_co, 
    number * u, 
    size_t fct 
  ) const
  {
    gass_type::extrapolate_by_lsf (num_co, base_co, u, fct);
  }
  virtual void extrapolate_by_lsf {…}
  
  virtual void extrapolate_by_lsf
  (
    size_t num_co, 
    number * u, 
    size_t fct 
  ) const
  {
    gass_type::extrapolate_by_lsf (num_co, u, fct);
  }
  virtual void extrapolate_by_lsf {…}
  
  virtual bool corner_inside
  (
    size_t co 
  ) const
  {return gass_type::corner_inside (co);}
  virtual bool corner_inside {…}
  
  virtual number lsf_at
  (
    size_t co 
  ) const
  {return gass_type::lsf_at (co);}
  virtual number lsf_at {…}
  
protected:
  SmartPtr<ls_constraint_type> m_spLSFGFConstraint;
};
class LSGFDomainDiscretization {…};
 
} // end namespace ug
 
#include "dom_disc_embb_impl.h"
 
#endif // __H__UG__PLUGINS__D3F__EMBASS__
 
/* End of File */