timeiterator.h

Go to the documentation of this file.

#ifndef TIMEITERATOR_H_
#define TIMEITERATOR_H_

#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/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.getelement_());
        else
          return false;
      }

      bool
      operator!=(const TimeIterator& element)
      {
        if (GetState() == element.GetState())
          return (element_ != element.getelement_());
        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&
      getelement_() 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_ */