NonSmoothDynamicalSystem.hpp#

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

#include "SiconosPointers.hpp"
#include "Topology.hpp"
#include "DynamicalSystem.hpp"

class NonSmoothDynamicalSystem
{
public:
  typedef enum
  {
    addDynamicalSystem, rmDynamicalSystem, addInteraction, rmInteraction, clearTopology
  } ChangeType;

  class Change
  {
  private:
    ACCEPT_SERIALIZATION(NonSmoothDynamicalSystem::Change);
    Change() = default;
  public:
    ChangeType typeOfChange;
    SP::DynamicalSystem ds;
    SP::Interaction i;

    Change(ChangeType t, SP::DynamicalSystem dsnew ):typeOfChange(t),ds(dsnew){};
    Change(ChangeType t, SP::Interaction inew):typeOfChange(t),i(inew){};
    Change(ChangeType t):typeOfChange(t){};
    void display() const;
  };

  typedef std::list<Change> ChangeLog;
  class ChangeLogIter
  {
    ACCEPT_SERIALIZATION(NonSmoothDynamicalSystem::Change);
  public:
    ChangeLogIter(){};
    ChangeLogIter(const ChangeLog& log,
                  const ChangeLog::const_iterator& i)
      : _log(&log), it(i) {};
    const ChangeLog *_log;
    ChangeLog::const_iterator it;
  };

private:

  ACCEPT_SERIALIZATION(NonSmoothDynamicalSystem);

  double _t0 = 0.;

  double _t = _t0;

  double _T = 0.;

  std::string _title = "none",
    _author = "none",
    _description = "none",
    _date="unknown";

  bool _BVP = false;

  std::list<Change> _changeLog;

  SP::Topology _topology;

  bool _mIsLinear = true;

  NonSmoothDynamicalSystem(const NonSmoothDynamicalSystem& nsds) = delete;

  OneStepNSProblem& operator=(const OneStepNSProblem& osnsp) = delete;

protected:
  NonSmoothDynamicalSystem(){};

public:

  NonSmoothDynamicalSystem(double t0, double T);

  ~NonSmoothDynamicalSystem();

  inline double currentTime() const
  {
    return _t;
  }

  inline void setCurrentTime(double newValue)
  {
    _t = newValue;
  }

  inline double t0() const
  {
    return _t0;
  }

  inline void sett0(double newT0)
  {
    _t0 = newT0;
  };

  inline double finalT() const
  {
    return _T;
  }

  void setT(double newValue)
  {
    _T = newValue;
  };

  inline const std::string  title() const
  {
    return _title;
  }

  inline void setTitle(const std::string & s)
  {
    _title = s;
  }

  inline const std::string  author() const
  {
    return _author;
  }

  inline void setAuthor(const std::string & s)
  {
    _author = s;
  }

  inline const std::string  description() const
  {
    return _description;
  }

  inline void setDescription(const std::string & s)
  {
    _description = s;
  }

  inline const std::string  date() const
  {
    return _date;
  }

  inline void setDate(const std::string & s)
  {
    _date = s;
  }

  inline bool isBVP() const
  {
    return _BVP;
  }

  inline bool isIVP() const
  {
    return !_BVP;
  }

  inline void setBVP(const bool& newBvp)
  {
    _BVP = newBvp;
  }

  inline const ChangeLog& changeLog()
  {
    return _changeLog;
  };

  inline ChangeLogIter changeLogPosition()
  {
    ChangeLogIter it(_changeLog, _changeLog.end());

    --it.it;
    return it;
  };

  inline ChangeLogIter changeLogBegin()
  {
    ChangeLogIter it(_changeLog, _changeLog.begin());
    return it;
  };

  void clearChangeLogTo(const ChangeLogIter& it);

  inline size_t getNumberOfDS() const
  {
    return _topology->dSG(0)->size();
  }

  inline const SP::DynamicalSystemsGraph dynamicalSystems() const
  {
    return _topology->dSG(0);
  }

  std::vector<SP::DynamicalSystem> dynamicalSystemsVector() const;

  void insertDynamicalSystem(SP::DynamicalSystem ds);

  inline SP::DynamicalSystem dynamicalSystem(unsigned int nb) const
  {
    return _topology->getDynamicalSystem(nb);
  }
  inline void displayDynamicalSystems() const
  {
    _topology->displayDynamicalSystems();
  }

  void removeDynamicalSystem(SP::DynamicalSystem ds);

  inline size_t getNumberOfInteractions() const
  {
    return _topology->indexSet0()->size();
  };

  inline const SP::InteractionsGraph  interactions() const
  {
    return _topology->indexSet0();
  };

  void removeInteraction(SP::Interaction inter);

  inline SP::Interaction interaction(unsigned int nb) const
  {
    return _topology->getInteraction(nb);
  }

  inline SP::Interaction interaction(std::string name) const
  {
    return _topology->getInteraction(name);
  }

  std::vector<SP::Interaction> InteractionsVector() const;

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

  inline void setName(SP::DynamicalSystem ds, const std::string& name)
  {
    _topology->setName(ds, name);
  };

  std::string name(SP::DynamicalSystem ds)
  {
    return _topology->name(ds);
  }

  inline void setName(SP::Interaction interaction, const std::string& name)
  {
    _topology->setName(interaction, name);
  };

  std::string name(SP::Interaction inter)
  {
    return _topology->name(inter);
  }

  void setControlProperty(SP::Interaction inter, const bool isControlInteraction)
  {
    _topology->setControlProperty(inter, isControlInteraction);
  }

  inline SP::Topology topology() const
  {
    return _topology;
  }

  void display() const;

  inline bool isLinear() const
  {
    return _mIsLinear;
  };

  void clear();

  void setSymmetric(bool val);

  void resetNonSmoothPart(unsigned int level);

  void swapInMemory();

  void pushInteractionsInMemory();

  void updateDSPlugins(double time);

  void updateInput(double time, unsigned int level);

  void updateOutput(double time, unsigned int level = 0);

  void updateOutput(double time, unsigned int level_min, unsigned int level_max);

  void computeInteractionJacobians(double time);

  void computeInteractionJacobians(double time, InteractionsGraph& indexSet);

  void visitDynamicalSystems(SP::SiconosVisitor visitor);
};

#endif