statespacetimehandler.h

Go to the documentation of this file.

#ifndef _STATE_SPACE_TIME_HANDLER_H_
#define _STATE_SPACE_TIME_HANDLER_H_

#include "spacetimehandler_base.h"
#include "active_fe_index_setter_interface.h"
#include "dataout_wrapper.h"

#include <lac/vector.h>
#include <lac/block_vector_base.h>
#include <lac/block_vector.h>
#include <lac/constraint_matrix.h>
#include <dofs/dof_handler.h>
#include <deal.II/multigrid/mg_dof_handler.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>

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

namespace DOpE
{
  template<template<int, int> class FE, template<int, int> class DH, typename SPARSITYPATTERN,
      typename VECTOR, int dealdim>
    class StateSpaceTimeHandler : public SpaceTimeHandlerBase<VECTOR>
    {
      public:
        StateSpaceTimeHandler() :
            SpaceTimeHandlerBase<VECTOR>()
        {
          _domain_dofhandler_vector.resize(1);
        }
        StateSpaceTimeHandler(const dealii::Triangulation<1> & times) :
            SpaceTimeHandlerBase<VECTOR>(times)
        {
          _domain_dofhandler_vector.resize(1);
        }
        StateSpaceTimeHandler(
            const ActiveFEIndexSetterInterface<dealdim>& index_setter) :
            SpaceTimeHandlerBase<VECTOR>(), _fe_index_setter(&index_setter)
        {
          _domain_dofhandler_vector.resize(1);
        }
        StateSpaceTimeHandler(const dealii::Triangulation<1> & times,
            const ActiveFEIndexSetterInterface<dealdim>& index_setter) :
            SpaceTimeHandlerBase<VECTOR>(times), _fe_index_setter(&index_setter)
        {
          _domain_dofhandler_vector.resize(1);
        }
        virtual
        ~StateSpaceTimeHandler()
        {
        }

        virtual void
        ReInit(unsigned int state_n_blocks,
            const std::vector<unsigned int>& state_block_component) =0;

        /******************************************************/

        virtual const DOpEWrapper::DoFHandler<dealdim, DH>&
        GetStateDoFHandler() const =0;

        /******************************************************/

        virtual const DOpEWrapper::Mapping<dealdim, DH>&
        GetMapping() const = 0;

        /******************************************************/

        const std::vector<const DOpEWrapper::DoFHandler<dealdim, DH>*>&
        GetDoFHandler() const
        {
          _domain_dofhandler_vector[0] = &GetStateDoFHandler();
          return _domain_dofhandler_vector;
        }

        /******************************************************/

        std::vector<
            typename DOpEWrapper::DoFHandler<dealdim, DH>::active_cell_iterator>
        GetDoFHandlerBeginActive() const
        {
          std::vector<
              typename DOpEWrapper::DoFHandler<dealdim, DH>::active_cell_iterator> ret(
              this->GetDoFHandler().size());
          for (unsigned int dh = 0; dh < this->GetDoFHandler().size(); dh++)
          {
            ret[dh] = this->GetDoFHandler()[dh]->begin_active();
          }
          return ret;
        }

        /******************************************************/

        std::vector<
            typename DOpEWrapper::DoFHandler<dealdim, DH>::active_cell_iterator>
        GetDoFHandlerEnd() const
        {
          std::vector<
              typename DOpEWrapper::DoFHandler<dealdim, DH>::active_cell_iterator> ret(
              this->GetDoFHandler().size());
          for (unsigned int dh = 0; dh < this->GetDoFHandler().size(); dh++)
          {
            ret[dh] = this->GetDoFHandler()[dh]->end();
          }
          return ret;
        }


        /******************************************************/

        std::vector<
            typename DOpEWrapper::DoFHandler<dealdim, DH>::cell_iterator>
        GetDoFHandlerBeginActiveAllLevels() const
        {
          std::vector<
              typename DOpEWrapper::DoFHandler<dealdim, DH>::cell_iterator> ret(
              this->GetDoFHandler().size());
          for (unsigned int dh = 0; dh < this->GetDoFHandler().size(); dh++)
          {
            ret[dh] = this->GetDoFHandler()[dh]->begin_active();
          }
          return ret;
        }

        /******************************************************/

        std::vector<
            typename DOpEWrapper::DoFHandler<dealdim, DH>::cell_iterator>
        GetDoFHandlerEndAllLevels() const
        {
          std::vector<
              typename DOpEWrapper::DoFHandler<dealdim, DH>::cell_iterator> ret(
              this->GetDoFHandler().size());
          for (unsigned int dh = 0; dh < this->GetDoFHandler().size(); dh++)
          {
            ret[dh] = this->GetDoFHandler()[dh]->end();
          }
          return ret;
        }



        /******************************************************/

        unsigned int
        GetStateIndex()
        {
          return 0;
        }

        /******************************************************/
        const ActiveFEIndexSetterInterface<dealdim>&
        GetFEIndexSetter() const
        {
          //makes only sense in the hp case.
          return *_fe_index_setter;
        }

        /******************************************************/
        /*
         * This function sets for every cell the right fe index for the state variable.
         * This is only useful in the hp case!
         *
         * @param dof_handler   The dof_handler for which the fe indices have to be set.
         */
        void
        SetActiveFEIndicesState(
            DOpEWrapper::DoFHandler<dealdim, DH>& dof_handler)
        {
          if (dof_handler.NeedIndexSetter())
          {
            for (typename DH<dealdim, dealdim>::active_cell_iterator element =
                dof_handler.begin_active(); element != dof_handler.end(); ++element)
            {
              this->GetFEIndexSetter().SetActiveFEIndexState(element);
            }
          }
        }

        /******************************************************/
        /*
         * Experimental status for MG prec
         */ 
        virtual const dealii::MGConstrainedDoFs & 
          GetMGConstrainedDoFs() const
          {
            throw DOpEException(
                "Not used for normal DofHandler",
                "StateSpaceTimeHandler.h");

          }

        /******************************************************/
        virtual const dealii::Triangulation<dealdim>&
          GetTriangulation() const
        {
          throw DOpEException(
                              "Not used for normal DofHandler",
                              "StateSpaceTimeHandler.h"); 

        }



        /******************************************************/

        virtual unsigned int
        GetStateDoFsPerBlock(unsigned int b, int time_point = -1) const =0;

        /******************************************************/

        virtual const std::vector<unsigned int>&
        GetStateDoFsPerBlock(int time_point = -1) const =0;

        /******************************************************/

        virtual const dealii::ConstraintMatrix &
        GetStateDoFConstraints() const=0;

        /*******************************************************/

        virtual const std::vector<dealii::Point<dealdim> > &
        GetMapDoFToSupportPoints()=0;

        /******************************************************/

        virtual void
        ComputeStateSparsityPattern(SPARSITYPATTERN & sparsity) const=0;

        /******************************************************/

        virtual void
          ComputeMGStateSparsityPattern(dealii::MGLevelObject<dealii::BlockSparsityPattern> & /*mg_sparsity_patterns*/,
                                        unsigned int /*n_levels*/) const
        {
           throw DOpEException(
                "Not used for normal DofHandler",
                "StateSpaceTimeHandler.h");
        }

        /******************************************************/

        virtual void
          ComputeMGStateSparsityPattern(dealii::MGLevelObject<dealii::SparsityPattern> & /*mg_sparsity_patterns*/,
                                        unsigned int /*n_levels*/) const
        {
           throw DOpEException(
                "Not used for normal DofHandler",
                "StateSpaceTimeHandler.h");
        }


        /******************************************************/
        virtual const FE<dealdim, dealdim>&
        GetFESystem(std::string name) const=0;

        /******************************************************/

        DOpEWrapper::DataOut<dealdim, DH>&
        GetDataOut()
        {
          _data_out.clear();
          return _data_out;
        }

      protected:
        //we need this here, because we know the type of the DoFHandler in use.
        //This saves us a template argument for statpdeproblem etc.
        DOpEWrapper::DataOut<dealdim, DH> _data_out;
        const ActiveFEIndexSetterInterface<dealdim>* _fe_index_setter;
        mutable std::vector<const DOpEWrapper::DoFHandler<dealdim, DH>*> _domain_dofhandler_vector;

    };
}

#endif