FemRepresentation.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SURGSIM_PHYSICS_FEMREPRESENTATION_H
#define SURGSIM_PHYSICS_FEMREPRESENTATION_H

#include <future>
#include <memory>

#include "SurgSim/DataStructures/IndexedLocalCoordinate.h"
#include "SurgSim/Math/Matrix.h"
#include "SurgSim/Math/SparseMatrix.h"
#include "SurgSim/Math/Vector.h"
#include "SurgSim/Physics/DeformableRepresentation.h"
#include "SurgSim/Physics/Fem.h"

namespace SurgSim
{

namespace Physics
{

class FemElement;

class FemRepresentation : public DeformableRepresentation
{
public:
    explicit FemRepresentation(const std::string& name);

    virtual ~FemRepresentation();

    virtual void loadFem(const std::string& filename) = 0;

    virtual void setFemElementType(const std::string& type);

    const std::string& getFemElementType() const;

    void addFemElement(const std::shared_ptr<FemElement> element);

    size_t getNumFemElements() const;

    std::shared_ptr<FemElement> getFemElement(size_t femElementId);

    double getTotalMass() const;

    double getRayleighDampingStiffness() const;

    double getRayleighDampingMass() const;

    void setRayleighDampingStiffness(double stiffnessCoef);

    void setRayleighDampingMass(double massCoef);

    virtual bool isValidCoordinate(const SurgSim::DataStructures::IndexedLocalCoordinate& coordinate) const;

    void beforeUpdate(double dt) override;

    void update(double dt) override;

    void setComplianceWarping(bool useComplianceWarping);

    bool getComplianceWarping() const;

    void setComplianceWarpingSynchronous(bool complianceWarpingSynchronous);

    bool isComplianceWarpingSynchronous() const;

    void setMassLumping(bool useMassLumping);

    bool getMassLumping() const;

    Math::Matrix applyCompliance(const Math::OdeState& state, const Math::Matrix& b) override;

    const SurgSim::Math::Matrix& getComplianceMatrix() const override;

    void updateFMDK(const SurgSim::Math::OdeState& state, int options) override;

protected:
    void addRayleighDampingForce(SurgSim::Math::Vector* f, const SurgSim::Math::OdeState& state,
                                 bool useGlobalMassMatrix = false, bool useGlobalStiffnessMatrix = false,
                                 double scale = 1.0);

    void addFemElementsForce(SurgSim::Math::Vector* f, const SurgSim::Math::OdeState& state, double scale = 1.0);

    void addGravityForce(SurgSim::Math::Vector* f, const SurgSim::Math::OdeState& state, double scale = 1.0);

    bool doInitialize() override;

    void updateComplianceMatrix(const SurgSim::Math::OdeState& state);

    virtual SurgSim::Math::Matrix getNodeTransformation(const SurgSim::Math::OdeState& state, size_t nodeId) const;

    virtual void calculateComplianceWarpingTransformation(const SurgSim::Math::OdeState& state);

    bool isInitialComplianceMatrixComputed() const;

    void setIsInitialComplianceMatrixComputed(bool flag);

    void computeF(const SurgSim::Math::OdeState& state) override;

    void computeM(const SurgSim::Math::OdeState& state) override;

    void computeD(const SurgSim::Math::OdeState& state) override;

    void computeK(const SurgSim::Math::OdeState& state) override;

    void computeFMDK(const SurgSim::Math::OdeState& state) override;

    std::vector<double> m_massPerNode; 

    std::vector<std::shared_ptr<FemElement>> m_femElements;

    std::string m_femElementType;

    bool m_useComplianceWarping; 

    bool m_isComplianceWarpingSynchronous;

    bool m_isInitialComplianceMatrixComputed; 

    SurgSim::Math::Matrix m_complianceWarpingMatrix; 

    Eigen::SparseMatrix<double> m_complianceWarpingTransformation;

    Eigen::SparseMatrix<double> m_complianceWarpingTransformationForCalculation;
    std::future<SurgSim::Math::Matrix> m_task;

private:
    struct
    {
        double massCoefficient;
        double stiffnessCoefficient;
    } m_rayleighDamping;

    bool m_useMassLumping;
};

} // namespace Physics
} // namespace SurgSim

#endif // SURGSIM_PHYSICS_FEMREPRESENTATION_H