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

Description
    Volumetric B-Splines design variables for shape optimisation

SourceFiles
    volumetricBSplinesDesignVariables.C

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

#ifndef volumetricBSplinesDesignVariables_H
#define volumetricBSplinesDesignVariables_H

#include "shapeDesignVariables.H"
#include "volBSplinesBase.H"
#include "morphingBoxConstraint.H"

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

namespace Foam
{

/*---------------------------------------------------------------------------*\
              Class volumetricBSplinesDesignVariables Declaration
\*---------------------------------------------------------------------------*/

class volumetricBSplinesDesignVariables
:
    public shapeDesignVariables,
    public localIOdictionary
{
protected:

    // Protected data

        //- Reference to underlaying volumetric B-Splines morpher
        volBSplinesBase& volBSplinesBase_;

        //- Should the control points be non-overlapping
        bool nonOverlappingCPs_;

        //- Should the bounds of the non-overlapping control points be updated
        //- in each optimisation cycle
        bool updateBounds_;

        //- Constraint imposed on the movement of the design variables.
        //  Can be used to e.g. impose a uniform movement of the control points
        //  in one direction, etc.
        autoPtr<morphingBoxConstraint> constraint_;


    // Protected Member Functions

        //- Size of the active control points
        virtual label sensSize() const;

        //- Components of the active control points
        virtual const labelList& activeSensitivities() const;

        //- Set IDs of active design variables
        //  Might be different than what volBSplinesBase_ returns, if
        //  constraint_ changes the number of design variables
        void setActiveDesignVariables();

        //- Set control points based on current design variables values
        void designVariablesToControlPoints();

        //- Set the design variables based on the current control points
        void controlPointsToDesignVariables();

        //- Set the design variables based on the given control points
        void controlPointsToDesignVariables(const vectorField& controlPoints);

        //- Read bounds for design variables, if present
        void readBounds
        (
            autoPtr<scalar> lowerBoundPtr = nullptr,
            autoPtr<scalar> upperBoundPtr = nullptr
        );

        //- Read one set of bounds (lower, upper)
        void readBounds
        (
            autoPtr<scalarField>& bounds,
            const word& boundsName,
            const label sign
        );

        //- Write current bounds to file
        void writeBounds(const scalarField& bounds, const word& name) const;

        //- Set the field driving the displacement method.
        //  Can be either the movement of the control points or the boundary
        //  displacement, depending on the method used to move the mesh
        void setDisplacement(const vectorField& cpMovement);


private:

    // Private Member Functions

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

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


public:

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


    // Constructors

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


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


    // Member Functions

        //- Are control points non-overlapping
        inline bool nonOverlappingCPs() const
        {
            return nonOverlappingCPs_;
        }

        //- Are bounds to be updated after each optmisation cycle
        inline bool updateBounds() const
        {
            return updateBounds_;
        }

        //- Constant access to the volBSplinesBase object
        inline const volBSplinesBase& getVolBSplinesBase() const
        {
            return volBSplinesBase_;
        }

        //- Non-constant access to the volBSplinesBase object
        inline volBSplinesBase& getVolBSplinesBase()
        {
            return volBSplinesBase_;
        }

        //- Transform correction of design variables to control points movement
        tmp<vectorField> controlPointMovement
        (
            const scalarField& correction
        );

        //- Update design variables based on a given correction
        virtual void update(scalarField& correction);

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

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

        //- Whether to use global sum when computing matrix-vector products
        //- in update methods
        virtual bool globalSum() const;

        //- Assemble the sensitivity derivatives, by also applying possible
        //- constraints
        virtual tmp<scalarField> assembleSensitivities
        (
            adjointSensitivity& adjointSens
        );

        //- For design variables with a dynamic character (i.e. changing
        //  number), perform the evolution.
        //  Hijacked here to evolve the bounds of the design variables
        //  after the end of each optimisation cycle
        virtual void evolveNumber();

        //- Write fields to support continuation
        virtual bool writeData(Ostream& os) const;

        // Fields related to sensitivity computations

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

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

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

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

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


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

} // End namespace Foam

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

#endif

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