GranularBodySystem.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_GRANULARBODYSYSTEM_H
#define MOMENTUM_GRANULARBODYSYSTEM_H
 
#include "momentum_namespace.h"
#include "momentum_export.h"
 
#include <memory>
 
#include "Vec3.h"
#include "AffineMatrix4x4.h"
#include "GranularBody.h"
#include "DataBufferAccessor.h"
 
 
#ifndef SWIG
namespace agx
{
  namespace Physics
  {
    class GranularBodySystem;
    class GranularBodyPtr;
  }
}
 
namespace agxSDK
{
  class Simulation;
}
 
#endif
 
namespace MOMENTUM_NAMESPACE
{
  class Geometry;
  class ParticleDistribution;
 
  class MOMENTUM_EXPORT GranularBodySystem
  {
  public:
#ifndef SWIG
    GranularBodySystem();
 
 
    GranularBodySystem( agx::Physics::GranularBodySystem* );
#endif
 
    enum LatticeType
    {
      SQUARE_PACK = 0, 
      HEXAGONAL_CLOSE_PACK = 1 
    };
 
    GranularBodyVector getGranularBodies() const;
 
    GranularBodyVector getGranularBodies( const std::vector<unsigned int>& ids ) const;
 
    std::shared_ptr<GranularBody> getGranularBody( unsigned int id ) const;
 
    double getTranslationalEnergy() const;
 
    double getRotationalEnergy() const;
 
    double getTotalEnergy() const;
 
    std::shared_ptr<DataBufferAccessor> getDataBufferAccessor();
 
    GranularBodyVector filterBodiesInGeometry( const Geometry* geometry,
                                               const GranularBodyVector& granularBodies,
                                               bool onlyCheckForMidPoint ) const;
 
    GranularBodyVector getGranularBodiesInsideGeometry( const Geometry* geometry,
                                                        bool onlyCheckForMidPoint ) const;
 
    bool writeFile( const std::string& filename,
                    const GranularBodyVector& granularBodies ) const;
 
    bool writeFileFromGeometry( const std::string& filename,
                                const GranularBodyVector& granularBodies,
                                const Geometry* geometry ) const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void applyAirResistance( double dragCoefficient, double viscousCoeffcient );
 
    GranularBodyVector spawnGranularBodyLatticeInBound( const Vec3& min,
                                                        const Vec3& max,
                                                        double radius,
                                                        const Vec3& spacing,
                                                        double jitterFactor,
                                                        const Material* material,
                                                        LatticeType latticeType = SQUARE_PACK );
 
    GranularBodyVector spawnGranularBodyLatticeInBound( const Vec3& min,
                                                        const Vec3& max,
                                                        const ParticleDistribution* distribution,
                                                        const Vec3& spacing,
                                                        double jitterFactor,
                                                        const Material* material,
                                                        LatticeType latticeType = SQUARE_PACK );
 
    GranularBodyVector spawnGranularBodyLatticeInGeometry( const Geometry* geometry,
                                                           double radius,
                                                           const Vec3& spacing,
                                                           double jitterFactor,
                                                           const Material* material,
                                                           LatticeType latticeType = SQUARE_PACK );
 
    GranularBodyVector spawnGranularBodyLatticeInGeometry( const Geometry* geometry,
                                                           const ParticleDistribution* distribution,
                                                           const Vec3& spacing,
                                                           double jitterFactor,
                                                           const Material* material,
                                                           LatticeType latticeType = SQUARE_PACK );
 
    std::shared_ptr<GranularBody> createGranularBody( double radius, const Material* material );
 
    int removeGranularBodiesInsideGeometry( const Geometry* geometry, bool onlyCheckForMidPoint );
 
    bool loadFileGetBodies( const std::string& filename,
                            const Material* initialMaterial,
                            GranularBodyVector& granularBodies,
                            const AffineMatrix4x4& offset = AffineMatrix4x4() );
 
    bool loadFile( const std::string& filename,
                   const Material* initialMaterial,
                   const AffineMatrix4x4& offset = AffineMatrix4x4() );
 
#endif
 
#ifndef SWIG
    agx::Physics::GranularBodySystem* m_granularBodySystem;
#endif
  };
}
 
#endif