data_evaluator.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2017:  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__DATA_EVALUATOR__
#define __H__UG__LIB_DISC__SPATIAL_DISC__DATA_EVALUATOR__
 
#include "lib_disc/spatial_disc/elem_disc/elem_disc_interface.h"
#include "lib_disc/spatial_disc/user_data/user_data.h"
#include "lib_disc/spatial_disc/user_data/data_import.h"
 
namespace ug{
 
enum ProcessType {PT_ALL=0, PT_STATIONARY, PT_INSTATIONARY, MAX_PROCESS};
 
 
template <typename TDomain, typename TElemDisc> // TElemDisc = IElemDisc<TDomain>
class DataEvaluatorBase
{
  public:
    static const int dim = TDomain::dim;
    
  public:
    DataEvaluatorBase(int discPart,
                  const std::vector<TElemDisc*>& vElemDisc,
                  ConstSmartPtr<FunctionPattern> fctPat,
                  const bool bNonRegularGrid,
                  LocalVectorTimeSeries* locTimeSeries = NULL,
                  const std::vector<number>* vScaleMass = NULL,
                  const std::vector<number>* vScaleStiff = NULL);
 
    void set_time_point(const size_t timePoint);
 
    bool time_series_needed() const {return m_bNeedLocTimeSeries;}
 
    bool use_hanging() const {return m_bUseHanging;}
 
    
 
    void prepare_err_est_elem_loop(const ReferenceObjectID id, int si);
 
    void prepare_err_est_elem(LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[],
                      const LocalIndices& ind, bool bDeriv = false);
 
    void compute_err_est_A_elem(LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], const LocalIndices& ind,
                  const number scaleMass = (number) 1.0, const number scaleStiff = (number) 1.0);
 
    void compute_err_est_M_elem(LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], const LocalIndices& ind,
                  const number scaleMass = (number) 1.0, const number scaleStiff = (number) 1.0);
 
    void compute_err_est_rhs_elem(GridObject* elem, const MathVector<dim> vCornerCoords[], const LocalIndices& ind,
                  const number scaleMass = (number) 1.0, const number scaleStiff = (number) 1.0);
 
    void finish_err_est_elem_loop();
 
  protected:
    void clear_extracted_data_and_mappings();
 
    void add_data_to_eval_data(std::vector<SmartPtr<ICplUserData<dim> > >& vEvalData,
                   std::vector<SmartPtr<ICplUserData<dim> > >& vTryingToAdd);
 
    void extract_imports_and_userdata(int subsetIndex, int discPart);
 
    void clear_positions_in_user_data();
 
  protected:
    int m_discPart;
 
    std::vector<TElemDisc*> m_vElemDisc[MAX_PROCESS];
 
    ConstSmartPtr<FunctionPattern> m_spFctPattern;
 
    bool m_bUseHanging;
 
    bool m_bNeedLocTimeSeries;
 
    LocalVectorTimeSeries* m_pLocTimeSeries;
 
    std::vector<IDataImport<dim>*> m_vImport[MAX_PROCESS][MAX_PART];
 
    std::vector<SmartPtr<ICplUserData<dim> > > m_vConstData;   //< constant data
    std::vector<SmartPtr<ICplUserData<dim> > > m_vPosData;       //< position dependent data
    std::vector<SmartPtr<ICplUserData<dim> > > m_vDependentData; //< dependent data
};
class DataEvaluatorBase {…};
 
 
template <typename TDomain>
class ErrorEvaluator : public DataEvaluatorBase<TDomain, IElemError<TDomain> >
{
public:
  ErrorEvaluator(int discPart,
                  const std::vector<IElemError<TDomain> *>& vElemDisc,
                  ConstSmartPtr<FunctionPattern> fctPat,
                  const bool bNonRegularGrid,
                  LocalVectorTimeSeries* locTimeSeries = NULL,
                  const std::vector<number>* vScaleMass = NULL,
                  const std::vector<number>* vScaleStiff = NULL)
  : DataEvaluatorBase<TDomain, IElemError<TDomain> > (discPart, vElemDisc, fctPat, bNonRegularGrid, locTimeSeries, vScaleMass, vScaleStiff) {}
  ErrorEvaluator(int discPart, {…}
};
class ErrorEvaluator : public DataEvaluatorBase<TDomain, IElemError<TDomain> > {…};
 
 
 
template <typename TDomain>
class DataEvaluator : public DataEvaluatorBase<TDomain, IElemDisc<TDomain> >
{
 
public:
  typedef DataEvaluatorBase<TDomain, IElemDisc<TDomain> > base_type;
  using base_type::dim;
 
  DataEvaluator(int discPart,
                  const std::vector<IElemDisc<TDomain> *>& vElemDisc,
                  ConstSmartPtr<FunctionPattern> fctPat,
                  const bool bNonRegularGrid,
                  LocalVectorTimeSeries* locTimeSeries = NULL,
                  const std::vector<number>* vScaleMass = NULL,
                  const std::vector<number>* vScaleStiff = NULL)
  : DataEvaluatorBase<TDomain, IElemDisc<TDomain> > (discPart, vElemDisc, fctPat, bNonRegularGrid, locTimeSeries, vScaleMass, vScaleStiff) {}
  DataEvaluator(int discPart, {…}
 
 
  // Regular assembling
 
      void prepare_timestep(number future_time, const number time, VectorProxyBase* u, size_t algebra_id);
 
      void prepare_timestep_elem(const number time, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
      void prepare_elem_loop(const ReferenceObjectID id, int si);
 
      void prepare_elem(LocalVector& u, GridObject* elem, const ReferenceObjectID roid, const MathVector<dim> vCornerCoords[],
                        const LocalIndices& ind, bool bDeriv = false);
 
      void finish_elem_loop();
 
      void finish_timestep(const number time, VectorProxyBase* u, size_t algebra_id);
 
      void finish_timestep_elem(const number time, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[]);
 
      void add_jac_A_elem(LocalMatrix& A, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], ProcessType type = PT_ALL);
 
      void add_jac_M_elem(LocalMatrix& M, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], ProcessType type = PT_ALL);
 
      void add_def_A_elem(LocalVector& d, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], ProcessType type = PT_ALL);
 
      void add_def_A_expl_elem(LocalVector& d, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], ProcessType type = PT_ALL);
 
      void add_def_M_elem(LocalVector& d, LocalVector& u, GridObject* elem, const MathVector<dim> vCornerCoords[], ProcessType type = PT_ALL);
 
      void add_rhs_elem(LocalVector& rhs, GridObject* elem, const MathVector<dim> vCornerCoords[], ProcessType type = PT_ALL);
 
      using base_type::time_series_needed;
protected:
 
  using base_type::m_vElemDisc;
  using base_type::m_vImport;
  using base_type::m_vDependentData;
  using base_type::m_vConstData;
  using base_type::m_vPosData;
  using base_type::m_discPart;
  using base_type::m_pLocTimeSeries;
 
  using base_type::clear_positions_in_user_data;
  using base_type::extract_imports_and_userdata;
 
};
class DataEvaluator : public DataEvaluatorBase<TDomain, IElemDisc<TDomain> > {…};
 
 
 
} // end namespace ug
 
#include "data_evaluator_impl.h"
 
#endif /* __H__UG__LIB_DISC__SPATIAL_DISC__DATA_EVALUATOR__ */