parameterinterface.hh

Go to the documentation of this file.

 
#ifndef __DUNE_ACFEM_PARAMETER_INTERFACE_HH__
#define __DUNE_ACFEM_PARAMETER_INTERFACE_HH__
 
#include <dune/fem/misc/bartonnackmaninterface.hh>
 
#include "../expressions/expressionoperations.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class Field, int dim>
    struct ParameterSpace
    {
      enum { dimension = dim };
      typedef Field FieldType;
      typedef FieldVector<FieldType, dimension> ValueType;
      typedef ParameterSpace<FieldType, 1> ScalarParameterSpaceType;
    };
 
    template<class ParameterImpl>
    struct ParameterTraits
    {
      // gcc-4.7 shit
      struct DummyParameterSpace {
        typedef void ScalarParameterSpaceType;
        typedef void FieldType;
        typedef void ValueType;
        enum { dimension = -1 };
      };
      typedef DummyParameterSpace ParameterSpaceType;
    };
 
    template<class ParameterImpl>
    class ParameterInterface
      : public Dune::Fem::BartonNackmanInterface<ParameterInterface<ParameterImpl>, ParameterImpl>
    {
      typedef ParameterInterface ThisType;
      typedef ParameterImpl ImplementationType;
      typedef Dune::Fem::BartonNackmanInterface<ThisType, ImplementationType> BaseType;
      typedef ParameterTraits<ParameterImpl> TraitsType;
      using BaseType::asImp;
     protected:
      ParameterInterface() {}
      ParameterInterface(const ParameterInterface& other) {}
      ParameterInterface& operator=(const ParameterInterface& other) {}
     public:
      typedef typename TraitsType::ParameterSpaceType ParameterSpaceType;
      typedef typename ParameterSpaceType::ScalarParameterSpaceType ScalarParameterSpaceType;
      enum { dimension = ParameterSpaceType::dimension };
      typedef typename ParameterSpaceType::FieldType FieldType;
      typedef typename ParameterSpaceType::ValueType ValueType;
 
      ValueType value() const { return asImp().value(); }
    };
 
    template<class ParameterImpl>
    class DefaultParameter
      : public ParameterInterface<ParameterImpl>
    {
      typedef DefaultParameter ThisType;
      typedef ParameterTraits<ParameterImpl> TraitsType;
     protected:
      DefaultParameter() {}
      DefaultParameter(const ThisType& other) {}
      ThisType& operator=(const ThisType& other) { return *this; }
     public:
      typedef typename TraitsType::ParameterSpaceType ParameterSpaceType;
      typedef typename ParameterSpaceType::ScalarParameterSpaceType ScalarParameterSpaceType;
      enum { dimension = ParameterSpaceType::dimension };
      typedef typename ParameterSpaceType::FieldType FieldType;
      typedef typename ParameterSpaceType::ValueType ValueType;
 
      // No default implementation.
    };
 
    template<class Type>
    struct ParameterSpaceTraits
    {
      typedef ParameterSpace<Type, 1> ParameterSpaceType;
    };
 
    template<class Field, int dim>
    struct ParameterSpaceTraits<FieldVector<Field, dim> >
    {
      typedef Field FieldType;
      enum { dimension = dim };
      typedef ParameterSpace<FieldType, dimension> ParameterSpaceType;
    };
 
    template<class Value>
    class TrivialParameter
      : public DefaultParameter<TrivialParameter<Value> >,
        public ExpressionTemplate<TrivialParameter<Value> >
    {
      typedef TrivialParameter ThisType;
     public:
      typedef typename ParameterSpaceTraits<Value>::ParameterSpaceType ParameterSpaceType;
      typedef typename ParameterSpaceType::ScalarParameterSpaceType ScalarParameterSpaceType;
      enum { dimension = ParameterSpaceType::dimension };
      typedef typename ParameterSpaceType::FieldType FieldType;
      typedef typename ParameterSpaceType::ValueType ValueType;
 
      TrivialParameter(const ValueType& value) : value_(value) {}
 
      TrivialParameter(const std::string& configKey)
        : value_(Fem::Parameter::getValue<ValueType>(configKey))
      {}
 
      TrivialParameter(const std::string& configKey, const ValueType& defaultValue)
        : value_(Fem::Parameter::getValue<ValueType>(configKey, defaultValue))
      {}
 
      ValueType value() const { return value_; }
 
     private:
      ValueType value_;
    };
 
    template<class Value>
    struct ParameterTraits<TrivialParameter<Value> >
    {
      typedef typename ParameterSpaceTraits<Value>::ParameterSpaceType ParameterSpaceType;
    };
 
    template<class Value>
    TrivialParameter<Value> P(const Value& s)
    {
      return TrivialParameter<Value>(s);
    }
 
    template<class Value>
    class ZeroParameter
      : public DefaultParameter<ZeroParameter<Value> >,
        public ZeroExpression<ZeroParameter<Value> >
    {
      typedef ZeroParameter ThisType;
     public:
      typedef typename ParameterSpaceTraits<Value>::ParameterSpaceType ParameterSpaceType;
      typedef typename ParameterSpaceType::ScalarParameterSpaceType ScalarParameterSpaceType;
      enum { dimension = ParameterSpaceType::dimension };
      typedef typename ParameterSpaceType::FieldType FieldType;
      typedef typename ParameterSpaceType::ValueType ValueType;
 
      ValueType value() const { ValueType(0); }
    };
 
    template<class Value>
    struct ParameterTraits<ZeroParameter<Value> >
    {
      typedef typename ParameterSpaceTraits<Value>::ParameterSpaceType ParameterSpaceType;
    };
 
    // Mere helper class for parameterValue
    template<class Type>
    struct ParameterValue
    {
      enum { isParameter = std::is_base_of<ParameterInterface<Type>, Type>::value };
     private:
      template<class Value, bool isParameter>
      struct ParameterValueHelper;
 
      template<class Value>
      struct ParameterValueHelper<Value, false>
      {
        typedef Value ValueType;
        typedef const Value& ResultType;
        static ResultType value(const Value& arg) { return arg; }
      };
 
      template<class Parameter>
      struct ParameterValueHelper<Parameter, true>
      {
        typedef typename Parameter::ValueType ValueType;
        typedef ValueType ResultType;
        static ResultType value(const Parameter& arg) { return arg.value(); }
      };
     public:
      typedef typename ParameterValueHelper<Type, isParameter>::ResultType ResultType;
      typedef typename ParameterValueHelper<Type, isParameter>::ValueType ValueType;
 
      static ResultType value(const Type& arg) {
        return ParameterValueHelper<Type, isParameter>::value(arg);
      }
    };
 
    template<class Value>
    typename ParameterValue<Value>::ResultType parameterValue(const Value& value)
    {
      return ParameterValue<Value>::value(value);
    }
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif //  __DUNE_ACFEM_PARAMETER_INTERFACE_HH__