#ifndef DUNE_PDELAB_TEST_TESTADAPTIVITY_ERROR_INDICATOR_HH
#define DUNE_PDELAB_TEST_TESTADAPTIVITY_ERROR_INDICATOR_HH

namespace Dune {
  namespace PDELab {

    /** a local operator for residual-based error estimation
     *
     * A call to residual() of a grid operator space will assemble
     * the quantity \eta_T^2 for each cell. Note that the squares
     * of the cell indicator \eta_T is stored. To compute the global
     * error estimate sum up all values and take the square root.
     *
     * Assumptions and limitations:
     * - Assumes that LFSU is P_k/Q_k finite element space
     *   and LFSV is a P_0 finite element space (one value per cell).
     *   However, the second order derivatives are ignored!
     * - Convection/reaction terms are ignored
     *
     */
    class ExampleErrorEstimator
      : public Dune::PDELab::LocalOperatorDefaultFlags
    {

    public:
      // pattern assembly flags
      enum { doPatternVolume = false };
      enum { doPatternSkeleton = false };

      // residual assembly flags
      enum { doAlphaSkeleton  = true };

      // skeleton integral depending on test and ansatz functions
      // each face is only visited ONCE!
      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
      {
        // domain and range field type
        typedef typename LFSU::Traits::FiniteElementType::
          Traits::LocalBasisType::Traits::DomainFieldType DF;
        typedef typename LFSU::Traits::FiniteElementType::
          Traits::LocalBasisType::Traits::RangeFieldType RF;
        typedef typename LFSU::Traits::FiniteElementType::
          Traits::LocalBasisType::Traits::JacobianType JacobianType;
        typedef typename LFSU::Traits::SizeType size_type;

        // make copy of inside and outside w.r.t. the intersection
        auto inside_cell = ig.inside();
        auto outside_cell = ig.outside();

        const int localdim = IG::mydimension;
        const int entitydim = IG::Entity::dimension;

        // select quadrature rule
        const int intorder = 2*lfsu_s.finiteElement().localBasis().order();
        Dune::GeometryType gtface = ig.geometryInInside().type();
        const auto& rule = Dune::QuadratureRules<DF,localdim>::rule(gtface,intorder);

        // tensor times normal
        auto n_F = ig.centerUnitOuterNormal();

        // loop over quadrature points and integrate normal flux
        RF sum(0.0);
        for (const auto& ip : rule)
          {
            // position of quadrature point in local coordinates of elements
            auto iplocal_s = ig.geometryInInside().global(ip.position());
            auto iplocal_n = ig.geometryInOutside().global(ip.position());

            // evaluate gradient of basis functions
            std::vector<JacobianType> gradphi_s(lfsu_s.size());
            lfsu_s.finiteElement().localBasis().evaluateJacobian(iplocal_s,gradphi_s);
            std::vector<JacobianType> gradphi_n(lfsu_n.size());
            lfsu_n.finiteElement().localBasis().evaluateJacobian(iplocal_n,gradphi_n);

            // transform gradients of shape functions to real element
            auto jac = inside_cell.geometry().jacobianInverseTransposed(iplocal_s);
            std::vector<Dune::FieldVector<RF,entitydim> > tgradphi_s(lfsu_s.size());
            for (size_type i=0; i<lfsu_s.size(); i++)
              jac.mv(gradphi_s[i][0],tgradphi_s[i]);
            jac = outside_cell.geometry().jacobianInverseTransposed(iplocal_n);
            std::vector<Dune::FieldVector<RF,entitydim> > tgradphi_n(lfsu_n.size());
            for (size_type i=0; i<lfsu_n.size(); i++)
              jac.mv(gradphi_n[i][0],tgradphi_n[i]);

            // compute gradient of u
            Dune::FieldVector<RF,entitydim> gradu_s(0.0);
            for (size_type i=0; i<lfsu_s.size(); i++)
              gradu_s.axpy(x_s(lfsu_s,i),tgradphi_s[i]);
            Dune::FieldVector<RF,entitydim> gradu_n(0.0);
            for (size_type i=0; i<lfsu_n.size(); i++)
              gradu_n.axpy(x_n(lfsu_n,i),tgradphi_n[i]);

            // integrate
            RF factor = ip.weight() * ig.geometry().integrationElement(ip.position());
            RF jump = (n_F*gradu_s)-(n_F*gradu_n);
            sum += 0.25*jump*jump*factor;
          }

        // accumulate indicator
        DF h_T = std::max( diameter(inside_cell.geometry()),
                           diameter(outside_cell.geometry()) );

        r_s.accumulate(lfsv_s,0,h_T*sum);
        r_n.accumulate(lfsv_n,0,h_T*sum);
      }

    private:

      template<class GEO>
      typename GEO::ctype diameter (const GEO& geo) const
      {
        typedef typename GEO::ctype DF;
        DF hmax = -1.0E00;
        const int dim = GEO::coorddimension;
        for (int i=0; i<geo.corners(); i++)
          {
            Dune::FieldVector<DF,dim> xi = geo.corner(i);
            for (int j=i+1; j<geo.corners(); j++)
              {
                Dune::FieldVector<DF,dim> xj = geo.corner(j);
                xj -= xi;
                hmax = std::max(hmax,xj.two_norm());
              }
          }
        return hmax;
      }

    };

  }
}

#endif // DUNE_PDELAB_TEST_TESTADAPTIVITY_ERROR_INDICATOR_HH
