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

Description
    Abstract base class for defining design variables for shape optimisation.

SourceFiles
    shapeDesignVariables.C

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

#ifndef shapeDesignVariables_H
#define shapeDesignVariables_H

#include "designVariables.H"
#include "displacementMethod.H"
#include "runTimeSelectionTables.H"

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

namespace Foam
{

/*---------------------------------------------------------------------------*\
                     Class shapeDesignVariables Declaration
\*---------------------------------------------------------------------------*/

class shapeDesignVariables
:
    public designVariables
{
protected:

    // Protected data

        //- Patches to be moved by the design variables
        labelHashSet parametertisedPatches_;

        //- Mesh movement mechanism
        autoPtr<displacementMethod> displMethodPtr_;

        //- Store old points. Useful for line search
        autoPtr<pointField> pointsInit_;

        //- Write the mesh points irrespective of whether this is a write time
        bool writeEachMesh_;

        // Auxiliary fields keeping track of the various sensitiity components

            //- Flow related term.
            //  Term including grad(dxdb) in the volume integrals of the FI
            //  formulation
            scalarField dxdbVolSens_;

            //- Flow related term.
            //  Main term in the E-SI formulation. Is the surface intergral
            //  emerging after performing the Gauss-divergence theorem on the
            //  FI-based sensitivities
            scalarField dxdbSurfSens_;

            //- Term depending on delta(n dS)/delta b
            scalarField dSdbSens_;

            //- Term depending on delta(n)/delta b
            scalarField dndbSens_;

            //- Term depending on delta(x)/delta b for objectives that directly
            //- depend on x
            scalarField dxdbDirectSens_;

            //- Term depending on delta(V)/delta b
            scalarField dVdbSens_;

            //- Term depending on distance differentiation
            scalarField distanceSens_;

            //- Term depending on fvOptions
            scalarField optionsSens_;

            //- Term depending on the differenation of boundary conditions
            scalarField bcSens_;

        //- Name of the sensitivity derivatives folder
        fileName derivativesFolder_;


    // Protected Member Functions

        //- Size of the sensitivity derivatives.
        //  Might be different than this->size() in some cases
        virtual label sensSize() const;

        //- Active variables for which to compute sensitivities
        //  Might be different than this->activeDesignVariables_ in some cases
        virtual const labelList& activeSensitivities() const;

        //- Compute dxdb at the mesh cell centers by solving a Laplace PDE
        virtual tmp<volVectorField> solveMeshMovementEqn
        (
            const label patchI,
            const label varID
        ) const;

        //- Allocate the fields assosiated with the computation of sensitivities
        //  Not allocated in the constructor since the size of the design
        //  variables is usually not known there
        void allocateSensFields();

        //- Zero the fields assosiated with the computation of sensitivities
        void zeroSensFields();


private:

    // Private Member Functions

        //- Disallow default bitwise copy construct
        shapeDesignVariables(const shapeDesignVariables&) = delete;

        //- Disallow default bitwise assignment
        void operator=(const shapeDesignVariables&) = delete;


public:

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


    // Declare run-time constructor selection table

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


    // Constructors

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


    // Selectors

        //- Construct and return the selected shapeDesignVariables
        static autoPtr<shapeDesignVariables> New
        (
            fvMesh& mesh,
            const dictionary& dict
        );


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


    // Member Functions

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

        //- Update design variables based on a given correction.
        //  Translates the scalarField of corrections to a meaningful
        //  update of the design variables
        virtual void update(scalarField& correction) = 0;

        //- Store design variables, as the starting point for line search
        virtual void storeDesignVariables();

        //- Reset to starting point of line search
        virtual void resetDesignVariables();

        //- Compute eta if not set in the first step
        virtual scalar computeEta(scalarField& correction) = 0;

        //- Whether to use global sum when computing matrix-vector products
        //- in update methods
        //  Depends on whether the design variables are common for all
        //  processors (e.g. volumetric B-Splines control points) or distributed
        //  across them (e.g. topology optimisation)
        virtual bool globalSum() const = 0;

        // Functions related to mesh movement

            //- Move mesh based on displacementMethod
            virtual void moveMesh();

            //- Patches affected by the parameterisation
            inline const labelHashSet& getPatches() const
            {
                return parametertisedPatches_;
            }

            //- Return displacementMethod
            inline autoPtr<displacementMethod>& returnDisplacementMethod()
            {
                return displMethodPtr_;
            }


        // Fields related to sensitivity computations

            //- Add part of sensitivity derivatives related to geometry
            //- variations
            virtual tmp<scalarField> assembleSensitivities
            (
                adjointSensitivity& adjointSens
            );

            //- Write final sensitivity derivatives to files
            virtual void writeSensitivities
            (
                const scalarField& sens,
                const adjointSensitivity& adjointSens
            );

            //- Get dxdb for all mesh points
            virtual tmp<vectorField> dxdbVol
            (
                const label varID
            ) const;

            //- Get dxdb for a given design variable and patch
            virtual tmp<vectorField> dxdbFace
            (
                const label patchI,
                const label varID
            ) const;

            //- Get dndb for a given design variable and patch
            virtual tmp<vectorField> dndb
            (
                const label patchI,
                const label varID
            ) const;

            //- Get dSdb for a given design variable and patch
            virtual tmp<vectorField> dSdb
            (
                const label patchI,
                const label varID
            ) const;

            //- Get dCdb for a given design variable.
            //  Used for FI-based sensitivities
            virtual tmp<volVectorField> dCdb(const label varID) const;
};


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

} // End namespace Foam

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

#endif

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