user_data.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__USER_DATA__USER_DATA__
#define __H__UG__LIB_DISC__SPATIAL_DISC__USER_DATA__USER_DATA__
 
#include <vector>
#include <cstring>
#include <functional>
 
#include "common/types.h"
#include "lib_disc/common/local_algebra.h"
#include "lib_disc/time_disc/solution_time_series.h"
#include "lib_disc/common/function_group.h"
 
namespace ug{
 
//  UserData Info
 
class UserDataInfo {
  public:
    virtual int get_dim() const = 0;
 
    virtual std::string type() const = 0;
 
    virtual bool continuous() const = 0;
 
    virtual ~UserDataInfo() {}
 
  public:
    virtual bool requires_grid_fct() const = 0;
 
    virtual void set_function_pattern(ConstSmartPtr<FunctionPattern> fctPatt) {
      m_fctGrp.set_function_pattern(fctPatt);
    }
 
    const FunctionGroup& function_group() const {return m_fctGrp;}
 
    const FunctionIndexMapping& map() const{return m_map;}
 
    size_t num_fct() const {return m_map.num_fct();}
    
 
    void set_obj_name(const char * name)
    {
      if (name == NULL) {m_objName = SPNULL; return;}
      if (m_objName.valid ()) // we assume that the name is assigned once; otherwise we warn
        UG_LOG ("Warning: Replacing existing UserData object name '" << m_objName.get() << "' with '" << name << "'.\n");
      const size_t name_len = strnlen (name, 128);
      SmartPtr<char> new_name (new char [name_len+1]);
      memcpy (new_name.get(), name, name_len); (new_name.get()) [name_len] = '\0';
      m_objName = new_name;
    }
  
 
    const char * obj_name () {return m_objName.get ();}
 
  protected:
    FunctionGroup m_fctGrp;
 
    FunctionIndexMapping m_map;
  
    SmartPtr<char> m_objName; 
};
 
//  UserData
 
// Traits
template <typename TData>
struct user_data_traits{static std::string name()               {return "(unknown)";}};
template <>
struct user_data_traits<number>{static std::string name()           {return "Number";}};
template <std::size_t dim>
struct user_data_traits< MathVector<dim> >{static std::string name()    {return "Vector";}};
template <std::size_t dim>
struct user_data_traits< MathMatrix<dim,dim> >{static std::string name()  {return "Matrix";}};
template <std::size_t dim>
struct user_data_traits< MathTensor<4,dim> >{static std::string name()    {return "Tensor4";}};
 
 
template <typename TData, int dim, typename TRet = void>
class UserData : virtual public UserDataInfo
{
  public:
    typedef TData data_type;
    typedef TRet return_type;
 
    int get_dim() const {return dim;}
 
    std::string type() const {return user_data_traits<TData>::name();}
 
    virtual bool continuous() const = 0;
 
    virtual bool requires_grid_fct() const = 0;
 
  public:
    virtual TRet operator() (TData& value,
                 const MathVector<dim>& globIP,
                 number time, int si) const = 0;
 
    virtual void operator()(TData vValue[],
                const MathVector<dim> vGlobIP[],
                number time, int si, const size_t nip) const = 0;
    
    virtual void operator() (TData& value,
                 const MathVector<dim>& globIP,
                 number time, int si,
                 Vertex* vrt) const
    {
    //  The standard version uses only the coordinates. But it can be redefined.
      operator()(value, globIP, time, si);
    }
 
    TRet operator() (TData& value,
             const MathVector<dim>& globIP,
             number time, int si,
             GridObject* elem,
             const MathVector<dim> vCornerCoords[],
             const MathVector<1>& locIP,
             LocalVector* u) const {
      operator()(&value, &globIP, time, si, elem, vCornerCoords, &locIP, 1, u);
    }
 
    TRet operator() (TData& value,
             const MathVector<dim>& globIP,
             number time, int si,
             GridObject* elem,
             const MathVector<dim> vCornerCoords[],
             const MathVector<2>& locIP,
             LocalVector* u) const {
      operator()(&value, &globIP, time, si, elem, vCornerCoords, &locIP, 1, u);
    }
 
    TRet operator() (TData& value,
             const MathVector<dim>& globIP,
             number time, int si,
             GridObject* elem,
             const MathVector<dim> vCornerCoords[],
             const MathVector<3>& locIP,
                       LocalVector* u) const {
      operator()(&value, &globIP, time, si, elem, vCornerCoords, &locIP, 1, u);
    }
 
    virtual void operator()(TData vValue[],
                            const MathVector<dim> vGlobIP[],
                            number time, int si,
                            GridObject* elem,
                            const MathVector<dim> vCornerCoords[],
                            const MathVector<1> vLocIP[],
                            const size_t nip,
                            LocalVector* u,
                            const MathMatrix<1, dim>* vJT = NULL) const = 0;
 
    virtual void operator()(TData vValue[],
                            const MathVector<dim> vGlobIP[],
                            number time, int si,
                            GridObject* elem,
                            const MathVector<dim> vCornerCoords[],
                            const MathVector<2> vLocIP[],
                            const size_t nip,
                            LocalVector* u,
                            const MathMatrix<2, dim>* vJT = NULL) const = 0;
 
    virtual void operator()(TData vValue[],
                            const MathVector<dim> vGlobIP[],
                            number time, int si,
                            GridObject* elem,
                            const MathVector<dim> vCornerCoords[],
                            const MathVector<3> vLocIP[],
                            const size_t nip,
                            LocalVector* u,
                            const MathMatrix<3, dim>* vJT = NULL) const = 0;
};
//  UserData Interface
 
 
template <int dim>
class ICplUserData : virtual public UserDataInfo
{
  public:
    ICplUserData();
 
    void clear();
 
  public:
    void set_subset(int si) {m_si = si;}
 
    int subset() const {return m_si;}
 
    void set_times(const std::vector<number>& vTime) {m_vTime = vTime;}
 
    void set_time_point(size_t timePoint) {m_timePoint = timePoint;}
    
    size_t time_point() {return m_timePoint;}
 
    number time() const {return m_vTime[m_timePoint];}
 
  public:
    virtual bool constant() const {return false;}
 
    virtual size_t num_needed_data() const {return 0;}
 
    virtual SmartPtr<ICplUserData> needed_data(size_t i) {return SPNULL;}
 
    virtual void compute(LocalVector* u,
                         GridObject* elem,
                         const MathVector<dim> vCornerCoords[],
                         bool bDeriv = false) = 0;
 
    virtual void compute(LocalVectorTimeSeries* u,
                         GridObject* elem,
                         const MathVector<dim> vCornerCoords[],
                         bool bDeriv = false) = 0;
 
    virtual void check_setup() const {}
 
    virtual ~ICplUserData() {};
 
  public:
    virtual bool zero_derivative() const {return true;}
 
    virtual void update_dof_sizes(const LocalIndices& ind) {}
 
  public:
    size_t num_series() const {return m_vNumIP.size();}
 
    size_t num_ip(size_t s) const {UG_ASSERT(s < num_series(), "Invalid series"); return m_vNumIP[s];}
 
 
    template <int ldim>
    size_t register_local_ip_series(const MathVector<ldim>* vPos,
                    const size_t numIP,
                    const int timePointSpec,
                    bool bMayChange = true);
 
    template <int ldim>
    size_t register_local_ip_series(const MathVector<ldim>* vPos,
                    const size_t numIP,
                    bool bMayChange = true)
    {
      return this->template register_local_ip_series<ldim> (vPos, numIP, -1, bMayChange);
    };
 
 
    template <int ldim>
    void set_local_ips(const size_t seriesId, const MathVector<ldim>* vPos,
               const size_t numIP);
 
 
    void set_time_point(const size_t seriesId, const int timePointSpec);
 
    int dim_local_ips() const {return m_locPosDim;}
 
    template <int ldim>
    const MathVector<ldim>* local_ips(size_t s) const;
 
    template <int ldim>
    const MathVector<ldim>& local_ip(size_t s, size_t ip) const;
    
    inline int time_point_specification(size_t s) const;
    
    inline size_t time_point(size_t s) const;
    
    number time(size_t s) const {return m_vTime[time_point(s)];}
 
    inline bool at_current_time(size_t s) const;
 
    void set_global_ips(size_t s, const MathVector<dim>* vPos, size_t numIP);
 
    const MathVector<dim>* ips(size_t s) const {check_s(s); return m_vvGlobPos[s];}
 
    const MathVector<dim>& ip(size_t s, size_t ip) const{check_s_ip(s,ip); return m_vvGlobPos[s][ip];}
 
  protected:
 
    virtual void local_ip_series_added(const size_t seriesID){m_vvGlobPos.resize(seriesID+1);}
 
    virtual void local_ips_changed(const size_t seriesID, const size_t newNumIP) = 0;
 
    virtual void local_ip_series_to_be_cleared() {m_vvGlobPos.clear();}
 
 
    virtual void global_ips_changed(const size_t seriesID, const MathVector<dim>* vPos, const size_t numIP) {};
 
    inline void check_s(size_t s) const;
 
    inline void check_s_ip(size_t s, size_t ip) const;
 
  protected:
    std::vector<const MathVector<1>*>& get_local_ips(Int2Type<1>) {return m_pvLocIP1d;}
    std::vector<const MathVector<2>*>& get_local_ips(Int2Type<2>) {return m_pvLocIP2d;}
    std::vector<const MathVector<3>*>& get_local_ips(Int2Type<3>) {return m_pvLocIP3d;}
    const std::vector<const MathVector<1>*>& get_local_ips(Int2Type<1>) const {return m_pvLocIP1d;}
    const std::vector<const MathVector<2>*>& get_local_ips(Int2Type<2>) const {return m_pvLocIP2d;}
    const std::vector<const MathVector<3>*>& get_local_ips(Int2Type<3>) const {return m_pvLocIP3d;}
 
  protected:
    std::vector<bool> m_vMayChange;
 
    std::vector<size_t> m_vNumIP;
 
    int m_locPosDim;
 
    std::vector<const MathVector<1>*> m_pvLocIP1d;
    std::vector<const MathVector<2>*> m_pvLocIP2d;
    std::vector<const MathVector<3>*> m_pvLocIP3d;
    
    std::vector<int> m_vTimePoint;
 
    std::vector<const MathVector<dim>*> m_vvGlobPos;
 
    std::vector<number> m_vTime;
 
    size_t m_timePoint;
    
    int m_defaultTimePoint;
 
    int m_si;
};
 
//  UserData
 
// predeclaration
template <typename TData, int dim> class DataImport;
 
 
template <typename TData, int dim, typename TRet = void>
class CplUserData : public ICplUserData<dim>, public UserData<TData,dim,TRet>
{
  public:
    typedef ICplUserData<dim> base_type;
 
    using base_type::num_series;
    using base_type::num_ip;
 
  public:
    const TData& value(size_t s, size_t ip) const
      {check_series_ip(s,ip); return m_vvValue[s][ip];}
 
    const TData* values(size_t s) const
      {
        check_series(s);
        if(m_vvValue[s].empty())
          return NULL;
        return &(m_vvValue[s][0]);
      }
 
    TData& value(size_t s, size_t ip)
      {check_series_ip(s,ip);return m_vvValue[s][ip];}
 
    TData* values(size_t s)
      {
        check_series(s);
        if(m_vvValue[s].empty())
          return NULL;
        return &(m_vvValue[s][0]);
      }
 
    bool defined(size_t s, size_t ip) const
      {check_series_ip(s,ip); return m_vvBoolFlag[s][ip];}
 
    ~CplUserData() {local_ip_series_to_be_cleared();}
 
    void register_storage_callback(DataImport<TData,dim>* obj, void (DataImport<TData,dim>::*func)());
 
    void unregister_storage_callback(DataImport<TData,dim>* obj);
 
  protected:
    inline void check_series(size_t s) const;
 
    inline void check_series_ip(size_t s, size_t ip) const;
 
    virtual void local_ip_series_added(const size_t seriesID);
 
    virtual void local_ip_series_to_be_cleared();
 
    virtual void local_ips_changed(const size_t seriesID, const size_t newNumIP);
 
    virtual void value_storage_changed(const size_t seriesID) {}
 
    void call_storage_callback() const;
 
  private:
    std::vector<std::vector<TData> > m_vvValue;
 
    std::vector<std::vector<bool> > m_vvBoolFlag;
 
//    typedef void (DataImport<TData,dim>::*CallbackFct)();
    typedef std::function<void ()> CallbackFct;
    std::vector<std::pair<DataImport<TData,dim>*, CallbackFct> > m_vCallback;
 
};
 
//  Dependent UserData
 
 
template <typename TData, int dim>
class DependentUserData : public CplUserData<TData, dim>
{
  public:
    typedef CplUserData<TData, dim> base_type;
 
  //  explicitly forward methods of ICplUserData
    using base_type::num_series;
    using base_type::num_ip;
    using base_type::local_ips;
 
  public:
    DependentUserData() {}
 
    DependentUserData(const char* symbFct) {set_functions(symbFct);}
    DependentUserData(const std::string& symbFct) {set_functions(symbFct);}
    DependentUserData(const std::vector<std::string>& symbFct) {set_functions(symbFct);}
 
  public:
    size_t num_sh(size_t fct) const
    {
      UG_ASSERT(fct < m_vvNumDoFPerFct.size(), "Wrong index");
      return m_vvNumDoFPerFct[fct];
    }
 
    const TData& deriv(size_t s, size_t ip, size_t fct, size_t dof) const
      {check_s_ip_fct_dof(s,ip,fct,dof);return m_vvvvDeriv[s][ip][fct][dof];}
 
    TData& deriv(size_t s, size_t ip, size_t fct, size_t dof)
      {check_s_ip_fct_dof(s,ip,fct,dof);return m_vvvvDeriv[s][ip][fct][dof];}
 
    TData* deriv(size_t s, size_t ip, size_t fct)
      {check_s_ip_fct(s,ip,fct);return &(m_vvvvDeriv[s][ip][fct][0]);}
 
    const TData* deriv(size_t s, size_t ip, size_t fct) const
      {check_s_ip_fct(s,ip,fct);return &(m_vvvvDeriv[s][ip][fct][0]);}
 
    static void set_zero(std::vector<std::vector<TData> > vvvDeriv[], const size_t nip);
 
  public:
    virtual bool zero_derivative() const {return false;}
 
    virtual bool requires_grid_fct() const {return true;}
 
    virtual void update_dof_sizes(const LocalIndices& ind);
 
    virtual void set_function_pattern(ConstSmartPtr<FunctionPattern> fctPatt);
 
    void set_functions(const char* symbFct);
    void set_functions(const std::string& symbFct);
    void set_functions(const std::vector<std::string>& symbFct);
 
  protected:
    void extract_fct_grp();
 
  protected:
    std::vector<std::string> m_SymbFct;
 
  protected:
    inline void check_s_ip(size_t s, size_t ip) const;
 
    inline void check_s_ip_fct(size_t s, size_t ip, size_t fct) const;
 
    inline void check_s_ip_fct_dof(size_t s, size_t ip, size_t fct, size_t dof) const;
 
    virtual void local_ip_series_added(const size_t seriesID);
 
    virtual void local_ips_changed(const size_t seriesID, const size_t newNumIP);
 
    virtual void local_ip_series_to_be_cleared();
 
    void resize_deriv_array();
 
    void resize_deriv_array(const size_t seriesID);
 
  protected:
    std::vector<size_t> m_vvNumDoFPerFct;
 
  //  Data (size: (0,...,num_series-1) x (0,...,num_ip-1) x (0,...,num_fct-1) x (0,...,num_sh(fct) )
    std::vector<std::vector<std::vector<std::vector<TData> > > > m_vvvvDeriv;
};
 
} // end namespace ug
 
//include implementation
#include "user_data_impl.h"
 
#endif /* __H__UG__LIB_DISC__SPATIAL_DISC__USER_DATA__USER_DATA__ */