Simulation.h

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material without having a written signed agreement with Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
#ifndef MOMENTUM_SIMULATION_H
#define MOMENTUM_SIMULATION_H
 
#include "momentum_export.h"
#include "momentum_namespace.h"
 
#include <memory>
 
#include "macros.h"
#include "Vec3.h"
#include "RigidBody.h"
#include "Observer.h"
#include "Joint.h"
#include "MaterialPair.h"
#include "GranularBodySystem.h"
#include "GranularContacts.h"
#include "ScalarColorMap.h"
#include "BodyDistribution.h"
#include "Emitter.h"
#include "Material.h"
#include "Geometry.h"
#include "ContactPoint.h"
#include "PrismaticJoint.h"
#include "CylindricalJoint.h"
#include "ConveyorBelt.h"
#include "BallJoint.h"
#include "LockJoint.h"
#include "SpringJoint.h"
#include "HingeJoint.h"
#include "Sensor.h"
#include "CustomBuffer.h"
#include <agx/ContactForceReader.h>
#include <agx/GranularContactForceReader.h>
 
#ifndef SWIG
namespace agxSDK
{
  class Simulation;
  class SimulationController;
}
#endif
 
namespace MOMENTUM_NAMESPACE
{
  class Simulation;
 
  MOMENTUM_EXPORT Simulation * getSimulation();
 
  class MOMENTUM_EXPORT Simulation
  {
  public:
 
    enum ContactType
    {
      IMPACT = 1,
      RESTING = 2,
      IMPACT_AND_RESTING = (IMPACT & RESTING)
    };
 
 
#ifndef SWIG
    Simulation(agxSDK::Simulation* simulation, agxSDK::SimulationController* simulationController);
 
#endif
 
    Simulation();
 
    ~Simulation();
 
    Vec3 getGravity() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setGravity(const Vec3& gravity);
 
    void setImpactSpeedThreshold( double threshold );
#endif
 
    double getImpactSpeedThreshold() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    std::shared_ptr< RigidBody > createRigidBodyFromBodyModel( const BodyModel* bodymodel,
                                                               const Vec3& position,
                                                               const Quat& rotation,
                                                               const Vec3& velocity );
#endif
 
    double getTimeStep() const;
 
 
    RigidBodyVector getRigidBodies() const;
 
    JointVector getJoints() const;
 
    HingeJointVector getHingeJoints() const;
 
    PrismaticJointVector getPrismaticJoints() const;
 
    CylindricalJointVector getCylindricalJoints() const;
 
    BallJointVector getBallJoints() const;
 
    LockJointVector getLockJoints() const;
 
    SpringJointVector getSpringJoints() const;
 
    ObserverVector getObservers() const;
 
    ConveyorBeltVector getConveyorBelts() const;
 
    MaterialPairVector getMaterialPairs() const;
 
    MaterialVector getMaterials() const;
 
    GeometryVector getGeometries() const;
 
    ContactPointVector getContacts(const RigidBody* body1, const RigidBody* body2 = nullptr) const;
 
    ContactPointVector getContacts(const Geometry* geometry1 = nullptr, const Geometry* geometry2 = nullptr) const;
 
    Vec3 getContactForces(const RigidBody* body1, const RigidBody* body2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setScalarColorMap(const std::shared_ptr<ScalarColorMap>& scalarColorMap);
#endif
    std::shared_ptr<ScalarColorMap> getScalarColorMap() const;
 
    Vec3 getContactForces(const RigidBody* rb, const Geometry* geo, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getContactForces(const Geometry* geometry1, const Geometry* geometry2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getNormalContactForces(const RigidBody* body1, const RigidBody* body2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getNormalContactForces(const RigidBody* rb, const Geometry* geo, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getNormalContactForces(const Geometry* geometry1, const Geometry* geometry2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getFrictionContactForces(const RigidBody* body1, const RigidBody* body2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getFrictionContactForces(const RigidBody* rb, const Geometry* geo, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getFrictionContactForces(const Geometry* geometry1, const Geometry* geometry2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteContactForces(const RigidBody* body1, const RigidBody* body2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteContactForces(const RigidBody* rb, const Geometry* geo, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteContactForces(const Geometry* geometry1, const Geometry* geometry2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteNormalContactForces(const RigidBody* body1, const RigidBody* body2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteNormalContactForces(const RigidBody* rb, const Geometry* geo, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteNormalContactForces(const Geometry* geometry1, const Geometry* geometry2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteFrictionContactForces(const RigidBody* body1, const RigidBody* body2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteFrictionContactForces(const RigidBody* rb, const Geometry* geo, ContactType type = IMPACT_AND_RESTING);
 
    Vec3 getSumAbsoluteFrictionContactForces(const Geometry* geometry1, const Geometry* geometry2=nullptr, ContactType type = IMPACT_AND_RESTING);
 
    std::shared_ptr<RigidBody> getRigidBody(const std::string& name) const;
 
    std::shared_ptr<Joint> getJoint(const std::string& name) const;
 
    std::shared_ptr<HingeJoint> getHingeJoint(const std::string& name) const;
 
    std::shared_ptr<PrismaticJoint> getPrismaticJoint(const std::string& name) const;
 
    std::shared_ptr<CylindricalJoint> getCylindricalJoint(const std::string& name) const;
 
    std::shared_ptr<BallJoint> getBallJoint(const std::string& name) const;
 
    std::shared_ptr<LockJoint> getLockJoint(const std::string& name) const;
 
    std::shared_ptr<SpringJoint> getSpringJoint(const std::string& name) const;
 
    std::shared_ptr<Observer> getObserver(const std::string& name) const;
 
    std::shared_ptr<Material> getMaterial(const std::string& name) const;
 
    std::shared_ptr<MaterialPair> getMaterialPair(Material* firstMaterial, Material* secondMaterial) const;
 
    std::shared_ptr<MaterialPair> getMaterialPair(const std::string& firstName, const std::string& secondName) const;
 
    std::shared_ptr<Geometry> getGeometry( const std::string& name ) const;
 
    std::shared_ptr<Geometry> getGeometry( unsigned int id ) const;
 
    std::shared_ptr<ConveyorBelt> getConveyorBelt( const std::string& name ) const;
 
    void addDisabledCollisionGroupPair(const std::string& name1, const std::string& name2);
 
    bool removeDisabledCollisionGroupPair(const std::string& name1, const std::string& name2);
 
    std::vector<std::pair<std::string, std::string>> getDisabledCollisionGroupPairs() const;
 
    std::shared_ptr<GranularBodySystem> getGranularBodySystem() const;
 
    RigidBodyVector getEmittedBodies() const;
 
    RigidBodyVector filterRigidBodiesInGeometry( const Geometry* geometry,
                                                 const RigidBodyVector& rigidBodies,
                                                 bool onlyCheckForMidPoint ) const;
 
    bool writeGranularFile( const std::string& filename,
                            const GranularBodyVector& granularBodies,
                            const RigidBodyVector& rigidBodies ) const;
 
    bool loadGranularFile( const std::string& filename,
                           Material* initMaterial,
                           const AffineMatrix4x4& offset = AffineMatrix4x4() );
 
    std::shared_ptr<Emitter> getEmitter(const std::string& name) const;
 
    EmitterVector getEmitters() const;
 
    std::shared_ptr<Sensor> getSensor( const std::string& name ) const;
 
    SensorVector getSensors() const;
 
    GranularRigidBodyContactVector getGranularGeometryContacts(const Geometry* geometry=nullptr) const;
 
    GranularRigidBodyContactVector getGranularRigidBodyContacts(const RigidBody* rigidBody=nullptr) const;
 
    GranularGranularContactVector getGranularContacts(const GranularBody* granularBody=nullptr) const;
 
    Vec3 getGranularRigidBodyContactForces(const RigidBody* body = nullptr);
 
    Vec3 getGranularGeometryContactForces(const Geometry* geometry = nullptr);
 
    Vec3 getGranularRigidBodyNormalContactForces(const RigidBody* body = nullptr);
 
    Vec3 getGranularGeometryNormalContactForces(const Geometry* geometry = nullptr);
 
    Vec3 getGranularRigidBodyFrictionContactForces(const RigidBody* body = nullptr);
 
    Vec3 getGranularGeometryFrictionContactForces(const Geometry* geometry = nullptr);
 
    Vec3 getGranularRigidBodySumAbsoluteContactForces(const RigidBody* body = nullptr);
 
    Vec3 getGranularGeometrySumAbsoluteContactForces(const Geometry* geometry = nullptr);
 
    Vec3 getGranularRigidBodySumAbsoluteNormalContactForces(const RigidBody* body = nullptr);
 
    Vec3 getGranularGeometrySumAbsoluteNormalContactForces(const Geometry* geometry = nullptr);
 
    Vec3 getGranularRigidBodySumAbsoluteFrictionContactForces(const RigidBody* body = nullptr);
 
    Vec3 getGranularGeometrySumAbsoluteFrictionContactForces(const Geometry* geometry = nullptr);
 
    std::shared_ptr<CustomBuffer> getCustomBuffer();
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
#endif
 
    size_t write( const std::string& filename );
 
    unsigned int getNumParallelRestingIterations() const;
 
    unsigned int getNumRestingIterations() const;
 
    unsigned int getNumImpactIterations() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
 
    void removeEmittedBodiesInGeometry( const Geometry* geometry );
#endif
 
    std::string __str__() const;
 
    bool operator==(const Simulation& other) const;
 
  protected:
 
  private:
    std::string getMaterialName(const std::string& name) const;
#ifndef SWIG
 
    agx::ContactForceReaderRef         m_contactForceReader;
    agx::GranularContactForceReaderRef m_granularContactForceReader;
    std::shared_ptr<ScalarColorMap>    m_scalarColorMap;
 
    friend Simulation *getSimulation();
#endif
  };
}
 
#endif