constraintvector.h

Go to the documentation of this file.

#ifndef CONSTRAINT_VECTOR_H_
#define CONSTRAINT_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 ConstraintVector
  {
  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...
    ConstraintVector(const ConstraintVector& ref);
    ConstraintVector(const SpaceTimeHandlerBase<VECTOR>* STH, DOpEtypes::VectorStorageType behavior);
    ~ConstraintVector();

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

    bool HasType(std::string name) const;
   
    VECTOR& GetSpacialVector(std::string name);

    const VECTOR& GetSpacialVector(std::string name) const;
    
    const dealii::Vector<double>& GetGlobalConstraints() const;
    dealii::Vector<double>& GetGlobalConstraints();
    void operator=(double value);
    void operator=(const ConstraintVector& dq);
    void operator+=(const ConstraintVector& dq);
    void operator*=(double a);
    double operator*(const ConstraintVector& dq) const;
    void add(double s, const ConstraintVector& dq);
    void equ(double s, const ConstraintVector& dq);

    void PrintInfos(std::stringstream& out);

    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;

    virtual bool
      IsFeasible() const;
    virtual bool
      IsEpsilonFeasible(double eps) const;
    
    virtual bool
      IsLargerThan(double eps) const;
   
     
    virtual double
      Complementarity(const ConstraintVector<VECTOR>& g) const;

  private:
    void ReSizeLocalSpace(unsigned int ndofs, const std::vector<unsigned int>& dofs_per_block);

    void ReSizeGlobal(unsigned int ndofs);

    std::vector<VECTOR* > local_control_constraint_;
    mutable VECTOR local_constraint_control_;

    dealii::Vector<double> global_constraint_;

    mutable int accessor_;

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


}
#endif