spacetimehandler_base.h

Go to the documentation of this file.

#ifndef _SPACE_TIME_HANDLER_BASE_H_
#define _SPACE_TIME_HANDLER_BASE_H_

#include <lac/vector.h>
#include <lac/block_vector_base.h>
#include <lac/block_vector.h>

#include <vector>
#include <iostream>
#include <sstream>
#include <limits>

#include "timedofhandler.h"
#include "timeiterator.h"
#include "dopetypes.h"

namespace DOpE
{
template<typename VECTOR>//has to be a class template because you can not have virtual member function templates.
class SpaceTimeHandlerBase
{
  public:

    SpaceTimeHandlerBase(DOpEtypes::ControlType control_type = DOpEtypes::undefined) : _control_type(control_type)
    {
      _state_ticket = 1;
      _control_ticket = 1;
    }

    SpaceTimeHandlerBase(const dealii::Triangulation<1> & times, DOpEtypes::ControlType type = DOpEtypes::undefined) :
      _tdfh(times), _interval(_tdfh.first_interval()), _control_type(type)
    {
      _state_ticket = 1;
      _control_ticket = 1;
    }

    SpaceTimeHandlerBase(const dealii::Triangulation<1> & times,
        const dealii::FiniteElement<1>& fe,
        DOpEtypes::ControlType type = DOpEtypes::undefined) :
          _tdfh(times, fe), _interval(_tdfh.first_interval()), _control_type(type)
    {
      _state_ticket = 1;
      _control_ticket = 1;
    }


    virtual ~SpaceTimeHandlerBase()
    {
      _tdfh.clear();
    }

    void ReInitTime()
    {
      IncrementStateTicket();
      _tdfh.distribute_dofs();
      //FIXME When we have temporal discretization also for control and constraint,
      //one has to increment here the _control_ticket!
    }

    unsigned int GetMaxTimePoint() const
    {
      return (_tdfh.GetNbrOfDoFs()-1);//because we start counting at 0.
    }

    unsigned int GetNbrOfIntervals() const
    {
      return _tdfh.GetNbrOfIntervals();
    }


    void SetInterval(const TimeIterator& it)
    {
      _interval = it;
    }


    const TimeIterator& GetInterval() const
    {
      return _interval;
    }


    double GetTime(unsigned int time_point) const
    {

      return _tdfh.GetTime(time_point);
    }


    const TimeDoFHandler& GetTimeDoFHandler() const
    {
      return _tdfh;
    }


    const std::vector<double>& GetTimes() const
    {
      return _tdfh.GetTimes();
    }

    void
    GetTimes(const TimeIterator& interval, std::vector<double>& local_times) const
    {
      return _tdfh.GetTimes(interval, local_times);
    }


    bool IsValidStateTicket(unsigned int& ticket) const
    {
      bool ret = (ticket == _state_ticket);
      ticket = _state_ticket;
      return ret;
    }

    bool IsValidControlTicket(unsigned int& ticket) const
    {
      bool ret = (ticket == _control_ticket);
      ticket = _control_ticket;
      return ret;
    }


    DOpEtypes::ControlType GetControlType() const
    {
      return _control_type;
    }


    virtual void
      InterpolateControl(VECTOR& /*result*/, const std::vector<VECTOR*> &/*local_vectors*/,
          double /*t*/, const TimeIterator&/*interval*/) const { abort(); }
    virtual void
      InterpolateState(VECTOR& /*result*/, const std::vector<VECTOR*> &/*local_vectors*/,
                       double /*t*/, const TimeIterator&/*interval*/) const = 0;
    virtual void InterpolateConstraint(VECTOR& /*result*/, const std::vector<VECTOR*> &/*local_vectors*/,
        double /*t*/, const TimeIterator&/*interval*/) const { abort(); }

    virtual unsigned int GetControlNDoFs() const { abort(); }
    virtual unsigned int GetStateNDoFs(int time_point = -1) const = 0;
    virtual unsigned int GetConstraintNDoFs(std::string /*name*/) const { abort(); return 0; }
    virtual const std::vector<unsigned int>& GetControlDoFsPerBlock() const { abort(); }
    virtual const std::vector<unsigned int>& GetStateDoFsPerBlock(int time_point = -1) const = 0;
    virtual const std::vector<unsigned int>& GetConstraintDoFsPerBlock(std::string /*name*/) const { abort(); }
    virtual unsigned int  GetNGlobalConstraints() const { abort(); }
    virtual unsigned int  GetNLocalConstraints() const { abort(); }
    
    double GetStepSize() const
    {
      return _interval.get_k();
    }
    double GetNextStepSize() const
    {
      assert(_interval!= _tdfh.last_interval());
      double k = (++_interval).get_k();
      --_interval;
      return k;
    }
    double GetPreviousStepSize() const
    {
      assert(_interval!= _tdfh.first_interval());
      double k = (--_interval).get_k();
      ++_interval;
      return k;
    }


    virtual unsigned int NewTimePointToOldTimePoint(unsigned int t) const = 0;


    virtual void SpatialMeshTransferControl(const VECTOR& /*old_values*/, VECTOR& /*new_values*/) const { abort(); }
    
    virtual void SpatialMeshTransferState(const VECTOR& /*old_values*/, VECTOR& /*new_values*/) const { abort(); }

  protected:
    void IncrementStateTicket()
    {
      assert( _state_ticket < std::numeric_limits<unsigned int>::max());
      _state_ticket++;
    }

    void IncrementControlTicket()
    {
      assert( _control_ticket < std::numeric_limits<unsigned int>::max());
      _control_ticket++;
    }

  private:
    mutable TimeDoFHandler _tdfh;//FIXME Is it really necessary for _tdfh and _interval to be mutable? this is really ugly
    mutable TimeIterator _interval;

    unsigned int _control_ticket;
    unsigned int _state_ticket;
    mutable DOpEtypes::ControlType _control_type;
};

}

#endif