DATurbulenceModel.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 
    DAFoam  : Discrete Adjoint with OpenFOAM
    Version : v3
 
    Description:
    Augmented turbulence model for the adjoint method, including residual 
    calculation functions, etc
 
    NOTE 1:
    Instead of inheriting from the OpenFOAM turbulence implementation, in 
    RASModel's children, we re-write all the correspndong functions for each 
    turbulence model. This is to avoid using template classes and template 
    functions for all the other classes in DAFoam. The downside is that we 
    need to update all the RASModel's children when upgrading to a new version 
    of OpenFOAM. Hopefully, the turbulence model part does not change too much 
    from version to version so the modification will be minimal. 
 
    NOTE 2:
    This function will lookup turbulence model object in fvMesh, so make sure
    you initialize a turbulence model BEFORE initialzing DATurbulenceModel
 
\*---------------------------------------------------------------------------*/
 
#ifndef DATurbulenceModel_H
#define DATurbulenceModel_H
 
#include "runTimeSelectionTables.H"
#include "wallDist.H"
#include "nearWallDist.H"
#include "DAUtility.H"
#include "DAOption.H"
#include "DARegDbNearWallDist.H"
#include "DAMacroFunctions.H"
#include "nutkWallFunctionFvPatchScalarField.H" // for yPlus
#include "wallFvPatch.H" // for yPlus
 
#ifdef IncompressibleFlow
#include "singlePhaseTransportModel.H"
#include "turbulentTransportModel.H"
#include "DARegDbTurbulenceModelIncompressible.H"
#include "DARegDbSinglePhaseTransportModel.H"
#endif
 
#ifdef CompressibleFlow
#include "fluidThermo.H"
#include "turbulentFluidThermoModel.H"
#include "DARegDbTurbulenceModelCompressible.H"
#include "DARegDbFluidThermo.H"
#endif
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                    Class DATurbulenceModel Declaration
\*---------------------------------------------------------------------------*/
 
class DATurbulenceModel
    : public regIOobject
{
 
private:
    //- Disallow default bitwise copy construct
    DATurbulenceModel(const DATurbulenceModel&);
 
    //- Disallow default bitwise assignment
    void operator=(const DATurbulenceModel&);
 
protected:
    const fvMesh& mesh_;
 
    const DAOption& daOption_;
 
    const dictionary& allOptions_;
 
    volScalarField& nut_;
 
    volVectorField& U_;
 
    surfaceScalarField& phi_;
 
    volScalarField phase_;
 
    surfaceScalarField& phaseRhoPhi_;
 
#ifdef IncompressibleFlow
    const DARegDbSinglePhaseTransportModel& daRegDbTransport_;
    const singlePhaseTransportModel& laminarTransport_;
    const DARegDbTurbulenceModelIncompressible& daRegDbTurbIncomp_;
    const incompressible::turbulenceModel& turbulence_;
    volScalarField rho_;
#endif
 
#ifdef CompressibleFlow
    const DARegDbFluidThermo& daRegDbThermo_;
    const fluidThermo& thermo_;
    const DARegDbTurbulenceModelCompressible& daRegDbTurbComp_;
    const compressible::turbulenceModel& turbulence_;
    volScalarField& rho_;
#endif
 
    IOdictionary turbDict_;
 
    dictionary coeffDict_;
 
    dimensionedScalar kMin_;
 
    dimensionedScalar epsilonMin_;
 
    dimensionedScalar omegaMin_;
 
    dimensionedScalar nuTildaMin_;
 
    scalar Pr_;
 
    scalar Prt_ = -9999.0;
 
public:
    //- Runtime type information
    TypeName("DATurbulenceModel");
 
    // Declare run-time constructor selection table
    declareRunTimeSelectionTable(
        autoPtr,
        DATurbulenceModel,
        dictionary,
        (const word modelType,
         const fvMesh& mesh,
         const DAOption& daOption),
        (modelType, mesh, daOption));
 
    // Constructors
 
    //- Construct from components
    DATurbulenceModel(
        const word modelType,
        const fvMesh& mesh,
        const DAOption& daOption);
 
    // Selectors
 
    //- Return a reference to the selected model
    static autoPtr<DATurbulenceModel> New(
        const word modelType,
        const fvMesh& mesh,
        const DAOption& daOption);
 
    //- Destructor
    virtual ~DATurbulenceModel()
    {
    }
 
    // Members
 
    void correctWallDist();
 
    void correctAlphat();
 
    virtual void correctNut() = 0;
 
    virtual void correctModelStates(wordList& modelStates) const = 0;
 
    virtual void correctBoundaryConditions() = 0;
 
    virtual void updateIntermediateVariables() = 0;
 
    virtual void correctStateResidualModelCon(List<List<word>>& stateCon) const = 0;
 
    virtual void addModelResidualCon(HashTable<List<List<word>>>& allCon) const = 0;
 
    virtual void calcResiduals(const dictionary& options) = 0;
 
    virtual void correct() = 0;
 
    virtual void getTurbProdTerm(scalarList& prodTerm) const;
 
    tmp<volSymmTensorField> devRhoReff() const;
 
    tmp<fvVectorMatrix> divDevRhoReff(volVectorField& U);
 
    tmp<fvVectorMatrix> divDevReff(volVectorField& U);
 
    tmp<volScalarField> nuEff() const;
 
    tmp<volScalarField> getNut()
    {
        return nut_;
    }
 
    tmp<volScalarField> alphaEff();
 
    tmp<volScalarField> nu() const;
 
    tmp<volScalarField> getAlpha() const;
 
    tmp<volScalarField> getRho()
    {
        return rho_;
    }
 
    tmp<volScalarField> getPhase()
    {
        return phase_;
    }
 
    scalar getPrt()
    {
        if (Prt_ > 0)
        {
            return Prt_;
        }
        else
        {
            // alphat not found in Db so Prt is not set
            FatalErrorIn("getPrt") << exit(FatalError);
            return -9999.0;
        }
    }
 
#ifdef CompressibleFlow
    const fluidThermo& getThermo() const;
#endif
 
    tmp<Foam::volScalarField> getMu() const;
 
    bool writeData(Ostream& os) const;
 
    void printYPlus() const;
 
    label isPrintTime(
        const Time& runTime,
        const label printInterval) const;
 
    virtual void invTranProdNuTildaEqn(
        const volScalarField& mySource,
        volScalarField& pseudoNuTilda);
 
    virtual void constructPseudoNuTildaEqn();
 
    virtual void rhsSolvePseudoNuTildaEqn(const volScalarField& nuTildaSource);
 
    virtual void calcLduResidualTurb(volScalarField& nuTildaRes);
};
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //