DATurbulenceModel.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 
    DAFoam  : Discrete Adjoint with OpenFOAM
    Version : v4
 
    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 "DAMacroFunctions.H"
#include "DAGlobalVar.H"
#include "nutkWallFunctionFvPatchScalarField.H" // for yPlus
#include "wallFvPatch.H" // for yPlus
 
#include "singlePhaseTransportModel.H"
#include "turbulentTransportModel.H"
#include "fluidThermo.H"
#include "turbulentFluidThermoModel.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
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_;
 
    DAGlobalVar& daGlobalVar_;
 
    volScalarField& nut_;
 
    volVectorField& U_;
 
    surfaceScalarField& phi_;
 
    volScalarField phase_;
 
    surfaceScalarField& phaseRhoPhi_;
 
    volScalarField rhoOne_;
 
    word turbModelType_ = "None";
 
    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(label printToScreen) = 0;
 
    virtual void getTurbProdTerm(volScalarField& prodTerm) const;
 
    virtual void getTurbProdOverDestruct(volScalarField& PoD) const;
 
    virtual void getTurbConvOverProd(volScalarField& CoP) const;
 
    tmp<volSymmTensorField> devRhoReff() const;
 
    tmp<fvVectorMatrix> divDevRhoReff(volVectorField& U);
 
    tmp<fvVectorMatrix> divDevReff(volVectorField& U);
 
    tmp<volScalarField> nuEff() const;
 
    tmp<volScalarField> nut()
    {
        return nut_;
    }
 
    tmp<volScalarField> alphaEff();
 
    tmp<volScalarField> nu() const;
 
    tmp<volScalarField> alpha() const;
 
    tmp<volScalarField> rho() const;
 
    dimensionSet rhoDimensions() const;
 
    tmp<volScalarField> phase()
    {
        return phase_;
    }
 
    scalar prt()
    {
        if (Prt_ > 0)
        {
            return Prt_;
        }
        else
        {
            // alphat not found in Db so Prt is not set
            FatalErrorIn("getPrt") << exit(FatalError);
            return -9999.0;
        }
    }
 
    tmp<Foam::volScalarField> mu() const;
 
    bool writeData(Ostream& os) const;
 
    void printYPlus(const label printToScreen) const;
 
    word getTurbModelType() const
    {
        return turbModelType_;
    }
 
    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);
 
    virtual void getFvMatrixFields(
        const word varName,
        scalarField& diag,
        scalarField& upper,
        scalarField& lower);
 
    virtual void solveAdjointFP(
        const word varName,
        const scalarList& rhs,
        scalarList& dPsi);
};
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //