dwrdatacontainer.h

Go to the documentation of this file.

#ifndef DWRDATACONTAINER_H_
#define DWRDATACONTAINER_H_

#include "constraintvector.h"
#include "controlvector.h"
#include "statevector.h"
#include "dopetypes.h"
#include "parameterreader.h"
#include "dopetypes.h"

namespace DOpE
{

  template<typename VECTOR>
    class DWRDataContainerBase
    {
      public:
        DWRDataContainerBase(DOpEtypes::EETerms ee_terms =
            DOpEtypes::EETerms::mixed)
            : ee_terms_(ee_terms)
        {
          lock_ = true;
          switch (this->GetEETerms())
          {
          case DOpEtypes::primal_only:
            n_error_comps_ = 2;
            break;
          case DOpEtypes::dual_only:
            n_error_comps_ = 2;
            break;
          case DOpEtypes::mixed:
            n_error_comps_ = 2;
            break;
          case DOpEtypes::mixed_control:
            n_error_comps_ = 3;
            break;
          default:
            throw DOpEException("Unknown DOpEtypes::EEterms.",
                                "DWRDataContainer::ReleaseLock");
            break;
          }
        }

        virtual
        ~DWRDataContainerBase()
        {
        }

        virtual std::string
        GetName() const = 0;

        virtual void
        ReInit(unsigned int n_elements);

        void
        ReleaseLock()
        {
          lock_ = false;

          switch (this->GetEETerms())
          {
            case DOpEtypes::primal_only:
              error_ind_ = GetPrimalErrorIndicators();
              break;
            case DOpEtypes::dual_only:
              error_ind_ = GetDualErrorIndicators();
              break;
            case DOpEtypes::mixed:
              error_ind_.equ(0.5, GetPrimalErrorIndicators());
              error_ind_.add(0.5, GetDualErrorIndicators());
              break;
             case DOpEtypes::mixed_control:
               error_ind_.equ(0.5, GetPrimalErrorIndicators());
               error_ind_.add(0.5, GetDualErrorIndicators());
               error_ind_.add(0.5, GetControlErrorIndicators());
              break;
            default:
              throw DOpEException("Unknown DOpEtypes::EEterms.",
                  "DWRDataContainer::ReleaseLock");
              break;
          }
        }

        double
        GetError() const
        {
          double error = 0;
          for (unsigned int i = 0; i < GetErrorIndicators().size(); ++i)
          {
            error += GetErrorIndicators()(i);
          }
          return error;
        }

        double
        GetPrimalError() const
        {
          double error = 0;
          for (unsigned int i = 0; i < GetAllErrorIndicators()[1]->size(); ++i)
          {
            error += GetAllErrorIndicators()[1]->operator()(i);
          }
          return error;
        }

        double
        GetDualError() const
        {
          double error = 0;
          for (unsigned int i = 0; i < GetAllErrorIndicators()[2]->size(); ++i)
          {
            error += GetAllErrorIndicators()[2]->operator()(i);
          }
          return error;
        }

        double
        GetControlError() const
        {
          double error = 0;
          for (unsigned int i = 0; i < GetAllErrorIndicators()[3]->size(); ++i)
          {
            error += GetAllErrorIndicators()[3]->operator()(i);
          }
          return error;
        }

        const Vector<double>&
        GetErrorIndicators() const
        {
          if (lock_)
          {
            throw DOpEException("Error indicators are still locked.",
                "DWRDataContainer::GetErrorIndicators");
          }
          else
          {
            return error_ind_;
          }
        }

        Vector<double>&
        GetPrimalErrorIndicators()
        {
          return error_ind_primal_;
        }

        const Vector<double>&
        GetPrimalErrorIndicators() const
        {
          return error_ind_primal_;
        }

        Vector<double>&
        GetDualErrorIndicators()
        {
          return error_ind_dual_;
        }

        const Vector<double>&
        GetDualErrorIndicators() const
        {
          return error_ind_dual_;
        }

        Vector<double>&
        GetControlErrorIndicators()
        {
          return error_ind_control_;
        }

        const Vector<double>&
        GetControlErrorIndicators() const
        {
          return error_ind_control_;
        }

        Vector<double>&
        GetErrorIndicators(unsigned int i)
        {
          if( i == 0)
            return error_ind_primal_;
          else
            if (i == 1) 
              return error_ind_dual_;
            else
              if (i == 2)
                return error_ind_control_;
              else
                throw DOpEException("Unknown Indicator","DWRDataContainer::GetErrorIndicators");
        }

        const Vector<double>&
        GetErrorIndicators(unsigned int i) const
        {
          if( i == 0)
            return error_ind_primal_;
          else
            if (i == 1) 
              return error_ind_dual_;
            else
              if (i == 2)
                return error_ind_control_;
              else
                throw DOpEException("Unknown Indicator","DWRDataContainer::GetErrorIndicators");
        }
        
        unsigned int GetNErrorComps() const
        {
          //number of error components...
          return n_error_comps_;
        }

        std::vector<const Vector<double>*>
        GetAllErrorIndicators() const
        {
          std::vector<const Vector<double>*> res;
          if (lock_)
          {
            throw DOpEException("Error indicators are still locked.",
                "DWRDataContainer::GetErrorIndicators");
          }
          else
          {
            res.push_back(&error_ind_);
            res.push_back(&this->GetPrimalErrorIndicators());
            res.push_back(&this->GetDualErrorIndicators());
            res.push_back(&this->GetControlErrorIndicators());
          }
          return res;
        }

        virtual DOpEtypes::WeightComputation
        GetWeightComputation() const = 0;

        virtual DOpEtypes::ResidualEvaluation
        GetResidualEvaluation() const =0;

        DOpEtypes::EETerms
        GetEETerms() const
        {
          return ee_terms_;
        }

        template<class PROBLEM, class INTEGRATOR>
          void
          ComputeRefinementIndicators(PROBLEM& problem, INTEGRATOR& integrator)
          {
            integrator.ComputeRefinementIndicators(problem, *this);
          }

        virtual bool
        NeedDual() const = 0;

        const std::map<std::string, const VECTOR*>&
        GetWeightData() const
        {
          return weight_data_;
        }

        void
        ClearWeightData()
        {
          weight_data_.clear();
        }

        void
        PrepareWeights(const StateVector<VECTOR>& u, const StateVector<VECTOR>& z)
        {
          //Dependend on the GetEETerms we let the dwrc compute the primal and/or dual weights
          switch (GetEETerms())
          {
            case DOpEtypes::primal_only:
              PreparePI_h_z(z);
              AddWeightData("weight_for_primal_residual",
                  &(GetPI_h_z().GetSpacialVector()));
              break;
            case DOpEtypes::dual_only:
              PreparePI_h_u(u);
              AddWeightData("weight_for_dual_residual",
                  &(GetPI_h_u().GetSpacialVector()));
              break;
            case DOpEtypes::mixed:
              PreparePI_h_u(u);
              AddWeightData("weight_for_dual_residual",
                  &(GetPI_h_u().GetSpacialVector()));
              PreparePI_h_z(z);
              AddWeightData("weight_for_primal_residual",
                  &(GetPI_h_z().GetSpacialVector()));
              break;
           case DOpEtypes::mixed_control:
              PreparePI_h_u(u);
              AddWeightData("weight_for_dual_residual",
                  &(GetPI_h_u().GetSpacialVector()));
              PreparePI_h_z(z);
              AddWeightData("weight_for_primal_residual",
                  &(GetPI_h_z().GetSpacialVector()));
              break;
            default:
              throw DOpEException("Unknown DOpEtypes::EETerms!",
                  "DWRDataContainerBase::PrepareWeights");
              break;
          }
        }
        void
        PrepareWeights(const ControlVector<VECTOR>& q)
        {
          //Dependend on the GetEETerms we let the dwrc compute the primal and/or dual weights
          switch (GetEETerms())
          {
           case DOpEtypes::mixed_control:
              PreparePI_h_q(q);
              AddWeightData("weight_for_control_residual",
                  &(GetPI_h_q().GetSpacialVector()));
              break;
          case DOpEtypes::primal_only:
            //Do nothing to be compatible with residual estimators not using the control!
            break;
            default:
              throw DOpEException("Unknown DOpEtypes::EETerms!",
                  "DWRDataContainerBase::PrepareWeights");
              break;
          }
        }

      protected:
        //TODO PI_h_u and PI_h_z are probably not the best names.
        //Basically, one could replace them with 'primalweight' and 'dualweight',
        //but i found them a little bit misleading. ~cg
        virtual StateVector<VECTOR>&
        GetPI_h_u() = 0;

        virtual StateVector<VECTOR>&
        GetPI_h_z() = 0;

        virtual ControlVector<VECTOR>&
        GetPI_h_q() = 0;

        virtual void
        PreparePI_h_u(const StateVector<VECTOR>& u) = 0;

        virtual void
        PreparePI_h_z(const StateVector<VECTOR>& z) = 0;
        
        virtual void
        PreparePI_h_q(const ControlVector<VECTOR>& q) = 0;

        void
        AddWeightData(std::string name, const VECTOR* new_data)
        {
          if (weight_data_.find(name) != weight_data_.end())
          {
            throw DOpEException(
                "Adding multiple Data with name " + name + " is prohibited!",
                "Integrator::AddDomainData");
          }
          weight_data_.insert(
              std::pair<std::string, const VECTOR*>(name, new_data));
        }

      private:
        DOpEtypes::EETerms ee_terms_;
        bool lock_;
        unsigned int n_error_comps_;
        std::map<std::string, const VECTOR*> weight_data_;
        Vector<double> error_ind_, error_ind_primal_, error_ind_dual_, error_ind_control_;
    }
    ;

  template<typename VECTOR>
    void
    DWRDataContainerBase<VECTOR>::ReInit(unsigned int n_elements)
    {
      error_ind_.reinit(n_elements);
      GetPrimalErrorIndicators().reinit(n_elements);
      GetDualErrorIndicators().reinit(n_elements);
      GetControlErrorIndicators().reinit(n_elements);
      lock_ = true;
    }

  template<class STH, class IDC, class EDC, class FDC, typename VECTOR>
    class DWRDataContainer : public DWRDataContainerBase<VECTOR>
    {
      public:
        DWRDataContainer(
            DOpEtypes::EETerms ee_terms = DOpEtypes::EETerms::mixed)
            : DWRDataContainerBase<VECTOR>(ee_terms)
        {
        }
        ;
        virtual
        ~DWRDataContainer()
        {
        }
        ;

        virtual EDC&
        GetElementWeight() const = 0;

        virtual FDC&
        GetFaceWeight() const = 0;

        virtual STH&
        GetWeightSTH() = 0;
        virtual const STH&
        GetWeightSTH() const = 0;

        virtual IDC&
        GetWeightIDC() = 0;
        virtual const IDC&
        GetWeightIDC() const = 0;
    };

  template<class EDC, class STH, class IDC, class FDC, typename VECTOR>
    EDC*
    ExtractEDC(const DWRDataContainer<STH, IDC, EDC, FDC, VECTOR>& dwrc)
    {
      return &dwrc.GetElementWeight();
    }
  template<class FDC, class STH, class IDC, class EDC, typename VECTOR>
    FDC*
    ExtractFDC(const DWRDataContainer<STH, IDC, EDC, FDC, VECTOR>& dwrc)
    {
      return &dwrc.GetFaceWeight();
    }

} //end of namespace
#endif /* DWRDATACONTAINER_H_ */