forcesfunctionalmodel.hh

#ifndef __DUNE_ACFEM_MODELS_MODULES_FORCESFUNCTIONALMODEL_HH__
#define __DUNE_ACFEM_MODELS_MODULES_FORCESFUNCTIONALMODEL_HH__
 
#include "../modelexpressionbase.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class LinearFunctional>
    struct ForcesFunctionalModel
      : public ModelExpression<ForcesFunctionalModel<LinearFunctional> >
    {
      typedef ForcesFunctionalModel     ThisType;
      typedef DefaultModel<ThisType>    BaseType;
      typedef ModelInterface<ThisType>  InterfaceType;
      typedef ModelTraits<ThisType>     TraitsType;
     public:
      typedef LinearFunctional LinearFunctionalType;
      typedef typename LinearFunctionalType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
 
      explicit
      ForcesFunctionalModel(const DiscreteLinearFunctional<DiscreteFunctionSpaceType,
                                                           typename LinearFunctionalType::TraitsType>&
                            functional,
                            const std::string& name = "")
        : functional_(functional),
          name_("-" + (name == "" ? functional_().name() : "name"))
      {}
 
      std::string name() const
      {
        return name_;
      }
 
      template<class DiscreteFunctionSpace>
      typename TraitsType::template ForcesFunctionalTraits<DiscreteFunctionSpace>::FunctionalType
      forcesFunctional(const DiscreteFunctionSpace& space) const
      {
        return *functional_();
      }
 
     protected:
      ExpressionStorage<LinearFunctionalType> functional_;
      const std::string name_;
    };
 
    template<class LinearFunctional>
    struct ModelTraits<ForcesFunctionalModel<LinearFunctional> >
      : public DefaultModelTraits<typename LinearFunctional::DiscreteFunctionSpaceType::FunctionSpaceType,
                                  typename LinearFunctional::GridPartType>
    {
     protected:
      typedef
      DefaultModelTraits<typename LinearFunctional::DiscreteFunctionSpaceType::FunctionSpaceType,
                         typename LinearFunctional::GridPartType>
      BaseType;
     public:
      enum StructureFlags {
        isLinear = true, 
        isSymmetric = true, 
        isSemiDefinite = true 
      };
 
      template<class DiscreteFunctionSpace>
      struct ForcesFunctionalTraits
        : public FixedForcesFunctionalTraits<DiscreteFunctionSpace, LinearFunctional>
      {
       protected:
        typedef
        FixedForcesFunctionalTraits<DiscreteFunctionSpace, LinearFunctional>
        BaseType;
       public:
        // still we define a single wrap here, as we do not know
        // whether LinearFuncional is copy-constructible
        typedef decltype(*std::declval<typename BaseType::FunctionalType>()) FunctionalType;
      };
    };
 
    template<class DiscreteFunctionSpace>
    class ForcesFunctionalModel<ZeroFunctional<DiscreteFunctionSpace> >
      : public ZeroModel<typename DiscreteFunctionSpace::FunctionSpaceType,
                         typename DiscreteFunctionSpace::GridPartType>
    {
      typedef
      ZeroModel<typename DiscreteFunctionSpace::FunctionSpaceType,
                typename DiscreteFunctionSpace::GridPartType>
      BaseType;
     public:
      typedef DiscreteFunctionSpace DiscreteFunctionSpaceType;
      typedef ZeroFunctional<DiscreteFunctionSpaceType> LinearFunctionalType;
 
      explicit
      ForcesFunctionalModel(const DiscreteLinearFunctional<DiscreteFunctionSpaceType,
                                                           typename LinearFunctionalType::TraitsType>&
                            functional,
                            const std::string& name = "")
        : BaseType("-" + (name == "" ? asImp(functional).name() : name))
      {}
    };
 
 
 
 
  } // namespace ACFem
 
}  //Namespace Dune
 
 
#endif // __DUNE_ACFEM_MODELS_MODULES_FORCESFUNCTIONALMODEL_HH__