timeiterator.h

Go to the documentation of this file.

#ifndef _TIMEITERATOR_H_
#define _TIMEITERATOR_H_

#include <deal.II/dofs/dof_handler.h>
#include <dofs/dof_accessor.h>

#include <grid/tria_iterator.h>

namespace DOpE
{
  namespace IteratorState
  {

    enum IteratorStates
    {
      valid,
      past_the_end,
      before_the_beginning,
      invalid
    };
  }

  typedef dealii::DoFHandler<1>::active_cell_iterator active_cell_it;


  class TimeIterator
  {
    public:
      //constructors

      TimeIterator()
      {
        _present_index = -3;//i.e. invalid
      }

      TimeIterator(const active_cell_it& element, int present_index) :
        _element(element)
      {
        _present_index = present_index;
      }

      TimeIterator(const TimeIterator& it)
      {
        _element = it._element;
        _present_index = it._present_index;
      }

      IteratorState::IteratorStates
      GetState() const
      {
        if (_present_index >= 0 && _present_index
            < static_cast<int>(_element->get_triangulation().n_active_cells()))
          return IteratorState::valid;
        else
          {
            if (_present_index == -1)
              return IteratorState::past_the_end;
            else
              {
                if (_present_index == -2)
                  return IteratorState::before_the_beginning;
                else
                  return IteratorState::invalid;
              }
          }
      }

      int
      GetIndex() const
      {
        return _present_index;
      }

      TimeIterator&
      operator=(const TimeIterator& element)
      {
        _element = element._element;
        _present_index = element._present_index;
        return *this;
      }

      void
      Initialize(const active_cell_it& element, int present_index)
      {
        _element = element;
        _present_index = present_index;
      }

      bool
      operator==(const TimeIterator& element)
      {
        if (GetState() == element.GetState())
          return (_element == element.get_element());
        else
          return false;
      }

      bool
      operator!=(const TimeIterator& element)
      {
        if (GetState() == element.GetState())
          return (_element != element.get_element());
        else
          return true;
      }

      double
      get_center() const
      {
        assert(GetState()==IteratorState::valid);
        return _element->center()(0);
      }

      double
      get_left() const
      {
        assert(GetState()==IteratorState::valid);
        return _element->face(0)->center()(0);
      }

      double
      get_right() const
      {
        assert(GetState()==IteratorState::valid);
        return _element->face(1)->center()(0);
      }

      double
      get_k() const
      {
        assert(GetState()==IteratorState::valid);
        return _element->diameter();
      }

      const active_cell_it&
      get_element() const
      {
        return _element;
      }

      void
      get_time_dof_indices(std::vector<unsigned int>& local_dof_indices) const
      {
        assert(GetState()==IteratorState::valid);
        _element->get_dof_indices(local_dof_indices);
      }

      TimeIterator &
      operator++()
      {
        assert(GetState()==IteratorState::valid);
        ++_present_index;
        if (_present_index < static_cast<int>(_element->get_triangulation().n_active_cells()))
          {
            _element = _element->neighbor(1);
          }
        else
          {
            _present_index = -1;
          }

        return *this;
      }

      TimeIterator
      operator++(int)
      {
        assert(GetState()==IteratorState::valid);
        TimeIterator tmp(_element, _present_index);

        ++_present_index;
        if (_present_index < static_cast<int>(_element->get_triangulation().n_active_cells()))
          {
            _element = _element->neighbor(1);
          }
        else
          {
            _present_index = -1;
          }
        return tmp;
      }

      TimeIterator&
      operator--()
      {
        assert(GetState()==IteratorState::valid);
        --_present_index;
        if (_present_index >= 0)
          {
            _element = _element->neighbor(0);
          }
        else
          {
            _present_index = -2;
          }

        return *this;
      }

      TimeIterator
      operator--(int)
      {
        assert(GetState()==IteratorState::valid);
        TimeIterator tmp(_element, _present_index);
        if (_present_index >= 0)
          {
            _element = _element->neighbor(0);
          }
        else
          {
            _present_index = -2;
          }
        return tmp;
      }
    private:
      active_cell_it _element;
      int _present_index;
  };
}

#endif /* TIMEITERATOR_H_ */