zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-12-28 03:37:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'feature-adjoint-shapeOptimisation' into 'develop'

Browse Source 
ENH: New adjont shape optimisation functionality

See merge request Development/openfoam!307
This commit is contained in:
Andrew Heather
2019-12-12 14:18:20 +00:00
parent a8ab9b8796 b863254308
commit 042c529f9f
608 changed files with 36342 additions and 1193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
applications/solvers/incompressible/adjointOptimisationFoam/adjointOptimisationFoam.C
View File

@ -55,10 +55,6 @@ int main(int argc, char *argv[])
for (om++; !om.end(); om++)
{
Info<< "* * * * * * * * * * * * * * * * * * *" << endl;
Info<< "Time = " << runTime.timeName() << endl;
Info<< "* * * * * * * * * * * * * * * * * * *" << endl;
if (om.update())
{
// Update design variables and solve all primal equations

3
applications/utilities/postProcessing/optimisation/cumulativeDisplacement/Make/files Normal file
View File

@ -0,0 +1,3 @@
cumulativeDisplacement.C
EXE = $(FOAM_APPBIN)/cumulativeDisplacement

11
applications/utilities/postProcessing/optimisation/cumulativeDisplacement/Make/options Normal file
View File

@ -0,0 +1,11 @@
EXE_INC = \
-I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude
EXE_LIBS = \
-ldynamicFvMesh \
-ldynamicMesh \
-lmeshTools \
-lfiniteVolume

16
applications/utilities/postProcessing/optimisation/cumulativeDisplacement/createFields.H Normal file
View File

@ -0,0 +1,16 @@
pointField points0
(
pointIOField
(
IOobject
(
"points",
mesh.time().constant(),
polyMesh::meshSubDir,
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
)
);

161
applications/utilities/postProcessing/optimisation/cumulativeDisplacement/cumulativeDisplacement.C Normal file
View File

@ -0,0 +1,161 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2007-2019 PCOpt/NTUA
Copyright (C) 2013-2019 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/>.
Application
cumulativeDisplacement
Description
Computes and writes the difference between the mesh points in each time
instance and the ones in the constant folder. Additionally, the projection
of this difference to the normal point vectors of the initial mesh is also
written
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "emptyFvPatch.H"
#include "coupledFvPatch.H"
#include "pointMesh.H"
#include "pointPatchField.H"
#include "pointPatchFieldsFwd.H"
#include "syncTools.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
timeSelector::addOptions();
#include "addRegionOption.H"
#include "setRootCase.H"
#include "createTime.H"
instantList timeDirs = timeSelector::select0(runTime, args);
#include "createNamedMesh.H"
#include "createFields.H"
// polyPatch::pointNormals will give the wrong result for points
// belonging to multiple patches or patch-processorPatch intersections.
// Keeping a mesh-wide field to allow easy reduction using syncTools.
// A bit expensive? Better way?
vectorField pointNormals(mesh.nPoints(), vector::zero);
for (const fvPatch& patch : mesh.boundary())
{
// Each local patch point belongs to these local patch faces.
// Local numbering
const labelListList& patchPointFaces = patch.patch().pointFaces();
if (!isA<coupledFvPatch>(patch) && !isA<emptyFvPatch>(patch))
{
const labelList& meshPoints = patch.patch().meshPoints();
const vectorField nf(patch.nf());
forAll(meshPoints, ppI)
{
const labelList& pointFaces = patchPointFaces[ppI];
forAll(pointFaces, pfI)
{
const label& localFaceIndex = pointFaces[pfI];
pointNormals[meshPoints[ppI]] += nf[localFaceIndex];
}
}
}
}
// Sum from all processors
syncTools::syncPointList
(
mesh, pointNormals, plusEqOp<vector>(), vector::zero
);
pointNormals /= mag(pointNormals) + VSMALL;
forAll(timeDirs, timeI)
{
runTime.setTime(timeDirs[timeI], timeI);
Info<< "Time = " << runTime.timeName() << endl;
mesh.readUpdate();
const pointMesh& pMesh(pointMesh::New(mesh));
// Point displacement projected to the
// unit point normal of the initial geometry
pointScalarField normalDisplacement
(
IOobject
(
"normalDisplacement",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
pMesh,
dimensionedScalar(dimless, Zero)
);
// Point displacement as a vector
pointVectorField displacement
(
IOobject
(
"displacement",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
pMesh,
dimensionedVector(dimless, Zero)
);
Info<< "Calculating cumulative mesh movement for time "
<< runTime.timeName() << endl;
// Normal displacement
const pointField& meshPoints = mesh.points();
forAll(mesh.boundary(), pI)
{
const polyPatch& patch = mesh.boundaryMesh()[pI];
const labelList& localPoints = patch.meshPoints();
forAll(localPoints, ppI)
{
label pointI = localPoints[ppI];
normalDisplacement[pointI] =
(meshPoints[pointI] - points0[pointI])
& pointNormals[pointI];
}
}
normalDisplacement.write();
// Vectorial displacement
displacement.primitiveFieldRef() = meshPoints - points0;
displacement.write();
}
// Print execution time
mesh.time().printExecutionTime(Info);
Info<< "End\n" << endl;
return(0);
}
// ************************************************************************* //

3
applications/utilities/preProcessing/optimisation/writeActiveDesignVariables/Make/files Normal file
View File

@ -0,0 +1,3 @@
writeActiveDesignVariables.C
EXE = $(FOAM_APPBIN)/writeActiveDesignVariables

14
applications/utilities/preProcessing/optimisation/writeActiveDesignVariables/Make/options Normal file
View File

@ -0,0 +1,14 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/finiteVolume/cfdTools \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/optimisation/adjointOptimisation/adjoint/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lfvOptions \
-ldynamicMesh \
-lfvMotionSolvers \
-ladjointOptimisation

110
applications/utilities/preProcessing/optimisation/writeActiveDesignVariables/writeActiveDesignVariables.C Normal file
View File

@ -0,0 +1,110 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2007-2019 PCOpt/NTUA
Copyright (C) 2013-2019 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/>.
Application
writeActiveDesignVariables
Description
Writes the active design variables based on the selected parameterisation
scheme, as read from the meshMovement part of optimisationDict.
Keeps a back-up of the original optimisationDict in
system/optimisationDict.org, as comments in the dict will be lost.
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "optMeshMovement.H"
#include "updateMethod.H"
#include "OFstream.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
IOdictionary optDict
(
IOobject
(
"optimisationDict",
mesh.time().caseSystem(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
// Back-up old optimisationDict, to maintain potential comments in it
if (Pstream::master())
{
cp(optDict.objectPath(), optDict.objectPath() + ".org");
}
// Construct mesh movement object and grab active design variables
// Will exit with error if not implemented for this type
const dictionary& movementDict =
optDict.subDict("optimisation").subDict("meshMovement");
// Empty patch list will do
labelList patchIDs(0);
autoPtr<optMeshMovement> movementPtr
(optMeshMovement::New(mesh, movementDict, patchIDs));
const labelList activeDesignVariables =
movementPtr().getActiveDesignVariables();
// Construct update method to grab the type
dictionary& updateMethodDict =
optDict.subDict("optimisation").subDict("updateMethod");
autoPtr<updateMethod> updMethod(updateMethod::New(mesh, updateMethodDict));
// Add to appropriate dictionary (creates it if it does not exist)
dictionary& coeffsDict = updateMethodDict.subDictOrAdd(updMethod().type());
coeffsDict.add<labelList>
(
"activeDesignVariables",
activeDesignVariables,
true
);
// Write modified dictionary
optDict.regIOobject::writeObject
(
IOstream::ASCII,
IOstream::currentVersion,
IOstream::UNCOMPRESSED,
true
);
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

3
applications/utilities/preProcessing/optimisation/writeMorpherCPs/Make/files Normal file
View File

@ -0,0 +1,3 @@
writeMorpherCPs.C
EXE = $(FOAM_APPBIN)/writeMorpherCPs

13
applications/utilities/preProcessing/optimisation/writeMorpherCPs/Make/options Normal file
View File

@ -0,0 +1,13 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/finiteVolume/cfdTools \
-I$(LIB_SRC)/optimisation/adjointOptimisation/adjoint/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lfvOptions \
-ldynamicMesh \
-lfvMotionSolvers \
-ladjointOptimisation

83
applications/utilities/preProcessing/optimisation/writeMorpherCPs/writeMorpherCPs.C Normal file
View File

@ -0,0 +1,83 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2007-2019 PCOpt/NTUA
Copyright (C) 2013-2019 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/>.
Application
writeMorpherCPs
Description
Writes the NURBS3DVolume control points corresponding to dynamicMeshDict
to csv files. Parametric coordinates are not computed.
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "NURBS3DVolume.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
IOdictionary dict
(
IOobject
(
"dynamicMeshDict",
mesh.time().constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
const dictionary& coeffDict =
dict.subDict("volumetricBSplinesMotionSolverCoeffs");
wordList controlBoxes(coeffDict.get<wordList>("controlBoxes"));
forAll(controlBoxes, iNURB)
{
// Creating an object writes the control points in the
// constructor
NURBS3DVolume::New
(
coeffDict.subDict(controlBoxes[iNURB]),
mesh,
false // do not compute parametric coordinates
);
}
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //