dirichletmodel.hh

#ifndef __DUNE_ACFEM_MODELS_MODULES_DIRICHLETMODEL_HH__
#define __DUNE_ACFEM_MODELS_MODULES_DIRICHLETMODEL_HH__
 
#include "../modelexpressionbase.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class GridFunction, class Indicator = EntireBoundaryIndicatorType>
    class DirichletBoundaryModel
      : public ModelExpression<DirichletBoundaryModel<GridFunction, Indicator> >
    {
      typedef DirichletBoundaryModel ThisType;
      typedef ModelTraits<ThisType> TraitsType;
     public:
      typedef Indicator OuterIndicatorType;
      typedef typename TraitsType::DirichletBoundaryFunctionType DirichletBoundaryFunctionType;
      typedef typename TraitsType::DirichletWeightFunctionType DirichletWeightFunctionType;
      typedef typename TraitsType::DirichletIndicatorType DirichletIndicatorType;
      typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
      typedef typename TraitsType::GridPartType GridPartType;
 
      DirichletBoundaryModel(const Fem::Function<FunctionSpaceType, GridFunction>& function,
                             const
                             BoundaryIndicatorInterface<OuterIndicatorType>&
                             indicator = DirichletIndicatorType(),
                             const std::string& name = "")
        : bndryFunction_(asImp(indicator) * asImp(function)),
          name_(name == "" ? "Dirichlet(" + bndryFunction_().name() + ")" : name)
      {}
 
      std::string name() const
      {
        return name_;
      }
 
      DirichletBoundaryFunctionType dirichletBoundaryFunction(const GridPartType& gridPart) const
      {
        return bndryFunction_();
      }
 
      DirichletWeightFunctionType dirichletWeightFunction(const GridPartType& gridPart) const
      {
        return boundarySupportedFunction(oneFunction(bndryFunction_()), bndryFunction_().indicator());
      }
 
      DirichletIndicatorType dirichletIndicator() const {
        return bndryFunction_().indicator();
      }
 
      const GridPartType& gridPart() const
      {
        return bndryFunction_().gridPart();
      }
 
     protected:
      ExpressionStorage<DirichletBoundaryFunctionType> bndryFunction_;
      const std::string name_;
    };
 
    template<class GridFunction, class Indicator>
    struct ModelTraits<DirichletBoundaryModel<GridFunction, Indicator> >
      : public DefaultModelTraits<typename GridFunction::DiscreteFunctionSpaceType::FunctionSpaceType,
                                  typename GridFunction::GridPartType>
    {
     protected:
      typedef
      DefaultModelTraits<typename GridFunction::DiscreteFunctionSpaceType::FunctionSpaceType,
                         typename GridFunction::GridPartType>
      BaseType;
      typedef Indicator OuterIndicatorType;
     public:
      enum StructureFlags {
        isLinear = true, 
        isSymmetric = true, 
        isSemiDefinite = true 
      };
 
      typedef
      decltype(std::declval<OuterIndicatorType>() * std::declval<GridFunction>())
        DirichletBoundaryFunctionType;
 
      typedef
      typename DirichletBoundaryFunctionType::IndicatorType
      DirichletIndicatorType;
 
      typedef
      BoundarySupportedFunction<decltype(oneFunction(std::declval<GridFunction>())),
                                DirichletIndicatorType>
      DirichletWeightFunctionType;
    };
 
    template<class GridFunction>
    class DirichletBoundaryModel<GridFunction, EmptyBoundaryIndicatorType>
      : public ZeroModel<typename GridFunction::FunctionSpaceType, typename GridFunction::GridPartType>
    {
      typedef
      ZeroModel<typename GridFunction::FunctionSpaceType, typename GridFunction::GridPartType>
      BaseType;
     public:
      typedef typename GridFunction::FunctionSpaceType FunctionSpaceType;
      typedef EmptyBoundaryIndicatorType DirichletIndicatorType;
 
      DirichletBoundaryModel(const Fem::Function<FunctionSpaceType, GridFunction>& function,
                             const BoundaryIndicatorInterface<DirichletIndicatorType>& indicator,
                             const std::string& name = "")
        : BaseType(name == "" ? ("Dirichlet(" + asImp(function).name() + ")") : name)
      {}
    };
 
 
    template<class GridFunction, class Indicator = EntireBoundaryIndicatorType>
    DirichletBoundaryModel<GridFunction, Indicator>
    dirichletBoundaryModel(const Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction>& values,
                           const BoundaryIndicatorInterface<Indicator>& where = Indicator())
    {
      return DirichletBoundaryModel<GridFunction, Indicator>(values, where);
    }
 
    template<class Object, class Indicator = EntireBoundaryIndicatorType>
    DirichletBoundaryModel<ZeroGridFunction<typename Object::FunctionSpaceType,
                                            typename Object::GridPartType>, Indicator>
    dirichletZeroModel(const Object& object,
                       const BoundaryIndicatorInterface<Indicator>& where = Indicator())
    {
      typedef
        ZeroGridFunction<typename Object::FunctionSpaceType,
                         typename Object::GridPartType>
        ZeroType;
      return dirichletBoundaryModel(ZeroType(object.gridPart()), where);
    }
 
 
 
 
  } // namespace ACFem
 
}  //Namespace Dune
 
 
#endif // __DUNE_ACFEM_MODELS_MODULES_DIRICHLETMODEL_HH__