FemElement.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_FEMELEMENT_H
#define SURGSIM_PHYSICS_FEMELEMENT_H

#include <vector>

#include "SurgSim/Framework/ObjectFactory.h"
#include "SurgSim/Math/Matrix.h"
#include "SurgSim/Math/SparseMatrix.h"
#include "SurgSim/Math/Vector.h"
#include "SurgSim/Physics/Fem.h"

namespace SurgSim
{

namespace Math
{
class OdeState;
};

namespace Physics
{

class FemElement
{
public:
    FemElement();

    virtual ~FemElement();

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

    typedef SurgSim::Framework::ObjectFactory1<FemElement, std::shared_ptr<FemElementStructs::FemElementParameter>>
            FactoryType;

    static FactoryType& getFactory();

    size_t getNumDofPerNode() const;

    size_t getNumNodes() const;

    size_t getNodeId(size_t elementNodeId) const;

    const std::vector<size_t>& getNodeIds() const;

    void setYoungModulus(double E);
    double getYoungModulus() const;

    void setPoissonRatio(double nu);
    double getPoissonRatio() const;

    void setMassDensity(double rho);
    double getMassDensity() const;

    double getMass(const SurgSim::Math::OdeState& state) const;

    virtual double getVolume(const SurgSim::Math::OdeState& state) const = 0;

    virtual void addForce(SurgSim::Math::Vector* F, double scale) const;
    virtual void addForce(SurgSim::Math::Vector* F) const;

    virtual void addMass(SurgSim::Math::SparseMatrix* M, double scale) const;
    virtual void addMass(SurgSim::Math::SparseMatrix* M) const;

    virtual void addDamping(SurgSim::Math::SparseMatrix* D, double scale) const;
    virtual void addDamping(SurgSim::Math::SparseMatrix* D) const;

    virtual void addStiffness(SurgSim::Math::SparseMatrix* K, double scale) const;
    virtual void addStiffness(SurgSim::Math::SparseMatrix* K) const;

    virtual void addFMDK(SurgSim::Math::Vector* F,
                         SurgSim::Math::SparseMatrix* M,
                         SurgSim::Math::SparseMatrix* D,
                         SurgSim::Math::SparseMatrix* K) const;

    virtual void addMatVec(double alphaM, double alphaD, double alphaK,
                           const SurgSim::Math::Vector& x, SurgSim::Math::Vector* F,
                           SurgSim::Math::Vector* extractedX, SurgSim::Math::Vector* acumulator) const;

    bool isValidCoordinate(const SurgSim::Math::Vector& naturalCoordinate) const;

    virtual SurgSim::Math::Vector computeCartesianCoordinate(
        const SurgSim::Math::OdeState& state,
        const SurgSim::Math::Vector& naturalCoordinate) const = 0;

    virtual SurgSim::Math::Vector computeNaturalCoordinate(
        const SurgSim::Math::OdeState& state,
        const SurgSim::Math::Vector& cartesianCoordinate) const = 0;

    template <typename T, int Opt, typename StorageIndex>
    void assembleMatrixBlocks(const Eigen::Ref<const Math::Matrix>& subMatrix,
        const std::vector<size_t>& blockIds, size_t blockSize, Eigen::SparseMatrix<T, Opt, StorageIndex>* matrix) const;

    template <typename T, int Opt, typename StorageIndex>
    void assembleMatrixBlocksNoInitialize(const Eigen::Ref<const Math::Matrix>& subMatrix,
        const std::vector<size_t>& blockIds, size_t blockSize, Eigen::SparseMatrix<T, Opt, StorageIndex>* matrix) const;

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

protected:
    void setNumDofPerNode(size_t numDofPerNode);

    virtual void doUpdateFMDK(const Math::OdeState& state, int options) = 0;

    void initializeFMDK();

    virtual void doInitializeFMDK();

    size_t m_numDofPerNode;

    std::vector<size_t> m_nodeIds;

    SurgSim::Math::Vector m_f;

    SurgSim::Math::Matrix m_K;

    SurgSim::Math::Matrix m_M;

    SurgSim::Math::Matrix m_D;

    bool m_useDamping;

    double m_rho;

    double m_E;

    double m_nu;

};

} // namespace Physics

} // namespace SurgSim

#include "SurgSim/Physics/FemElement-inl.h"

#endif // SURGSIM_PHYSICS_FEMELEMENT_H