parameterfunction.hh

Go to the documentation of this file.

 
#ifndef __DUNE_ACFEM_PARAMETER_FUNCTION_HH__
#define __DUNE_ACFEM_PARAMETER_FUNCTION_HH__
 
#include <cassert>
#include <cmath>
 
#include <dune/common/exceptions.hh>
#include <dune/fem/function/common/function.hh>
 
#include "../functions/gridfunctionexpressionbase.hh"
#include "../expressions/parameterinterface.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class Parameter, class FunctionSpace>
    class ParameterFunction
      : public Fem::Function<typename FunctionSpace::FunctionSpaceType,
                             ParameterFunction<Parameter, typename FunctionSpace::FunctionSpaceType> >
    {
      static_assert((std::is_same<typename Parameter::ValueType, typename FunctionSpace::FunctionSpaceType::RangeType>::value == true),
                    "ValueType of parameter needs to be the same as the RangeType of the function space");
 
     public:
      typedef Parameter ParameterType;
      typedef typename ParameterType::ParameterSpaceType ParameterSpaceType;
      typedef typename FunctionSpace::FunctionSpaceType FunctionSpaceType;
 
      enum { dimRange  = FunctionSpaceType::dimRange  };
      enum { dimDomain = FunctionSpaceType::dimDomain };
 
      typedef typename FunctionSpaceType::RangeFieldType   RangeFieldType;
 
      typedef typename FunctionSpaceType::RangeType   RangeType;
      typedef typename FunctionSpaceType::DomainType  DomainType;
 
      typedef typename FunctionSpaceType::JacobianRangeType  JacobianRangeType;
      typedef typename FunctionSpaceType::HessianRangeType HessianRangeType;
 
      ParameterFunction(const ParameterInterface<ParameterType>& value) : value_(value) {}
 
      void evaluate(const DomainType& x, RangeType& res) const
      {
        res = value_.value();
      }
 
      void jacobian(const DomainType& x, JacobianRangeType& res) const
      {
        res = 0;
      }
 
      void hessian(const DomainType& x, HessianRangeType& res) const
      {
        res = 0;
      }
 
      const ParameterType& value() const
      {
        return value_;
      }
 
     private:
      const ParameterType& value_;
    };
 
    template<class Parameter, class FunctionSpace, class GridPart>
    class ParameterGridFunction;
 
    template<class Parameter, class FunctionSpace, class GridPart>
    struct ParameterGridFunctionTraits
    {
      typedef FunctionSpace FunctionSpaceType;
 
      typedef typename FunctionSpaceType::RangeFieldType RangeFieldType;
      typedef typename FunctionSpaceType::DomainFieldType DomainFieldType;
      typedef typename FunctionSpaceType::RangeType RangeType;
      typedef typename FunctionSpaceType::DomainType DomainType;
      typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
 
      typedef Fem::DiscreteFunctionSpaceAdapter<FunctionSpaceType, GridPart> DiscreteFunctionSpaceType;
 
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename GridPartType::GridType GridType;
      typedef typename GridPartType::template Codim<0>::EntityType EntityType;
      typedef typename GridPartType::template Codim<0>::IteratorType IteratorType;
      typedef typename GridPartType::IndexSetType IndexSetType;
 
      typedef ParameterGridFunction<Parameter, FunctionSpace, GridPart> DiscreteFunctionType;
    };
 
 
    template<class Parameter, class FunctionSpace, class GridPart>
    class ParameterGridFunction
      : public GridFunctionExpression<FunctionSpace, ParameterGridFunction<Parameter, FunctionSpace, GridPart> >,
        public IsPieceWiseConstant // in space
    {
      typedef ParameterGridFunction<Parameter, FunctionSpace, GridPart> ThisType;
      typedef Function<FunctionSpace, ThisType> BaseType;
      typedef GridFunctionExpression<FunctionSpace, ParameterGridFunction> ExpressionBaseType;
 
      static_assert((std::is_same<typename Parameter::ValueType, typename FunctionSpace::FunctionSpaceType::RangeType>::value == true),
                    "ValueType of parameter needs to be the same as the RangeType of the function space");
 
     public:
      typedef ParameterGridFunctionTraits<Parameter, FunctionSpace, GridPart> Traits;
 
      typedef typename Traits::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
 
      // type of discrete function space
      typedef typename Traits::FunctionSpaceType FunctionSpaceType;
 
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
 
      typedef typename DiscreteFunctionSpaceType::GridType GridType;
 
      typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType ;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType ;
      typedef typename DiscreteFunctionSpaceType::DomainType DomainType ;
      typedef typename DiscreteFunctionSpaceType::RangeType RangeType ;
      typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
      typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
 
      typedef typename Traits::EntityType  EntityType;
 
     private:
      class LocalFunction;
      using ExpressionBaseType::expressionName_;
 
     public:
      typedef Parameter ParameterType;
      typedef typename ParameterType::ParameterSpaceType ParameterSpaceType;
 
      typedef LocalFunction LocalFunctionType;
 
      ParameterGridFunction(const ParameterInterface<ParameterType>& value, const GridPart& grid)
        : space_(grid, 0), value_(value)
      {}
 
      void evaluate(const DomainType &global, RangeType &result) const
      {
        result = value_().value();
      }
 
      void jacobian(const DomainType &global, JacobianRangeType &result) const
      {
        result = 0;
      }
 
      void hessian(const DomainType &global, HessianRangeType &result) const
      {
        result = 0;
      }
 
      const LocalFunctionType localFunction(const EntityType &entity) const
      {
        return LocalFunctionType(entity, *this);
      }
 
      LocalFunctionType localFunction(const EntityType &entity)
      {
        return LocalFunctionType(entity, *this);
      }
 
      const std::string &expressionName() const
      {
        makeName(value_().value(), expressionName_);
        return expressionName_;
      }
 
      const DiscreteFunctionSpaceType &space () const
      {
        return space_;
      }
 
      const GridPartType &gridPart() const
      {
        return space().gridPart();
      }
 
      const ParameterType& value() const
      {
        return value_();
      }
 
     protected:
      template<class Value>
      static void makeName(const Value& value, std::string& name)
      {
        if (!objectToString(value, name)) {
          name = "C";
        }
        name = "P[" + name + "]";
      }
 
      DiscreteFunctionSpaceType space_;
      ExpressionStorage<ParameterType> value_;
    };
 
    // ParameterGridFunction::LocalFunction
    // ----------------------------------
    template<class Parameter, class FunctionSpace, class GridPart>
    class ParameterGridFunction<Parameter, FunctionSpace, GridPart>::LocalFunction
    {
      typedef LocalFunction ThisType;
      typedef ParameterGridFunction<Parameter, FunctionSpace, GridPart> DiscreteFunctionType;
     public:
      typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
     private:
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename EntityType::Geometry GeometryType;
     public:
 
      static const int dimRange = DiscreteFunctionSpaceType::dimRange;
      static const int dimDomain = GridPartType::GridType::dimensionworld;
      static const int dimLocal = GridPartType::GridType::dimension;
 
      typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType ;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType ;
      typedef typename DiscreteFunctionSpaceType::DomainType DomainType ;
      typedef typename DiscreteFunctionSpaceType::RangeType RangeType ;
      typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
 
      LocalFunction (const EntityType &entity, const DiscreteFunctionType &df)
        : value_(df.value()),
          entity_(&entity)
      {}
 
      LocalFunction (const DiscreteFunctionType &df)
        : value_(df.value()),
          entity_(0)
      {}
 
      template<class PointType>
      void evaluate (const PointType &x, RangeType &ret) const
      {
        ret = value_.value();
      }
 
      template<class PointType>
      void jacobian (const PointType &x, JacobianRangeType &ret) const
      {
        ret = 0;
      }
 
      template<class PointType>
      void hessian(const PointType &x, HessianRangeType &ret) const
      {
        ret = 0;
      }
 
      int order () const { return 0; }
 
      void init (const EntityType &entity)
      {
        entity_ = &entity;
      }
 
      const EntityType &entity () const
      {
        assert(entity_);
        return *entity_;
      }
 
     private:
      const ParameterType& value_;
      const EntityType *entity_;
    };
 
 
  } // ACFem::
 
} // Dune::
 
#endif