Program Listing for File SurfaceTension_Jeske2023.h

↰ Return to documentation for file (SPlisHSPlasH/SurfaceTension/SurfaceTension_Jeske2023.h)

#ifndef __SurfaceTension_Jeske2023_Surface_Tension_h__
#define __SurfaceTension_Jeske2023_Surface_Tension_h__

#include "SPlisHSPlasH/Common.h"
#include "SPlisHSPlasH/FluidModel.h"
#include "SPlisHSPlasH/NonPressureForceBase.h"
#include "SPlisHSPlasH/Utilities/MatrixFreeSolver.h"
#include "Utilities/Logger.h"

namespace SPH
{
    class SurfaceTension_Jeske2023 : public NonPressureForceBase
    {
    protected:
        Real m_surfaceTension;
        Real m_surfaceTensionBoundary;

        Real m_viscosity;
        Real m_boundaryViscosity;

        unsigned int m_maxIter;
        Real m_maxError;
        unsigned int m_iterations;
        std::vector<Vector3r> m_vDiff;
        std::vector<Real> m_gradRho;
        std::vector<Real> m_surfaceEnergy;
        std::vector<Real> m_color;
        std::vector<Vector3r> m_colorGrad;
        std::vector<Vector3r> m_nonlinearAcc;
        std::vector<Vector3r> m_nonlinearRes;
        std::vector<Vector3r> m_nonlinearGrad;

        Real m_tangentialDistanceFactor;
        bool m_weakPhaseCoupling;
        Real m_xsph;

        typedef Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, Eigen::IdentityPreconditioner> Solver;

        Solver m_solver;


        virtual void initParameters();

    public:
        static std::string METHOD_NAME;
        static int SURFACE_TENSION;
        static int SURFACE_TENSION_BOUNDARY;
        static int ITERATIONS;
        static int MAX_ITERATIONS;
        static int MAX_ERROR;
        static int VISCOSITY_COEFFICIENT;
        static int VISCOSITY_COEFFICIENT_BOUNDARY;
        static int XSPH;

        SurfaceTension_Jeske2023(FluidModel *model);
        virtual ~SurfaceTension_Jeske2023(void);

        static NonPressureForceBase* creator(FluidModel* model) { return new SurfaceTension_Jeske2023(model); }
        virtual std::string getMethodName() { return METHOD_NAME; }

        virtual void step();
        virtual void reset();

        virtual void performNeighborhoodSearchSort();

        static void matrixVecProd(const Real* vec, Real *result, void *userData);

        FORCE_INLINE const Vector3r& getVDiff(const unsigned int i) const
        {
            return m_vDiff[i];
        }

        FORCE_INLINE Vector3r& getVDiff(const unsigned int i)
        {
            return m_vDiff[i];
        }

        FORCE_INLINE void setVDiff(const unsigned int i, const Vector3r& val)
        {
            m_vDiff[i] = val;
        }

        FORCE_INLINE const Real& getDensityGrad(const unsigned int i) const
        {
            return m_gradRho[i];
        }

        FORCE_INLINE Real& getDensityGrad(const unsigned int i)
        {
            return m_gradRho[i];
        }

        FORCE_INLINE void setDensityGrad(const unsigned int i, const Real& val)
        {
            m_gradRho[i] = val;
        }

        void computeRHS(VectorXr &b, VectorXr &g);

        void applyForces(const VectorXr &x);

        Real getMaxSolverError(){ return m_maxError; }
        void setMaxSolverError(Real error){ m_maxError = error; }

        bool getWeakCoupling(){ return m_weakPhaseCoupling; }
        void setWeakCoupling(bool val){ m_weakPhaseCoupling = val; }

        bool getViscosity(){ return m_viscosity; }
        void setViscosity(Real val){ m_viscosity = val; }

        void computeDensityGradient();
    };
}

#endif