scaled.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
#ifndef DUNE_PDELAB_LOCALOPERATOR_SCALED_HH
#define DUNE_PDELAB_LOCALOPERATOR_SCALED_HH
 
namespace Dune {
  namespace PDELab {
 
 
    template<typename Backend, typename Factor, typename Time = double>
    class ScaledLocalOperator
    // do *not* derive from LocalOperatorDefaultFlags -- we need to take care
    // of all the possible flags ourselves.
    //
    // If there is a new flag added to LocalOperatorDefaultFlags, it will
    // probably be false by default.  If we would derive from
    // LocalOperatorDefaultFlags, we would derive from that flag -- and claim
    // this flag to be false no matter what the underlying local operator
    // says.  It that flag controls a method that the underlying operator
    // implements, that method would never get called, and no diagnostic would
    // be given.  The only way to notice this situation would be by noticing
    // that the solution of the simulation is errornous.
    //
    // By not deriving from LocalOperatorDefaultFlags, we do not inherit any
    // new flags.  If anything tries to use this new flag, this will result in
    // a compilation error.  This way the missing implementation in this class
    // gets noticed, and the flag can be correctly forwarded from the
    // underlying local operator.
    //
    // The same argument applies for not deriving from
    // InstationaryLocalOperatorDefaultMethods.
    {
      Factor factor;
      Backend* bp;
 
    public:
      //
      //
 
 
      ScaledLocalOperator(Backend& backend, Factor factor_ = 0)
        : factor(factor_), bp(&backend) { }
 
      ScaledLocalOperator(Factor factor_ = 0) : factor(factor_), bp(0) { }
 
      void setFactor(Factor factor_) { factor = factor_; }
      Factor getFactor() const { return factor; }
 
      void setBackend(Backend& backend) { bp = &backend; }
      Backend& getBackend() const { return *bp; }
 
 
      //
      //
 
      enum { doPatternVolume = Backend::doPatternVolume };
      enum {
        doPatternVolumePostSkeleton = Backend::doPatternVolumePostSkeleton
      };
      enum { doPatternSkeleton = Backend::doPatternSkeleton };
      enum { doPatternBoundary = Backend::doPatternBoundary };
 
      enum { doAlphaVolume = Backend::doAlphaVolume };
      enum { doAlphaVolumePostSkeleton = Backend::doAlphaVolumePostSkeleton };
      enum { doAlphaSkeleton = Backend::doAlphaSkeleton };
      enum { doAlphaBoundary = Backend::doAlphaBoundary };
 
      enum { doLambdaVolume = Backend::doLambdaVolume };
      enum {
        doLambdaVolumePostSkeleton = Backend::doLambdaVolumePostSkeleton
      };
      enum { doLambdaSkeleton = Backend::doLambdaSkeleton };
      enum { doLambdaBoundary = Backend::doLambdaBoundary };
 
      enum { doSkeletonTwoSided = Backend::doSkeletonTwoSided };
 
 
      //
      //
 
 
      template<typename LFSU, typename LFSV, typename LocalPattern>
      void pattern_volume
      ( const LFSU& lfsu, const LFSV& lfsv,
        LocalPattern& pattern) const
      {
        if(factor != 0)
          bp->pattern_volume(lfsu, lfsv, pattern);
      }
 
 
      template<typename LFSU, typename LFSV, typename LocalPattern>
      void pattern_volume_post_skeleton
      ( const LFSU& lfsu, const LFSV& lfsv,
        LocalPattern& pattern) const
      {
        if(factor != 0)
          bp->pattern_volume_post_skeleton(lfsu, lfsv, pattern);
      }
 
 
      template<typename LFSU, typename LFSV, typename LocalPattern>
      void pattern_skeleton
      ( const LFSU& lfsu_s, const LFSV& lfsv_s,
        const LFSU& lfsu_n, const LFSV& lfsv_n,
        LocalPattern& pattern_sn,
        LocalPattern& pattern_ns) const
      {
        if(factor != 0)
          bp->pattern_skeleton(lfsu_s, lfsv_s, lfsu_n, lfsv_n,
                               pattern_sn, pattern_ns);
      }
 
 
      template<typename LFSU, typename LFSV, typename LocalPattern>
      void pattern_boundary
      ( const LFSU& lfsu_s, const LFSV& lfsv_s,
        LocalPattern& pattern_ss) const
      {
        if(factor != 0)
          bp->pattern_boundary(lfsu_s, lfsv_s, pattern_ss);
      }
 
 
      //
      //
 
 
      template<typename EG, typename LFSU, typename X, typename LFSV,
               typename R>
      void alpha_volume
      ( const EG& eg,
        const LFSU& lfsu, const X& x, const LFSV& lfsv,
        R& r) const
      {
        if(factor != 0) {
          typename R::WeightedAccumulationView
            my_r(r.weightedAccumulationView(factor));
          bp->alpha_volume(eg, lfsu, x, lfsv, my_r);
        }
      }
 
 
      template<typename EG, typename LFSU, typename X, typename LFSV,
               typename R>
      void alpha_volume_post_skeleton
      ( const EG& eg,
        const LFSU& lfsu, const X& x, const LFSV& lfsv,
        R& r) const
      {
        if(factor != 0) {
          typename R::WeightedAccumulationView
            my_r(r.weightedAccumulationView(factor));
          bp->alpha_volume_post_skeleton(eg, lfsu, x, lfsv, my_r);
        }
      }
 
 
      template<typename IG, typename LFSU, typename X, typename LFSV,
               typename R>
      void alpha_skeleton
      ( const IG& ig,
        const LFSU& lfsu_s, const X& x_s, const LFSV& lfsv_s,
        const LFSU& lfsu_n, const X& x_n, const LFSV& lfsv_n,
        R& r_s, R& r_n) const
      {
        if(factor != 0) {
          typename R::WeightedAccumulationView
            my_r_s(r_s.weightedAccumulationView(factor));
          typename R::WeightedAccumulationView
            my_r_n(r_n.weightedAccumulationView(factor));
          bp->alpha_skeleton(ig,
                             lfsu_s, x_s, lfsv_s,
                             lfsu_n, x_n, lfsv_n,
                             my_r_s, my_r_n);
        }
      }
 
 
      template<typename IG, typename LFSU, typename X, typename LFSV,
               typename R>
      void alpha_boundary
      ( const IG& ig,
        const LFSU& lfsu_s, const X& x_s, const LFSV& lfsv_s,
        R& r_s) const
      {
        if(factor != 0) {
          typename R::WeightedAccumulationView
            my_r_s(r_s.weightedAccumulationView(factor));
          bp->alpha_boundary(ig, lfsu_s, x_s, lfsv_s, my_r_s);
        }
      }
 
 
      //
      //
 
 
      template<typename EG, typename LFSV, typename R>
      void lambda_volume(const EG& eg, const LFSV& lfsv, R& r) const
      {
        if(factor != 0) {
          typename R::WeightedAccumulationView
            my_r(r.weightedAccumulationView(factor));
          bp->lambda_volume(eg, lfsv, my_r);
        }
      }
 
 
      template<typename EG, typename LFSV, typename R>
      void lambda_volume_post_skeleton(const EG& eg,
                                       const LFSV& lfsv,
                                       R& r) const
      {
        if(factor != 0) {
          typename R::WeightedAccumulationView
            my_r(r.weightedAccumulationView(factor));
          bp->lambda_volume_post_skeleton(eg, lfsv, my_r);
        }
      }
 
 
      template<typename IG, typename LFSV, typename R>
      void lambda_skeleton(const IG& ig,
                           const LFSV& lfsv_s, const LFSV& lfsv_n,
                           R& r_s, R& r_n) const
      {
        if(factor != 0) {
          typename R::WeightedAccumulationView
            my_r_s(r_s.weightedAccumulationView(factor));
          typename R::WeightedAccumulationView
            my_r_n(r_n.weightedAccumulationView(factor));
          bp->lambda_skeleton(ig, lfsv_s, lfsv_n, my_r_s, my_r_n);
        }
      }
 
 
      template<typename IG, typename LFSV, typename R>
      void lambda_boundary(const IG& ig, const LFSV& lfsv_s, R& r_s) const
      {
        if(factor != 0) {
          typename R::WeightedAccumulationView
            my_r_s(r_s.weightedAccumulationView(factor));
          bp->lambda_boundary(ig, lfsv_s, my_r_s);
        }
      }
 
 
      //
      //
 
 
      template<typename EG, typename LFSU, typename X, typename LFSV,
               typename Y>
      void jacobian_apply_volume
      ( const EG& eg,
        const LFSU& lfsu, const X& x, const LFSV& lfsv,
        Y& y) const
      {
        if(factor != 0) {
          typename Y::WeightedAccumulationView
            my_y(y.weightedAccumulationView(factor));
          bp->jacobian_apply_volume(eg, lfsu, x, lfsv, my_y);
        }
      }
 
 
      template<typename EG, typename LFSU, typename X, typename LFSV,
               typename Y>
      void jacobian_apply_volume_post_skeleton
      ( const EG& eg,
        const LFSU& lfsu, const X& x, const LFSV& lfsv,
        Y& y) const
      {
        if(factor != 0) {
          typename Y::WeightedAccumulationView
            my_y(y.weightedAccumulationView(factor));
          bp->jacobian_apply_volume_post_skeleton(eg, lfsu, x, lfsv, my_y);
        }
      }
 
 
      template<typename IG, typename LFSU, typename X, typename LFSV,
               typename Y>
      void jacobian_apply_skeleton
      ( const IG& ig,
        const LFSU& lfsu_s, const X& x_s, const LFSV& lfsv_s,
        const LFSU& lfsu_n, const X& x_n, const LFSV& lfsv_n,
        Y& y_s, Y& y_n) const
      {
        if(factor != 0) {
          typename Y::WeightedAccumulationView
            my_y_s(y_s.weightedAccumulationView(factor));
          typename Y::WeightedAccumulationView
            my_y_n(y_n.weightedAccumulationView(factor));
          bp->jacobian_apply_skeleton(ig,
                                      lfsu_s, x_s, lfsv_s,
                                      lfsu_n, x_n, lfsv_n,
                                      my_y_s, my_y_n);
        }
      }
 
 
      template<typename IG, typename LFSU, typename X, typename LFSV,
               typename Y>
      void jacobian_apply_boundary
      ( const IG& ig,
        const LFSU& lfsu_s, const X& x_s, const LFSV& lfsv_s,
        Y& y_s) const
      {
        if(factor != 0) {
          typename Y::WeightedAccumulationView
            my_y_s(y_s.weightedAccumulationView(factor));
          bp->jacobian_apply_boundary(ig, lfsu_s, x_s, lfsv_s, my_y_s);
        }
      }
 
 
      //
      //
 
 
      template<typename EG, typename LFSU, typename X, typename LFSV,
               typename M>
      void jacobian_volume
      ( const EG& eg,
        const LFSU& lfsu, const X& x, const LFSV& lfsv,
        M& mat) const
      {
        if(factor != 0) {
          typename M::WeightedAccumulationView
            my_mat(mat.weightedAccumulationView(factor));
          bp->jacobian_volume(eg, lfsu, x, lfsv, my_mat);
        }
      }
 
 
      template<typename EG, typename LFSU, typename X, typename LFSV,
               typename M>
      void jacobian_volume_post_skeleton
      ( const EG& eg,
        const LFSU& lfsu, const X& x, const LFSV& lfsv,
        M& mat) const
      {
        if(factor != 0) {
          typename M::WeightedAccumulationView
            my_mat(mat.weightedAccumulationView(factor));
          bp->jacobian_volume_post_skeleton(eg, lfsu, x, lfsv, my_mat);
        }
      }
 
 
      template<typename IG, typename LFSU, typename X, typename LFSV,
               typename M>
      void jacobian_skeleton
      ( const IG& ig,
        const LFSU& lfsu_s, const X& x_s, const LFSV& lfsv_s,
        const LFSU& lfsu_n, const X& x_n, const LFSV& lfsv_n,
        M& mat_ss, M& mat_sn, M& mat_ns, M& mat_nn) const
      {
        if(factor != 0) {
          typename M::WeightedAccumulationView
            my_mat_ss(mat_ss.weightedAccumulationView(factor));
          typename M::WeightedAccumulationView
            my_mat_sn(mat_sn.weightedAccumulationView(factor));
          typename M::WeightedAccumulationView
            my_mat_ns(mat_ns.weightedAccumulationView(factor));
          typename M::WeightedAccumulationView
            my_mat_nn(mat_nn.weightedAccumulationView(factor));
          bp->jacobian_skeleton(ig,
                                lfsu_s, x_s, lfsv_s,
                                lfsu_n, x_n, lfsv_n,
                                my_mat_ss, my_mat_sn, my_mat_ns, my_mat_nn);
        }
      }
 
 
      template<typename IG, typename LFSU, typename X, typename LFSV,
               typename M>
      void jacobian_boundary
      ( const IG& ig,
        const LFSU& lfsu_s, const X& x_s, const LFSV& lfsv_s,
        M& mat_ss) const
      {
        if(factor != 0) {
          typename M::WeightedAccumulationView
            my_mat_ss(mat_ss.weightedAccumulationView(factor));
          bp->jacobian_boundary(ig, lfsu_s, x_s, lfsv_s, my_mat_ss);
        }
      }
 
 
      //
 
      typedef Time RealType;
 
 
      void setTime (Time t) { bp->setTime(t); }
 
 
      Time getTime () const { return bp->getTime(); }
 
 
      void preStep (Time time, Time dt, int stages)
      { bp->preStep(time, dt, stages); }
 
 
      void postStep () { bp->postStep(); }
 
 
      void preStage (Time time, int r) { bp->preStage(time, r); }
 
 
      int getStage () const { return bp->getStage(); }
 
      void postStage () { bp->postStage(); }
 
 
      Time suggestTimestep (Time dt) const
      { return bp->suggestTimestep(dt); }
 
 
    };
 
  }
}
 
#endif // DUNE_PDELAB_LOCALOPERATOR_SCALED_HH