SphRepresentation.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013-2015, 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_PARTICLES_SPHREPRESENTATION_H
#define SURGSIM_PARTICLES_SPHREPRESENTATION_H

#include <Eigen/Core>
#include <vector>

#include "SurgSim/Math/Vector.h"
#include "SurgSim/Particles/Representation.h"


namespace SurgSim
{

namespace DataStructures
{
template <class T, size_t N>
class Grid;
}; // namespace DataStructures

namespace Particles
{

SURGSIM_STATIC_REGISTRATION(SphRepresentation);

class SphRepresentation : public Representation
{
public:
    SURGSIM_CLASSNAME(SurgSim::Particles::SphRepresentation);

    explicit SphRepresentation(const std::string& name);

    virtual ~SphRepresentation();

    void setMassPerParticle(double particleMass);

    double getMassPerParticle() const;

    void setDensity(double density);

    double getDensity() const;

    void setGasStiffness(double stiffness);

    double getGasStiffness() const;

    void setSurfaceTension(double surfaceTension);

    double getSurfaceTension() const;

    void setGravity(const SurgSim::Math::Vector3d& gravity);

    SurgSim::Math::Vector3d getGravity() const;

    void setViscosity(double viscosity);

    double getViscosity() const;

    void setKernelSupport(double support);

    double getKernelSupport() const;

    void setStiffness(double stiffness);

    double getStiffness() const;

    void setDamping(double damping);

    double getDamping() const;

    void setFriction(double friction);

    double getFriction() const;

protected:
    bool doInitialize() override;

    bool doUpdate(double dt) override;

    bool doHandleCollisions(double dt, const SurgSim::Collision::ContactMapType& collisions) override;

    void computeVelocityAndPosition(double dt);

    Eigen::Matrix<double, Eigen::Dynamic, 3, Eigen::RowMajor> m_normal;         
    Eigen::Matrix<double, Eigen::Dynamic, 3, Eigen::RowMajor> m_acceleration;   
    Math::Vector m_density;                         
    Math::Vector m_pressure;                        
    double m_mass;                                  
    double m_densityReference;                      
    double m_gasStiffness;                          
    double m_surfaceTension;                        
    double m_stiffness;                             
    double m_damping;                               
    double m_friction;                              
    SurgSim::Math::Vector3d m_gravity;              
    double m_viscosity;                             

    double m_h;
    double m_hSquared;
    double m_kernelPoly6;
    double m_kernelPoly6Gradient;
    double m_kernelSpikyGradient;
    double m_kernelViscosityLaplacian;
    double m_kernelPoly6Laplacian;

    std::shared_ptr<SurgSim::DataStructures::Grid<size_t, 3>> m_grid;

private:
    void computeNeighbors();

    void computeDensityAndPressureField();

    void computeNormalField();

    void computeAccelerations();

};

};  // namespace Particles
};  // namespace SurgSim

#endif  // SURGSIM_PARTICLES_SPHREPRESENTATION_H