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 <base/utilities.h>
#include <lac/vector.h>
#include <lac/block_vector_base.h>
#include <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, std::string behavior,
                                                                ParameterReader &param_reader);
                ~StateVector();

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

                void SetTime(double t, const TimeIterator& interval) const;
                void SetTimeDoFNumber(unsigned int time_point) const;
                VECTOR& GetSpacialVector();
                const VECTOR& GetSpacialVector() 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;
                }
                std::string 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);

                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;//FIXME why is this not of type VECTOR??
                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;

                //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;

                std::string _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