Simulation.hpp#

Return to documentation for this file
#ifndef SIMULATION_H
#define SIMULATION_H

#include <fstream>

#include "InteractionManager.hpp"
#include "NonSmoothDynamicalSystem.hpp"
#include "SiconosConst.hpp"
#include "SiconosFwd.hpp"
#include "SimulationTypeDef.hpp"

class Simulation : public std::enable_shared_from_this<Simulation> {
 protected:
  ACCEPT_SERIALIZATION(Simulation);

  std::string _name;

  SP::EventsManager _eventsManager;

  double _tinit;

  double _tend;

  double _tout;

  double _T;

  SP::OSISet _allOSI;

  SP::OneStepNSProblems _allNSProblems;

  SP::NonSmoothDynamicalSystem _nsds;

  SP::InteractionManager _interman;

  unsigned int _numberOfIndexSets;

  double _tolerance;

  bool _printStat;

  bool _staticLevels;

  std::ofstream statOut;

  bool _useRelativeConvergenceCriterion;

  bool _relativeConvergenceCriterionHeld;

  double _relativeConvergenceTol;

  bool _isInitialized;

  NonSmoothDynamicalSystem::ChangeLogIter _nsdsChangeLogPosition;

  std::map<SP::OneStepIntegrator, std::list<SP::DynamicalSystem> > _OSIDSmap;

 private:

  Simulation(const Simulation&);

  Simulation& operator=(const Simulation&);

 public:

  Simulation(){};

  Simulation(SP::NonSmoothDynamicalSystem nsds, SP::TimeDiscretisation td);

  Simulation(SP::TimeDiscretisation td);

  virtual ~Simulation();

  void clear();

  inline const std::string name() const { return _name; }

  inline void setName(const std::string& newName) { _name = newName; }

  double getTk() const;

  double getTkp1() const;

  double getTkp2() const;

  double currentTimeStep() const;

  inline SP::EventsManager eventsManager() const { return _eventsManager; };

  double startingTime() const;

  double nextTime() const;

  inline double timeStep() const { return (nextTime() - startingTime()); };

  bool hasNextEvent() const;

  inline const SP::OSISet oneStepIntegrators() const { return _allOSI; };

  inline size_t numberOfOSI() const { return _allOSI->size(); }

  virtual void insertIntegrator(SP::OneStepIntegrator osi);

  void associate(SP::OneStepIntegrator osi, SP::DynamicalSystem ds);

  SP::InteractionsGraph indexSet(unsigned int i);

  inline const SP::OneStepNSProblems oneStepNSProblems() const { return _allNSProblems; };

  inline size_t numberOfOSNSProblems() const { return _allNSProblems->size(); }

  SP::OneStepNSProblem oneStepNSProblem(int id);

  virtual void insertNonSmoothProblem(SP::OneStepNSProblem osns,
                                      int Id = SICONOS_OSNSP_DEFAULT);

  inline SP::NonSmoothDynamicalSystem nonSmoothDynamicalSystem() const { return _nsds; }

  void setNonSmoothDynamicalSystemPtr(SP::NonSmoothDynamicalSystem newPtr) {
    _nsdsChangeLogPosition = _nsds->changeLogBegin();
    _nsds = newPtr;
  }

  double tolerance() const { return _tolerance; };

  void setTolerance(double inputVal) { _tolerance = inputVal; };

  inline void setPrintStat(const bool& newVal) { _printStat = newVal; };

  inline bool getPrintStat() const { return _printStat; };
  virtual void computeInitialStateOfTheStep(){};

  void updateIndexSets();

  virtual void updateIndexSet(unsigned int level) = 0;

  virtual void initialize();

  virtual void initializeInteraction(double time, SP::Interaction inter);

  void insertInteractionManager(SP::InteractionManager manager) { _interman = manager; }

  void computeResidu();

  int computeOneStepNSProblem(int nb);

  virtual void updateDSPlugins(double time);

  virtual void updateInput(unsigned int level);

  virtual void updateAllInput();

  virtual void updateState(unsigned int level = 0);

  virtual void updateOutput(unsigned int level = 0);

  void update(unsigned int level = 0) {
    updateInput(level);
    updateState(level);
    updateOutput(level);
  }

  virtual void run();

  virtual void initializeOneStepNSProblem() = 0;

  virtual void advanceToEvent() = 0;

  void clearNSDSChangeLog();

  inline void setUseRelativeConvergenceCriteron(bool use) {
    _useRelativeConvergenceCriterion = use;
  };

  inline bool useRelativeConvergenceCriteron() { return _useRelativeConvergenceCriterion; };

  inline void setRelativeConvergenceTol(double v) { _relativeConvergenceTol = v; };

  inline double relativeConvergenceTol() { return _relativeConvergenceTol; };

  inline void setRelativeConvergenceCriterionHeld(bool newVal) {
    _relativeConvergenceCriterionHeld = newVal;
  };

  inline bool relativeConvergenceCriterionHeld() { return _relativeConvergenceCriterionHeld; };

  SP::SiconosVector lambda(unsigned int level = 0, unsigned int coor = 0);

  SP::SiconosVector y(unsigned int level = 0, unsigned int coor = 0);

  void processEvents();

  void setStaticLevels(bool b) { _staticLevels = b; }

  void updateT(double T);

  virtual bool computeResiduY() { return false; };

  virtual bool computeResiduR() { return false; };

  void link(SP::Interaction inter, SP::DynamicalSystem ds1,
            SP::DynamicalSystem ds2 = SP::DynamicalSystem());

  void unlink(SP::Interaction inter);

  void updateInteractions();

  virtual void updateWorldFromDS() { ; };

  void initializeOSIAssociations();

  void initializeNSDSChangelog();

  void applyNSDSChangelogForDS();

  void initializeIndexSets();

  virtual void firstInitialize();

  VIRTUAL_ACCEPT_VISITORS(Simulation);
};

#endif