neumannmodel.hh

#ifndef __DUNE_ACFEM_MODELS_MODULES_NEUMANNMODEL_HH__
#define __DUNE_ACFEM_MODELS_MODULES_NEUMANNMODEL_HH__
 
#include "../modelexpressionbase.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class GridFunction, class Indicator = EntireBoundaryIndicatorType>
    class NeumannBoundaryModel
      : public ModelExpression<NeumannBoundaryModel<GridFunction, Indicator> >
    {
      typedef NeumannBoundaryModel ThisType;
      typedef ModelTraits<ThisType> TraitsType;
     public:
      typedef Indicator OuterIndicatorType;
      typedef typename TraitsType::NeumannBoundaryFunctionType NeumannBoundaryFunctionType;
      typedef typename TraitsType::NeumannIndicatorType NeumannIndicatorType;
      typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
      typedef typename TraitsType::GridPartType GridPartType;
      typedef typename GridPartType::IntersectionType IntersectionType;
      typedef typename FunctionSpaceType::DomainType DomainType;
      typedef typename FunctionSpaceType::RangeType RangeType;
      typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
 
      NeumannBoundaryModel(const Fem::Function<FunctionSpaceType, GridFunction>& uExt,
                           const
                           BoundaryIndicatorInterface<OuterIndicatorType>&
                           indicator = NeumannIndicatorType(),
                           const std::string& name = "")
      : bndryFunction_(asImp(indicator) * asImp(uExt)),
        name_(name == "" ? "Neumann(" + bndryFunction_().name() + ")" : name)
        {}
 
      std::string name() const
      {
        return name_;
      }
 
      bool setIntersection(const IntersectionType& intersection) const
      {
        // Really, this is for Robin data, so we return indeed false.
        return false;
      }
 
      NeumannIndicatorType neumannIndicator() const
      {
        return bndryFunction_().indicator();
      }
 
      NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType& gridPart) const
      {
        return bndryFunction_();
      }
 
      const GridPartType& gridPart() const
      {
        return bndryFunction_().gridPart();
      }
 
     protected:
      ExpressionStorage<NeumannBoundaryFunctionType> bndryFunction_;
      const std::string name_;
    };
 
    template<class GridFunction, class Indicator>
    struct ModelTraits<NeumannBoundaryModel<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>())
      NeumannBoundaryFunctionType;
 
      typedef
      typename NeumannBoundaryFunctionType::IndicatorType
        NeumannIndicatorType;
    };
 
    template<class GridFunction>
    class NeumannBoundaryModel<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 NeumannIndicatorType;
 
      NeumannBoundaryModel(const Fem::Function<FunctionSpaceType, GridFunction>& function,
                           const BoundaryIndicatorInterface<NeumannIndicatorType>& indicator,
                           const std::string& name = "")
        : BaseType(name == "" ? ("Neumann(" + asImp(function).name() + ")") : name)
      {}
    };
 
 
    template<class GridFunction, class Indicator = EntireBoundaryIndicatorType>
    NeumannBoundaryModel<GridFunction, Indicator>
    neumannBoundaryModel(const Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction>& values,
                       const BoundaryIndicatorInterface<Indicator>& where = Indicator())
    {
      return NeumannBoundaryModel<GridFunction, Indicator>(values, where);
    }
 
    template<class Object, class Indicator = EntireBoundaryIndicatorType>
    NeumannBoundaryModel<ZeroGridFunction<typename Object::FunctionSpaceType,
                                        typename Object::GridPartType>, Indicator>
     neumannZeroModel(const Object& object,
                      const BoundaryIndicatorInterface<Indicator>& where = Indicator())
    {
      typedef
        ZeroGridFunction<typename Object::FunctionSpaceType,
                         typename Object::GridPartType>
        ZeroType;
      return neumannBoundaryModel(ZeroType(object.gridPart()), where);
    }
 
 
 
 
  } // namespace ACFem
 
}  //Namespace Dune
 
 
#endif // __DUNE_ACFEM_MODELS_MODULES_NEUMANNMODEL_HH__