DeformableRepresentation.h

Go to the documentation of this file.

// 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_DEFORMABLEREPRESENTATION_H
#define SURGSIM_PHYSICS_DEFORMABLEREPRESENTATION_H

#include <memory>

#include "SurgSim/Math/LinearSparseSolveAndInverse.h"
#include "SurgSim/Math/Matrix.h"
#include "SurgSim/Math/OdeEquation.h"
#include "SurgSim/Math/OdeSolver.h"
#include "SurgSim/Math/OdeState.h"
#include "SurgSim/Math/Vector.h"
#include "SurgSim/Physics/Representation.h"

namespace SurgSim
{

namespace Physics
{

class Localization;

class DeformableRepresentation :
    public Representation,
    public SurgSim::Math::OdeEquation
{
public:
    explicit DeformableRepresentation(const std::string& name);

    virtual ~DeformableRepresentation();

    void resetState() override;

    virtual void setInitialState(std::shared_ptr<SurgSim::Math::OdeState> initialState);

    virtual const std::shared_ptr<SurgSim::Math::OdeState> getCurrentState() const;

    virtual const std::shared_ptr<SurgSim::Math::OdeState> getPreviousState() const;

    virtual const std::shared_ptr<SurgSim::Math::OdeState> getFinalState() const;

    virtual void interpolatePreviousState(double t);

    size_t getNumDofPerNode() const;

    void setIntegrationScheme(SurgSim::Math::IntegrationScheme integrationScheme);

    SurgSim::Math::IntegrationScheme getIntegrationScheme() const;

    std::shared_ptr<SurgSim::Math::OdeSolver> getOdeSolver() const;

    void setLinearSolver(SurgSim::Math::LinearSolver linearSolver);

    SurgSim::Math::LinearSolver getLinearSolver() const;

    virtual void addExternalGeneralizedForce(std::shared_ptr<Localization> localization,
            const SurgSim::Math::Vector& generalizedForce,
            const SurgSim::Math::Matrix& K = SurgSim::Math::Matrix(),
            const SurgSim::Math::Matrix& D = SurgSim::Math::Matrix()) = 0;

    const SurgSim::Math::Vector& getExternalGeneralizedForce() const;

    const SurgSim::Math::SparseMatrix& getExternalGeneralizedStiffness() const;

    const SurgSim::Math::SparseMatrix& getExternalGeneralizedDamping() const;

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

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

    void update(double dt) override;

    void afterUpdate(double dt) override;

    void applyCorrection(double dt, const Eigen::VectorBlock<SurgSim::Math::Vector>& deltaVelocity) override;

    void deactivateAndReset();

    void setCollisionRepresentation(std::shared_ptr<SurgSim::Collision::Representation> representation) override;

    void setLocalPose(const SurgSim::Math::RigidTransform3d& pose) override;



protected:
    bool doInitialize() override;
    bool doWakeUp() override;

    virtual void transformState(std::shared_ptr<SurgSim::Math::OdeState> state,
                                const SurgSim::Math::RigidTransform3d& transform) = 0;

    std::shared_ptr<SurgSim::Math::OdeState> m_previousState;

    std::shared_ptr<SurgSim::Math::OdeState> m_currentState;

    std::shared_ptr<SurgSim::Math::OdeState> m_newState;

    std::shared_ptr<SurgSim::Math::OdeState> m_finalState;

    bool m_hasExternalGeneralizedForce;
    SurgSim::Math::Vector m_externalGeneralizedForce;
    SurgSim::Math::SparseMatrix m_externalGeneralizedStiffness;
    SurgSim::Math::SparseMatrix m_externalGeneralizedDamping;
    bool m_previousHasExternalGeneralizedForce;
    SurgSim::Math::SparseMatrix m_previousExternalGeneralizedStiffness;
    SurgSim::Math::SparseMatrix m_previousExternalGeneralizedDamping;

    size_t m_numDofPerNode;

    SurgSim::Math::IntegrationScheme m_integrationScheme;

    SurgSim::Math::LinearSolver m_linearSolver;

    std::shared_ptr<SurgSim::Math::OdeSolver> m_odeSolver;

private:
    DeformableRepresentation(const DeformableRepresentation&);

    DeformableRepresentation& operator =(const DeformableRepresentation&);
};

}; // namespace Physics

}; // namespace SurgSim

#endif // SURGSIM_PHYSICS_DEFORMABLEREPRESENTATION_H