cachedcomponentwrapper.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE-FUFEM Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef CACHED_COMPONENT_WRAPPER_HH
#define CACHED_COMPONENT_WRAPPER_HH
 
#warning This header is deprecated and will be removed after 2.11.
 
#include <vector>
#include <map>
 
#include <dune/common/fvector.hh>
#include <dune/common/fmatrix.hh>
 
 
 
template<class RT>
struct
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
Components
{
    template<class RFT>
    static void setComponent(RT& x, int i, const RFT& xi)
    {
        x = xi;
    }
 
    template<class RFT>
    static void getComponent(const RT& x, int i, RFT& xi)
    {
        xi = x;
    }
    static int size(const RT& x)
    {
        return 1;
    }
};
 
template<class T, int n>
struct
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
Components<typename Dune::FieldVector<T, n> >
{
    typedef typename Dune::FieldVector<T, n> RT;
 
    template<class RFT>
    static void setComponent(RT& x, int i, const RFT& xi)
    {
        x[i] = xi;
    }
 
    template<class RFT>
    static void getComponent(const RT& x, int i, RFT& xi)
    {
        xi = x[i];
    }
 
    static int size(const RT& x)
    {
        return n;
    }
};
 
template<class T, int n, int m>
struct
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
Components<typename Dune::FieldMatrix<T, n, m> >
{
    typedef typename Dune::FieldMatrix<T, n, m> RT;
 
    template<class RFT>
    static void setComponent(RT& x, int i, const RFT& xi)
    {
        x[i/m][i%m] = xi;
    }
 
    template<class RFT>
    static void getComponent(const RT& x, int i, RFT& xi)
    {
        xi = x[i/m][i%m];
    }
 
    static int size(const RT& x)
    {
        return n*m;
    }
};
 
template<class T>
struct
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
Components<typename std::vector<T> >
{
    typedef typename std::vector<T> RT;
 
    template<class RFT>
    static void setComponent(RT& x, int i, const RFT& xi)
    {
        x[i] = xi;
    }
 
    template<class RFT>
    static void getComponent(const RT& x, int i, RFT& xi)
    {
        xi = x[i];
    }
 
    static int size(const RT& x)
    {
        return x.size();
    }
};
 
 
 
template <class Imp, class AllRangeType, class FunctionBaseClass>
class
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
CachedComponentWrapper
{
    public:
        typedef typename FunctionBaseClass::DomainType DomainType;
        typedef typename FunctionBaseClass::RangeType RangeType;
 
    private:
        typedef DomainType Position;
        struct DomainCmp
        {
            bool operator() (const DomainType& a, const DomainType& b) const
            {
                for(int i=0; i<DomainType::dimension; ++i)
                {
                    if (a[i]<b[i])
                        return true;
                    if (a[i]>b[i])
                        return false;
                }
                return false;
            }
        };
        typedef typename std::map<DomainType, AllRangeType, DomainCmp> EvaluationCache;
 
    public:
 
        CachedComponentWrapper(const int i=0) :
            i_(i)
        {}
 
        void setIndex(int i)
        {
            i_ = i;
        }
 
        RangeType operator()(const DomainType& x) const
        {
            RangeType y;
            typename EvaluationCache::const_iterator it = evalCache_.find(x);
            if (it != evalCache_.end())
                Components<AllRangeType>::getComponent(it->second, i_, y);
            else
            {
                AllRangeType& yy = evalCache_[x];
                asImp().evaluateAll(x, yy);
                Components<AllRangeType>::getComponent(yy, i_, y);
            }
            return y;
        }
 
    protected:
 
        const Imp& asImp () const
        {
            return static_cast<const Imp &> (*this);
        }
 
        int i_;
 
        mutable EvaluationCache evalCache_;
};
 
#endif