Integrator.cuh

#ifndef PBAT_GPU_IMPL_XPBD_INTEGRATOR_H
#define PBAT_GPU_IMPL_XPBD_INTEGRATOR_H
 
#include "pbat/Aliases.h"
#include "pbat/gpu/Aliases.h"
#include "pbat/gpu/impl/common/Buffer.cuh"
#include "pbat/gpu/impl/contact/VertexTriangleMixedCcdDcd.cuh"
#include "pbat/gpu/impl/geometry/Bvh.cuh"
#include "pbat/sim/xpbd/Data.h"
#include "pbat/sim/xpbd/Enums.h"
 
#include <array>
#include <vector>
 
namespace pbat {
namespace gpu {
namespace impl {
namespace xpbd {
 
class Integrator
{
  public:
    using EConstraint                      = pbat::sim::xpbd::EConstraint;
    static auto constexpr kConstraintTypes = static_cast<int>(EConstraint::NumberOfConstraintTypes);
 
    using Data = pbat::sim::xpbd::Data;

    Integrator(Data const& data);
    void Step(GpuScalar dt, GpuIndex iterations, GpuIndex substeps);
    void SetCompliance(Eigen::Ref<GpuMatrixX const> const& alpha, EConstraint eConstraint);
    void SetFrictionCoefficients(GpuScalar muS, GpuScalar muK);
    void SetSceneBoundingBox(
        Eigen::Vector<GpuScalar, 3> const& min,
        Eigen::Vector<GpuScalar, 3> const& max);
    common::Buffer<GpuScalar> const& GetLagrangeMultiplier(EConstraint eConstraint) const;
    common::Buffer<GpuScalar> const& GetCompliance(EConstraint eConstraint) const;
 
    // Ideally, these would not be public, but nvcc will otherwise report that
    // "The enclosing parent function ("[...]") for an extended __device__ lambda
    // cannot have private or protected access within its class"
    void ProjectBlockNeoHookeanConstraints(GpuScalar dt, GpuScalar dt2);
    void ProjectClusteredBlockNeoHookeanConstraints(GpuScalar dt, GpuScalar dt2);
    void ProjectCollisionConstraints(GpuScalar dt, GpuScalar dt2);
 
  public:
    common::Buffer<GpuScalar, 3> x; 
    common::Buffer<GpuIndex, 4> T;  
 
    contact::VertexTriangleMixedCcdDcd cd; 
 
    common::Buffer<GpuScalar, 3> xt;   
    common::Buffer<GpuScalar, 3> xb;   
    common::Buffer<GpuScalar, 3> v;    
    common::Buffer<GpuScalar, 3> aext; 
    common::Buffer<GpuScalar> minv;    
    common::Buffer<GpuScalar> lame;    
    common::Buffer<GpuScalar> DmInv;   
    common::Buffer<GpuScalar> gamma;   
    std::array<common::Buffer<GpuScalar>, kConstraintTypes>
        lagrange; 
    std::array<common::Buffer<GpuScalar>, kConstraintTypes>
        alpha; 
    std::array<common::Buffer<GpuScalar>, kConstraintTypes>
        beta; 
 
    std::vector<Index> Pptr;       
    common::Buffer<GpuIndex> Padj; 
 
    std::vector<Index> SGptr;       
    common::Buffer<GpuIndex> SGadj; 
    common::Buffer<Index> Cptr;     
    common::Buffer<GpuIndex> Cadj;  
 
    common::Buffer<GpuScalar> muC;          
    GpuScalar muS;                          
    GpuScalar muK;                          
    Eigen::Vector<GpuScalar, 3> Smin, Smax; 
    GpuIndex mActiveSetUpdateFrequency;     
};
 
} // namespace xpbd
} // namespace impl
} // namespace gpu
} // namespace pbat
 
#endif // PBAT_GPU_IMPL_XPBD_INTEGRATOR_H