abstract_interface.hh

Go to the documentation of this file.

#ifndef ABSTRACT_INTERFACE_HH
#define ABSTRACT_INTERFACE_HH
 
#include <memory>
#include <iostream>
#include <boost/signals2.hpp>
#include <string>
#include <cmath>
#include <vector>
 
#include <dune/grid/config.h>
#include "linalg/triplet.hh"
 
namespace Kaskade
{
  class AbstractFunctionSpaceElement
  {
  public:
    // No copy constructor.
    AbstractFunctionSpaceElement(AbstractFunctionSpaceElement const &) = delete;
 
    virtual ~AbstractFunctionSpaceElement() {}
 
    AbstractFunctionSpaceElement& axpy(double alpha, AbstractFunctionSpaceElement const& l, int component)
    {
      if(this==&l)
      {
        std::vector<double> alphaV(nComponents(),alpha+1.0);
        return doscale(alphaV);
      }
      else
        return doaxpy(alpha, l, component);
    }
 
    AbstractFunctionSpaceElement& axpy(double alpha, AbstractFunctionSpaceElement const&l, std::string const role)
    {
      return axpy_role(alpha,l,role);
    }
 
    AbstractFunctionSpaceElement& axpy_role(double alpha, AbstractFunctionSpaceElement const&l, std::string const role)
    {
      for(int i=0; i<nComponents(); ++i)
      {
        if(getRole(i)==role) axpy(alpha,l,i);
      }
      return *this;
    }
 
    AbstractFunctionSpaceElement& axpy(double alpha, AbstractFunctionSpaceElement const& l)
    {
      if(this==&l)
      {
        std::vector<double> alphaV(nComponents(),alpha+1.0);
        return doscale(alphaV);
      }
      else
        return doaxpy_(alpha, l);
    }
 
 
    AbstractFunctionSpaceElement& operator=(AbstractFunctionSpaceElement const& v)
    {
      if(this!=&v) return doassign(v);
      return *this;
    }
 
    AbstractFunctionSpaceElement& operator+=(AbstractFunctionSpaceElement const& v) { return doaxpy_(1.0,v); }
    AbstractFunctionSpaceElement& operator-=(AbstractFunctionSpaceElement const& v) { return doaxpy_(-1.0,v); }
    AbstractFunctionSpaceElement& operator*=(double lambda)
    {
      std::vector<double> lambdaV(nComponents(),lambda);
      return doscale(lambdaV);
    }
 
    AbstractFunctionSpaceElement& operator*=(std::vector<double>const& lambda)
    {
      return doscale(lambda);
    }
 
 
    double applyAsDualTo(AbstractFunctionSpaceElement const& v, int component) const
    {
      return doapplyAsDualTo(v,component,component+1);
    }
 
    double applyAsDualTo(AbstractFunctionSpaceElement const& v) const
    {
      return doapplyAsDualTo(v,0,nComponents());
    }
 
    double applyAsDualTo(AbstractFunctionSpaceElement const& v, std::string const& role) const
    {
      return applyAsDualTo_role(v,role);
    }
 
    double applyAsDualTo_role(AbstractFunctionSpaceElement const&v, std::string const role) const
    {
      double res(0.0);
      for(int i=0; i<nComponents(); ++i)
      {
        if(getRole(i)==role) res+=applyAsDualTo(v,i);
      }
      return res;
    }
 
    virtual std::string getRole(int component) const = 0;
 
    void swap(AbstractFunctionSpaceElement& v) { doswap(v); }
 
    virtual int nComponents() const = 0;
 
    virtual void writeToFile(std::string const& file, bool append, int order=1) const {}
 
    virtual void print(std::string const& message="") const { std::cout << "AbstractFunctionSpaceElement: No printing available!" << std::endl;}
 
    virtual std::unique_ptr<AbstractFunctionSpaceElement> clone() const = 0;
 
    virtual std::unique_ptr<AbstractFunctionSpaceElement> initZeroVector() const = 0;
 
  private:
    virtual AbstractFunctionSpaceElement& doaxpy(double alpha, AbstractFunctionSpaceElement const& l, int component) = 0;
    virtual AbstractFunctionSpaceElement& doaxpy_(double alpha, AbstractFunctionSpaceElement const& l) = 0;
    virtual AbstractFunctionSpaceElement& doscale(std::vector<double> const& lambda) = 0;
    virtual AbstractFunctionSpaceElement& doassign(AbstractFunctionSpaceElement const& l) = 0;
    virtual void doswap(AbstractFunctionSpaceElement& l) = 0;
    virtual double doapplyAsDualTo(AbstractFunctionSpaceElement const& v,int vbegin, int vend) const = 0;
 
  protected:
    AbstractFunctionSpaceElement() {}
  };
  
 
  class AbstractLinearization
  {
  public:
    virtual double eval() const = 0;
    virtual double evalL1norm() const = 0;
    virtual void evald(AbstractFunctionSpaceElement &g, int rbegin=0, int rend=-1) const = 0;
    void ddxpy(AbstractFunctionSpaceElement& y, AbstractFunctionSpaceElement const& x, int rbegin=0, int rend=-1, int cbegin=0, int cend=-1) const
    {
      d2axpy(1.0,y,x,rbegin,rend,cbegin,cend);
    }
    void ddtxpy(AbstractFunctionSpaceElement& y, AbstractFunctionSpaceElement const& x, int rbegin=0, int rend=-1, int cbegin=0, int cend=-1) const
    {
      d2taxpy(1.0,y,x,rbegin,rend,cbegin,cend);
    }
    virtual void d2axpy(double a, AbstractFunctionSpaceElement& y, AbstractFunctionSpaceElement const& x, int rbegin=0, int rend=-1, int cbegin=0, int cend=-1) const = 0;
    virtual void d2taxpy(double a, AbstractFunctionSpaceElement& y, AbstractFunctionSpaceElement const& x, int rbegin=0, int rend=-1, int cbegin=0, int cend=-1) const = 0;
    virtual void getMatrixBlocks(MatrixAsTriplet<double>& mat, int rbegin=0, int rend=-1, int cbegin=0, int cend=-1) const = 0;//{ assert(!"not implemented"); }
    virtual AbstractFunctionSpaceElement const& getOrigin() const = 0;
 
    virtual void precompute() = 0;
 
    virtual void flush() = 0;
 
    virtual ~AbstractLinearization() {}
  };
 
  class AbstractPreconditioner
  {
  public:
    virtual void setLinearization(AbstractLinearization&) = 0;
    virtual void apply(AbstractFunctionSpaceElement const& x, AbstractFunctionSpaceElement& Px) = 0;
  };
 
 
  class AbstractFlushConnection
  {
  public:
    virtual ~AbstractFlushConnection(){}
    virtual void connectToSignalForFlush(boost::signals2::signal<void()>&) = 0;
  };
 
  class AbstractConnectedLinearization : public AbstractLinearization, public AbstractFlushConnection
  {};
 
  class AbstractFunctional
  {
  public:
    virtual double evaluate(AbstractFunctionSpaceElement const& x) const { assert(!"not implemented"); return 0; }
    virtual std::unique_ptr<AbstractLinearization> getLinearization(AbstractFunctionSpaceElement const& x) const = 0;
    virtual std::unique_ptr<AbstractFunctionSpaceElement> getImageVector(AbstractFunctionSpaceElement const& x) const = 0;
    virtual bool inDomain(AbstractFunctionSpaceElement const& x) const { return true; }
    virtual ~AbstractFunctional() {}
  };
 
  class AbstractParameters
  {
  public:
    virtual ~AbstractParameters() {}
  };
 
 
  template<typename ParameterType>
  class Parameters : public AbstractParameters
  {
  public:
    explicit Parameters(ParameterType const& p) : pref(p) {}
    ParameterType const& getPars() const {return pref;}
  private:
    ParameterType const& pref;
  };
 
  template<class ParameterType>
  Parameters<ParameterType> makePars(ParameterType const& p) { return Parameters<ParameterType>(p); }
 
 
  class AbstractParameterFunctional
  {
  public:
    virtual std::unique_ptr<AbstractFunctional> getFunctional(AbstractParameters const&) const = 0;
    virtual std::unique_ptr<AbstractFunctional> getParameterLinFunctional(AbstractParameters const& p) const
          { assert(!"ParameterFunctional: Linearization not Implemented"); return getFunctional(p);}
    virtual std::unique_ptr<AbstractFunctional> getLinFunctionValue(AbstractParameters const& p) const
          { assert(!"ParameterFunctional: Linearization not Implemented"); return getFunctional(p);}
    virtual ~AbstractParameterFunctional() {}
  };
 
  class AbstractNewtonDirection
  {
  public:
    void ordinary(AbstractFunctionSpaceElement& correction, AbstractLinearization& linearization)
    {  doSolve(correction, linearization);
    correction *= -1.0;
    }
    void simplified(AbstractFunctionSpaceElement& correction, AbstractLinearization const& linearization, AbstractLinearization const& oldlinearization) const
    {  doResolve(correction, linearization, oldlinearization);
    correction *= -1.0;
    }
 
    void simplified(AbstractFunctionSpaceElement& correction, AbstractLinearization const& linearization) const
    {  doResolve(correction, linearization);
    correction *= -1.0;
    }
 
    virtual void setRelativeAccuracy(double accuracy) = 0;
    virtual void setAbsoluteAccuracy(double) {}
    virtual double getRelativeAccuracy() = 0;
    virtual double getAbsoluteAccuracy() = 0;
 
    virtual bool improvementPossible() = 0;
 
    virtual bool changedGrid() { return false; }
 
    virtual ~AbstractNewtonDirection() {}
 
    virtual void doSolve(AbstractFunctionSpaceElement& correction,
        AbstractLinearization& lin) = 0;
    virtual void doResolve(AbstractFunctionSpaceElement& correction,
        AbstractLinearization const& lin,
        AbstractLinearization const& olin) const = 0;
 
    virtual void doResolve(AbstractFunctionSpaceElement& correction,
        AbstractLinearization const& lin) const = 0;
 
    mutable boost::signals2::signal<void()> changed;
  };
 
 
  class AbstractChart
  {
  public:
    virtual void addPerturbation
    (AbstractFunctionSpaceElement& newIterate,
        AbstractFunctionSpaceElement const& perturbation,
        AbstractLinearization const& lin,
        std::vector<std::shared_ptr<AbstractFunctionSpaceElement> > basis = std::vector<std::shared_ptr<AbstractFunctionSpaceElement> >()) const = 0;
 
    virtual std::unique_ptr<AbstractChart> clone() const = 0;
  };
 
 
  class AbstractNorm
  {
  public:
    virtual ~AbstractNorm(){}
    virtual double operator()(AbstractFunctionSpaceElement const&) const = 0;
    virtual void setOrigin(AbstractLinearization const&) {}
  };
 
  class AbstractScalarProduct : public AbstractNorm
  {
  public:
    virtual double operator()(AbstractFunctionSpaceElement const&, AbstractFunctionSpaceElement const&) const = 0;
    double operator()(AbstractFunctionSpaceElement const& v) const
    {
      double sc = this->operator()(v,v);
      if(sc < 0) std::cout << "Warning: scalar product not positive definite! Taking absolute value" << std::endl;
      return sqrt(std::fabs(sc));
    }
  };
 
  class AbstractErrorEstimate
  {
  public:
    virtual double absoluteError() const = 0;
    virtual ~AbstractErrorEstimate() {}
  };
 
  class AbstractErrorEstimator
  {
  public:
    virtual std::unique_ptr<AbstractErrorEstimate> createEstimate(AbstractFunctionSpaceElement const& correction,
        AbstractLinearization const& lin) const = 0;
    virtual ~AbstractErrorEstimator() {}
  };
 
  class AbstractAdaptiveGrid
  {
  public:
    virtual void adapt() = 0;
    virtual void mark(AbstractErrorEstimate&, double portion) = 0;
    virtual void flushMarks() = 0;
    virtual int size() = 0;
    virtual ~AbstractAdaptiveGrid() {}
 
    virtual int getNMarked() = 0;
 
    mutable boost::signals2::signal<void()> gridWillChange;
  };
 
  class AbstractHierarchicalErrorEstimator
  {
  public:
    virtual ~AbstractHierarchicalErrorEstimator(){}
 
    virtual void operator()(AbstractLinearization const& lin, AbstractFunctionSpaceElement const& x, AbstractFunctionSpaceElement const& dx, int, AbstractFunctionSpaceElement const& rhs) = 0;
 
    virtual void refineGrid() = 0;
 
    virtual double estimatedAbsoluteError() const = 0;
 
    virtual size_t gridSize() const = 0;
 
//    virtual void setNorm(AbstractNorm const&) = 0;
  };
 
  class ContinuousScalarFunction
  {
  public:
    virtual ~ContinuousScalarFunction() {}
    virtual double d0(std::vector<double> const&) const = 0;
  };
 
  class DifferentiableScalarFunction : public ContinuousScalarFunction
  {
  public:
    virtual ~DifferentiableScalarFunction() {}
 
    virtual std::vector<double> d1(std::vector<double> const&) const = 0;
  };
 
}  // namespace Kaskade
#endif