adjointSolverManager.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::adjointSolverManager
 
Description
    Class for managing adjoint solvers, which may be more than one per
    operating point
 
SourceFiles
    adjointSolverManager.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef adjointSolverManager_H
#define adjointSolverManager_H
 
#include "adjointSolver.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                     Class adjointSolverManager Declaration
\*---------------------------------------------------------------------------*/
 
class adjointSolverManager
:
    public regIOobject
{
private:
 
    // Private Member Functions
 
        //- No  copy construct
        adjointSolverManager(const adjointSolverManager&) = delete;
 
        //- No copy assignment
        void operator=(const adjointSolverManager&) = delete;
 
 
protected:
 
    // Protected Data
 
        fvMesh& mesh_;
 
        dictionary dict_;
 
        const word managerName_;
 
        const word managerType_;
 
        const word primalSolverName_;
 
        PtrList<adjointSolver> adjointSolvers_;
 
        labelList objectiveSolverIDs_;
 
        labelList oneSidedConstraintSolverIDs_;
 
        labelList doubleSidedConstraintSolverIDs_;
 
        scalar operatingPointWeight_;
 
        label nActiveAdjointSolvers_;
 
        autoPtr<designVariables>& designVars_;
 
 
public:
 
    TypeName("adjointSolverManager");
 
 
    // Constructors
 
        //- Construct from components
        adjointSolverManager
        (
            fvMesh& mesh,
            autoPtr<designVariables>& designVars,
            const word& managerType,
            const dictionary& dict,
            bool overrideUseSolverName
        );
 
 
    //- Destructor
    virtual ~adjointSolverManager() = default;
 
 
    // Member Functions
 
        bool readDict(const dictionary& dict);
 
 
        // Access
 
            //- Const access to the manager name
            const word& managerName() const;
 
            //- Const access to the primal solver name
            const word& primalSolverName() const;
 
            //- Const access to the construction dictionary
            const dictionary& dict() const;
 
            //- Const access to adjoint solvers
            const PtrList<adjointSolver>& adjointSolvers() const;
 
            //- Non-const access to adjoint solvers
            PtrList<adjointSolver>& adjointSolvers();
 
            //- Return the names of all adjointSolvers
            wordList adjointSolversNames() const;
 
            //- Const access to adjoint solvers
            scalar operatingPointWeight() const;
 
            //- Return number of active adjoint solvers, either corresponding
            //  to objectives or constraints
            label nActiveAdjointSolvers() const;
 
            //- Static function returning the number of active adjoint
            //  solvers reading dict
            static label nActiveAdjointSolvers(const dictionary& dict);
 
            //- Number of constraints
            //  Is the sum of one-sided and double-sided constraints, the
            //  latter multiplied by two
            label nConstraints() const;
 
            //- Number of adjoint solvers corresponding to one-sided
            //- constraints
            label nOneSidedConstraints() const;
 
            //- Number of adjoint solvers corresponding to double-sided
            //- constraints
            label nDoubleSidedConstraints() const;
 
            //- Number of adjoint solvers corresponding to objectives
            label nObjectives() const;
 
            //- Total number of adjoint solvers
            label nAdjointSolvers() const;
 
 
        // Evolution
 
            //- Update objective function-related values and solve adjoint
            //- equations
            void solveAdjointEquations();
 
            //- Aggregate sensitivities from various adjoint solvers
            tmp<scalarField> aggregateSensitivities();
 
            //- Get constraint sensitivities. One scalarField per constraint
            PtrList<scalarField> constraintSensitivities();
 
            //- Compute sensitivities for all adjoint solvers
            //- (both objective- and constraint-related ones)
            void computeAllSensitivities();
 
            //- Clear sensitivity fields from all adjoint solvers
            void clearSensitivities();
 
            //- Get objective value
            scalar objectiveValue();
 
            //- Get constraint values
            tmp<scalarField> constraintValues();
 
            //- Update fields related to primal solution.
            //  For instance, primal fields of adjoint turbulence models
            void updatePrimalBasedQuantities(const word& name);
 
            //- Whether the primal solver corresponding to the
            //- adjointSolverManager is the master one, in case of coupled
            //- solvers
            bool isMaster() const;
 
 
        // IO
 
            virtual bool writeData(Ostream&) const
            {
                return true;
            }
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //