Interaction.hpp#

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

#include "RelationNamespace.hpp"
#include "SiconosPointers.hpp"
#include "SiconosVector.hpp"
#include "SiconosMemory.hpp"
#include "SiconosAlgebraTypeDef.hpp"
#include <vector>

class Interaction : public std::enable_shared_from_this<Interaction >
{
private:

  ACCEPT_SERIALIZATION(Interaction);

  static size_t __count;

  size_t _number;

  unsigned int _lowerLevelForOutput = 0;

  unsigned int _upperLevelForOutput = 0;

  unsigned int _lowerLevelForInput = 0;

  unsigned int _upperLevelForInput = 0;

  unsigned int _interactionSize = 0;

  unsigned int _sizeOfDS = 0;

  bool _has2Bodies = false;

  VectorOfVectors _y;

  VectorOfMemories _yMemory;

  VectorOfVectors _lambda;

  VectorOfMemories _lambdaMemory;

  SP::NonSmoothLaw _nslaw;

  SP::Relation _relation;

  VectorOfBlockVectors _linkToDSVariables;

  VectorOfSMatrices _relationMatrices;

  VectorOfVectors _relationVectors;

  struct _setLevels;
  friend struct Interaction::_setLevels;

  Interaction(const Interaction& inter) = delete;
  Interaction& operator=(const Interaction&) = delete;

protected:
  Interaction() {}

private:

  void __initDataFirstOrder(VectorOfBlockVectors& DSlink, DynamicalSystem& ds1, DynamicalSystem& ds2);

  void __initDSDataFirstOrder(DynamicalSystem& ds, VectorOfBlockVectors& DSlink);

  void __initDataLagrangian(VectorOfBlockVectors& DSlink, DynamicalSystem& ds1, DynamicalSystem& ds2);

  void __initDSDataLagrangian(DynamicalSystem& ds, VectorOfBlockVectors& DSlink);

  void __initDataNewtonEuler(VectorOfBlockVectors& DSlink, DynamicalSystem& ds1, DynamicalSystem& ds2);

  void __initDSDataNewtonEuler(DynamicalSystem& ds, VectorOfBlockVectors& DSlink);

public:

  Interaction(SP::NonSmoothLaw NSL, SP::Relation rel);

  ~Interaction() {};

  void reset();

  void initializeLinkToDsVariables(DynamicalSystem& ds1,
                                   DynamicalSystem& ds2);

  void resetAllLambda() ;

  void resetLambda(unsigned int level);

  void initializeMemory(unsigned int steps);

  inline size_t number() const
  {
    return _number;
  }

  inline void setLowerLevelForOutput(const unsigned int newVal)
  {
    _lowerLevelForOutput = newVal;
  };

  inline void setUpperLevelForOutput(const unsigned int newVal)
  {
    _upperLevelForOutput = newVal;
  };

  inline unsigned int lowerLevelForOutput()
  {
    return _lowerLevelForOutput;
  };

  inline unsigned int  upperLevelForOutput()
  {
    return _upperLevelForOutput;
  };

  inline void setLowerLevelForInput(const unsigned int newVal)
  {
    _lowerLevelForInput = newVal;
  };

  inline void setUpperLevelForInput(const unsigned int newVal)
  {
    _upperLevelForInput = newVal;
  };

  inline unsigned int lowerLevelForInput()
  {
    return _lowerLevelForInput ;
  };

  inline unsigned int upperLevelForInput()
  {
    return _upperLevelForInput;
  };

  inline unsigned int dimension() const
  {
    return _interactionSize;
  }

  inline unsigned int getSizeOfDS() const
  {
    return _sizeOfDS;
  }

  void setHas2Bodies(bool val) {_has2Bodies = val;}

  bool has2Bodies() const {return _has2Bodies;}

  inline const SiconosVector getCopyOfy(const unsigned int i) const
  {
    assert(_y[i] && "_y[i]");
    return *(_y[i]);
  }

  inline const VectorOfVectors y() const
  {
    return _y;
  }

  inline SP::SiconosVector y(const unsigned int i) const
  {
    assert(_y[i]);
    return _y[i];
  }

  void setY(const VectorOfVectors& v);

  void setYPtr(const VectorOfVectors& v);

  void setY(const unsigned int i, const SiconosVector& v);

  void setYPtr(const unsigned int i, SP::SiconosVector v);

  inline SiconosMemory& yMemory(unsigned int level)
  {
    return _yMemory[level];
  }

  inline const SiconosVector& y_k(const unsigned int i) const
  {
    return _yMemory[i].getSiconosVector(0);
  }

  inline const VectorOfVectors getLambda() const
  {
    return _lambda;
  }

  inline const SiconosVector getLambda(const unsigned int i) const
  {
    assert(_lambda[i]);
    return *(_lambda[i]);
  }

  inline SP::SiconosVector lambda(const unsigned int i) const
  {
    assert(_lambda[i]);
    return _lambda[i];
  }

  inline SiconosMemory& lambdaMemory(unsigned int level)
  {
    return _lambdaMemory[level];
  }

  inline const SiconosVector& lambda_k(const unsigned int i) const
  {
    return _lambdaMemory[i].getSiconosVector(0);
  }

  void setLambda(const VectorOfVectors& v);

  void setLambdaPtr(const VectorOfVectors& v);

  void setLambda(const unsigned int i, const SiconosVector& newValue);

  void setLambdaPtr(const unsigned int i, SP::SiconosVector newPtr);

  inline SP::Relation relation() const
  {
    return _relation;
  }

  inline SP::NonSmoothLaw nonSmoothLaw() const
  {
    return _nslaw;
  }

  inline VectorOfBlockVectors & linkToDSVariables()
  {
    return _linkToDSVariables;
  };

  inline VectorOfVectors & relationVectors()
  {
    return _relationVectors;
  };

  inline VectorOfSMatrices & relationMatrices()
  {
    return _relationMatrices;
  };

  inline void setDSSizes(unsigned int s1)
  {
    _sizeOfDS = s1;
  }

  void swapInMemory();

  void display(bool brief = true) const;

  static inline size_t resetCount(size_t new_count=0)
  {
    size_t old_count = __count;
    __count = new_count;
    return old_count;
  };

  void computeOutput(double time, unsigned int derivativeNumber = 0);

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

  SP::SiconosMatrix getLeftInteractionBlock() const;

  SP::SiconosMatrix getLeftInteractionBlockForDS(unsigned int pos, unsigned int size,  unsigned int sizeDS) const;

  void getLeftInteractionBlockForDSProjectOnConstraints(unsigned int pos, SP::SiconosMatrix InteractionBlock) const;

  SP::SiconosMatrix  getRightInteractionBlockForDS(unsigned int pos, unsigned int sizeDS, unsigned size) const;

  void getExtraInteractionBlock(SP::SiconosMatrix InteractionBlock) const;

};

#endif