interfaceTrackingFvMesh.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2019 Zeljko Tukovic, FSB Zagreb.
    Copyright (C) 2020-2024 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

Class
    Foam::interfaceTrackingFvMesh

Description
    The interfaceTrackingFvMesh

SourceFiles
    interfaceTrackingFvMesh.C

\*---------------------------------------------------------------------------*/

#ifndef interfaceTrackingFvMesh_H
#define interfaceTrackingFvMesh_H

#include "dynamicMotionSolverFvMesh.H"
#include "regIOobject.H"
#include "faCFD.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "surfactantProperties.H"
#include "singlePhaseTransportModel.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

/*---------------------------------------------------------------------------*\
                    Class interfaceTrackingFvMesh Declaration
\*---------------------------------------------------------------------------*/

class interfaceTrackingFvMesh
:
    public dynamicMotionSolverFvMesh
{
    // Private Data

        //- Finite area mesh
        autoPtr<faMesh> aMeshPtr_;

        //- Free surface patch index
        label fsPatchIndex_;

        //- Free surface faPatch-es which do not move
        wordList fixedFreeSurfacePatches_;

        //- Free surface faPatch-es where wave shuld not reflect
        wordList nonReflectingFreeSurfacePatches_;

        //- Free surface patches for which point normals must be corrected
        wordList pointNormalsCorrectionPatches_;

        //- Is it free-surface points displacement direction
        //  parallel with free-surface point normals
        Switch normalMotionDir_;

        //- Free-surface points displacement direction
        //  if not normal motion direction
        vector motionDir_;

        //- Interface smoothing at the beginning of time step
        Switch smoothing_;

        //- Pure free-surface
        Switch pureFreeSurface_;

        //- Rigid free-surface
        Switch rigidFreeSurface_;

        //- Correct contact line point normals
        Switch correctContactLineNormals_;

        //- Surface tension coefficient of pure free-surface
        dimensionedScalar sigma0_;

        //- Fluid density
        dimensionedScalar rho_;

        //- Current interface tracking time index
        label timeIndex_;

        //- Free-surface velocity field
        mutable std::unique_ptr<areaVectorField> UsPtr_;

        //- Points which are attached to the free-surface A side faces
        //  and which defines the free-surface shape
        mutable std::unique_ptr<vectorIOField> controlPointsPtr_;

        //- Field which additionally determines
        //  the motion of free-surface points
        mutable std::unique_ptr<labelList> motionPointsMaskPtr_;

        //- Displacement direction of free-surface points
        mutable std::unique_ptr<vectorField> pointsDisplacementDirPtr_;

        //- Displacement direction of free-surface control points
        mutable std::unique_ptr<vectorField> facesDisplacementDirPtr_;

        //- Free-surface net flux
        mutable std::unique_ptr<areaScalarField> fsNetPhiPtr_;

        //- Free-surface flux
        mutable std::unique_ptr<edgeScalarField> phisPtr_;

        //- Free-surface surfactant concetration
        mutable std::unique_ptr<areaScalarField> surfactConcPtr_;

        //- Volume surfactant concetration
        mutable std::unique_ptr<volScalarField> bulkSurfactConcPtr_;

        //- Surface tension field
        mutable std::unique_ptr<areaScalarField> surfaceTensionPtr_;

        //- Surfactant properties
        mutable std::unique_ptr<surfactantProperties> surfactantPtr_;

        //- Contact angle
        mutable std::unique_ptr<areaScalarField> contactAnglePtr_;


    // Private Member Functions

        // Make demand-driven data

            //- Create free surface velocity field
            void makeUs() const;

            //- Create control points
            void makeControlPoints();

            //- Create motion points mask
            void makeMotionPointsMask();

            //- Create points and control point motion direction
            void makeDirections();

            //- Create free surface net flux
            void makeFsNetPhi() const;

            //- Create free-surface flux
            void makePhis();

            //- Create surfactant volume concentration field
            void makeBulkSurfactConc() const;

            //- Create surfactant concentration field
            void makeSurfactConc() const;

            //- Create surface tension field
            void makeSurfaceTension() const;

            //- Create surfactant properties
            void makeSurfactant() const;

            //- Create contact angle
            void makeContactAngle();

        //- No copy construct
        interfaceTrackingFvMesh(const interfaceTrackingFvMesh&) = delete;

        //- No copy assignment
        void operator=(const interfaceTrackingFvMesh&) = delete;

        //- Initialize data
        void initializeData();

        //- Update control points end displacement directions
        void updateDisplacementDirections();

        //- Initialize control points position
        void initializeControlPointsPosition();

        //- Calculate free surface points displacement
        //  for given new control points position
        tmp<vectorField> pointDisplacement();

        //- Calc least sqare plane point and normal
        tmp<vectorField> lsPlanePointAndNormal
        (
            const vectorField& points,
            const vector& origin,
            const vector& axis
        ) const;

        //- Smooth free-surface mesh
        void smoothFreeSurfaceMesh();

        //- Update free-surface flux
        void updateSurfaceFlux();

        //- Update free-surface surfactant concentration
        void updateSurfactantConcentration();

        //- Calculate total pressure force
        vector totalPressureForce() const;

        //- Calculate total viscous force
        vector totalViscousForce() const;

        //- Calculate total surface tension force
        vector totalSurfaceTensionForce() const;

        //- Maximal surface tension based Courant number
        scalar maxCourantNumber();

        //- Update properties
        void updateProperties();

        //- Correct free surface point normals at contact line
        void correctContactLinePointNormals();

        //- Correct free surface point displacement next to fixed contact line
        void correctPointDisplacement
        (
            const scalarField& sweptVolCorr,
            vectorField& displacement
        );

public:

    //- Runtime type information
    TypeName("interfaceTrackingFvMesh");


    // Constructors

        //- Construct from IOobject
        interfaceTrackingFvMesh(const IOobject& io, const bool doInit=true);
/*
        //- Construct from components without boundary.
        //  Boundary is added using addFvPatches() member function
        interfaceTrackingFvMesh
        (
            const IOobject& io,
            pointField&& points,
            faceList&& faces,
            labelList&& allOwner,
            labelList&& allNeighbour,
            const bool syncPar = true
        );
*/

    //- Destructor
    ~interfaceTrackingFvMesh();


    // Member Functions

        //- Initialise all non-demand-driven data
        virtual bool init(const bool doInit);

        fvMesh& mesh()
        {
            return *this;
        }

        const fvMesh& mesh() const
        {
            return *this;
        }

        //- Return reference to finite area mesh
        faMesh& aMesh()
        {
            return aMeshPtr_();
        }

        //- Return reference to finite area mesh
        const faMesh& aMesh() const
        {
            return aMeshPtr_();
        }

        const label& fsPatchIndex() const
        {
            return fsPatchIndex_;
        }

        //- Pure free-surface
        Switch pureFreeSurface() const noexcept
        {
            return pureFreeSurface_;
        }

        //- Rigid free-surface
        Switch rigidFreeSurface() const noexcept
        {
            return rigidFreeSurface_;
        }

        //- Rigid free-surface
        Switch& rigidFreeSurface() noexcept
        {
            return rigidFreeSurface_;
        }

        //- Correct contact line point normals
        Switch correctContactLineNormals() const noexcept
        {
            return correctContactLineNormals_;
        }

        //- Correct contact line point normals
        Switch& correctContactLineNormals() noexcept
        {
            return correctContactLineNormals_;
        }

        //- Surface tension coefficient of pure free-surface
        const dimensionedScalar& sigma() const
        {
            return sigma0_;
        }

        //- Return free-surface velocity field
        areaVectorField& Us();

        //- Return free-surface velocity field
        const areaVectorField& Us() const;

        //- Return free-surface net flux
        const areaScalarField& fsNetPhi() const;

        //- Return free-surface net flux
        areaScalarField& fsNetPhi();

        //- Correct surface velocity boundary conditions
        void correctUsBoundaryConditions();

        //- Update free-surface velocity field
        void updateUs();

        //- Return constant reference to velocity field
        const volVectorField& U() const;

        //- Return constant reference to pressure field
        const volScalarField& p() const;

        //- Return constant reference to velocity field
        const surfaceScalarField& phi() const;

        //- Return free surface normal derivative of velocity
        tmp<vectorField> freeSurfaceSnGradU();

        //- Return free surface normal derivative of normal velocity comp
        tmp<scalarField> freeSurfaceSnGradUn();

        //- Return free surface pressure jump
        tmp<scalarField> freeSurfacePressureJump();

        //- Return control points
        vectorField& controlPoints();

        //- Return reference to motion points mask field
        labelList& motionPointsMask();

        //- Return reference to point displacement direction field
        vectorField& pointsDisplacementDir();

        //- Return reference to control points displacement direction field
        vectorField& facesDisplacementDir();

        //- Motion direction swithc
        bool normalMotionDir() const
        {
            return normalMotionDir_;
        }

        //- Return free-surface fluid flux field
        edgeScalarField& Phis();

        //- Return free-surface surfactant concentration field
        areaScalarField& surfactantConcentration();

        //- Return free-surface surfactant concentration field
        const areaScalarField& surfactantConcentration() const;

        //- Return volume surfactant concentration field
        volScalarField& bulkSurfactantConcentration();

        //- Return volume surfactant concentration field
        const volScalarField& bulkSurfactantConcentration() const;

        //- Return surface tension field
        areaScalarField& surfaceTension();

        //- Return surface tension field
        const areaScalarField& surfaceTension() const;

        //- Return surface tension gradient
        tmp<areaVectorField> surfaceTensionGrad();

        //- Return surfactant properties
        const surfactantProperties& surfactant() const;

        //- Update the mesh for both mesh motion and topology change
        virtual bool update();

        //- Clear control points
        void clearControlPoints()
        {
            controlPointsPtr_.reset(nullptr);
        }

        //- Write VTK freeSurface mesh
        void writeVTK() const;

        //- Write VTK freeSurface control points
        void writeVTKControlPoints();
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //