cf3d6cd1e9
Mesh motion and topology change are now combinable run-time selectable options within fvMesh, replacing the restrictive dynamicFvMesh which supported only motion OR topology change. All solvers which instantiated a dynamicFvMesh now instantiate an fvMesh which reads the optional constant/dynamicFvMeshDict to construct an fvMeshMover and/or an fvMeshTopoChanger. These two are specified within the optional mover and topoChanger sub-dictionaries of dynamicFvMeshDict. When the fvMesh is updated the fvMeshTopoChanger is first executed which can change the mesh topology in anyway, adding or removing points as required, for example for automatic mesh refinement/unrefinement, and all registered fields are mapped onto the updated mesh. The fvMeshMover is then executed which moved the points only and calculates the cell volume change and corresponding mesh-fluxes for conservative moving mesh transport. If multiple topological changes or movements are required these would be combined into special fvMeshMovers and fvMeshTopoChangers which handle the processing of a list of changes, e.g. solidBodyMotionFunctions:multiMotion. The tutorials/multiphase/interFoam/laminar/sloshingTank3D3DoF case has been updated to demonstrate this new functionality by combining solid-body motion with mesh refinement/unrefinement: /*--------------------------------*- C++ -*----------------------------------*\ ========= | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / O peration | Website: https://openfoam.org \\ / A nd | Version: dev \\/ M anipulation | \*---------------------------------------------------------------------------*/ FoamFile { format ascii; class dictionary; location "constant"; object dynamicMeshDict; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // mover { type motionSolver; libs ("libfvMeshMovers.so" "libfvMotionSolvers.so"); motionSolver solidBody; solidBodyMotionFunction SDA; CofG (0 0 0); lamda 50; rollAmax 0.2; rollAmin 0.1; heaveA 4; swayA 2.4; Q 2; Tp 14; Tpn 12; dTi 0.06; dTp -0.001; } topoChanger { type refiner; libs ("libfvMeshTopoChangers.so"); // How often to refine refineInterval 1; // Field to be refinement on field alpha.water; // Refine field in between lower..upper lowerRefineLevel 0.001; upperRefineLevel 0.999; // Have slower than 2:1 refinement nBufferLayers 1; // Refine cells only up to maxRefinement levels maxRefinement 1; // Stop refinement if maxCells reached maxCells 200000; // Flux field and corresponding velocity field. Fluxes on changed // faces get recalculated by interpolating the velocity. Use 'none' // on surfaceScalarFields that do not need to be reinterpolated. correctFluxes ( (phi none) (nHatf none) (rhoPhi none) (alphaPhi.water none) (meshPhi none) (meshPhi_0 none) (ghf none) ); // Write the refinement level as a volScalarField dumpLevel true; } // ************************************************************************* // Note that currently this is the only working combination of mesh-motion with topology change within the new framework and further development is required to update the set of topology changers so that topology changes with mapping are separated from the mesh-motion so that they can be combined with any of the other movements or topology changes in any manner. All of the solvers and tutorials have been updated to use the new form of dynamicMeshDict but backward-compatibility was not practical due to the complete reorganisation of the mesh change structure.
673 lines
17 KiB
C++
673 lines
17 KiB
C++
/*---------------------------------------------------------------------------*\
|
|
========= |
|
|
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
\\ / O peration | Website: https://openfoam.org
|
|
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
|
|
\\/ M anipulation |
|
|
-------------------------------------------------------------------------------
|
|
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
|
|
mapFields
|
|
|
|
Description
|
|
Maps volume fields from one mesh to another, reading and
|
|
interpolating all fields present in the time directory of both cases.
|
|
Parallel and non-parallel cases are handled without the need to reconstruct
|
|
them first.
|
|
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
#include "fvCFD.H"
|
|
#include "meshToMesh0.H"
|
|
#include "processorFvPatch.H"
|
|
#include "MapMeshes.H"
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
void mapConsistentMesh
|
|
(
|
|
const fvMesh& meshSource,
|
|
const fvMesh& meshTarget,
|
|
const meshToMesh0::order& mapOrder,
|
|
const bool subtract
|
|
)
|
|
{
|
|
if (subtract)
|
|
{
|
|
MapConsistentMesh<minusEqOp>
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
mapOrder
|
|
);
|
|
}
|
|
else
|
|
{
|
|
MapConsistentMesh<eqOp>
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
mapOrder
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
void mapSubMesh
|
|
(
|
|
const fvMesh& meshSource,
|
|
const fvMesh& meshTarget,
|
|
const HashTable<word>& patchMap,
|
|
const wordList& cuttingPatches,
|
|
const meshToMesh0::order& mapOrder,
|
|
const bool subtract
|
|
)
|
|
{
|
|
if (subtract)
|
|
{
|
|
MapSubMesh<minusEqOp>
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
patchMap,
|
|
cuttingPatches,
|
|
mapOrder
|
|
);
|
|
}
|
|
else
|
|
{
|
|
MapSubMesh<eqOp>
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
patchMap,
|
|
cuttingPatches,
|
|
mapOrder
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
void mapConsistentSubMesh
|
|
(
|
|
const fvMesh& meshSource,
|
|
const fvMesh& meshTarget,
|
|
const meshToMesh0::order& mapOrder,
|
|
const bool subtract
|
|
)
|
|
{
|
|
if (subtract)
|
|
{
|
|
MapConsistentSubMesh<minusEqOp>
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
mapOrder
|
|
);
|
|
}
|
|
else
|
|
{
|
|
MapConsistentSubMesh<eqOp>
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
mapOrder
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
wordList addProcessorPatches
|
|
(
|
|
const fvMesh& meshTarget,
|
|
const wordList& cuttingPatches
|
|
)
|
|
{
|
|
// Add the processor patches to the cutting list
|
|
HashTable<label> cuttingPatchTable;
|
|
forAll(cuttingPatches, i)
|
|
{
|
|
cuttingPatchTable.insert(cuttingPatches[i], i);
|
|
}
|
|
|
|
forAll(meshTarget.boundary(), patchi)
|
|
{
|
|
if (isA<processorFvPatch>(meshTarget.boundary()[patchi]))
|
|
{
|
|
if
|
|
(
|
|
!cuttingPatchTable.found
|
|
(
|
|
meshTarget.boundaryMesh()[patchi].name()
|
|
)
|
|
)
|
|
{
|
|
cuttingPatchTable.insert
|
|
(
|
|
meshTarget.boundaryMesh()[patchi].name(),
|
|
-1
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return cuttingPatchTable.toc();
|
|
}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
argList::addNote
|
|
(
|
|
"map volume fields from one mesh to another"
|
|
);
|
|
argList::noParallel();
|
|
argList::validArgs.append("sourceCase");
|
|
|
|
argList::addOption
|
|
(
|
|
"sourceTime",
|
|
"scalar|'latestTime'",
|
|
"specify the source time"
|
|
);
|
|
argList::addOption
|
|
(
|
|
"sourceRegion",
|
|
"word",
|
|
"specify the source region"
|
|
);
|
|
argList::addOption
|
|
(
|
|
"targetRegion",
|
|
"word",
|
|
"specify the target region"
|
|
);
|
|
argList::addBoolOption
|
|
(
|
|
"parallelSource",
|
|
"the source is decomposed"
|
|
);
|
|
argList::addBoolOption
|
|
(
|
|
"parallelTarget",
|
|
"the target is decomposed"
|
|
);
|
|
argList::addBoolOption
|
|
(
|
|
"consistent",
|
|
"source and target geometry and boundary conditions identical"
|
|
);
|
|
argList::addOption
|
|
(
|
|
"mapMethod",
|
|
"word",
|
|
"specify the mapping method"
|
|
);
|
|
argList::addBoolOption
|
|
(
|
|
"subtract",
|
|
"subtract mapped source from target"
|
|
);
|
|
|
|
argList args(argc, argv);
|
|
|
|
if (!args.check())
|
|
{
|
|
FatalError.exit();
|
|
}
|
|
|
|
fileName rootDirTarget(args.rootPath());
|
|
fileName caseDirTarget(args.globalCaseName());
|
|
|
|
fileName casePath = args[1];
|
|
const fileName rootDirSource = casePath.path().toAbsolute();
|
|
const fileName caseDirSource = casePath.name();
|
|
|
|
Info<< "Source: " << rootDirSource << " " << caseDirSource << endl;
|
|
word sourceRegion = fvMesh::defaultRegion;
|
|
if (args.optionFound("sourceRegion"))
|
|
{
|
|
sourceRegion = args["sourceRegion"];
|
|
Info<< "Source region: " << sourceRegion << endl;
|
|
}
|
|
|
|
Info<< "Target: " << rootDirTarget << " " << caseDirTarget << endl;
|
|
word targetRegion = fvMesh::defaultRegion;
|
|
if (args.optionFound("targetRegion"))
|
|
{
|
|
targetRegion = args["targetRegion"];
|
|
Info<< "Target region: " << targetRegion << endl;
|
|
}
|
|
|
|
const bool parallelSource = args.optionFound("parallelSource");
|
|
const bool parallelTarget = args.optionFound("parallelTarget");
|
|
const bool consistent = args.optionFound("consistent");
|
|
|
|
meshToMesh0::order mapOrder = meshToMesh0::INTERPOLATE;
|
|
if (args.optionFound("mapMethod"))
|
|
{
|
|
const word mapMethod(args["mapMethod"]);
|
|
if (mapMethod == "mapNearest")
|
|
{
|
|
mapOrder = meshToMesh0::MAP;
|
|
}
|
|
else if (mapMethod == "interpolate")
|
|
{
|
|
mapOrder = meshToMesh0::INTERPOLATE;
|
|
}
|
|
else if (mapMethod == "cellPointInterpolate")
|
|
{
|
|
mapOrder = meshToMesh0::CELL_POINT_INTERPOLATE;
|
|
}
|
|
else
|
|
{
|
|
FatalErrorInFunction
|
|
<< "Unknown mapMethod " << mapMethod << ". Valid options are: "
|
|
<< "mapNearest, interpolate and cellPointInterpolate"
|
|
<< exit(FatalError);
|
|
}
|
|
|
|
Info<< "Mapping method: " << mapMethod << endl;
|
|
}
|
|
|
|
const bool subtract = args.optionFound("subtract");
|
|
if (subtract)
|
|
{
|
|
Info<< "Subtracting mapped source field from target" << endl;
|
|
}
|
|
|
|
|
|
#include "createTimes.H"
|
|
|
|
HashTable<word> patchMap;
|
|
wordList cuttingPatches;
|
|
|
|
if (!consistent)
|
|
{
|
|
IOdictionary mapFieldsDict
|
|
(
|
|
IOobject
|
|
(
|
|
"mapFieldsDict",
|
|
runTimeTarget.system(),
|
|
runTimeTarget,
|
|
IOobject::MUST_READ_IF_MODIFIED,
|
|
IOobject::NO_WRITE,
|
|
false
|
|
)
|
|
);
|
|
|
|
mapFieldsDict.lookup("patchMap") >> patchMap;
|
|
mapFieldsDict.lookup("cuttingPatches") >> cuttingPatches;
|
|
}
|
|
|
|
if (parallelSource && !parallelTarget)
|
|
{
|
|
IOdictionary decompositionDict
|
|
(
|
|
IOobject
|
|
(
|
|
"decomposeParDict",
|
|
runTimeSource.system(),
|
|
runTimeSource,
|
|
IOobject::MUST_READ_IF_MODIFIED,
|
|
IOobject::NO_WRITE
|
|
)
|
|
);
|
|
|
|
const int nProcs(decompositionDict.lookup<int>("numberOfSubdomains"));
|
|
|
|
Info<< "Create target mesh\n" << endl;
|
|
|
|
fvMesh meshTarget
|
|
(
|
|
IOobject
|
|
(
|
|
targetRegion,
|
|
runTimeTarget.timeName(),
|
|
runTimeTarget
|
|
),
|
|
false
|
|
);
|
|
|
|
Info<< "Target mesh size: " << meshTarget.nCells() << endl;
|
|
|
|
for (int proci=0; proci<nProcs; proci++)
|
|
{
|
|
Info<< nl << "Source processor " << proci << endl;
|
|
|
|
Time runTimeSource
|
|
(
|
|
Time::controlDictName,
|
|
rootDirSource,
|
|
caseDirSource/fileName(word("processor") + name(proci))
|
|
);
|
|
|
|
#include "setTimeIndex.H"
|
|
|
|
fvMesh meshSource
|
|
(
|
|
IOobject
|
|
(
|
|
sourceRegion,
|
|
runTimeSource.timeName(),
|
|
runTimeSource
|
|
),
|
|
false
|
|
);
|
|
|
|
Info<< "mesh size: " << meshSource.nCells() << endl;
|
|
|
|
if (consistent)
|
|
{
|
|
mapConsistentSubMesh
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
mapOrder,
|
|
subtract
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mapSubMesh
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
patchMap,
|
|
cuttingPatches,
|
|
mapOrder,
|
|
subtract
|
|
);
|
|
}
|
|
}
|
|
}
|
|
else if (!parallelSource && parallelTarget)
|
|
{
|
|
IOdictionary decompositionDict
|
|
(
|
|
IOobject
|
|
(
|
|
"decomposeParDict",
|
|
runTimeTarget.system(),
|
|
runTimeTarget,
|
|
IOobject::MUST_READ_IF_MODIFIED,
|
|
IOobject::NO_WRITE
|
|
)
|
|
);
|
|
|
|
const int nProcs(decompositionDict.lookup<int>("numberOfSubdomains"));
|
|
|
|
Info<< "Create source mesh\n" << endl;
|
|
|
|
#include "setTimeIndex.H"
|
|
|
|
fvMesh meshSource
|
|
(
|
|
IOobject
|
|
(
|
|
sourceRegion,
|
|
runTimeSource.timeName(),
|
|
runTimeSource
|
|
),
|
|
false
|
|
);
|
|
|
|
Info<< "Source mesh size: " << meshSource.nCells() << endl;
|
|
|
|
for (int proci=0; proci<nProcs; proci++)
|
|
{
|
|
Info<< nl << "Target processor " << proci << endl;
|
|
|
|
Time runTimeTarget
|
|
(
|
|
Time::controlDictName,
|
|
rootDirTarget,
|
|
caseDirTarget/fileName(word("processor") + name(proci))
|
|
);
|
|
|
|
fvMesh meshTarget
|
|
(
|
|
IOobject
|
|
(
|
|
targetRegion,
|
|
runTimeTarget.timeName(),
|
|
runTimeTarget
|
|
),
|
|
false
|
|
);
|
|
|
|
Info<< "mesh size: " << meshTarget.nCells() << endl;
|
|
|
|
if (consistent)
|
|
{
|
|
mapConsistentSubMesh
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
mapOrder,
|
|
subtract
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mapSubMesh
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
patchMap,
|
|
addProcessorPatches(meshTarget, cuttingPatches),
|
|
mapOrder,
|
|
subtract
|
|
);
|
|
}
|
|
}
|
|
}
|
|
else if (parallelSource && parallelTarget)
|
|
{
|
|
IOdictionary decompositionDictSource
|
|
(
|
|
IOobject
|
|
(
|
|
"decomposeParDict",
|
|
runTimeSource.system(),
|
|
runTimeSource,
|
|
IOobject::MUST_READ_IF_MODIFIED,
|
|
IOobject::NO_WRITE
|
|
)
|
|
);
|
|
|
|
const int nProcsSource
|
|
(
|
|
decompositionDictSource.lookup<int>("numberOfSubdomains")
|
|
);
|
|
|
|
|
|
IOdictionary decompositionDictTarget
|
|
(
|
|
IOobject
|
|
(
|
|
"decomposeParDict",
|
|
runTimeTarget.system(),
|
|
runTimeTarget,
|
|
IOobject::MUST_READ_IF_MODIFIED,
|
|
IOobject::NO_WRITE
|
|
)
|
|
);
|
|
|
|
const int nProcsTarget
|
|
(
|
|
decompositionDictTarget.lookup<int>("numberOfSubdomains")
|
|
);
|
|
|
|
List<boundBox> bbsTarget(nProcsTarget);
|
|
List<bool> bbsTargetSet(nProcsTarget, false);
|
|
|
|
for (int procISource=0; procISource<nProcsSource; procISource++)
|
|
{
|
|
Info<< nl << "Source processor " << procISource << endl;
|
|
|
|
Time runTimeSource
|
|
(
|
|
Time::controlDictName,
|
|
rootDirSource,
|
|
caseDirSource/fileName(word("processor") + name(procISource))
|
|
);
|
|
|
|
#include "setTimeIndex.H"
|
|
|
|
fvMesh meshSource
|
|
(
|
|
IOobject
|
|
(
|
|
sourceRegion,
|
|
runTimeSource.timeName(),
|
|
runTimeSource
|
|
),
|
|
false
|
|
);
|
|
|
|
Info<< "mesh size: " << meshSource.nCells() << endl;
|
|
|
|
boundBox bbSource(meshSource.bounds());
|
|
|
|
for (int procITarget=0; procITarget<nProcsTarget; procITarget++)
|
|
{
|
|
if
|
|
(
|
|
!bbsTargetSet[procITarget]
|
|
|| (
|
|
bbsTargetSet[procITarget]
|
|
&& bbsTarget[procITarget].overlaps(bbSource)
|
|
)
|
|
)
|
|
{
|
|
Info<< nl << "Target processor " << procITarget << endl;
|
|
|
|
Time runTimeTarget
|
|
(
|
|
Time::controlDictName,
|
|
rootDirTarget,
|
|
caseDirTarget/fileName(word("processor")
|
|
+ name(procITarget))
|
|
);
|
|
|
|
fvMesh meshTarget
|
|
(
|
|
IOobject
|
|
(
|
|
targetRegion,
|
|
runTimeTarget.timeName(),
|
|
runTimeTarget
|
|
),
|
|
false
|
|
);
|
|
|
|
Info<< "mesh size: " << meshTarget.nCells() << endl;
|
|
|
|
bbsTarget[procITarget] = meshTarget.bounds();
|
|
bbsTargetSet[procITarget] = true;
|
|
|
|
if (bbsTarget[procITarget].overlaps(bbSource))
|
|
{
|
|
if (consistent)
|
|
{
|
|
mapConsistentSubMesh
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
mapOrder,
|
|
subtract
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mapSubMesh
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
patchMap,
|
|
addProcessorPatches(meshTarget, cuttingPatches),
|
|
mapOrder,
|
|
subtract
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#include "setTimeIndex.H"
|
|
|
|
Info<< "Create meshes\n" << endl;
|
|
|
|
fvMesh meshSource
|
|
(
|
|
IOobject
|
|
(
|
|
sourceRegion,
|
|
runTimeSource.timeName(),
|
|
runTimeSource
|
|
),
|
|
false
|
|
);
|
|
|
|
fvMesh meshTarget
|
|
(
|
|
IOobject
|
|
(
|
|
targetRegion,
|
|
runTimeTarget.timeName(),
|
|
runTimeTarget
|
|
),
|
|
false
|
|
);
|
|
|
|
Info<< "Source mesh size: " << meshSource.nCells() << tab
|
|
<< "Target mesh size: " << meshTarget.nCells() << nl << endl;
|
|
|
|
if (consistent)
|
|
{
|
|
mapConsistentMesh(meshSource, meshTarget, mapOrder, subtract);
|
|
}
|
|
else
|
|
{
|
|
mapSubMesh
|
|
(
|
|
meshSource,
|
|
meshTarget,
|
|
patchMap,
|
|
cuttingPatches,
|
|
mapOrder,
|
|
subtract
|
|
);
|
|
}
|
|
}
|
|
|
|
Info<< "\nEnd\n" << endl;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// ************************************************************************* //
|