Program listing for file kernel/src/simulationTools/OneStepIntegrator.hpp

• Return to documentation for this file

#ifndef ONESTEPINTEGRATOR_H
#define ONESTEPINTEGRATOR_H

#include "SiconosVisitor.hpp"
#include "SiconosException.hpp"
#include "SimulationTypeDef.hpp"
#include "OneStepIntegratorTypes.hpp"
#include "SimulationGraphs.hpp"
#include "Simulation.hpp"


class OneStepIntegrator :public std::enable_shared_from_this<OneStepIntegrator>
{

protected:

  ACCEPT_SERIALIZATION(OneStepIntegrator);


  OSI::TYPES _integratorType;


  SP::DynamicalSystemsGraph _dynamicalSystemsGraph;


  unsigned int _sizeMem;


  unsigned int _steps;


  unsigned int _levelMinForOutput;


  unsigned int _levelMaxForOutput;


  unsigned int _levelMinForInput;


  unsigned int _levelMaxForInput;

  bool _isInitialized;



  bool _explicitJacobiansOfRelation;




  SP::Simulation _simulation;


  OneStepIntegrator(const OSI::TYPES& type)
    : _integratorType(type), _sizeMem(1), _steps(0),
      _levelMinForOutput(0), _levelMaxForOutput(0),
      _levelMinForInput(0), _levelMaxForInput(0),
      _isInitialized(false), _explicitJacobiansOfRelation(false) {};


  SP::ExtraAdditionalTerms _extraAdditionalTerms;


  void _check_and_update_interaction_levels(Interaction& inter);


  SP::VectorOfVectors _initializeDSWorkVectors(SP::DynamicalSystem ds);


  OneStepIntegrator() {};

private:


  OneStepIntegrator(const OneStepIntegrator&);


  OneStepIntegrator& operator=(const OneStepIntegrator& OSI);


public:


  virtual ~OneStepIntegrator() {};


  inline OSI::TYPES getType() const
  {
    return _integratorType;
  }


  inline SP::DynamicalSystemsGraph dynamicalSystemsGraph() const
  {
    return _dynamicalSystemsGraph;
  };


  inline void setDynamicalSystemsGraph(SP::DynamicalSystemsGraph dsg)
  {
    _dynamicalSystemsGraph = dsg;
  };


  inline unsigned int getSizeMem() const
  {
    return _sizeMem;
  };


  inline SP::Simulation simulation() const
  {
    return _simulation;
  }


  inline void setSimulationPtr(SP::Simulation newS)
  {
    _simulation = newS;
  }


  virtual unsigned int levelMinForOutput()
  {
    return _levelMinForOutput;
  }


  virtual unsigned int levelMaxForOutput()
  {
    return _levelMaxForOutput;
  }


  virtual unsigned int levelMinForInput()
  {
    return _levelMinForInput;
  }


  virtual unsigned int levelMaxForInput()
  {
    return _levelMaxForInput;
  }


  virtual unsigned int numberOfIndexSets() const = 0;

  inline bool isInitialized(){return _isInitialized;};

  inline void setIsInitialized( bool value) {_isInitialized = value;};

  bool explicitJacobiansOfRelation()
  {
  return  _explicitJacobiansOfRelation;
  }

  void setExplicitJacobiansOfRelation(bool newval)
  {
    _explicitJacobiansOfRelation = newval;
  };


  virtual void initialize();


  virtual void initialize_nonsmooth_problems(){};


  virtual void initializeWorkVectorsForDS(double t, SP::DynamicalSystem ds) = 0 ;


  virtual void initializeWorkVectorsForInteraction(Interaction &inter,
                             InteractionProperties& interProp,
                             DynamicalSystemsGraph & DSG) = 0 ;



  void UpdateAndSwapAllOutput(double time);


  void UpdateAndSwapAllOutput(Interaction& inter, double time);


  virtual void computeInitialNewtonState(){

  }


  virtual double computeResidu(){

    THROW_EXCEPTION("OneStepIntegrator::computeResidu not implemented for integrator of type " + std::to_string(_integratorType));
    return 0.0;
  }


  virtual void computeFreeState()
  {

    THROW_EXCEPTION("OneStepIntegrator::computeFreeState not implemented for integrator of type " + std::to_string(_integratorType));
  }


  virtual void computeFreeOutput(InteractionsGraph::VDescriptor& vertex_inter, OneStepNSProblem* osnsp)
  {

    THROW_EXCEPTION("OneStepIntegrator::computeFreeOutput not implemented for integrator of type " + std::to_string(_integratorType));
  }


  virtual double computeResiduOutput(double time, SP::InteractionsGraph indexSet);

  virtual double computeResiduInput(double time, SP::InteractionsGraph indexSet);


  virtual void integrate(double& tinit, double& tend, double& tout, int& idid) = 0;


  void resetAllNonSmoothParts();


  void resetNonSmoothPart(unsigned int level);


  virtual void updateState(const unsigned int level) = 0;


  void updateState() { updateState(0); }


  virtual void updateOutput(double time);


  virtual void updateInput(double time);


  virtual void updateOutput(double time, unsigned int level);


  virtual void updateInput(double time, unsigned int level);

  virtual void prepareNewtonIteration(double time) = 0;


  virtual void display() = 0;


  virtual bool addInteractionInIndexSet(SP::Interaction inter, unsigned int i)
  {
    THROW_EXCEPTION("OneStepIntegrator::addInteractionInIndexSet - Should be called at this level");
    return 0;
  }
  ;


  virtual bool removeInteractionFromIndexSet(SP::Interaction inter, unsigned int i)
  {
    THROW_EXCEPTION("OneStepIntegrator::removeInteractionFromIndexSet - Should not be called at this level");
    return 0;
  };


  inline SP::ExtraAdditionalTerms extraAdditionalTerms()
  {
    return _extraAdditionalTerms;
  }


  inline void setExtraAdditionalTerms(SP::ExtraAdditionalTerms eat)
  {
    _extraAdditionalTerms = eat;
  }

  inline bool checkOSI(DynamicalSystemsGraph::VIterator dsi)
  {
    return  (_dynamicalSystemsGraph->properties(*dsi).osi.get()) == this;
  };


  inline bool checkOSI(DynamicalSystemsGraph::VDescriptor dsgv)
  {
    return  (_dynamicalSystemsGraph->properties(dsgv).osi.get()) == this;
  };


  inline bool checkInteractionOSI(InteractionsGraph & indexSet0, InteractionsGraph::VIterator ui)
  {
    return  (indexSet0.properties(*ui).osi1.get()) == this;
  };

  virtual SiconosVector& osnsp_rhs(InteractionsGraph::VDescriptor& vertex_inter,  InteractionsGraph& indexSet) = 0;


  VIRTUAL_ACCEPT_VISITORS(OneStepIntegrator);

};

#endif