Program Listing for File ODEWallModelFvPatchScalarField.H

↰ Return to documentation for file (wallModels/ODEWallModelFvPatchScalarField.H)

/*---------------------------------------------------------------------------* \
License
    This file is part of libWallModelledLES.

    libWallModelledLES 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.

    libWallModelledLES 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 libWallModelledLES.
    If not, see <http://www.gnu.org/licenses/>.

Class
    Foam::ODEWallModelFvPatchScalarField

@brief
    Base abstract class for ODE-based wall models.

    All the models are based on the following equation

    \f[
        \frac{\partial}{\partial y}
        \left[ (\nu + \nu_t)\frac{\partial U_i}{\partial y}\right] = F_i,
    \f]

    where i corresponds to the two wall-parallel coordinates.
    If the source term F is not dependent on y this can be integrated to give
    \f[
         \tau_{w,i} =
            \left(
                U_i|_h -
                F_i \int^h_0 \frac{y}{\nu + \nu_t}dy
            \right)
            \bigg  /
            \int^h_0 \frac{dy}{\nu + \nu_t}
    \f]

    The integration is performed using an adaptive quadrature.

    The friction velocity can then be expressed through the
    magnitude of the the wall-parallel component of velocity and the source
    term.
    Note that no ODE is actually being solved, only numerical integration.

    All ODE wall models require an eddy viscosity model. All share the following
    parameters
    - maxIter, the amount of iterations in the coupling loop between the wall
    shear stress and the eddy viscosity values.
    - eps, the relative error tolerance for the convergence of the wall shear
    stress.

Contributors/Copyright:
    2016-2026 Timofey Mukha
    2017      Saleh Rezaeiravesh

SourceFiles
    ODEWallModelFvPatchScalarField.C

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

#ifndef ODEWallModelFvPatchScalarField_H
#define ODEWallModelFvPatchScalarField_H

#include "wallModelFvPatchScalarField.H"
#include "EddyViscosity.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

/*---------------------------------------------------------------------------*\
                  Class ODEWallModelPatchScalarField Declaration
\*---------------------------------------------------------------------------*/

class ODEWallModelFvPatchScalarField
:
    public wallModelFvPatchScalarField
{
protected:

    // Protected Data
        //- Pointer to an eddy viscosity model
        autoPtr<EddyViscosity> eddyViscosity_;

        //- The sampler
        autoPtr<SingleCellSampler> sampler_;

        //- Maximum amount of iterations for coupling between uTau and nut
        label maxIter_;

        //- Error for exiting the uTau and nut coupling loop
        scalar eps_;

    // Protected Member Functions
        //- Write model properties to stream
        virtual void writeLocalEntries(Ostream &) const;

        //- Calculate the turbulence viscosity at the wall
        virtual tmp<scalarField> calcNut() const;

        //- Calculate the friction velocity
        virtual tmp<scalarField> calcUTau(const scalarField & magGradU) const;

        //- Source term defining the type of ODE model
        virtual void source(vectorField &) const = 0;

public:

#if !defined(DOXYGEN_SHOULD_SKIP_THIS)
    //- Runtime type information
    TypeName("ODEWallModel");
#endif

    // Constructors

        //- Construct from patch and internal field
        ODEWallModelFvPatchScalarField
        (
            const fvPatch &,
            const DimensionedField<scalar, volMesh> &
        );

        //- Construct from patch, internal field and dictionary
        ODEWallModelFvPatchScalarField
        (
            const fvPatch &,
            const DimensionedField<scalar, volMesh> &,
            const dictionary &
        );

        //- Construct by mapping given ODEWallModelFvPatchScalarField
        //  onto a new patch
        ODEWallModelFvPatchScalarField
        (
            const ODEWallModelFvPatchScalarField &,
            const fvPatch &,
            const DimensionedField<scalar, volMesh> &,
            const fvPatchFieldMapper &
        );

        #ifdef FOAM_FVPATCHFIELD_NO_COPY
        #else
        //- Construct as copy
        ODEWallModelFvPatchScalarField
        (
            const ODEWallModelFvPatchScalarField &
        );
        #endif

        //- Construct as copy setting internal field reference
        ODEWallModelFvPatchScalarField
        (
            const ODEWallModelFvPatchScalarField &,
            const DimensionedField<scalar, volMesh> &
        );


    // Member functions


        //- Write
        virtual void write(Ostream& os) const;

        virtual void updateCoeffs();

        //- Return the error tolerance
        scalar eps() const
        {
            return eps_;
        }

        //- Return the max number of coupling iterations
        scalar maxIter() const
        {
            return maxIter_;
        }

        SingleCellSampler & sampler()
        {
            return sampler_();
        }

        const SingleCellSampler & sampler() const
        {
            return sampler_();
        }
};


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

} // End namespace Foam

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


#endif