facelocalfiniteelement.hh

Go to the documentation of this file.

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set ts=8 sw=4 et sts=4:
 
// 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 FACE_LOCAL_FINITE_ELEMENT_HH
#define FACE_LOCAL_FINITE_ELEMENT_HH
 
#warning This header is deprecated and will be removed after 2.11.
 
#include <vector>
 
#include <dune/localfunctions/common/localfiniteelementtraits.hh>
#include <dune/common/fvector.hh>
#include <dune/geometry/type.hh>
 
template <class Traits>
struct
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
FaceTraits
{
    typedef typename Traits::DomainFieldType DomainFieldType;
 
    enum {
      dimDomain = Traits::dimDomain-1
    };
 
    typedef Dune::FieldVector<DomainFieldType,dimDomain> DomainType;
 
    typedef typename Traits::RangeFieldType RangeFieldType;
 
    enum {
        dimRange = Traits::dimRange
    };
 
    typedef typename Traits::RangeType RangeType;
 
    typedef typename Traits::JacobianType JacobianType;
 
    enum {
        diffOrder=  Traits::diffOrder
    };
};
 
 
 
 
template <class LocalBasis,class LocalGeometry>
class
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
FaceLocalBasis
{
public:
    typedef FaceTraits<typename LocalBasis::Traits> Traits;
 
    [[deprecated("This class is deprecated and will be removed after 2.11.")]]
    FaceLocalBasis(const LocalBasis& localBasis, const LocalGeometry& geometryInInside) :
        localBasis_(localBasis),
        geometryInInside_(geometryInInside)
    {}
 
    unsigned int size () const
    {
        return localBasis_.size() ;
    }
 
    inline void evaluateFunction (const typename Traits::DomainType& in,
                                  std::vector<typename Traits::RangeType>& out) const
    {
        out.resize(size());
 
        // transform the coordinates to the inside of the intersection
        typename LocalBasis::Traits::DomainType inInside = geometryInInside_.global(in);
 
        // then evaluate the basis of that element
        localBasis_.evaluateFunction(inInside, out);
    }
 
    inline void evaluateJacobian (
        const typename Traits::DomainType& in,                  // position
        std::vector<typename Traits::JacobianType>& out) const  // return value
    {
        out.resize(size());
 
        // transform the coordinates to the inside of the intersection
        typename LocalBasis::Traits::DomainType inInside = geometryInInside_.global(in);
 
        // then evaluate the basis of that element
        localBasis_.evaluateJacobian(inInside, out);
    }
 
    unsigned int order () const
    {
        return localBasis_.order();
    }
 
private:
    const LocalBasis& localBasis_;
    const LocalGeometry& geometryInInside_;
};
 
 
 
template <class LocalFiniteElement, class LocalGeometry>
class
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
FaceLocalFiniteElement
{
public:
 
    typedef FaceLocalBasis<typename LocalFiniteElement::Traits::LocalBasisType,LocalGeometry> LocalBasis;
 
    typedef Dune::LocalFiniteElementTraits< LocalBasis, typename LocalFiniteElement::Traits::LocalCoefficientsType,
                                      typename LocalFiniteElement::Traits::LocalInterPolationType> Traits;
 
    FaceLocalFiniteElement(const LocalFiniteElement& lFE, const LocalGeometry& geometryInInside) :
        lFE_(lFE),
        geometryInInside_(geometryInInside),
        localBasis_(lFE_.localBasis(),geometryInInside)
    {}
 
    const typename Traits::LocalBasisType& localBasis() const
    {
        return localBasis_;
    }
 
    const typename Traits::LocalCoefficientsType& localCoefficients () const
    {
        return lFE_.localCoefficients();
    }
 
    const typename Traits::LocalInterpolationType& localInterpolation () const
    {
        return lFE_.localInterpolation();
    }
 
    // What type is it the for the intersection or the inside type?
    Dune::GeometryType type () const
    {
        return geometryInInside_.type();
    }
 
private:
    const LocalFiniteElement& lFE_;
    const LocalGeometry& geometryInInside_;
    const LocalBasis& localBasis_;
 
};
 
 
 
#endif