objectiveIncompressible.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) 2007-2023 PCOpt/NTUA
    Copyright (C) 2013-2023 FOSS GP
    Copyright (C) 2019-2020 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::objectiveIncompressible

Description
    Abstract base class for objective functions in incompressible flows

SourceFiles
    objectiveIncompressible.C

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

#ifndef objectiveIncompressible_H
#define objectiveIncompressible_H

#include "objective.H"
#include "incompressibleVars.H"
#include "adjointRASModel.H"

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

namespace Foam
{

/*---------------------------------------------------------------------------*\
                   Class objectiveIncompressible Declaration
\*---------------------------------------------------------------------------*/

class objectiveIncompressible
:
    public objective
{
protected:

    // Protected data

        const incompressibleVars& vars_;

        // Contribution to field adjoint equations
        // v,p,T and turbulence model variables
        //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        autoPtr<volVectorField> dJdvPtr_;
        autoPtr<volScalarField> dJdpPtr_;
        autoPtr<volScalarField> dJdTPtr_;

        //- First  turbulence model variable
        autoPtr<volScalarField> dJdTMvar1Ptr_;

        //- Second turbulence model variable
        autoPtr<volScalarField> dJdTMvar2Ptr_;

        // Contribution to adjoint boundary conditions
        //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        autoPtr<boundaryVectorField> bdJdvPtr_;

        //- Adjoint outlet pressure
        autoPtr<boundaryScalarField> bdJdvnPtr_;

        //- Adjoint outlet velocity
        autoPtr<boundaryVectorField> bdJdvtPtr_;

        //- Adjoint (intlet,wall) velocity
        autoPtr<boundaryVectorField> bdJdpPtr_;

        //- Adjoint outlet temperature
        autoPtr<boundaryScalarField> bdJdTPtr_;

        //- Adjoint outlet turbulence model var 1
        autoPtr<boundaryScalarField> bdJdTMvar1Ptr_;

        //- Adjoint outlet turbulence model var 2
        autoPtr<boundaryScalarField> bdJdTMvar2Ptr_;

        //- Jacobian wrt to nut
        autoPtr<boundaryScalarField> bdJdnutPtr_;

        //- Term multiplying gradU variations
        autoPtr<boundaryTensorField> bdJdGradUPtr_;


private:

    // Private Member Functions

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

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


public:

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


    // Declare run-time constructor selection table

        declareRunTimeSelectionTable
        (
            autoPtr,
            objectiveIncompressible,
            dictionary,
            (
                const fvMesh& mesh,
                const dictionary& dict,
                const word& adjointSolverName,
                const word& primalSolverName
            ),
            (mesh, dict, adjointSolverName, primalSolverName)
        );


    // Constructors

        //- Construct from components
        objectiveIncompressible
        (
            const fvMesh& mesh,
            const dictionary& dict,
            const word& adjointSolverName,
            const word& primalSolverName
        );


    // Selectors

        //- Return a reference to the selected turbulence model
        static autoPtr<objectiveIncompressible> New
        (
            const fvMesh& mesh,
            const dictionary& dict,
            const word& adjointSolverName,
            const word& primalSolverName
        );


    //- Destructor
    virtual ~objectiveIncompressible() = default;


    // Member Functions

        //- Return the objective function value
        virtual scalar J() = 0;

        //- Normalize all fields allocated by the objective
        virtual void doNormalization();

        //- Contribution to field adjoint momentum eqs
        inline const volVectorField& dJdv();

        //- Contribution to field adjoint continuity eq
        inline const volScalarField& dJdp();

        //- Contribution to field adjoint energy eq
        inline const volScalarField& dJdT();

        //- Contribution to field adjoint turbulence model variable 1
        inline const volScalarField& dJdTMvar1();

        //- Contribution to field adjoint turbulence model variable 2
        inline const volScalarField& dJdTMvar2();

        //- Objective partial deriv wrt velocity for a specific patch
        const fvPatchVectorField& boundarydJdv(const label);

        //- Objective partial deriv wrt normal velocity for a specific patch
        inline const fvPatchScalarField& boundarydJdvn(const label);

        //- Objective partial deriv wrt tangent velocity for a specific patch
        inline const fvPatchVectorField& boundarydJdvt(const label);

        //- Objective partial deriv wrt pressure (times normal) for a specific
        //- patch
        inline const fvPatchVectorField& boundarydJdp(const label);

        //- Objective partial deriv wrt temperature for a specific patch
        inline const fvPatchScalarField& boundarydJdT(const label);

        //- Objective partial deriv wrt turbulence model var 1 for a specific
        //- patch
        inline const fvPatchScalarField& boundarydJdTMvar1(const label);

        //- Objective partial deriv wrt turbulence model var 2 for a specific
        //- patch
        inline const fvPatchScalarField& boundarydJdTMvar2(const label);

        //- Objective partial deriv wrt nut for a specific patch
        inline const fvPatchScalarField& boundarydJdnut(const label);

        //- Objective partial deriv wrt stress tensor
        inline const fvPatchTensorField& boundarydJdGradU(const label);

        //- Objective partial deriv wrt velocity for all patches
        inline const boundaryVectorField& boundarydJdv();

        //- Objective partial deriv wrt normal velocity for all patches
        inline const boundaryScalarField& boundarydJdvn();

        //- Objective partial deriv wrt tangent velocity for all patches
        inline const boundaryVectorField& boundarydJdvt();

        //- Objective partial deriv wrt pressure (times normal) for all patches
        inline const boundaryVectorField& boundarydJdp();

        //- Objective partial deriv wrt temperature for all patches
        inline const boundaryScalarField& boundarydJdT();

        //- Objective partial deriv wrt turbulence model var 1 for all patches
        inline const boundaryScalarField& boundarydJdTMvar1();

        //- Objective partial deriv wrt turbulence model var 2 for all patches
        inline const boundaryScalarField& boundarydJdTMvar2();

        //- Objective partial deriv wrt nut for all patches
        inline const boundaryScalarField& boundarydJdnut();

        //- Objective partial deriv wrt gradU
        inline const boundaryTensorField& boundarydJdGradU();

        //- Update objective function derivatives
        virtual void update();

        //- Update objective function derivatives
        virtual void nullify();

        // Funtions used in objectives including turbulent quantities

            //- Allocate fields related to the differentiation of turbulence
            //- models, if necessary
            void allocatedJdTurbulence();

            //- Check if cellZones provided include at least one cell
            void checkCellZonesSize(const labelList& zoneIDs) const;

            //- Compute dJdTMVar{1,2}
            void update_dJdTMvar
            (
                autoPtr<volScalarField>& dJdTMvarPtr,
                tmp<volScalarField>
                    (incompressibleAdjoint::adjointRASModel::*JacobianFunc)()
                    const,
                const volScalarField& JacobianMultiplier,
                const labelList& zones
            );


        //- Update vol and boundary fields and derivatives
        //  Do nothing in the base. The relevant ones should be overwritten
        //  in the child objective functions
        virtual void update_dJdv()
        {}

        virtual void update_dJdp()
        {}

        virtual void update_dJdT()
        {}

        virtual void update_dJdTMvar1()
        {}

        virtual void update_dJdTMvar2()
        {}

        virtual void update_dJdb()
        {}

        virtual void update_dJdbField()
        {}

        virtual void update_divDxDbMultiplier()
        {}

        virtual void update_gradDxDbMultiplier()
        {}

        virtual void update_boundarydJdv()
        {}

        virtual void update_boundarydJdvn()
        {}

        virtual void update_boundarydJdvt()
        {}

        virtual void update_boundarydJdp()
        {}

        virtual void update_boundarydJdT()
        {}

        virtual void update_boundarydJdTMvar1()
        {}

        virtual void update_boundarydJdTMvar2()
        {}

        virtual void update_boundarydJdnut()
        {}

        virtual void update_boundarydJdGradU()
        {}

        //- Vector sources can be given only to the adjoint momentum equations.
        //- Implemented in base objectiveIncompressible
        virtual void addSource(fvVectorMatrix& matrix);

        //- Scalar sources are more ambigious (adjoint pressure, turbulence
        //- model, energy, etc equations), so the equivalent functions should
        //- be overridden on an objective-basis
        virtual void addSource(fvScalarMatrix& matrix)
        {}


        //- Some objectives need to store some auxiliary values.
        //- If averaging is enabled, update these mean values here.
        //  By convention, the mean values (eg mean drag) refer to these flow
        //  values computed using the mean fields, rather than averaging the
        //  values themselves
        virtual void update_meanValues()
        {}

        //- Write objective function history
        virtual bool write(const bool valid = true) const;

        //- Inline functions for checking whether pointers are set or not
        inline bool hasdJdv() const noexcept;
        inline bool hasdJdp() const noexcept;
        inline bool hasdJdT() const noexcept;
        inline bool hasdJdTMVar1() const noexcept;
        inline bool hasdJdTMVar2() const noexcept;
        inline bool hasBoundarydJdv() const noexcept;
        inline bool hasBoundarydJdvn() const noexcept;
        inline bool hasBoundarydJdvt() const noexcept;
        inline bool hasBoundarydJdp() const noexcept;
        inline bool hasBoundarydJdT() const noexcept;
        inline bool hasBoundarydJdTMVar1() const noexcept;
        inline bool hasBoundarydJdTMVar2() const noexcept;
        inline bool hasBoundarydJdnut() const noexcept;
        inline bool hasBoundarydJdGradU() const noexcept;
};


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

} // End namespace Foam

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

#include "objectiveIncompressibleI.H"

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

#endif

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