sensitivityVolBSplinesFIIncompressible.C

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-2021 PCOpt/NTUA
    Copyright (C) 2013-2021 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/>.
 
\*---------------------------------------------------------------------------*/
 
#include "sensitivityVolBSplinesFIIncompressible.H"
#include "pointVolInterpolation.H"
#include "IOmanip.H"
#include "addToRunTimeSelectionTable.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
namespace incompressible
{
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
defineTypeNameAndDebug(sensitivityVolBSplinesFI, 0);
addToRunTimeSelectionTable
(
    adjointSensitivity,
    sensitivityVolBSplinesFI,
    dictionary
);
 
// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
sensitivityVolBSplinesFI::sensitivityVolBSplinesFI
(
    const fvMesh& mesh,
    const dictionary& dict,
    incompressibleAdjointSolver& adjointSolver
)
:
    FIBase(mesh, dict, adjointSolver),
    volBSplinesBase_
    (
        const_cast<volBSplinesBase&>(volBSplinesBase::New(mesh))
    ),
    flowSens_(0),
    dSdbSens_(0),
    dndbSens_(0),
    dxdbDirectSens_(0),
    dVdbSens_(0),
    distanceSens_(0),
    optionsSens_(0),
    bcSens_(0),
 
    derivativesFolder_("optimisation"/type() + "Derivatives")
{
    // No boundary field pointers need to be allocated
 
    label nCPs = volBSplinesBase_.getTotalControlPointsNumber();
    derivatives_ = scalarField(3*nCPs, Zero);
    flowSens_ = vectorField(nCPs, Zero);
    dSdbSens_ = vectorField(nCPs, Zero);
    dndbSens_ = vectorField(nCPs, Zero);
    dxdbDirectSens_ = vectorField(nCPs, Zero);
    dVdbSens_ = vectorField(nCPs, Zero);
    distanceSens_ = vectorField(nCPs, Zero);
    optionsSens_ = vectorField(nCPs, Zero);
    bcSens_ = vectorField(nCPs, Zero);
 
    // Create folder to store sensitivities
    mkDir(derivativesFolder_);
}
 
 
// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
void sensitivityVolBSplinesFI::assembleSensitivities()
{
    /*
    addProfiling
    (
        sensitivityVolBSplinesFI,
        "sensitivityVolBSplinesFI::assembleSensitivities"
    );
    */
    read();
 
    // Interpolation engine
    pointVolInterpolation volPointInter(pointMesh::New(mesh_), mesh_);
 
    // Adjoint to the eikonal equation
    autoPtr<volTensorField> distanceSensPtr(nullptr);
    if (includeDistance_)
    {
        // Solver equation
        eikonalSolver_->solve();
 
        // Allocate memory and compute grad(dxdb) multiplier
        distanceSensPtr.reset
        (
            createZeroFieldPtr<tensor>
            (
                mesh_,
                "distanceSensPtr",
                dimensionSet(0, 2, -3, 0, 0, 0, 0)
            )
        );
        distanceSensPtr() = eikonalSolver_->getFISensitivityTerm()().T();
    }
 
    // Integration
    label passedCPs(0);
    PtrList<NURBS3DVolume>& boxes = volBSplinesBase_.boxesRef();
    forAll(boxes, iNURB)
    {
        const label nb(boxes[iNURB].getControlPoints().size());
        vectorField boxSensitivities(nb, Zero);
 
        vectorField dxdbSens = boxes[iNURB].computeControlPointSensitivities
        (
            dxdbDirectMult_(),
            sensitivityPatchIDs_.toc()
        );
 
        vectorField bcSens = boxes[iNURB].computeControlPointSensitivities
        (
            bcDxDbMult_(),
            sensitivityPatchIDs_.toc()
        );
 
        for (label cpI = 0; cpI < nb; cpI++)
        {
            label globalCP = passedCPs + cpI;
 
            // Parameterization info
            tmp<volTensorField> tvolDxDbI
            (
                volPointInter.interpolate(boxes[iNURB].getDxDb(cpI))
            );
            const volTensorField& volDxDbI = tvolDxDbI();
 
            // Chain rule used to get dx/db at cells
            // Gives practically the same results at a much higher CPU cost
            /*
            tmp<volTensorField> tvolDxDbI(boxes[iNURB].getDxCellsDb(cpI));
            volTensorField& volDxDbI = tvolDxDbI.ref();
            */
 
            const tensorField& gradDxDbMultInt = gradDxDbMult_.primitiveField();
            for (label idir = 0; idir < pTraits<vector>::nComponents; ++idir)
            {
                // Gradient of parameterization info
                auto ttemp =
                    tmp<volVectorField>::New
                    (
                        IOobject
                        (
                            "dxdb",
                            mesh_.time().timeName(),
                            mesh_,
                            IOobject::NO_READ,
                            IOobject::NO_WRITE
                        ),
                        mesh_,
                        dimensionedVector(dimless, Zero)
                    );
                volVectorField& temp = ttemp.ref();
                unzipCol(volDxDbI, vector::components(idir), temp);
 
                volTensorField gradDxDb(fvc::grad(temp));
                // Volume integral terms
                flowSens_[globalCP].component(idir) = gSum
                (
                    (gradDxDbMultInt && gradDxDb.primitiveField())
                   *mesh_.V()
                );
 
                if (includeDistance_)
                {
                    const tensorField& distSensInt =
                        distanceSensPtr().primitiveField();
                    distanceSens_[globalCP].component(idir) =
                        gSum
                        (
                            (distSensInt && gradDxDb.primitiveField())
                            *mesh_.V()
                        );
                }
            }
 
            // Contribution from objective function term from
            // delta( n dS ) / delta b and
            // delta ( x )   / delta b
            // for objectives directly depending on x
            for (const label patchI : sensitivityPatchIDs_)
            {
                tensorField dSdb
                (
                    boxes[iNURB].dndbBasedSensitivities(patchI, cpI)
                );
                dSdbSens_[globalCP] += gSum(dSfdbMult_()[patchI] & dSdb);
                tensorField dndb
                (
                    boxes[iNURB].dndbBasedSensitivities(patchI, cpI, false)
                );
                dndbSens_[globalCP] += gSum((dnfdbMult_()[patchI] & dndb));
            }
 
            // Contribution from delta (V) / delta b
            // For objectives defined as volume integrals only
            dVdbSens_[globalCP] +=
                gSum
                (
                    divDxDbMult_
                   *fvc::div(T(volDxDbI))().primitiveField()
                   *mesh_.V()
                );
 
            // Terms from fvOptions
            optionsSens_[globalCP] +=
                gSum((optionsDxDbMult_ & volDxDbI.primitiveField())*mesh_.V());
 
            // dxdbSens storage
            dxdbDirectSens_[globalCP] = dxdbSens[cpI];
 
            // bcSens storage
            bcSens_[globalCP] = bcSens[cpI];
 
            boxSensitivities[cpI] =
                flowSens_[globalCP]
              + dSdbSens_[globalCP]
              + dndbSens_[globalCP]
              + dVdbSens_[globalCP]
              + distanceSens_[globalCP]
              + dxdbDirectSens_[globalCP]
              + optionsSens_[globalCP]
              + bcSens_[globalCP];
        }
 
        // Zero sensitivities in non-active design variables
        boxes[iNURB].boundControlPointMovement(boxSensitivities);
 
        // Transfer sensitivities to global list
        for (label cpI = 0; cpI < nb; cpI++)
        {
            label globalCP = passedCPs + cpI;
            derivatives_[3*globalCP] = boxSensitivities[cpI].x();
            derivatives_[3*globalCP + 1] = boxSensitivities[cpI].y();
            derivatives_[3*globalCP + 2] = boxSensitivities[cpI].z();
        }
 
        // Increment number of passed sensitivities
        passedCPs += nb;
    }
 
    // Zero non-active sensitivity components.
    // For consistent output only, does not affect optimisation
    volBSplinesBase_.boundControlPointMovement(flowSens_);
    volBSplinesBase_.boundControlPointMovement(dSdbSens_);
    volBSplinesBase_.boundControlPointMovement(dndbSens_);
    volBSplinesBase_.boundControlPointMovement(dVdbSens_);
    volBSplinesBase_.boundControlPointMovement(distanceSens_);
    volBSplinesBase_.boundControlPointMovement(dxdbDirectSens_);
    volBSplinesBase_.boundControlPointMovement(optionsSens_);
    volBSplinesBase_.boundControlPointMovement(bcSens_);
 
  //profiling::writeNow();
}
 
 
void sensitivityVolBSplinesFI::clearSensitivities()
{
    flowSens_ = vector::zero;
    dSdbSens_ = vector::zero;
    dndbSens_ = vector::zero;
    dxdbDirectSens_ = vector::zero;
    dVdbSens_ = vector::zero;
    distanceSens_ = vector::zero;
    optionsSens_ = vector::zero;
    bcSens_ = vector::zero;
 
    FIBase::clearSensitivities();
}
 
 
void sensitivityVolBSplinesFI::write(const word& baseName)
{
    Info<< "Writing control point sensitivities to file" << endl;
    if (Pstream::master())
    {
        OFstream derivFile
        (
             derivativesFolder_/
                baseName + adjointVars_.solverName() + mesh_.time().timeName()
        );
        unsigned int widthDV
        (
            max(int(Foam::name(flowSens_.size()).size()), int(3))
        );
        unsigned int width = IOstream::defaultPrecision() + 7;
        derivFile
            << setw(widthDV) << "#cp" << " "
            << setw(width) << "total::x" << " "
            << setw(width) << "total::y" << " "
            << setw(width) << "total::z" << " "
            << setw(width) << "flow::x" << " "
            << setw(width) << "flow::y" << " "
            << setw(width) << "flow::z" << " "
            << setw(width) << "dSdb::x" << " "
            << setw(width) << "dSdb::y" << " "
            << setw(width) << "dSdb::z" << " "
            << setw(width) << "dndb::x" << " "
            << setw(width) << "dndb::y" << " "
            << setw(width) << "dndb::z" << " "
            << setw(width) << "dxdbDirect::x" << " "
            << setw(width) << "dxdbDirect::y" << " "
            << setw(width) << "dxdbDirect::z" << " "
            << setw(width) << "dVdb::x" << " "
            << setw(width) << "dVdb::y" << " "
            << setw(width) << "dVdb::z" << " "
            << setw(width) << "distance::x" << " "
            << setw(width) << "distance::y" << " "
            << setw(width) << "distance::z" << " "
            << setw(width) << "options::x" << " "
            << setw(width) << "options::y" << " "
            << setw(width) << "options::z" << " "
            << setw(width) << "dvdb::x" << " "
            << setw(width) << "dvdb::y" << " "
            << setw(width) << "dvdb::z" << endl;
 
        label passedCPs(0);
        label lastActive(-1);
        PtrList<NURBS3DVolume>& boxes = volBSplinesBase_.boxesRef();
        forAll(boxes, iNURB)
        {
            label nb = boxes[iNURB].getControlPoints().size();
            const boolList& activeCPs = boxes[iNURB].getActiveCPs();
            for (label iCP = 0; iCP < nb; iCP++)
            {
                if (activeCPs[iCP])
                {
                    label globalCP = passedCPs + iCP;
                    if (globalCP!=lastActive + 1) derivFile << "\n";
                    lastActive = globalCP;
 
                    derivFile
                        << setw(widthDV) << globalCP << " "
                        << setw(width) << derivatives_[3*globalCP] << " "
                        << setw(width) << derivatives_[3*globalCP + 1] << " "
                        << setw(width) << derivatives_[3*globalCP + 2] << " "
                        << setw(width) << flowSens_[globalCP].x() << " "
                        << setw(width) << flowSens_[globalCP].y() << " "
                        << setw(width) << flowSens_[globalCP].z() << " "
                        << setw(width) << dSdbSens_[globalCP].x() << " "
                        << setw(width) << dSdbSens_[globalCP].y() << " "
                        << setw(width) << dSdbSens_[globalCP].z() << " "
                        << setw(width) << dndbSens_[globalCP].x() << " "
                        << setw(width) << dndbSens_[globalCP].y() << " "
                        << setw(width) << dndbSens_[globalCP].z() << " "
                        << setw(width) << dxdbDirectSens_[globalCP].x() << " "
                        << setw(width) << dxdbDirectSens_[globalCP].y() << " "
                        << setw(width) << dxdbDirectSens_[globalCP].z() << " "
                        << setw(width) << dVdbSens_[globalCP].x() << " "
                        << setw(width) << dVdbSens_[globalCP].y() << " "
                        << setw(width) << dVdbSens_[globalCP].z() << " "
                        << setw(width) << distanceSens_[globalCP].x() << " "
                        << setw(width) << distanceSens_[globalCP].y() << " "
                        << setw(width) << distanceSens_[globalCP].z() << " "
                        << setw(width) << optionsSens_[globalCP].x() << " "
                        << setw(width) << optionsSens_[globalCP].y() << " "
                        << setw(width) << optionsSens_[globalCP].z() << " "
                        << setw(width) << bcSens_[globalCP].x() << " "
                        << setw(width) << bcSens_[globalCP].y() << " "
                        << setw(width) << bcSens_[globalCP].z() << endl;
                }
            }
            passedCPs += nb;
        }
    }
}
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace incompressible
} // End namespace Foam
 
// ************************************************************************* //