statevector.h

Go to the documentation of this file.

#ifndef STATE_VECTOR_H_
#define STATE_VECTOR_H_

#include "spacetimehandler_base.h"
#include "parameterreader.h"
#include "dopetypes.h"

#include <deal.II/base/utilities.h>
#include <deal.II/lac/vector.h>
#include <deal.II/lac/block_vector_base.h>
#include <deal.II/lac/block_vector.h>

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

namespace DOpE
{
template<typename VECTOR>
class StateVector
{
        public:
    //FIXME this is not a real copyconstructor, it just
    //uses the information of ref about size and so on. Is this correct?
                StateVector(const StateVector<VECTOR>& ref);
                StateVector(const SpaceTimeHandlerBase<VECTOR>* STH, 
                            DOpEtypes::VectorStorageType behavior,
                            ParameterReader &param_reader);
                ~StateVector();

                void SetTimeDoFNumber(unsigned int dof_number,
                    const TimeIterator& interval) const;

//              /**
//               * Sets the time in the vector for interpolation. This Function or SetTimeDoFNumber
//               * or SetTimeDoFNumber must be called before calling GetSpacialVector
//               * in order to load the required data.
//               *
//               * @param t            A double containing the time we are interested in.
//     *
//               * @param interval      An TimeIterator. The interval containing t.
//               *
//               */
//              void SetTime(double t, const TimeIterator& interval) const;
                void SetTimeDoFNumber(unsigned int time_point) const;
                VECTOR& GetSpacialVector();
                const VECTOR& GetSpacialVector() const;
                VECTOR& GetNextSpacialVector();
                const VECTOR& GetNextSpacialVector() const;
                VECTOR& GetPreviousSpacialVector();
                const VECTOR& GetPreviousSpacialVector() const;
                const dealii::Vector<double>& GetSpacialVectorCopy() const;
                void operator=(double value);
                void operator=(const StateVector<VECTOR>& dq);
                void operator+=(const StateVector<VECTOR>& dq);
                void operator*=(double a);
                double operator*(const StateVector<VECTOR>& dq) const;
                void add(double s, const StateVector<VECTOR>& dq);
                void equ(double s, const StateVector<VECTOR>& dq);

                void PrintInfos(std::stringstream& out);
                void UnLockCopy() const
                {
                        lock_ = false;
                }
                DOpEtypes::VectorStorageType GetBehavior() const
                {
                        return behavior_;
                }
                const SpaceTimeHandlerBase<VECTOR>* GetSpaceTimeHandler() const
                {
                        return STH_;
                }
                void ReInit();

        private:
                struct SpatialVectorInfos
        {
            int size_;
            bool on_disc_;

            SpatialVectorInfos(int size = -1, bool on_disc = false)
            {
              size_ = size;
              on_disc_ = on_disc;
            }
            ;
        };
                void ReSizeSpace(unsigned int ndofs, const std::vector<unsigned int>& dofs_per_block) const;

                void MakeName(unsigned int time_point) const;
                void StoreOnDisc() const;
                void FetchFromDisc(unsigned int time_point, VECTOR & vector) const;
                bool FileExists(unsigned int time_point) const;
                void SwapPtr(VECTOR* & a,VECTOR* & b ) const;

                void ComputeLocalVectors(const TimeIterator& interval) const;

                void ResizeLocalVectors(unsigned int size) const;

                mutable std::vector<VECTOR*> state_;
                mutable std::vector<SpatialVectorInfos> state_information_;

                mutable VECTOR local_state_;
                mutable dealii::Vector<double> copy_state_;
                mutable int accessor_;

                mutable bool lock_;

                //Needed in the store_on_disc case for read/write operations on the hard disc
                mutable std::string filename_;
                mutable std::fstream filestream_;

                //Needed in the only_recent case to decide if the operation is allowed.
                mutable unsigned int current_dof_number_;
                
                //pointer to the dofs in the actual interval. Is only used if the interval is set!
                mutable std::vector<VECTOR*> local_vectors_;


                //Map: global time dof index - local time DoF index
                mutable std::map<unsigned int, unsigned int> global_to_local_;
                //the index of the interval, to which the vectors stored in local_vectors belong
                mutable int accessor_index_;

                DOpEtypes::VectorStorageType behavior_;
                std::string tmp_dir_;
                unsigned int sfh_ticket_;

                const SpaceTimeHandlerBase<VECTOR>* STH_;
                const unsigned int unique_id_;

                static unsigned int id_counter_;
                static unsigned int num_active_;
};

}
#endif