Skip to content

GitLab

Commit 55e5a777 authored by shunbo's avatar shunbo
Browse files

initial commit

parents
Hide whitespace changes
Inline Side-by-side
Showing with 1591 additions and 0 deletions
OpenFOAM-v2112/applications/test/hexRef8/Test-hexRef8.C 0 → 100644
View file @ 55e5a777
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2013-2016 OpenFOAM Foundation
-------------------------------------------------------------------------------
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
Test-hexRef8
Description
Test app for refinement and unrefinement. Runs a few iterations refining
and unrefining.
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "Time.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "pointFields.H"
#include "hexRef8.H"
#include "mapPolyMesh.H"
#include "polyTopoChange.H"
#include "Random.H"
#include "zeroGradientFvPatchFields.H"
#include "calculatedPointPatchFields.H"
#include "pointConstraints.H"
#include "fvCFD.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
#include "addTimeOptions.H"
argList::addArgument("inflate (true|false)");
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
const pointConstraints& pc = pointConstraints::New(pointMesh::New(mesh));
const Switch inflate(args[1]);
if (inflate)
{
Info<< "Splitting/deleting cells using inflation/deflation" << nl
<< endl;
}
else
{
Info<< "Splitting/deleting cells, introducing points at new position"
<< nl << endl;
}
Random rndGen(0);
// Force generation of V()
(void)mesh.V();
// Test mapping
// ------------
// 1. uniform field stays uniform
volScalarField one
(
IOobject
(
"one",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("one", dimless, 1.0),
zeroGradientFvPatchScalarField::typeName
);
Info<< "Writing one field "
<< one.name() << " in " << runTime.timeName() << endl;
one.write();
// 2. linear profile gets preserved
volScalarField ccX
(
IOobject
(
"ccX",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh.C().component(0)
);
Info<< "Writing x component of cell centres to "
<< ccX.name()
<< " in " << runTime.timeName() << endl;
ccX.write();
// Uniform surface field
surfaceScalarField surfaceOne
(
IOobject
(
"surfaceOne",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("one", dimless, 1.0),
calculatedFvsPatchScalarField::typeName
);
Info<< "Writing surface one field "
<< surfaceOne.name() << " in " << runTime.timeName() << endl;
surfaceOne.write();
// Uniform point field
pointScalarField pointX
(
IOobject
(
"pointX",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
pointMesh::New(mesh),
dimensionedScalar("one", dimless, 1.0),
calculatedPointPatchScalarField::typeName
);
pointX.primitiveFieldRef() = mesh.points().component(0);
pointX.correctBoundaryConditions();
Info<< "Writing x-component field "
<< pointX.name() << " in " << runTime.timeName() << endl;
pointX.write();
// Force allocation of V. Important for any mesh changes since otherwise
// old time volumes are not stored
const scalar totalVol = gSum(mesh.V());
// Construct refiner. Read initial cell and point levels.
hexRef8 meshCutter(mesh);
// Comparison for inequality
const auto isNotEqual = notEqualOp<scalar>(1e-10);
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
if (mesh.globalData().nTotalCells() == 0)
{
break;
}
mesh.moving(false);
mesh.topoChanging(false);
label action = rndGen.position<label>(0, 5);
if (action == 0)
{
Info<< nl << "-- moving only" << endl;
mesh.movePoints(pointField(mesh.points()));
}
else if (action == 1 || action == 2)
{
// Mesh changing engine.
polyTopoChange meshMod(mesh);
if (action == 1)
{
// Refine
label nRefine = mesh.nCells()/20;
DynamicList<label> refineCandidates(nRefine);
for (label i=0; i<nRefine; i++)
{
refineCandidates.append
(
rndGen.position<label>(0, mesh.nCells()-1)
);
}
labelList cellsToRefine
(
meshCutter.consistentRefinement
(
refineCandidates,
true // buffer layer
)
);
Info<< nl << "-- selected "
<< returnReduce(cellsToRefine.size(), sumOp<label>())
<< " cells out of " << mesh.globalData().nTotalCells()
<< " for refinement" << endl;
// Play refinement commands into mesh changer.
meshCutter.setRefinement(cellsToRefine, meshMod);
}
else
{
// Unrefine
labelList allSplitPoints(meshCutter.getSplitPoints());
label nUnrefine = allSplitPoints.size()/20;
labelHashSet candidates(2*nUnrefine);
for (label i=0; i<nUnrefine; i++)
{
const label index =
rndGen.position<label>(0, allSplitPoints.size()-1);
candidates.insert(allSplitPoints[index]);
}
labelList splitPoints = meshCutter.consistentUnrefinement
(
candidates.toc(),
false
);
Info<< nl << "-- selected "
<< returnReduce(splitPoints.size(), sumOp<label>())
<< " points out of "
<< returnReduce(allSplitPoints.size(), sumOp<label>())
<< " for unrefinement" << endl;
// Play refinement commands into mesh changer.
meshCutter.setUnrefinement(splitPoints, meshMod);
}
// Create mesh, return map from old to new mesh.
Info<< nl << "-- actually changing mesh" << endl;
autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh, inflate);
// Update fields
Info<< nl << "-- mapping mesh data" << endl;
mesh.updateMesh(map());
// Inflate mesh
if (map().hasMotionPoints())
{
Info<< nl << "-- moving mesh" << endl;
mesh.movePoints(map().preMotionPoints());
}
// Update numbering of cells/vertices.
Info<< nl << "-- mapping hexRef8 data" << endl;
meshCutter.updateMesh(map());
}
Info<< nl<< "-- Mesh : moving:" << mesh.moving()
<< " topoChanging:" << mesh.topoChanging()
<< " changing:" << mesh.changing()
<< endl;
Info<< "Writing fields" << nl << endl;
runTime.write();
// Check mesh volume conservation
if (mesh.moving())
{
#include "volContinuity.H"
}
else
{
if (mesh.V().size() != mesh.nCells())
{
FatalErrorInFunction
<< "Volume not mapped. V:" << mesh.V().size()
<< " nCells:" << mesh.nCells()
<< exit(FatalError);
}
const scalar newVol = gSum(mesh.V());
Info<< "Initial volume = " << totalVol
<< " New volume = " << newVol
<< endl;
if (mag(newVol-totalVol)/totalVol > 1e-10)
{
FatalErrorInFunction
<< "Volume loss: old volume:" << totalVol
<< " new volume:" << newVol
<< exit(FatalError);
}
else
{
Info<< "Volume check OK" << nl << endl;
}
}
// Check constant profile
{
const scalar max = gMax(one);
const scalar min = gMin(one);
Info<< "Uniform one field min = " << min
<< " max = " << max << endl;
if (isNotEqual(min, 1) || isNotEqual(max, 1))
{
FatalErrorInFunction
<< "Uniform volVectorField not preserved."
<< " Min and max should both be 1.0. min:" << min
<< " max:" << max
<< exit(FatalError);
}
else
{
Info<< "Uniform field mapping check OK" << nl << endl;
}
}
// Check linear profile
{
const scalarField diff = ccX-mesh.C().component(0);
const scalar max = gMax(diff);
const scalar min = gMin(diff);
Info<< "Linear profile field min = " << min
<< " max = " << max << endl;
if (isNotEqual(min, 0) || isNotEqual(max, 0))
{
Info<< "Linear profile not preserved."
<< " Min and max should both be 0.0. min:" << min
<< " max:" << max << nl << endl;
}
else
{
Info<< "Linear profile mapping check OK" << nl << endl;
}
}
// Check face field mapping
if (surfaceOne.size())
{
const scalar max = gMax(surfaceOne.primitiveField());
const scalar min = gMin(surfaceOne.primitiveField());
Info<< "Uniform surface field min = " << min
<< " max = " << max << endl;
if (isNotEqual(min, 1) || isNotEqual(max, 1))
{
FatalErrorInFunction
<< "Uniform surfaceScalarField not preserved."
<< " Min and max should both be 1.0. min:" << min
<< " max:" << max
<< exit(FatalError);
}
else
{
Info<< "Uniform surfaceScalarField mapping check OK" << nl
<< endl;
}
}
runTime.printExecutionTime(Info);
}
Info<< "pc:" << pc.patchPatchPointConstraintPoints().size() << endl;
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //
OpenFOAM-v2112/applications/test/hexRef8/block/Allrun 0 → 100644
View file @ 55e5a777
#!/bin/sh
cd "${0%/*}" || exit # Run from this directory
. ${WM_PROJECT_DIR:?}/bin/tools/RunFunctions # Tutorial run functions
#------------------------------------------------------------------------------
application=Test-hexRef8
runApplication wmake ..
runApplication blockMesh
# Run with inflation
runApplication $application true
mv "log.$application" "log.$application-inflate"
# Run without inflation
runApplication $application false
#------------------------------------------------------------------------------
OpenFOAM-v2112/applications/test/hexRef8/block/constant/manualDecomposition 0 → 100644
View file @ 55e5a777
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2112 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class labelList;
location "constant";
object cellDecomposition;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
400
(
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
)
// ************************************************************************* //
OpenFOAM-v2112/applications/test/hexRef8/block/constant/transportProperties 0 → 100644
View file @ 55e5a777
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2112 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object transportProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
nu nu [ 0 2 -1 0 0 0 0 ] 0.01;
// ************************************************************************* //
OpenFOAM-v2112/applications/test/hexRef8/block/system/blockMeshDict 0 → 100644
View file @ 55e5a777
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2112 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
scale 1;
vertices
(
(0 0 0)
(1 0 0)
(1 1 0)
(0 1 0)
(0 0 1)
(1 0 1)
(1 1 1)
(0 1 1)
);
blocks
(
hex (0 1 2 3 4 5 6 7) (5 5 5) simpleGrading (1 1 1)
);
edges
(
);
boundary
(
allWalls
{
type wall;
faces
(
(3 7 6 2)
(0 4 7 3)
(2 6 5 1)
(1 5 4 0)
(0 3 2 1)
(4 5 6 7)
);
}
);
// ************************************************************************* //
OpenFOAM-v2112/applications/test/hexRef8/block/system/controlDict 0 → 100644
View file @ 55e5a777
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2112 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
DebugSwitches
{
primitiveMesh 1;
polyMesh 1;
fvMesh 1;
polyTopoChange 1;
pointMesh 1;
pointConstraints 1;
}
application icoFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 30;
deltaT 1;
writeControl timeStep;
writeInterval 1;
purgeWrite 0;
writeFormat ascii;
writePrecision 10;
writeCompression off;
timeFormat general;
timePrecision 6;
runTimeModifiable true;
// ************************************************************************* //
OpenFOAM-v2112/applications/test/hexRef8/block/system/fvSchemes 0 → 100644
View file @ 55e5a777
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2112 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
grad(p) Gauss linear;
}
divSchemes
{
default none;
div(phi,U) Gauss linear;
}
laplacianSchemes
{
default Gauss linear orthogonal;
}
interpolationSchemes
{
default linear;
}
snGradSchemes
{
default orthogonal;
}
// ************************************************************************* //
OpenFOAM-v2112/applications/test/hexRef8/block/system/fvSolution 0 → 100644
View file @ 55e5a777
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2112 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
p
{
solver PCG;
preconditioner DIC;
tolerance 1e-06;
relTol 0;
}
U
{
solver PBiCGStab;
preconditioner DILU;
tolerance 1e-05;
relTol 0;
}
}
PISO
{
nCorrectors 2;
nNonOrthogonalCorrectors 0;
pRefCell 0;
pRefValue 0;
}
// ************************************************************************* //
OpenFOAM-v2112/applications/test/instant/Make/files 0 → 100644
View file @ 55e5a777
Test-instant.C
EXE = $(FOAM_USER_APPBIN)/Test-instant
OpenFOAM-v2112/applications/test/instant/Make/options 0 → 100644
View file @ 55e5a777
/* EXE_INC = -I$(LIB_SRC)/finiteVolume/lnInclude */
/* EXE_LIBS = -lfiniteVolume */
OpenFOAM-v2112/applications/test/instant/Test-instant.C 0 → 100644
View file @ 55e5a777
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2018 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/>.
Description
Test instant, fileNameInstant
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "instant.H"
#include "fileNameInstant.H"
#include "DynamicList.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
DynamicList<instant> times;
times.append(instant{});
times.append({12, "abc"});
times.append(instant{3.14159});
times.append({300.456, "def"});
times.append({454.456, "xyz"});
times.append({10, "ten"});
{
word timeName("twenty");
Info<<"move append: " << timeName << nl;
times.append({20, std::move(timeName)});
Info<<"after append: " << timeName << nl;
}
Info<< nl << "times:" << times << nl;
sort(times);
Info<< "Sorted:" << times << nl;
DynamicList<fileNameInstant> files;
files.append(fileNameInstant{});
files.append({12, "twelve"});
files.append({3.14, "/path/almost-pi"});
files.append({300, "/dev/value"});
files.append({454, "/tmp/xyz"});
files.append({10, "ten"});
Info<< nl << "files:" << files << nl;
sort(files);
Info<< "Sorted:" << files << nl;
Info<< "\nEnd\n" << endl;
return 0;
}
// ************************************************************************* //
OpenFOAM-v2112/applications/test/io/Make/files 0 → 100644
View file @ 55e5a777
Test-io.C
EXE = $(FOAM_USER_APPBIN)/Test-io
OpenFOAM-v2112/applications/test/io/Test-io.C 0 → 100644
View file @ 55e5a777
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011 OpenFOAM Foundation
Copyright (C) 2018 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
Test-io
Description
Test basic stream functionality
\*---------------------------------------------------------------------------*/
#include "IOstreams.H"
#include "IOmanip.H"
#include "scalar.H"
#include "List.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(void)
{
string st("sfdsf sdfs23df sdf32f . sdfsdff23/2sf32");
Info<<"string: " << st << nl;
Info<<"word: \"" << string::validate<word>(st) << "\"" << endl;
string st1("1234567");
Info<< label(st1.size()) << tab << string(word(st1)) << endl;
Info<< setw(20) << setprecision(3) << 1.234234 << endl;
Info<< hex << 255 << endl;
Info<< nl << "Formatted fields" << nl;
const char oldfill = static_cast<OSstream&>(Info).fill();
Info<< setfill('-');
Info<< "|" << setf(ios_base::left) << setw(32) << " foo " << "|" << nl;
Info<< "|" << setf(ios_base::left) << setw(10) << " bar " << "|" << nl;
Info<< "|" << setf(ios_base::left) << setw(10) << "" << "|" << nl;
Info<< "resetting fill from (0x" << hex << int(oldfill) << ")" << nl;
Info<< setfill(oldfill);
Info<< "|" << setf(ios_base::left) << setw(10) << " bar " << "|" << nl;
Info<< nl << nl;
Info.operator Foam::OSstream&() << "stop" << endl;
static_cast<OSstream&>(Info) << "\nEnd\n" << nl;
return 0;
}
// ************************************************************************* //
OpenFOAM-v2112/applications/test/labelRanges/Make/files 0 → 100644
View file @ 55e5a777
Test-labelRanges.C
EXE = $(FOAM_USER_APPBIN)/Test-labelRanges
OpenFOAM-v2112/applications/test/labelRanges/Test-labelRanges.C 0 → 100644
View file @ 55e5a777
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011 OpenFOAM Foundation
Copyright (C) 2017-2021 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
Description
Test label ranges
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "labelRanges.H"
using namespace Foam;
void printInfo(const labelRange& range)
{
Info<< "first " << range.first() << nl
<< "last " << range.last() << nl
<< "min " << range.min() << nl
<< "max " << range.max() << nl
<< "after " << range.after() << nl
<< "begin end " << *range.cbegin() << ' ' << *range.cend() << nl;
// Info<< "rbegin rend " << *range.rbegin() << ' ' << *range.rend() << nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
argList::noParallel();
argList::noFunctionObjects();
argList::addArgument("start size .. startN sizeN");
argList::addVerbose("enable labelRange::debug");
argList::addNote
(
"The default is to add ranges, use 'add' and 'del' to toggle\n\n"
"Eg, 0 10 30 10 del 20 15"
);
argList args(argc, argv, false, true);
if (args.verbose())
{
labelRange::debug = 1;
}
{
labelRange range(5, 10);
Info<< "identity: " << identity(range) << nl;
}
{
Info<<"test sorting" << endl;
DynamicList<labelRange> list1(10);
list1.append(labelRange(25, 8));
list1.append(labelRange(8));
list1.append(labelRange(15, 5));
list1.append(labelRange(50, -10, true));
sort(list1);
Info<<"sorted" << list1 << endl;
}
{
Info<<"test intersections" << endl;
labelRange range1(-15, 25);
labelRange range2(7, 8);
labelRange range3(-20, 8);
labelRange range4(50, 8);
Info<<range1 << " & " << range2
<< " = " << range1.subset(range2) << nl;
Info<< range1 << " & " << range3
<< " = " << range1.subset(range3) << nl;
Info<< range2 << " & " << range4
<< " = " << range2.subset(range4) << nl;
}
labelRange range;
labelRanges ranges;
bool removeMode = false;
for (label argI=1; argI < args.size()-1; ++argI)
{
if (args[argI] == "add")
{
removeMode = false;
continue;
}
else if (args[argI] == "del")
{
removeMode = true;
continue;
}
{
label start = args.get<label>(argI);
label size = args.get<label>(argI+1);
++argI;
range.reset(start, size);
}
Info<< "---------------" << nl;
if (removeMode)
{
Info<< "del " << range << " :";
for (auto i : range)
{
Info<< " " << i;
}
Info<< nl;
ranges.remove(range);
}
else
{
Info<< "add " << range << " :";
for (auto i : range)
{
Info<< " " << i;
}
Info<< nl;
ranges.add(range);
}
Info<< "<list>" << ranges << "</list>" << nl
<< "content:";
for (auto i : ranges)
{
Info<< " " << i;
}
Info<< nl;
}
{
range.reset(5, 5);
Info<< nl << "Tests on " << range << nl;
printInfo(range);
range += 3;
Info<< "increase size " << range << nl;
range -= 3; // Probably not a great idea
Info<< "decrease size " << range << nl;
auto iter = range.begin();
Info<< "iter: " << *iter << nl;
++iter;
Info<< "iter: " << *iter << nl;
iter += 3;
Info<< "iter: " << *iter << nl;
Info<< nl << "reversed:" << nl;
forAllConstReverseIters(range, iter)
{
Info<< ' ' << *iter;
}
Info<< nl;
}
Info<< "\nEnd\n" << endl;
return 0;
}
// ************************************************************************* //
OpenFOAM-v2112/applications/test/leastSquareGrad/Make/files 0 → 100644
View file @ 55e5a777
Test-leastSquareGrad.C
EXE = $(FOAM_USER_APPBIN)/Test-leastSquareGrad
OpenFOAM-v2112/applications/test/leastSquareGrad/Make/options 0 → 100644
View file @ 55e5a777
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lsampling
OpenFOAM-v2112/applications/test/leastSquareGrad/Test-leastSquareGrad.C 0 → 100644
View file @ 55e5a777
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2020 DLR
-------------------------------------------------------------------------------
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
Test-leastSquareGrad
Description
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "leastSquareGrad.H"
#include "labelVector.H"
#include "Field.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
labelVector geomDim(1,1,-1);
leastSquareGrad<scalar> lsGrad("polyDegree1", geomDim);
List<vector> pos
({
{0,0,0},
{1,0,0},
{-1,0,0},
{0,1,0},
{0,-1,0},
// {1,1,0}
});
List<scalar> values
({
0, 1, -1, 1, -1
//, 2
});
Map<List<vector>> posMap;
posMap.insert(0, pos);
posMap.insert(1, pos);
posMap.insert(2, pos);
Map<List<scalar>> valMap;
valMap.insert(0, values);
valMap.insert(1, values);
valMap.insert(2, values);
Info<< lsGrad.grad(posMap, valMap) << nl;
leastSquareGrad<vector> lsGradVec("polyDegree1", geomDim);
List<vector> valuesVec
({
{0,0,0},
{1,0,0},
{-1,0,0},
{1,0,0},
{-1,0,0}
});
Map<List<vector>> valMapVec;
valMapVec.insert(0, valuesVec);
valMapVec.insert(1, valuesVec);
valMapVec.insert(2, valuesVec);
Info<< lsGradVec.grad(posMap,valMapVec) << nl;
return 0;
}
// ************************************************************************* //
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment