include/Solver.h

Go to the documentation of this file.

#ifndef SOLVER_H
#define SOLVER_H

#include "vector"

#include "ngl/TransformStack.h"
#include "ngl/Obj.h"
#include "ngl/BBox.h"

#include "ShaderLibrary.h"
#include "Neighbour.h"
#include "Environment.h"
#include "FluidParticle.h"

typedef std::vector<FluidParticle> ParticleVector;


class Solver
{
public:
    Solver();

    ~Solver();

    void updateFluid
            (
                Environment* io_environment,
                Integration* _integration
            );

    void initialiseDrawing();

    void render
            (
                ngl::TransformStack _txStack,
                ShaderLibrary* io_sman,
                const std::string _shader
            );

    void injectParticles();

    std::vector<std::vector<ngl::Vector> > getPositionList();

    std::vector<std::string> getNameList();

    inline void toggleNextHoseableFluid()
    {
        m_currentHoseableFluid = ++m_currentHoseableFluid % m_hoseParticlePrototypeList.size();
        std::cout << "New Hoseable Fluid Id : " << m_currentHoseableFluid << "\n";
    }

    inline void setCurrentHoseableFluid(const int _v) { m_currentHoseableFluid = _v; }

    inline bool getEnableAutoFluidUpdate() const { return m_enableAutoFluid; }

    inline void toggleEnableAutoFluidUpdate() { m_enableAutoFluid ^= true; }

    inline ngl::Real getSmoothingLength() const { return m_smoothingLength; }

    inline bool getDrawHoseMarker() const { return m_drawHoseMarker; }

    inline ngl::Vector getHoseCenter() const { return m_hoseCenter; }

    inline ngl::Vector getHoseVelocity() const { return m_hoseVelocity; }

    inline bool getHoseWaitUntilHitBoundary() const { return m_hoseWaitUntilHitBoundary; }

    inline bool getHoseWaitUntilHitRBD() const { return m_hoseWaitUntilHitRBD; }

    inline void setHoseWaitUntilHitBoundary(const bool _v) { m_hoseWaitUntilHitBoundary = _v; }

    inline void setHoseWaitUntilHitRBD(const bool _v) { m_hoseWaitUntilHitRBD = _v; }

    inline void setDrawHoseMarker(const bool _v) { m_drawHoseMarker = _v; }

    inline void setHoseCenter(const ngl::Vector _v) { m_hoseCenter = _v; }

    inline void setHoseVelocity(const ngl::Vector _v) { m_hoseVelocity = _v; }

    inline void setSmoothingLength(const ngl::Real _v)
    {
        m_smoothingLength = _v;
        m_neighbour->setCellSize(_v);
    }

    inline std::vector<FluidParticle> getHoseParticlePrototypeList() const { return m_hoseParticlePrototypeList; }

    void updateRestDensityForFluid
                (
                    const int _fluidId,
                    const ngl::Real _restDensity
                );

    void updateGasConstantForFluid
                (
                    const int _fluidId,
                    const ngl::Real _gasConstant
                );

    void updateViscosityConstantForFluid
                (
                    const int _fluidId,
                    const ngl::Real _viscosityConstant
                );

    void updateSurfaceCoefficientForFluid
                (
                    const int _fluidId,
                    const ngl::Real _coefficient
                );

    void updateSurfaceThresholdForFluid
                (
                    const int _fluidId,
                    const ngl::Real _threshold
                );

    void updateInterfaceCoefficientForFluid
                (
                    const int _fluidId,
                    const ngl::Real _coefficient
                );

    void updateInterfaceThresholdForFluid
                (
                    const int _fluidId,
                    const ngl::Real _threshold
                );

    void updateInterfaceColorForFluid
                (
                    const int _fluidId,
                    const ngl::Real _color
                );


private:
    std::vector<FluidParticle> m_particleList;

    std::vector<ParticleVector> m_neighbourForParticleList;

    ngl::Real m_smoothingLength;

    bool m_enableAutoFluid;

    Neighbour* m_neighbour;

    ngl::Real m_weightPoly;

    ngl::Real m_weightPolyGradient;

    ngl::Real m_weightPolyLaplacian;

    ngl::Real m_weightPressureGradient;

    ngl::Real m_weightViscosityLaplacian;

    std::vector<FluidParticle> m_hoseParticlePrototypeList;

    std::vector<FluidParticle> m_hoseParticleList;

    int m_currentHoseableFluid;

    ngl::Vector m_hoseInitialCenter;

    ngl::Vector m_hoseCenter;

    ngl::Vector m_hoseVelocity;

    bool m_drawHoseMarker;

    bool m_hoseWaitUntilHitBoundary;

    bool m_hoseWaitUntilHitRBD;

    int m_iteration;

private:
    ngl::Real WKernel_Poly(const ngl::Real _separationLength);

    ngl::Vector WKernel_Poly_Gradient(const ngl::Vector _separationVector);

    ngl::Real WKernel_Poly_Laplacian(const ngl::Real _separationLength);

    ngl::Vector WKernel_Pressure_Gradient(const ngl::Vector _separationVector);

    ngl::Real WKernel_Viscosity_Laplacian(const ngl::Real _separationLength);

    ngl::Vector normalise(const ngl::Vector _vector);

    int getFluidIdFromName(const std::string _name);


};

#endif // SOLVER_H