elem_disc_interface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Author: Andreas Vogel
 * 
 * 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.
 */
 
#ifndef __H__UG__LIB_DISC__SPATIAL_DISC__ELEM_DISC__ELEM_DISC_INTERFACE__
#define __H__UG__LIB_DISC__SPATIAL_DISC__ELEM_DISC__ELEM_DISC_INTERFACE__
 
// extern headers
#include <vector>
#include <string>
 
// intern headers
#include "lib_disc/common/local_algebra.h"
#include "lib_disc/time_disc/solution_time_series.h"
#include "lib_disc/function_spaces/approximation_space.h"
#include "lib_disc/local_finite_element/local_finite_element_id.h"
#include "lib_disc/reference_element/reference_element_traits.h"
#include "lib_disc/spatial_disc/user_data/data_import.h"
#include "common/util/provider.h"
#include "lib_disc/domain_util.h"
#include "lib_disc/domain_traits.h"
#include "elem_modifier.h"
#include "lib_disc/spatial_disc/elem_disc/err_est_data.h"
#include "bridge/util_algebra_dependent.h"
#include "lib_disc/common/multi_index.h"
 
namespace ug{
 
enum ElemDiscType
{
  EDT_NONE = 0,
  EDT_ELEM = 1 << 0,
  EDT_SIDE = 1 << 1,
  EDT_BND = 1 << 2,
  EDT_ALL = EDT_NONE | EDT_SIDE | EDT_ELEM | EDT_BND
};
enum ElemDiscType {…};
 
 
struct VectorProxyBase
{
  virtual ~VectorProxyBase() {};
  virtual number evaluate(const DoFIndex& di) const = 0;
};
struct VectorProxyBase {…};
 
template <typename TVector>
struct VectorProxy : public VectorProxyBase
{
  VectorProxy(const TVector& v) : m_v(v) {}
 
  virtual number evaluate(const DoFIndex& di) const {return DoFRef(m_v, di);}
 
  const TVector& m_v;
 
};
struct VectorProxy : public VectorProxyBase {…};
 
/*
template <typename TDomain>
class IElemDiscBaseData
{
public:
  typedef TDomain domain_type;
 
  static const int dim = TDomain::dim;
};
*/
template <typename TLeaf, typename TDomain>
class IElemAssembleFuncs
{
public:
  IElemAssembleFuncs() { set_default_add_fct(); }
 
  virtual ~IElemAssembleFuncs(){}
 
  typedef TLeaf leaf_type;
 
  TLeaf& asLeaf()
  { return static_cast<TLeaf&>(*this); }
  TLeaf& asLeaf() {…}
 
  typedef TDomain domain_type;
 
  static const int dim = TDomain::dim;
 
  // assembling functions
public:
  virtual void prep_assemble_loop() {}
 
  virtual void post_assemble_loop() {}
 
  virtual void prep_timestep(number future_time, number time, VectorProxyBase* u);
 
  virtual void prep_timestep_elem(const number time, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
  virtual void prep_elem_loop(const ReferenceObjectID roid, const int si);
 
  virtual void prep_elem(const LocalVector& u, GridObject* elem, const ReferenceObjectID roid, const MathVector<dim> vCornerCoords[]);
 
  virtual void fsh_elem_loop();
 
  virtual void fsh_timestep(number time, VectorProxyBase* u);
 
  virtual void fsh_timestep_elem(const number time, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
  virtual void add_jac_A_elem(LocalMatrix& J, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
  virtual void add_jac_M_elem(LocalMatrix& J, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
  virtual void add_def_A_elem(LocalVector& d, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
  virtual void add_def_A_expl_elem(LocalVector& d, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
  virtual void add_def_M_elem(LocalVector& d, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
  virtual void add_rhs_elem(LocalVector& rhs, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
 
  void do_prep_timestep(number future_time, const number time, VectorProxyBase* u, size_t algebra_id);
  void do_prep_timestep_elem(const number time, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  void do_prep_elem_loop(const ReferenceObjectID roid, const int si);
  void do_prep_elem(LocalVector& u, GridObject* elem, const ReferenceObjectID roid, const MathVector<dim> vCornerCoords[]);
  void do_fsh_elem_loop();
  void do_fsh_timestep(const number time, VectorProxyBase* u, size_t algebra_id);
  void do_fsh_timestep_elem(const number time, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  void do_add_jac_A_elem(LocalMatrix& J, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  void do_add_jac_M_elem(LocalMatrix& J, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  void do_add_def_A_elem(LocalVector& d, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  void do_add_def_A_expl_elem(LocalVector& d, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  void do_add_def_M_elem(LocalVector& d, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  void do_add_rhs_elem(LocalVector& rhs, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
 
 
 
protected:
  //  register the functions
  template <typename TAssFunc> void set_prep_timestep_fct(size_t algebra_id, TAssFunc func);
  template <typename TAssFunc> void set_prep_timestep_elem_fct(ReferenceObjectID id, TAssFunc func);
  template <typename TAssFunc> void set_fsh_timestep_fct(size_t algebra_id, TAssFunc func);
  template <typename TAssFunc> void set_fsh_timestep_elem_fct(ReferenceObjectID id, TAssFunc func);
 
  template <typename TAssFunc> void set_prep_elem_loop_fct(ReferenceObjectID id, TAssFunc func);
  template <typename TAssFunc> void set_prep_elem_fct(ReferenceObjectID id, TAssFunc func);
  template <typename TAssFunc> void set_fsh_elem_loop_fct(ReferenceObjectID id, TAssFunc func);
 
  template <typename TAssFunc> void set_add_jac_A_elem_fct(ReferenceObjectID id, TAssFunc func);
  template <typename TAssFunc> void set_add_jac_M_elem_fct(ReferenceObjectID id, TAssFunc func);
  template <typename TAssFunc> void set_add_def_A_elem_fct(ReferenceObjectID id, TAssFunc func);
  template <typename TAssFunc> void set_add_def_A_expl_elem_fct(ReferenceObjectID id, TAssFunc func);
  template <typename TAssFunc> void set_add_def_M_elem_fct(ReferenceObjectID id, TAssFunc func);
  template <typename TAssFunc> void set_add_rhs_elem_fct(ReferenceObjectID id, TAssFunc func);
 
 
 
  //  unregister functions
  void remove_prep_timestep_fct(size_t algebra_id);
  void remove_prep_timestep_elem_fct(ReferenceObjectID id);
  void remove_fsh_timestep_fct(size_t algebra_id);
  void remove_fsh_timestep_elem_fct(ReferenceObjectID id);
 
  void remove_prep_elem_loop_fct(ReferenceObjectID id);
  void remove_prep_elem_fct(ReferenceObjectID id);
  void remove_fsh_elem_loop_fct(ReferenceObjectID id);
 
  void remove_add_jac_A_elem_fct(ReferenceObjectID id);
  void remove_add_jac_M_elem_fct(ReferenceObjectID id);
  void remove_add_def_A_elem_fct(ReferenceObjectID id);
  void remove_add_def_A_expl_elem_fct(ReferenceObjectID id);
  void remove_add_def_M_elem_fct(ReferenceObjectID id);
  void remove_add_rhs_elem_fct(ReferenceObjectID id);
 
protected:
  void set_default_add_fct();
 
  void clear_add_fct(ReferenceObjectID id);
 
  void clear_add_fct();
 
private:
//  abbreviation for own type
  typedef IElemAssembleFuncs<TLeaf, TDomain> T;
 
//  types of timestep function pointers
  typedef void (T::*PrepareTimestepFct)(number, number, VectorProxyBase*);
  typedef void (T::*PrepareTimestepElemFct)(number, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  typedef void (T::*FinishTimestepFct)(number, VectorProxyBase*);
  typedef void (T::*FinishTimestepElemFct)(number, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
//  types of loop function pointers
  typedef void (T::*PrepareElemLoopFct)(ReferenceObjectID roid, int si);
  typedef void (T::*PrepareElemFct)(const LocalVector& u, GridObject* elem, const ReferenceObjectID roid, const MathVector<dim> vCornerCoords[]);
  typedef void (T::*FinishElemLoopFct)();
 
//  types of Jacobian assemble functions
  typedef void (T::*ElemJAFct)(LocalMatrix& J, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  typedef void (T::*ElemJMFct)(LocalMatrix& J, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
//  types of Defect assemble functions
  typedef void (T::*ElemdAFct)(LocalVector& d, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  typedef void (T::*ElemdMFct)(LocalVector& d, const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
//  types of right hand side assemble functions
  typedef void (T::*ElemRHSFct)(LocalVector& rhs, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
 
private:
//  timestep function pointers
  PrepareTimestepFct      m_vPrepareTimestepFct[bridge::NUM_ALGEBRA_TYPES];
  PrepareTimestepElemFct    m_vPrepareTimestepElemFct[NUM_REFERENCE_OBJECTS];
  FinishTimestepFct     m_vFinishTimestepFct[bridge::NUM_ALGEBRA_TYPES];
  FinishTimestepElemFct     m_vFinishTimestepElemFct[NUM_REFERENCE_OBJECTS];
 
//  loop function pointers
  PrepareElemLoopFct  m_vPrepareElemLoopFct[NUM_REFERENCE_OBJECTS];
  PrepareElemFct    m_vPrepareElemFct[NUM_REFERENCE_OBJECTS];
  FinishElemLoopFct   m_vFinishElemLoopFct[NUM_REFERENCE_OBJECTS];
 
//  Jacobian function pointers
  ElemJAFct   m_vElemJAFct[NUM_REFERENCE_OBJECTS];
  ElemJMFct   m_vElemJMFct[NUM_REFERENCE_OBJECTS];
 
//  Defect function pointers
  ElemdAFct   m_vElemdAFct[NUM_REFERENCE_OBJECTS];
  ElemdAFct   m_vElemdAExplFct[NUM_REFERENCE_OBJECTS];
  ElemdMFct   m_vElemdMFct[NUM_REFERENCE_OBJECTS];
 
//  Rhs function pointers
  ElemRHSFct  m_vElemRHSFct[NUM_REFERENCE_OBJECTS];
 
public:
 
  void set_roid(ReferenceObjectID id, int discType);
 
  void check_roid(ReferenceObjectID roid, int discType);
 
protected:
  ReferenceObjectID m_roid;
};
class IElemAssembleFuncs {…};
 
 
 
 
template <typename TLeaf, typename TDomain>
class IElemEstimatorFuncs
{
public:
  IElemEstimatorFuncs() : m_bDoErrEst(false), m_spErrEstData(SPNULL)
  { set_default_add_fct(); }
  IElemEstimatorFuncs() : m_bDoErrEst(false), m_spErrEstData(SPNULL) {…}
 
  virtual ~IElemEstimatorFuncs(){}
 
  typedef TLeaf leaf_type;
 
  TLeaf& asLeaf()
  { return static_cast<TLeaf&>(*this); }
  TLeaf& asLeaf() {…}
 
  typedef TDomain domain_type;
 
  static const int dim = TDomain::dim;
 
  void do_prep_err_est_elem_loop(const ReferenceObjectID roid, const int si);
  void do_prep_err_est_elem(LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  void do_compute_err_est_A_elem(LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], const number& scale);
  void do_compute_err_est_M_elem(LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], const number& scale);
  void do_compute_err_est_rhs_elem(GridObject* elem, const MathVector<dim> vCornerCoords[], const number& scale);
  void do_fsh_err_est_elem_loop();
 
public:
    virtual void prep_err_est_elem_loop(const ReferenceObjectID roid, const int si);
 
    virtual void prep_err_est_elem(const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
    virtual void compute_err_est_A_elem(const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], const number& scale);
 
    virtual void compute_err_est_M_elem(const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], const number& scale);
 
    virtual void compute_err_est_rhs_elem(GridObject* elem, const MathVector<dim> vCornerCoords[], const number& scale);
 
    virtual void fsh_err_est_elem_loop();
 
protected:
    template <typename TAssFunc> void set_prep_err_est_elem_loop(ReferenceObjectID id, TAssFunc func);
    template <typename TAssFunc> void set_prep_err_est_elem(ReferenceObjectID id, TAssFunc func);
    template <typename TAssFunc> void set_compute_err_est_A_elem(ReferenceObjectID id, TAssFunc func);
    template <typename TAssFunc> void set_compute_err_est_M_elem(ReferenceObjectID id, TAssFunc func);
    template <typename TAssFunc> void set_compute_err_est_rhs_elem(ReferenceObjectID id, TAssFunc func);
    template <typename TAssFunc> void set_fsh_err_est_elem_loop(ReferenceObjectID id, TAssFunc func);
 
    void remove_prep_err_est_elem_loop(ReferenceObjectID id);
    void remove_prep_err_est_elem(ReferenceObjectID id);
    void remove_compute_err_est_A_elem(ReferenceObjectID id);
    void remove_compute_err_est_M_elem(ReferenceObjectID id);
    void remove_compute_err_est_rhs_elem(ReferenceObjectID id);
    void remove_fsh_err_est_elem_loop(ReferenceObjectID id);
 
    void clear_add_fct(ReferenceObjectID id);
 
    void clear_add_fct();
 
    void set_default_add_fct();
 
 
 
private:
  //  abbreviation for own type
  typedef IElemEstimatorFuncs<TLeaf, TDomain> T;
 
  //  types of the error estimator assembler
  typedef void (T::*PrepareErrEstElemLoopFct)(ReferenceObjectID roid, int si);
  typedef void (T::*PrepareErrEstElemFct)(const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
  typedef void (T::*ElemComputeErrEstAFct)(const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], const number&);
  typedef void (T::*ElemComputeErrEstMFct)(const LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], const number&);
  typedef void (T::*ElemComputeErrEstRhsFct)(GridObject* elem, const MathVector<dim> vCornerCoords[], const number&);
  typedef void (T::*FinishErrEstElemLoopFct)();
 
  //  Error estimator functions
  PrepareErrEstElemLoopFct  m_vPrepareErrEstElemLoopFct[NUM_REFERENCE_OBJECTS];
  PrepareErrEstElemFct    m_vPrepareErrEstElemFct[NUM_REFERENCE_OBJECTS];
  ElemComputeErrEstAFct   m_vElemComputeErrEstAFct[NUM_REFERENCE_OBJECTS];
  ElemComputeErrEstMFct   m_vElemComputeErrEstMFct[NUM_REFERENCE_OBJECTS];
  ElemComputeErrEstRhsFct   m_vElemComputeErrEstRhsFct[NUM_REFERENCE_OBJECTS];
  FinishErrEstElemLoopFct   m_vFinishErrEstElemLoopFct[NUM_REFERENCE_OBJECTS];
 
 
  // //////////////////////////
  // Error estimator
  // //////////////////////////
public:
 
  void set_error_estimator(SmartPtr<IErrEstData<TDomain> > ee) {m_spErrEstData = ee; m_bDoErrEst = true;}
 
  bool err_est_enabled() const {return m_bDoErrEst;}
 
  virtual SmartPtr<IErrEstData<TDomain> > err_est_data() {return m_spErrEstData;}
 
private:
  bool m_bDoErrEst;
 
protected:
  SmartPtr<IErrEstData<TDomain> > m_spErrEstData;
 
public:
 
  void set_roid(ReferenceObjectID id, int discType);
 
  void check_roid(ReferenceObjectID roid, int discType);
 
protected:
  ReferenceObjectID m_roid;
};
class IElemEstimatorFuncs {…};
 
 
template <typename TDomain>
class IElemDiscBase
 
{
  public:
    typedef TDomain domain_type;
 
    typedef typename TDomain::position_type position_type;
 
    static const int dim = TDomain::dim;
    
  public:
    IElemDiscBase(const char* functions = "", const char* subsets = "");
 
    IElemDiscBase(const std::vector<std::string>& vFct, const std::vector<std::string>& vSubset);
 
    virtual ~IElemDiscBase(){}
 
  public:
 
    void set_approximation_space(SmartPtr<ApproximationSpace<TDomain> > approxSpace);
 
    SmartPtr<ApproximationSpace<TDomain> > approx_space() {return m_spApproxSpace;}
 
    ConstSmartPtr<ApproximationSpace<TDomain> > approx_space() const {return m_spApproxSpace;}
 
    SmartPtr<TDomain> domain(){return m_spApproxSpace->domain();}
 
    ConstSmartPtr<TDomain> domain() const{return m_spApproxSpace->domain();}
 
    typename TDomain::subset_handler_type& subset_handler()
    {
      UG_ASSERT(m_spApproxSpace.valid(), "ApproxSpace not set.");
      return *m_spApproxSpace->domain()->subset_handler();
    }
    typename TDomain::subset_handler_type& subset_handler() {…}
 
    const typename TDomain::subset_handler_type& subset_handler() const
    {
      UG_ASSERT(m_spApproxSpace.valid(), "ApproxSpace not set.");
      return *m_spApproxSpace->domain()->subset_handler();
    }
    const typename TDomain::subset_handler_type& subset_handler() const {…}
/*
    void add_elem_modifier(SmartPtr<IElemDiscModifier<TDomain> > elemModifier )
    {
      m_spElemModifier.push_back(elemModifier);
      elemModifier->set_elem_disc(this);
    }
    std::vector<SmartPtr<IElemDiscModifier<TDomain> > >& get_elem_modifier(){ return m_spElemModifier;}
    */
 
  protected:
    virtual void approximation_space_changed() {}
 
    SmartPtr<ApproximationSpace<TDomain> > m_spApproxSpace;
 
  //  std::vector<SmartPtr<IElemDiscModifier<TDomain> > > m_spElemModifier;
 
  // Functions and Subsets
  public:
    void set_functions(const std::string& functions);
 
    void set_functions(const std::vector<std::string>& functions);
 
    void set_subsets(const std::string& subsets);
 
    void set_subsets(const std::vector<std::string>& subsets);
 
    size_t num_fct() const {return m_vFct.size();}
 
    const std::vector<std::string>& symb_fcts() const {return m_vFct;}
 
    size_t num_subsets() const {return m_vSubset.size();}
 
    const std::vector<std::string>& symb_subsets() const {return m_vSubset;}
 
    ConstSmartPtr<FunctionPattern> function_pattern() const {return m_spFctPattern;}
 
    const FunctionGroup& function_group() const {return m_fctGrp;}
 
    const FunctionIndexMapping& map() const {return m_fctIndexMap;}
 
    void check_setup(bool bNonRegularGrid);
 
  protected:
    std::vector<std::string> m_vFct;
 
    std::vector<std::string> m_vSubset;
 
    ConstSmartPtr<FunctionPattern> m_spFctPattern;
 
    FunctionGroup m_fctGrp;
 
    FunctionIndexMapping m_fctIndexMap;
 
    void set_function_pattern(ConstSmartPtr<FunctionPattern> fctPatt);
 
    void update_function_index_mapping();
 
  // UserData and Coupling
  public:
    void register_import(IDataImport<dim>& Imp);
 
    size_t num_imports() const {return m_vIImport.size();}
 
    IDataImport<dim>& get_import(size_t i)
    {
      UG_ASSERT(i < num_imports(), "Invalid index");
      return *m_vIImport[i];
    }
    IDataImport<dim>& get_import(size_t i) {…}
 
    void clear_imports() {m_vIImport.clear();}
 
  protected:
    std::vector<IDataImport<dim>*> m_vIImport;
 
  // time handling
  public:
 
    void set_time_dependent(LocalVectorTimeSeries& locTimeSeries,
                    const std::vector<number>& vScaleMass,
                    const std::vector<number>& vScaleStiff);
 
    void set_time_independent();
 
    bool is_time_dependent() const {return (m_pLocalVectorTimeSeries != NULL) && !m_bStationaryForced;}
 
    void set_stationary(bool bStationaryForced = true) {m_bStationaryForced = bStationaryForced;}
    void set_stationary() {set_stationary(true);}
 
 
    virtual bool requests_local_time_series() {return false;}
 
    bool local_time_series_needed() {return is_time_dependent() && requests_local_time_series();}
 
    void set_time_point(const size_t timePoint) {m_timePoint = timePoint;}
 
    size_t time_point() const {return m_timePoint;}
 
    number time() const
    {
      if(m_pLocalVectorTimeSeries) return m_pLocalVectorTimeSeries->time(m_timePoint);
      else return 0.0;
    }
    number time() const {…}
 
 
    const LocalVectorTimeSeries* local_time_solutions() const
    {return m_pLocalVectorTimeSeries;}
    const LocalVectorTimeSeries* local_time_solutions() const {…}
 
    const std::vector<number>& mass_scales() const {return m_vScaleMass;}
    const std::vector<number>& stiff_scales() const {return m_vScaleStiff;}
 
    number mass_scale(const size_t timePoint) const {return m_vScaleMass[timePoint];}
    number stiff_scale(const size_t timePoint) const {return m_vScaleStiff[timePoint];}
 
    number mass_scale() const {return m_vScaleMass[m_timePoint];}
    number stiff_scale() const {return m_vScaleStiff[m_timePoint];}
 
  protected:
    size_t m_timePoint;
 
    LocalVectorTimeSeries* m_pLocalVectorTimeSeries;
 
    std::vector<number> m_vScaleMass;
    std::vector<number> m_vScaleStiff;
 
    bool m_bStationaryForced;
 
  
 
  // general info
  public:
    virtual int type() const {return EDT_ELEM | EDT_SIDE;}
 
 
    virtual void prepare_setting(const std::vector<LFEID>& vLfeID, bool bNonRegularGrid) = 0;
 
 
    virtual bool use_hanging() const {return false;}
};
class IElemDiscBase {…};
 
 
template <typename TDomain>
class IElemError :
  public IElemDiscBase<TDomain>,
  public IElemEstimatorFuncs<IElemDisc<TDomain>, TDomain>
{
public:
  typedef TDomain domain_type;
  static const int dim = TDomain::dim;
 
  friend class IElemEstimatorFuncs<IElemDisc<TDomain>, TDomain>;
  typedef IElemEstimatorFuncs<IElemDisc<TDomain>, TDomain> estimator_base_type;
 
  IElemError(const char* functions, const char* subsets)
  : IElemDiscBase<TDomain>(functions, subsets), estimator_base_type()  {}
  IElemError(const char* functions, const char* subsets) {…}
 
  IElemError(const std::vector<std::string>& vFct, const std::vector<std::string>& vSubset)
  : IElemDiscBase<TDomain>(vFct, vSubset), estimator_base_type()  {}
  IElemError(const std::vector<std::string>& vFct, const std::vector<std::string>& vSubset) {…}
 
 
protected:
 
  void clear_add_fct(ReferenceObjectID id)
  { estimator_base_type::clear_add_fct(id); }
  void clear_add_fct(ReferenceObjectID id) {…}
 
  void clear_add_fct()
  { estimator_base_type::clear_add_fct(); }
  void clear_add_fct() {…}
 
  //void set_default_add_fct();
  using estimator_base_type::set_default_add_fct;
 
};
class IElemError : {…};
 
 
template <typename TDomain>
class IElemDisc :
    public IElemAssembleFuncs<IElemDisc<TDomain>, TDomain>,
    public IElemError<TDomain>
{
public:
  typedef TDomain domain_type;
  static const int dim = TDomain::dim;
 
  typedef IElemError<TDomain> base_type;
  typedef IElemEstimatorFuncs<IElemDisc<TDomain>, TDomain> estimator_base_type;
  typedef IElemAssembleFuncs<IElemDisc<TDomain>, TDomain> assemble_base_type;
 
  friend class IElemEstimatorFuncs<IElemDisc<TDomain>, TDomain>;
  friend class IElemAssembleFuncs<IElemDisc<TDomain>, TDomain>;
 
 
  IElemDisc(const char* functions, const char* subsets)
  : assemble_base_type(), IElemError<TDomain>(functions, subsets) {}
  IElemDisc(const char* functions, const char* subsets) {…}
 
  IElemDisc(const std::vector<std::string>& vFct, const std::vector<std::string>& vSubset)
  : assemble_base_type(), IElemError<TDomain>(vFct, vSubset) {}
  IElemDisc(const std::vector<std::string>& vFct, const std::vector<std::string>& vSubset) {…}
 
protected:
 
    void clear_add_fct(ReferenceObjectID id)
    {
      base_type::clear_add_fct(id);
      assemble_base_type::clear_add_fct(id);
    }
    void clear_add_fct(ReferenceObjectID id) {…}
 
    void clear_add_fct()
    {
      base_type::clear_add_fct();
      assemble_base_type::clear_add_fct();
    }
    void clear_add_fct() {…}
 
    void set_default_add_fct()
    {
      base_type::set_default_add_fct();
      assemble_base_type::set_default_add_fct();
    }
    void set_default_add_fct() {…}
 
 
public:
  void add_elem_modifier(SmartPtr<IElemDiscModifier<TDomain> > elemModifier )
  {
      m_spElemModifier.push_back(elemModifier);
      elemModifier->set_elem_disc(this);
  }
  void add_elem_modifier(SmartPtr<IElemDiscModifier<TDomain> > elemModifier ) {…}
 
  std::vector<SmartPtr<IElemDiscModifier<TDomain> > >& get_elem_modifier()
  { return m_spElemModifier;}
  std::vector<SmartPtr<IElemDiscModifier<TDomain> > >& get_elem_modifier() {…}
 
protected:
  std::vector<SmartPtr<IElemDiscModifier<TDomain> > > m_spElemModifier;
 
 
};
class IElemDisc : {…};
 
 
 
 
} // end namespace ug
 
#include "elem_disc_interface_impl.h"
 
#endif /* __H__UG__LIB_DISC__SPATIAL_DISC__ELEM_DISC__ELEM_DISC_INTERFACE__ */