bulkforcesmodel.hh

#ifndef __DUNE_ACFEM_MODELS_MODULES_BULKFORCESMODEL_HH__
#define __DUNE_ACFEM_MODELS_MODULES_BULKFORCESMODEL_HH__
 
#include "../modelexpressionbase.hh"
#include "../zeromodel.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class GridFunction>
    struct BulkForcesFunctionModel
      : public ModelExpression<BulkForcesFunctionModel<GridFunction> >
    {
      typedef BulkForcesFunctionModel   ThisType;
      typedef DefaultModel<ThisType>    BaseType;
      typedef ModelInterface<ThisType>  InterfaceType;
      typedef ModelTraits<ThisType>     TraitsType;
     public:
      typedef GridFunction BulkForcesFunctionImpType;
      typedef typename TraitsType::BulkForcesFunctionType BulkForcesFunctionType;
      typedef typename BulkForcesFunctionImpType::FunctionSpaceType FunctionSpaceType;
      typedef typename BulkForcesFunctionImpType::GridPartType GridPartType;
 
      BulkForcesFunctionModel(const Fem::Function<FunctionSpaceType, BulkForcesFunctionImpType>& function,
                              const std::string& name = "")
        : function_(function),
          name_(name == "" ? "- (" + function_().name() + ", . )" : name)
      {}
 
      std::string name() const
      {
        return name_;
      }
 
      BulkForcesFunctionType bulkForcesFunction(const GridPartType& gridPart) const
      {
        return *function_();
      }
 
     protected:
      ExpressionStorage<BulkForcesFunctionImpType> function_;
      const std::string name_;
    };
 
    template<class GridFunction>
    struct ModelTraits<BulkForcesFunctionModel<GridFunction> >
      : public DefaultModelTraits<typename GridFunction::DiscreteFunctionSpaceType::FunctionSpaceType,
                                  typename GridFunction::GridPartType>
    {
     protected:
      typedef
      DefaultModelTraits<typename GridFunction::DiscreteFunctionSpaceType::FunctionSpaceType,
                         typename GridFunction::GridPartType>
      BaseType;
     public:
      enum StructureFlags {
        isLinear = true, 
        isSymmetric = true, 
        isSemiDefinite = true 
      };
 
      typedef decltype(*std::declval<GridFunction>()) BulkForcesFunctionType;
    };
 
    template<class FunctionSpace, class GridPart>
    class BulkForcesFunctionModel<ZeroGridFunction<FunctionSpace, GridPart> >
      : public ZeroModel<FunctionSpace, GridPart>
    {
      typedef ZeroModel<FunctionSpace, GridPart> BaseType;
     public:
      typedef FunctionSpace FunctionSpaceType;
      typedef GridPart GridPartType;
      typedef ZeroGridFunction<FunctionSpaceType, GridPartType> BulkForcesFunctionImpType;
 
      BulkForcesFunctionModel(const Fem::Function<FunctionSpaceType, BulkForcesFunctionImpType>& function,
                              const std::string& name = "")
        : BaseType(name == "" ? "- (" + asImp(function).name() + ", . )" : name)
      {}
    };
 
 
    template<class GridFunction>
    BulkForcesFunctionModel<GridFunction>
    bulkForcesModel(const Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction>& f,
                    const std::string& name = "")
    {
      return BulkForcesFunctionModel<GridFunction>(f, name);
    }
 
 
 
 
  } // namespace ACFem
 
}  //Namespace Dune
 
 
#endif // __DUNE_ACFEM_MODELS_MODULES_BULKFORCESMODEL_HH__