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 <deal.II/lac/vector.h>
#include <deal.II/lac/block_vector_base.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/constraint_matrix.h>
#include <deal.II/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(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(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 dealii::ConstraintMatrix &
        GetStateDoFConstraints() const=0;

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

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

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

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

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

//        /**
//       * Experimental status: 
//         * Needed for MG prec.
//         */
//        virtual void
//        ComputeMGStateSparsityPattern(dealii::MGLevelObject<dealii::BlockSparsityPattern> & /*mg_sparsity_patterns*/,
//                                      unsigned int /*n_levels*/) const
//      {
//         throw DOpEException(
//                "Not used for normal DofHandler",
//                "StateSpaceTimeHandler.h");
//      }
//
//      /******************************************************/
//
//        /**
//         * Experimental status: 
//         * Needed for MG prec.
//         */
//        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