imstkPbdModelConfig.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkPbdCollisionConstraint.h"
#include "imstkPbdFemConstraint.h"
#include "imstkPbdConstraintFunctor.h"
#include "imstkDataTracker.h"

#include <unordered_map>
#include <unordered_set>

namespace imstk
{
class PbdModelConfig
{
public:
    enum class ConstraintGenType
    {
        Custom,
        Distance,
        FemTet,
        Volume,
        Area,
        Bend,
        Dihedral,
        ConstantDensity
    };

public:
    void enableConstraint(ConstraintGenType type, const double stiffness, const int bodyId = 2);

    void enableDistanceConstraint(const double stiffness, const double stretch, const int bodyId);

    void enableBendConstraint(const double stiffness, const int stride, const bool restLength0 = true, const int bodyId = 2);

    void enableConstantDensityConstraint(const double stiffness,
                                         const double particleRadius, const double restDensity = 6378.0, const int bodyId = 2);

    void enableFemConstraint(PbdFemConstraint::MaterialType material, const int bodyId = 2);

    void enableFemConstraint(PbdFemConstraint::MaterialType material, double youngsModulus, double poissonRatio, const int bodyId);

    void computeElasticConstants();

    void addPbdConstraintFunctor(std::shared_ptr<PbdConstraintFunctor> functor)
    {
        m_functors[ConstraintGenType::Custom].push_back(functor);
    }

    void addPbdConstraintFunctor(std::function<void(PbdConstraintContainer&)> functor)
    {
        m_functors[ConstraintGenType::Custom].push_back(
            std::make_shared<PbdConstraintFunctorLambda>(functor));
    }

    std::unordered_map<ConstraintGenType, std::vector<std::shared_ptr<PbdConstraintFunctor>>>& getFunctors() { return m_functors; }

    void setBodyDamping(const int bodyId,
                        const double linearDampCoeff, const double angularDampCoeff = 0.01);

    double getLinearDamping(const int bodyId);
    double getAngularDamping(const int bodyId);

public:
    double m_linearDampingCoeff  = 0.01;      
    double m_angularDampingCoeff = 0.01;      

    unsigned int m_iterations = 10;           
    double       m_dt     = 0.01;             
    bool m_doPartitioning = true;             

    Vec3d m_gravity = Vec3d(0.0, -9.81, 0.0); 

    std::shared_ptr<PbdFemConstraintConfig> m_femParams =
        std::make_shared<PbdFemConstraintConfig>(PbdFemConstraintConfig
        {
            0.0,                // Lame constant, if constraint type is FEM
            0.0,                // Lame constant, if constraint type is FEM
            1000.0,             // FEM parameter, if constraint type is FEM
            0.2                 // FEM parameter, if constraint type is FEM
            });

    PbdConstraint::SolverType m_solverType = PbdConstraint::SolverType::xPBD;

    std::unordered_map<int, double> m_bodyLinearDampingCoeff;  
    std::unordered_map<int, double> m_bodyAngularDampingCoeff; 

    std::shared_ptr<DataTracker> m_dataTracker;

protected:
    friend class PbdModel;

    std::unordered_map<ConstraintGenType, std::vector<std::shared_ptr<PbdConstraintFunctor>>> m_functors;
};
} // namespace imstk