constraintvector.h

Go to the documentation of this file.

#ifndef _CONSTRAINT_VECTOR_H_
#define _CONSTRAINT_VECTOR_H_

#include "spacetimehandler_base.h"

#include <lac/vector.h>
#include <lac/block_vector_base.h>
#include <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, std::string behavior);
    ~ConstraintVector();

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

    std::string 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;
    std::string _behavior;
    unsigned int _sfh_ticket;
  };


}
#endif