controlvector.h

Go to the documentation of this file.

#ifndef CONTROL_VECTOR_H_
#define CONTROL_VECTOR_H_

#include "spacetimehandler_base.h"
#include "dopetypes.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>


namespace DOpE
{

template<typename VECTOR>
  class ControlVector
  {
  public:
    //TODO: Currently we only consider one fixed control 
    //      for all timesteps, if more is desired one needs to augment the 
    //      Spacetimehandler to have a time discretization for the control,
    //      Then one can update this vector similar to the statevector 
    //      with different meshes for Vectors.
    //      Note that this requires to keep track of the interpolation
    //      between state and control time points...
    ControlVector(const ControlVector& ref);
    ControlVector(const SpaceTimeHandlerBase<VECTOR>* STH, DOpEtypes::VectorStorageType behavior);
    ~ControlVector();

//    /**
//     * Sets the time in the vector. This Function 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. If t doesn't match the time given by
//     *                     time_point, then an interpolation between the corresponding time_points is
//     *                                       computed.
//     * @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;
    const dealii::Vector<double>& GetSpacialVectorCopy() const;

    void operator=(double value);
    void operator=(const ControlVector& dq);
    void operator+=(const ControlVector& dq);
    void operator*=(double a);
    double operator*(const ControlVector& dq) const;
    void add(double s, const ControlVector& dq);
    void equ(double s, const ControlVector& dq);
    void max(const ControlVector& dq);
    void min(const ControlVector& dq);

    void comp_mult(const ControlVector& dq);
    
    void comp_invert();
    
    void init_by_sign(double smaller, double larger, double unclear, double TOL = 1.e-10);
    
    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();
 
    double Norm(std::string name,std::string restriction = "all") const;

  private:
    void ReSizeSpace(unsigned int ndofs, const std::vector<unsigned int>& dofs_per_block);
    void ComputeLocalVectors(const TimeIterator& interval) const;
    
    std::vector<VECTOR* > control_;
    mutable VECTOR local_control_;
    mutable dealii::Vector<double> copy_control_;
    
    //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_;
                
    mutable int accessor_;
    mutable bool lock_;

    const SpaceTimeHandlerBase<VECTOR>* STH_;
    DOpEtypes::VectorStorageType behavior_;
    DOpEtypes::ControlType c_type_;
    unsigned int sfh_ticket_;
  };


}
#endif