adjointSensitivity.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 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::adjointSensitivity

Description
    Abstract base class for adjoint-based sensitivities

SourceFiles
    adjointSensitivity.C

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

#ifndef adjointSensitivityIncompressible_H
#define adjointSensitivityIncompressible_H

#include "boundaryFieldsFwd.H"
#include "adjointEikonalSolver.H"
#include "adjointMeshMovementSolver.H"
#include "sensitivity.H"
#include "volFieldsFwd.H"
#include "wallFvPatch.H"

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

namespace Foam
{

// Forward declaration
class adjointSolver;

/*---------------------------------------------------------------------------*\
                     Class adjointSensitivity Declaration
\*---------------------------------------------------------------------------*/

class adjointSensitivity
:
    public sensitivity
{
protected:


    // Protected data

        //- Reference to the underlaying adjoint solver
        adjointSolver& adjointSolver_;

        //- The sensitivity derivative values
        scalarField derivatives_;

        //- Append this word to files related to the sensitivities
        word suffix_;

        //- Include distance variation in sensitivity computations
        bool includeDistance_;

        //- Adjoint eikonal equation solver
        autoPtr<adjointEikonalSolver> eikonalSolver_;

        //- Adjoint grid displacement solver
        autoPtr<adjointMeshMovementSolver> adjointMeshMovementSolver_;

        // Fields to accumulated through the adjoint solver

            // Shape optimisation

                //- Multiplier of grad(dx/b)
                autoPtr<volTensorField> gradDxDbMult_;

                //- Multiplier of div(dx/db)
                autoPtr<scalarField> divDxDbMult_;

                //- Multiplier of face dx/db
                //  The term that multiplies the adjoint-related part of the
                //  sensitivities in the (E)SI approach
                autoPtr<boundaryVectorField> dxdbMult_;

                //- Multiplier of dSf/db
                autoPtr<boundaryVectorField> dSfdbMult_;

                //- Multiplier of dnf/db
                autoPtr<boundaryVectorField> dnfdbMult_;

                //- Multiplier of dCf/db, found in the objective function
                autoPtr<boundaryVectorField> dxdbDirectMult_;

                //- Multiplier of dx/db computed at points,
                //- found in the objective function
                autoPtr<pointBoundaryVectorField> pointDxDbDirectMult_;

                //- Multiplier of dx/db, coming from boundary conditions that
                //- depend on the geometry, like rotatingWallVelocity
                autoPtr<boundaryVectorField> bcDxDbMult_;

                //- dx/db multiplier coming from fvOptions
                autoPtr<vectorField> optionsDxDbMult_;


private:

    // Private Member Functions

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

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


public:

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


    // Declare run-time constructor selection table

        declareRunTimeSelectionTable
        (
            autoPtr,
            adjointSensitivity,
            dictionary,
            (
                const fvMesh& mesh,
                const dictionary& dict,
                adjointSolver& adjointSolver
            ),
            (
                mesh,
                dict,
                adjointSolver
            )
        );


    // Constructors

        //- Construct from components
        adjointSensitivity
        (
            const fvMesh& mesh,
            const dictionary& dict,
            adjointSolver& adjointSolver
        );

    // Selectors

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


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


    // Member Functions

        //- Read dictionary if changed
        virtual bool readDict(const dictionary& dict);

        //- Const access to adjoint solver
        inline const adjointSolver& getAdjointSolver() const
        {
            return adjointSolver_;
        }

        //- Non-const access to adjoint solver
        inline adjointSolver& getAdjointSolver()
        {
            return adjointSolver_;
        }

        //- Should the adjoint eikonal PDE should be solved
        inline bool includeDistance() const
        {
            return includeDistance_;
        }

        //- Return the adjoint eikonal solver
        inline autoPtr<adjointEikonalSolver>& getAdjointEikonalSolver()
        {
            return eikonalSolver_;
        }

        //- Return the adjoint eikonal solver
        inline autoPtr<adjointMeshMovementSolver>&
        getAdjointMeshMovementSolver()
        {
            return adjointMeshMovementSolver_;
        }

        //- Set suffix
        inline void setSuffix(const word& suffix)
        {
            suffix_ = suffix;
        }

        //- Get suffix
        inline const word& getSuffix() const
        {
            return suffix_;
        }

        //- Should the parameterization compute the internalField of dxdb
        virtual bool computeDxDbInternalField() const;

        //- Accumulate sensitivity integrands
        //  Corresponds to the flow and adjoint part of the sensitivities
        virtual void accumulateIntegrand(const scalar dt) = 0;

        //- Assemble sensitivities
        //  Adds the geometric part of the sensitivities
        virtual void assembleSensitivities
        (
            autoPtr<designVariables>& designVars
        );

        //- Calculates and returns sensitivity fields.
        //  Used with optimisation libraries
        virtual const scalarField& calculateSensitivities
        (
            autoPtr<designVariables>& designVars
        );

        //- Returns the sensitivity fields
        //  Assumes it has already been updated/computed
        const scalarField& getSensitivities() const;

        //- Zero sensitivity fields and their constituents
        virtual void clearSensitivities();

        //- Write sensitivity fields.
        //  If valid, copies boundaryFields to volFields and writes them.
        //  Virtual to be reimplemented by control points-based methods
        //  (Bezier, RBF) which do not need to write fields
        virtual void write(const word& baseName = word::null);

        // Access functions to multipliers

            // Shape optimisation

                inline const autoPtr<volTensorField>& gradDxDbMult() const;
                inline autoPtr<volTensorField>& gradDxDbMult();
                inline const autoPtr<scalarField>& divDxDbMult() const;
                inline const autoPtr<boundaryVectorField>& dxdbMult() const;
                inline const autoPtr<boundaryVectorField>& dSfdbMult() const;
                inline const autoPtr<boundaryVectorField>& dnfdbMult() const;
                inline const autoPtr<boundaryVectorField>&
                    dxdbDirectMult() const;
                inline const autoPtr<pointBoundaryVectorField>&
                    pointDxDbDirectMult() const;
                inline const autoPtr<boundaryVectorField>& bcDxDbMult() const;
                inline const autoPtr<vectorField>& optionsDxDbMult() const;
};


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

} // End namespace Foam

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

#include "adjointSensitivityI.H"

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

#endif

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