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

Merge branch 'develop' of develop.openfoam.com:Development/OpenFOAM-plus into develop

Browse Source
This commit is contained in:
sergio
2016-06-22 09:19:36 -07:00
parent 36ad131dc9 9aa3681dcc
commit 08be9fcb5d
102 changed files with 2732 additions and 809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
applications/test/cpuInfo/Make/files Normal file
View File

@ -0,0 +1,3 @@
Test-cpuInfo.C
EXE = $(FOAM_USER_APPBIN)/Test-cpuInfo

0
applications/test/cpuInfo/Make/options Normal file
View File

51
src/OSspecific/POSIX/memInfo/memInfoIO.C → applications/test/cpuInfo/Test-cpuInfo.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -21,49 +21,26 @@ License
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
\*---------------------------------------------------------------------------*/
#include "memInfo.H"
#include "cpuInfo.H"
#include "IOstreams.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
using namespace Foam;
Foam::memInfo::memInfo(Istream& is)
:
base1(is),
base2(is),
member1(is),
member2(is)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
// Check state of Istream
is.check("Foam::memInfo::memInfo(Foam::Istream&)");
}
cpuInfo().write(Info);
Info<< endl;
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
Foam::Istream& Foam::operator>>(Istream& is, memInfo&)
{
// Check state of Istream
is.check
(
"Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::memInfo&)"
);
return is;
}
Foam::Ostream& Foam::operator<<(Ostream& os, const memInfo&)
{
// Check state of Ostream
os.check
(
"Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
"const Foam::memInfo&)"
);
return os;
return 0;
}

3
applications/test/sysInfo/Make/files Normal file
View File

@ -0,0 +1,3 @@
Test-sysInfo.C
EXE = $(FOAM_USER_APPBIN)/Test-sysInfo

0
applications/test/sysInfo/Make/options Normal file
View File

46
applications/test/sysInfo/Test-sysInfo.C Normal file
View File

@ -0,0 +1,46 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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
Description
\*---------------------------------------------------------------------------*/
#include "ProfilingSysInfo.H"
#include "IOstreams.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
Profiling::sysInfo().write(Info);
return 0;
}
// ************************************************************************* //

24
applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | Copyright 2015 OpenCFD Ltd.
\\/ M anipulation | Copyright 2015-2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -59,6 +59,7 @@ Description
#include "IOmanip.H"
#include "decompositionModel.H"
#include "fvMeshTools.H"
#include "profiling.H"
using namespace Foam;
@ -633,6 +634,7 @@ int main(int argc, char *argv[])
"fileName",
"name of the file to save the simplified surface to"
);
#include "addProfilingOption.H"
#include "addDictOption.H"
#include "setRootCase.H"
@ -816,7 +818,6 @@ int main(int argc, char *argv[])
const Switch keepPatches(meshDict.lookupOrDefault("keepPatches", false));
// Read decomposePar dictionary
dictionary decomposeDict;
{
@ -927,6 +928,8 @@ int main(int argc, char *argv[])
}
}
// for the impatient who want to see some output files:
profiling::writeNow();
// Read geometry
// ~~~~~~~~~~~~~
@ -957,6 +960,7 @@ int main(int argc, char *argv[])
if (surfaceSimplify)
{
addProfiling(surfaceSimplify, "snappyHexMesh::surfaceSimplify");
IOdictionary foamyHexMeshDict
(
IOobject
@ -1001,6 +1005,8 @@ int main(int argc, char *argv[])
refineDict.lookupOrDefault("gapLevelIncrement", 0),
initialCellSize/defaultCellSize
);
profiling::writeNow();
}
else
{
@ -1535,6 +1541,8 @@ int main(int argc, char *argv[])
Info<< "Mesh refined in = "
<< timer.cpuTimeIncrement() << " s." << endl;
profiling::writeNow();
}
if (wantSnap)
@ -1583,6 +1591,8 @@ int main(int argc, char *argv[])
Info<< "Mesh snapped in = "
<< timer.cpuTimeIncrement() << " s." << endl;
profiling::writeNow();
}
if (wantLayers)
@ -1639,11 +1649,14 @@ int main(int argc, char *argv[])
Info<< "Layers added in = "
<< timer.cpuTimeIncrement() << " s." << endl;
profiling::writeNow();
}
{
addProfiling(checkMesh, "snappyHexMesh::checkMesh");
// Check final mesh
Info<< "Checking final mesh ..." << endl;
faceSet wrongFaces(mesh, "wrongFaces", mesh.nFaces()/100);
@ -1665,11 +1678,15 @@ int main(int argc, char *argv[])
{
Info<< "Finished meshing without any errors" << endl;
}
profiling::writeNow();
}
if (surfaceSimplify)
{
addProfiling(surfaceSimplify, "snappyHexMesh::surfaceSimplify");
const polyBoundaryMesh& bMesh = mesh.boundaryMesh();
labelHashSet includePatches(bMesh.size());
@ -1727,6 +1744,7 @@ int main(int argc, char *argv[])
cellCentres.write();
}
profiling::writeNow();
Info<< "Finished meshing in = "
<< runTime.elapsedCpuTime() << " s." << endl;

95
applications/utilities/preProcessing/mapFieldsPar/MapVolFields.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -35,6 +35,88 @@ License
namespace Foam
{
template<class Type>
void evaluateConstraintTypes(GeometricField<Type, fvPatchField, volMesh>& fld)
{
typename GeometricField<Type, fvPatchField, volMesh>::
GeometricBoundaryField& fldBf = fld.boundaryField();
if
(
Pstream::defaultCommsType == Pstream::blocking
|| Pstream::defaultCommsType == Pstream::nonBlocking
)
{
label nReq = Pstream::nRequests();
forAll(fldBf, patchi)
{
fvPatchField<Type>& tgtField = fldBf[patchi];
if
(
tgtField.type() == tgtField.patch().patch().type()
&& polyPatch::constraintType(tgtField.patch().patch().type())
)
{
tgtField.initEvaluate(Pstream::defaultCommsType);
}
}
// Block for any outstanding requests
if
(
Pstream::parRun()
&& Pstream::defaultCommsType == Pstream::nonBlocking
)
{
Pstream::waitRequests(nReq);
}
forAll(fldBf, patchi)
{
fvPatchField<Type>& tgtField = fldBf[patchi];
if
(
tgtField.type() == tgtField.patch().patch().type()
&& polyPatch::constraintType(tgtField.patch().patch().type())
)
{
tgtField.evaluate(Pstream::defaultCommsType);
}
}
}
else if (Pstream::defaultCommsType == Pstream::scheduled)
{
const lduSchedule& patchSchedule =
fld.mesh().globalData().patchSchedule();
forAll(patchSchedule, patchEvali)
{
label patchi = patchSchedule[patchEvali].patch;
fvPatchField<Type>& tgtField = fldBf[patchi];
if
(
tgtField.type() == tgtField.patch().patch().type()
&& polyPatch::constraintType(tgtField.patch().patch().type())
)
{
if (patchSchedule[patchEvali].init)
{
tgtField.initEvaluate(Pstream::scheduled);
}
else
{
tgtField.evaluate(Pstream::scheduled);
}
}
}
}
}
template<class Type, class CombineOp>
void MapVolFields
(
@ -57,8 +139,6 @@ void MapVolFields
if (selectedFields.empty() || selectedFields.found(fieldName))
{
Info<< " interpolating " << fieldName << endl;
const fieldType fieldSource(*fieldIter(), meshSource);
IOobject targetIO
@ -71,14 +151,21 @@ void MapVolFields
if (targetIO.typeHeaderOk<fieldType>(true))
{
Info<< " interpolating onto existing field "
<< fieldName << endl;
fieldType fieldTarget(targetIO, meshTarget);
interp.mapSrcToTgt(fieldSource, cop, fieldTarget);
evaluateConstraintTypes(fieldTarget);
fieldTarget.write();
}
else
{
Info<< " creating new field "
<< fieldName << endl;
targetIO.readOpt() = IOobject::NO_READ;
tmp<fieldType>
@ -86,6 +173,8 @@ void MapVolFields
fieldType fieldTarget(targetIO, tfieldTarget);
evaluateConstraintTypes(fieldTarget);
fieldTarget.write();
}
}

30
applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C
View File

@ -121,34 +121,6 @@ void mapSubMesh
}
wordList addProcessorPatches
(
const fvMesh& meshTarget,
const wordList& cuttingPatches
)
{
// Add the processor patches to the cutting list
HashSet<word> cuttingPatchTable;
forAll(cuttingPatches, i)
{
cuttingPatchTable.insert(cuttingPatches[i]);
}
const polyBoundaryMesh& pbm = meshTarget.boundaryMesh();
forAll(pbm, patchI)
{
if (isA<processorPolyPatch>(pbm[patchI]))
{
const word& patchName = pbm[patchI].name();
cuttingPatchTable.insert(patchName);
}
}
return cuttingPatchTable.toc();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
@ -369,7 +341,7 @@ int main(int argc, char *argv[])
meshSource,
meshTarget,
patchMap,
addProcessorPatches(meshTarget, cuttingPatches),
cuttingPatches,
mapMethod,
patchMapMethod,
subtract,

1
src/OSspecific/POSIX/Make/files
View File

@ -10,6 +10,7 @@ fileStat.C
POSIX.C
cpuTime/cpuTime.C
clockTime/clockTime.C
cpuInfo/cpuInfo.C
memInfo/memInfo.C
/*

241
src/OSspecific/POSIX/cpuInfo/cpuInfo.C Normal file
View File

@ -0,0 +1,241 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
\*---------------------------------------------------------------------------*/
#include "cpuInfo.H"
#include "IFstream.H"
#include "IOstreams.H"
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
// file-scope function
template<class T>
inline static void writeEntry
(
Foam::Ostream& os, const Foam::word& key, const T& value
)
{
os.writeKeyword(key) << value << Foam::token::END_STATEMENT << '\n';
}
// file-scope function
static bool split(std::string& line, std::string& key, std::string& val)
{
std::string::size_type sep = line.find(':');
if (sep == std::string::npos)
{
return false;
}
std::string::size_type endKey = line.find_last_not_of("\t:", sep);
std::string::size_type begVal = line.find_first_not_of(" :", sep);
if (endKey == std::string::npos || begVal == std::string::npos)
{
return false;
}
++endKey;
// replace spaces in key with '_' for ease of use/consistency
for
(
std::string::iterator iter = line.begin();
iter != line.end();
++iter
)
{
if (*iter == ' ')
{
*iter = '_';
}
else if (*iter == ':')
{
break;
}
}
key = line.substr(0, endKey);
val = line.substr(begVal);
// std::cerr<<"key=" << key << " val= " << val << '\n';
return true;
}
// file-scope function - get int
static inline bool getInt(const std::string& str, int& val)
{
int i;
if (sscanf(str.c_str(), "%d", &i) == 1)
{
val = i;
return true;
}
else
{
return false;
}
}
// file-scope function - get float
static inline bool getFlt(const std::string& str, float& val)
{
float f;
if (sscanf(str.c_str(), "%f", &f) == 1)
{
val = f;
return true;
}
else
{
return false;
}
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// parse this type of content:
// ===========================
// processor : 0
// vendor_id : GenuineIntel
// cpu family : 6
// model : 63
// model name : Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz
// stepping : 2
// microcode : 0x35
// cpu MHz : 1200.000
// cache size : 15360 KB
// physical id : 0
// siblings : 12
// core id : 0
// cpu cores : 6
// apicid : 0
// initial apicid : 0
// fpu : yes
// fpu_exception : yes
// cpuid level : 15
// wp : yes
// flags : fpu vme ...
// bugs :
// bogomips : 4789.15
// clflush size : 64
// cache_alignment : 64
// address sizes : 46 bits physical, 48 bits virtual
// power management:
void Foam::cpuInfo::parse()
{
int ncpu = 0;
IFstream is("/proc/cpuinfo");
while (is.good())
{
string line, key, value;
is.getLine(line);
if (!split(line, key, value))
{
continue;
}
if (key == "processor")
{
if (ncpu++)
{
break; // stop after the first cpu
}
}
else if (key == "vendor_id") { vendor_id = value; }
else if (key == "model_name") { model_name = value; }
else if (key == "cpu_family") { getInt(value, cpu_family); }
else if (key == "model") { getInt(value, model); }
else if (key == "cpu_MHz") { getFlt(value, cpu_MHz); }
else if (key == "cpu_cores") { getInt(value, cpu_cores); }
else if (key == "siblings") { getInt(value, siblings); }
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cpuInfo::cpuInfo()
:
vendor_id(),
model_name(),
cpu_family(-1),
model(-1),
cpu_MHz(0),
siblings(0),
cpu_cores(0)
{
parse();
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cpuInfo::~cpuInfo()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::cpuInfo::write(Ostream& os) const
{
if (!vendor_id.empty())
{
writeEntry(os, "vendor_id", vendor_id);
}
if (!model_name.empty())
{
writeEntry(os, "model_name", model_name);
}
if (cpu_family != -1)
{
writeEntry(os, "cpu_family", cpu_family);
}
if (model != -1)
{
writeEntry(os, "model", model);
}
if (cpu_MHz > 0)
{
writeEntry(os, "cpu_MHz", cpu_MHz);
}
if (cpu_cores > 0)
{
writeEntry(os, "cpu_cores", cpu_cores);
}
if (siblings > 0)
{
writeEntry(os, "siblings", siblings);
}
}
// ************************************************************************* //

110
src/OSspecific/POSIX/cpuInfo/cpuInfo.H Normal file
View File

@ -0,0 +1,110 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
Class
Foam::cpuInfo
Description
General CPU characteristics.
If the machine has multiple cpus/cores, only the characteristics
of the first core are used.
Note
Uses the information from /proc/cpuinfo
SourceFiles
cpuInfo.C
\*---------------------------------------------------------------------------*/
#ifndef cpuInfo_H
#define cpuInfo_H
#include <string>
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// forward declarations
class Ostream;
/*---------------------------------------------------------------------------*\
Class cpuInfo Declaration
\*---------------------------------------------------------------------------*/
class cpuInfo
{
// Private data
// Various bits from /proc/cpuinfo
std::string vendor_id;
std::string model_name;
int cpu_family;
int model;
float cpu_MHz;
int siblings;
int cpu_cores;
// Private Member Functions
//- Parse /proc/cpuinfo
void parse();
//- Disallow default bitwise assignment
void operator=(const cpuInfo&) = delete;
//- Disallow default copy constructor
cpuInfo(const cpuInfo&) = delete;
public:
// Constructors
//- Construct null
cpuInfo();
//- Destructor
~cpuInfo();
// Member Functions
//- Write content as dictionary entries
void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

42
src/OSspecific/POSIX/memInfo/memInfo.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -24,14 +24,29 @@ License
\*---------------------------------------------------------------------------*/
#include "memInfo.H"
#include "IFstream.H"
#include "IOstreams.H"
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
// file-scope function
template<class T>
inline static void writeEntry
(
Foam::Ostream& os, const Foam::word& key, const T& value
)
{
os.writeKeyword(key) << value << Foam::token::END_STATEMENT << '\n';
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::memInfo::memInfo()
:
peak_(-1),
size_(-1),
rss_(-1)
peak_(0),
size_(0),
rss_(0)
{
update();
}
@ -48,7 +63,7 @@ Foam::memInfo::~memInfo()
const Foam::memInfo& Foam::memInfo::update()
{
// reset to invalid values first
peak_ = size_ = rss_ = -1;
peak_ = size_ = rss_ = 0;
IFstream is("/proc/" + name(pid()) + "/status");
while (is.good())
@ -81,7 +96,15 @@ const Foam::memInfo& Foam::memInfo::update()
bool Foam::memInfo::valid() const
{
return peak_ != -1;
return peak_ > 0;
}
void Foam::memInfo::write(Ostream& os) const
{
writeEntry(os, "size", size_);
writeEntry(os, "peak", peak_);
writeEntry(os, "rss", rss_);
}
@ -108,14 +131,15 @@ Foam::Istream& Foam::operator>>(Istream& is, memInfo& m)
Foam::Ostream& Foam::operator<<(Ostream& os, const memInfo& m)
{
os << token::BEGIN_LIST
<< m.peak_ << token::SPACE << m.size_ << token::SPACE << m.rss_
<< m.peak_ << token::SPACE
<< m.size_ << token::SPACE
<< m.rss_
<< token::END_LIST;
// Check state of Ostream
os.check
(
"Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
"const Foam::memInfo&)"
"Foam::Ostream& Foam::operator<<(Foam::Ostream&, const Foam::memInfo&)"
);
return os;

34
src/OSspecific/POSIX/memInfo/memInfo.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -28,7 +28,7 @@ Description
Memory usage information for the process running this object.
Note
Uses the information from /proc/\<pid\>/status
Uses the information from /proc/PID/status
SourceFiles
memInfo.C
@ -47,6 +47,10 @@ SourceFiles
namespace Foam
{
// forward declarations
class Istream;
class Ostream;
/*---------------------------------------------------------------------------*\
Class memInfo Declaration
\*---------------------------------------------------------------------------*/
@ -55,15 +59,20 @@ class memInfo
{
// Private data
//- Peak memory used by the process (VmPeak in /proc/\<pid\>/status)
//- Peak memory used by the process (VmPeak in /proc/PID/status)
int peak_;
//- Memory used by the process (VmSize in /proc/\<pid\>/status)
//- Memory used by the process (VmSize in /proc/PID/status)
int size_;
//- Resident set size of the process (VmRSS in /proc/\<pid\>/status)
//- Resident set size of the process (VmRSS in /proc/PID/status)
int rss_;
//- Disallow default bitwise assignment
void operator=(const memInfo&) = delete;
//- Disallow default copy constructor
memInfo(const memInfo&) = delete;
public:
@ -79,27 +88,24 @@ public:
// Member Functions
//- Parse /proc/\<pid\>/status
//- Parse /proc/PID/status and update accordingly
const memInfo& update();
// Access
//- Access the stored peak memory (VmPeak in /proc/\<pid\>/status)
// The value is stored from the previous update()
//- Peak memory (VmPeak in /proc/PID/status) at last update()
int peak() const
{
return peak_;
}
//- Access the stored memory size (VmSize in /proc/\<pid\>/status)
// The value is stored from the previous update()
//- Memory size (VmSize in /proc/PID/status) at last update()
int size() const
{
return size_;
}
//- Access the stored rss value (VmRSS in /proc/\<pid\>/status)
// The value is stored from the previous update()
//- Resident set size (VmRSS in /proc/PID/status) at last update()
int rss() const
{
return rss_;
@ -109,6 +115,10 @@ public:
bool valid() const;
//- Write content as dictionary entries
void write(Ostream&) const;
// IOstream Operators
//- Read peak/size/rss from stream

2
src/OpenFOAM/Make/files
View File

@ -3,6 +3,8 @@ global/global.Cver
/* global/constants/dimensionedConstants.C in global.Cver */
global/argList/argList.C
global/clock/clock.C
global/profiling/profiling.C
global/profiling/profilingSysInfo.C
bools = primitives/bools
$(bools)/bool/bool.C

139
src/OpenFOAM/db/Time/Time.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | Copyright (C) 2015 OpenCFD Ltd.
\\/ M anipulation | Copyright (C) 2015-2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -27,6 +27,7 @@ License
#include "PstreamReduceOps.H"
#include "argList.H"
#include "HashSet.H"
#include "profiling.H"
#include <sstream>
@ -333,6 +334,72 @@ void Foam::Time::setControls()
}
void Foam::Time::setMonitoring(bool forceProfiling)
{
const dictionary* profilingDict = controlDict_.subDictPtr("profiling");
// initialize profiling on request
// otherwise rely on profiling entry within controlDict
// and skip if 'active' keyword is explicitly set to false
if (forceProfiling)
{
profiling::initialize
(
IOobject
(
"profiling",
timeName(),
"uniform",
*this,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
*this
);
}
else if
(
profilingDict
&& profilingDict->lookupOrDefault<Switch>("active", true)
)
{
profiling::initialize
(
*profilingDict,
IOobject
(
"profiling",
timeName(),
"uniform",
*this,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
*this
);
}
// Time objects not registered so do like objectRegistry::checkIn ourselves.
if (runTimeModifiable_)
{
monitorPtr_.reset
(
new fileMonitor
(
regIOobject::fileModificationChecking == inotify
|| regIOobject::fileModificationChecking == inotifyMaster
)
);
// Monitor all files that controlDict depends on
addWatches(controlDict_, controlDict_.files());
}
// Clear dependent files - not needed now
controlDict_.files().clear();
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::Time::Time
@ -401,25 +468,7 @@ Foam::Time::Time
readOpt() = IOobject::MUST_READ_IF_MODIFIED;
setControls();
// Time objects not registered so do like objectRegistry::checkIn ourselves.
if (runTimeModifiable_)
{
monitorPtr_.reset
(
new fileMonitor
(
regIOobject::fileModificationChecking == inotify
|| regIOobject::fileModificationChecking == inotifyMaster
)
);
// Monitor all files that controlDict depends on
addWatches(controlDict_, controlDict_.files());
}
// Clear dependent files
controlDict_.files().clear();
setMonitoring();
}
@ -496,24 +545,8 @@ Foam::Time::Time
setControls();
// Time objects not registered so do like objectRegistry::checkIn ourselves.
if (runTimeModifiable_)
{
monitorPtr_.reset
(
new fileMonitor
(
regIOobject::fileModificationChecking == inotify
|| regIOobject::fileModificationChecking == inotifyMaster
)
);
// Monitor all files that controlDict depends on
addWatches(controlDict_, controlDict_.files());
}
// Clear dependent files since not needed
controlDict_.files().clear();
// '-profiling' = force profiling, ignore controlDict entry
setMonitoring(args.optionFound("profiling"));
}
@ -588,25 +621,7 @@ Foam::Time::Time
controlDict_.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
setControls();
// Time objects not registered so do like objectRegistry::checkIn ourselves.
if (runTimeModifiable_)
{
monitorPtr_.reset
(
new fileMonitor
(
regIOobject::fileModificationChecking == inotify
|| regIOobject::fileModificationChecking == inotifyMaster
)
);
// Monitor all files that controlDict depends on
addWatches(controlDict_, controlDict_.files());
}
// Clear dependent files since not needed
controlDict_.files().clear();
setMonitoring();
}
@ -667,6 +682,7 @@ Foam::Time::Time
functionObjects_(*this, enableFunctionObjects)
{
libs_.open(controlDict_, "libs");
setMonitoring(); // for profiling etc
}
@ -681,6 +697,9 @@ Foam::Time::~Time()
// destroy function objects first
functionObjects_.clear();
// cleanup profiling
profiling::stop(*this);
}
@ -922,9 +941,13 @@ bool Foam::Time::run() const
{
// Ensure functionObjects execute on last time step
// (and hence write uptodate functionObjectProperties)
addProfiling(foExec, "functionObjects.execute()");
functionObjects_.execute();
endProfiling(foExec);
addProfiling(foEnd, "functionObjects.end()");
functionObjects_.end();
endProfiling(foEnd);
}
}
@ -936,10 +959,12 @@ bool Foam::Time::run() const
if (timeIndex_ == startTimeIndex_)
{
addProfiling(functionObjects, "functionObjects.start()");
functionObjects_.start();
}
else
{
addProfiling(functionObjects, "functionObjects.execute()");
functionObjects_.execute();
}
}

6
src/OpenFOAM/db/Time/Time.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -181,6 +181,10 @@ protected:
//- Set the controls from the current controlDict
void setControls();
//- Set file monitoring, profiling, etc
// Optionally force profiling without inspecting the controlDict
void setMonitoring(const bool forceProfiling=false);
//- Read the control dictionary and set the write controls etc.
virtual void readDict();

5
src/OpenFOAM/db/Time/TimeIO.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -27,6 +27,7 @@ License
#include "Pstream.H"
#include "simpleObjectRegistry.H"
#include "dimensionedConstants.H"
#include "profiling.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
@ -518,6 +519,8 @@ bool Foam::Time::writeObject
{
if (outputTime())
{
addProfiling(writing, "objectRegistry::writeObject");
const word tmName(timeName());
IOdictionary timeDict

27
src/OpenFOAM/db/functionObjects/functionObjectList/functionObjectList.C
View File

@ -26,6 +26,7 @@ License
#include "functionObjectList.H"
#include "Time.H"
#include "mapPolyMesh.H"
#include "profiling.H"
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
@ -220,6 +221,12 @@ bool Foam::functionObjectList::execute(const bool forceWrite)
forAll(*this, objectI)
{
addProfiling
(
fo,
"functionObject::" + operator[](objectI).name() + "::execute"
);
ok = operator[](objectI).execute(forceWrite) && ok;
}
}
@ -257,6 +264,12 @@ bool Foam::functionObjectList::end()
forAll(*this, objectI)
{
addProfiling
(
fo,
"functionObject::" + operator[](objectI).name() + "::end"
);
ok = operator[](objectI).end() && ok;
}
}
@ -339,6 +352,8 @@ bool Foam::functionObjectList::read()
label nFunc = 0;
addProfiling(fo,"functionObjects::read");
if (entryPtr->isDict())
{
// A dictionary of functionObjects
@ -366,12 +381,24 @@ bool Foam::functionObjectList::read()
// An existing functionObject, and dictionary changed
if (newDigs[nFunc] != digests_[oldIndex])
{
addProfiling
(
fo2,
"functionObject::" + objPtr->name() + "::read"
);
ok = objPtr->read(dict) && ok;
}
}
else
{
// New functionObject
addProfiling
(
fo2,
"functionObject::" + key + "::start"
);
objPtr = functionObject::New(key, time_, dict).ptr();
ok = objPtr->start() && ok;
}

16
src/OpenFOAM/global/foamDoc.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -56,8 +56,22 @@ License
\section usingTheCode Using the code
Solvers
- \subpage pageSolvers
Modelling
- \subpage pageThermophsyicalModels
- \subpage pageTurbulenceModelling
- \subpage pageLagrangianIntermediate
Boundary conditions
- \subpage pageBoundaryConditions
Numerics
- \subpage pageFiniteVolumeSchemes
- \subpage pageMatrixSolvers
Post-processing
- \subpage pagePostProcessing

562
src/OpenFOAM/global/profiling/profiling.C Normal file
View File

@ -0,0 +1,562 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2016 Bernhard Gschaider
\\/ M anipulation | Copyright (C) 2016 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 "profiling.H"
#include "profilingSysInfo.H"
#include "cpuInfo.H"
#include "memInfo.H"
#include "OSspecific.H"
#include "IOstreams.H"
#include "dictionary.H"
#include "demandDrivenData.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
Foam::profiling* Foam::profiling::pool_(0);
Foam::label Foam::profiling::Information::nextId_(0);
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
// file-scope function
template<class T>
inline static void writeEntry
(
Foam::Ostream& os, const Foam::word& key, const T& value
)
{
os.writeKeyword(key) << value << Foam::token::END_STATEMENT << '\n';
}
Foam::label Foam::profiling::Information::getNextId()
{
return nextId_++;
}
void Foam::profiling::Information::raiseID(label maxVal)
{
if (nextId_ < maxVal)
{
nextId_ = maxVal;
}
}
bool Foam::profiling::active()
{
return pool_;
}
bool Foam::profiling::writeNow()
{
if (pool_)
{
Info<<"profiling::writeNow() at time = "
<< pool_->owner().timeName() << endl;
return pool_->write();
}
else
{
return false;
}
}
void Foam::profiling::initialize
(
const IOobject& ioObj,
const Time& owner
)
{
if (pool_)
{
WarningInFunction
<< "Already initialized" << endl;
}
else
{
pool_ = new profiling(ioObj, owner);
Information *info = pool_->store
(
new Information()
);
pool_->push(info, pool_->clockTime_);
Info<< "profiling initialized" << nl;
}
}
void Foam::profiling::initialize
(
const dictionary& dict,
const IOobject& ioObj,
const Time& owner
)
{
if (pool_)
{
WarningInFunction
<< "Already initialized" << endl;
}
else
{
pool_ = new profiling(dict, ioObj, owner);
Information *info = pool_->store
(
new Information()
);
pool_->push(info, pool_->clockTime_);
Info<< "profiling initialized" << nl;
}
}
void Foam::profiling::stop(const Time& owner)
{
if (pool_ && &owner == &(pool_->owner_))
{
delete pool_;
pool_ = 0;
}
}
Foam::profiling::Information* Foam::profiling::New
(
const string& name,
clockTime& timer
)
{
Information *info = 0;
if (pool_)
{
info = pool_->find(name);
if (!info)
{
info = pool_->store
(
new Information(pool_->stack_.top(), name)
);
}
pool_->push(info, timer);
if (pool_->memInfo_)
{
info->maxMem_ = Foam::max
(
info->maxMem_,
pool_->memInfo_->update().size()
);
}
}
return info;
}
void Foam::profiling::unstack(const Information *info)
{
if (pool_ && info)
{
Information *top = pool_->pop();
if (info->id() != top->id())
{
FatalErrorInFunction
<< "The profiling information to unstack has different"
<< " id than on the top of the profiling stack" << nl
<< " info: " << info->id() << " (" << info->description()
<< ")\n"
<< " top: " << top->id() << " (" << top->description()
<< ")\n" << endl
<< abort(FatalError);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::profiling::profiling
(
const IOobject& io,
const Time& owner
)
:
regIOobject(io),
owner_(owner),
clockTime_(),
hash_(),
stack_(),
timers_(),
sysInfo_(new sysInfo()),
cpuInfo_(new cpuInfo()),
memInfo_(new memInfo())
{}
Foam::profiling::profiling
(
const dictionary& dict,
const IOobject& io,
const Time& owner
)
:
regIOobject(io),
owner_(owner),
clockTime_(),
hash_(),
stack_(),
timers_(),
sysInfo_
(
dict.lookupOrDefault<Switch>("sysInfo", true)
? new sysInfo() : 0
),
cpuInfo_
(
dict.lookupOrDefault<Switch>("cpuInfo", true)
? new cpuInfo() : 0
),
memInfo_
(
dict.lookupOrDefault<Switch>("memInfo", false)
? new memInfo() : 0
)
{}
Foam::profiling::Information::Information()
:
id_(getNextId()),
description_("application::main"),
parent_(this),
calls_(0),
totalTime_(0),
childTime_(0),
maxMem_(0),
onStack_(false)
{}
Foam::profiling::Information::Information
(
Information *parent,
const string& descr
)
:
id_(getNextId()),
description_(descr),
parent_(parent),
calls_(0),
totalTime_(0),
childTime_(0),
maxMem_(0),
onStack_(false)
{}
Foam::profiling::Trigger::Trigger(const char* name)
:
clock_(),
ptr_(profiling::New(name, clock_))
{}
Foam::profiling::Trigger::Trigger(const string& name)
:
clock_(),
ptr_(profiling::New(name, clock_))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::profiling::~profiling()
{
deleteDemandDrivenData(sysInfo_);
deleteDemandDrivenData(cpuInfo_);
deleteDemandDrivenData(memInfo_);
if (pool_ == this)
{
pool_ = 0;
Information::nextId_ = 0;
}
}
Foam::profiling::Information::~Information()
{}
Foam::profiling::Trigger::~Trigger()
{
stop();
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::Time& Foam::profiling::owner() const
{
return owner_;
}
Foam::label Foam::profiling::size() const
{
return stack_.size();
}
Foam::profiling::Information* Foam::profiling::find(const string& name)
{
StorageContainer::iterator iter = hash_.find(name);
return (iter != hash_.end() ? iter() : 0);
}
void Foam::profiling::Information::update(const scalar& elapsed)
{
++calls_;
totalTime_ += elapsed;
if (id_ != parent().id())
{
parent().childTime_ += elapsed;
}
}
bool Foam::profiling::writeData(Ostream& os) const
{
os << indent << "profiling" << nl
<< indent << token::BEGIN_LIST << incrIndent << nl;
// write on-stack items
// newest is first on the stack, top-level is at the end
// this is how the child times are summed
{
scalar oldElapsed = 0;
forAllConstIter(StackContainer, stack_, iter)
{
const Information *info = *iter;
scalar elapsed = timers_[info->id()]->elapsedTime();
info->write(os, true, elapsed, oldElapsed);
oldElapsed = elapsed;
}
}
// write off-stack items
// using an additional Map to sort by Id
{
typedef Map<const Information*> LookupContainer;
LookupContainer lookup;
forAllConstIter(StorageContainer, hash_, iter)
{
const Information *info = iter();
if (!info->onStack())
{
lookup.set(info->id(), info);
}
}
forAllConstIter(LookupContainer, lookup, iter)
{
iter()->write(os);
}
}
os << decrIndent
<< indent << token::END_LIST << token::END_STATEMENT << nl;
if (sysInfo_)
{
os << nl;
os.beginBlock("sysInfo") << nl; // FUTURE: without nl
sysInfo_->write(os);
os.endBlock() << nl; // FUTURE: without nl
}
if (cpuInfo_)
{
os << nl;
os.beginBlock("cpuInfo") << nl; // FUTURE: without nl
cpuInfo_->write(os);
os.endBlock() << nl; // FUTURE: without nl
}
if (memInfo_)
{
memInfo_->update();
os << nl;
os.beginBlock("memInfo") << nl; // FUTURE: without nl
memInfo_->write(os);
writeEntry(os, "units", "kB");
os.endBlock() << nl; // FUTURE: without nl
}
return os;
}
bool Foam::profiling::writeObject
(
IOstream::streamFormat,
IOstream::versionNumber ver,
IOstream::compressionType
) const
{
return regIOobject::writeObject
(
IOstream::ASCII,
ver,
IOstream::UNCOMPRESSED
);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::profiling::Information* Foam::profiling::store(Information *info)
{
hash_.insert(info->description(), info);
return info;
}
void Foam::profiling::push(Information *info, clockTime& timer)
{
stack_.push(info);
timers_.set(info->id(), &timer);
info->push(); // mark as on stack
}
Foam::profiling::Information* Foam::profiling::pop()
{
Information *info = stack_.pop();
timers_.erase(info->id());
info->pop(); // mark as off stack
return info;
}
bool Foam::profiling::Trigger::running() const
{
return ptr_;
}
void Foam::profiling::Trigger::stop()
{
if (ptr_)
{
ptr_->update(clock_.elapsedTime());
profiling::unstack(ptr_);
// pointer is managed by pool storage -> thus no delete here
}
ptr_ = 0;
}
void Foam::profiling::Information::push() const
{
onStack_ = true;
}
void Foam::profiling::Information::pop() const
{
onStack_ = false;
}
Foam::Ostream& Foam::profiling::Information::write
(
Ostream& os,
const bool offset,
const scalar& elapsedTime,
const scalar& childTimes
) const
{
// write in dictionary format
// os.beginBlock("_" + Foam::name(id_)) << nl;
os.beginBlock() << nl; // FUTURE: without nl
// FUTURE: os.writeEntry(key, value);
writeEntry(os, "id", id_);
if (id_ != parent().id())
{
writeEntry(os, "parentId", parent().id());
}
writeEntry(os, "description", description());
writeEntry(os, "calls", calls() + (offset ? 1 : 0));
writeEntry(os, "totalTime", totalTime() + elapsedTime);
writeEntry(os, "childTime", childTime() + childTimes);
if (maxMem_)
{
writeEntry(os, "maxMem", maxMem_);
}
writeEntry(os, "onStack", Switch(onStack()));
os.endBlock() << nl; // FUTURE: without nl
return os;
}
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
Foam::Ostream& Foam::operator<<
(
Ostream& os,
const profiling::Information& info
)
{
return info.write(os);
}
// ************************************************************************* //

486
src/OpenFOAM/global/profiling/profiling.H Normal file
View File

@ -0,0 +1,486 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2016 Bernhard Gschaider
\\/ M anipulation | Copyright (C) 2016 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::profiling
Description
Code profiling.
This is typically activated from within the system/controlDict as follows
(defaults shown):
\code
profiling
{
active true;
cpuInfo true;
memInfo false;
sysInfo true;
}
\endcode
or simply using all defaults:
\code
profiling
{}
\endcode
SourceFiles
profiling.C
\*---------------------------------------------------------------------------*/
#ifndef profiling_H
#define profiling_H
#include "HashPtrTable.H"
#include "LIFOStack.H"
#include "Map.H"
#include "Time.H"
#include "clockTime.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class Ostream;
class dictionary;
class cpuInfo;
class memInfo;
/*---------------------------------------------------------------------------*\
Class profiling Declaration
\*---------------------------------------------------------------------------*/
class profiling
:
public regIOobject
{
public:
// Forward declarations of components
class Information;
class Trigger;
class sysInfo;
private:
// Private Static Data Members
//- Only one global pool object is possible
static profiling *pool_;
// Private Data Members
typedef HashPtrTable<Information, string> StorageContainer;
typedef LIFOStack<Information*> StackContainer;
//- The owner of the profiling
const Time& owner_;
//- A global timer for the profiling
clockTime clockTime_;
//- Storage of profiling information
StorageContainer hash_;
//- Local stack of profiling information
StackContainer stack_;
//- Note the timers (by Id) for the correct stack-output
Map<clockTime*> timers_;
//- General system information (optional)
sysInfo* sysInfo_;
//- CPU-Information (optional)
cpuInfo* cpuInfo_;
//- MEM-Information (optional)
memInfo* memInfo_;
// Private Member Functions
//- Disallow default bitwise copy construct
profiling(const profiling&) = delete;
//- Disallow default bitwise assignment
void operator=(const profiling&) = delete;
protected:
// Friendship
friend class Time;
// Constructors
//- Construct IO object, everything enabled
profiling(const IOobject&, const Time&);
//- Construct IO object with finer control over behaviour
profiling(const dictionary&, const IOobject&, const Time&);
//- Destructor
~profiling();
// Protected Member Functions
//- Find profiling information element or null on failure
Information* find(const string& name);
//- Add to hashed storage,
// returns pointer to newly stored element for chaining
Information* store(Information*);
//- Add to stack and set timer lookup (based on Id)
void push(Information*, clockTime& timer);
//- Remove from stack and remove timer lookup (based on Id).
// Returns pointer to profiling information element
Information* pop();
// Static control elements
//- Singleton to initialize profiling pool, everything enabled
static void initialize(const IOobject&, const Time&);
//- Singleton to initialize profiling pool with finer control
static void initialize(const dictionary&, const IOobject&, const Time&);
//- Stop profiling, cleanup pool if possible
static void stop(const Time&);
//- Existing or new element on pool, add to stack.
// Returns null if profiling has not been initialized
static Information* New(const string& name, clockTime& timer);
//- Remove the information from the top of the stack
static void unstack(const Information*);
public:
// Member Functions
//- True if profiling is active
static bool active();
//- Write profiling information now
static bool writeNow();
//- The owner of the profiling
const Time& owner() const;
//- The size of the current stack
Foam::label size() const;
//- writeData member function required by regIOobject
virtual bool writeData(Ostream&) const;
//- Write as uncompressed ASCII, using given format
virtual bool writeObject
(
IOstream::streamFormat ignoreAlwaysASCII,
IOstream::versionNumber ver,
IOstream::compressionType ignoreAlwaysUncompressed
) const;
};
/*---------------------------------------------------------------------------*\
Class profiling::Information Declaration
\*---------------------------------------------------------------------------*/
class profiling::Information
{
// Private Static Data Members
//- Counter to generate the ids
static label nextId_;
//- get a new ID and update the counter
static label getNextId();
//- raise the next possible ID (to avoid ID-clashes during reading)
static void raiseID(label maxVal);
// Private Data Members
//- Unique id to identify it
const label id_;
//- What this timer does
const string description_;
//- Pointer to the parent object (or self for top-level)
Information* parent_;
//- Nr of times this was called
label calls_;
//- Total time spent
scalar totalTime_;
//- Time spent in children
scalar childTime_;
//- Max memory usage on call.
// Only valid when the calling profiling has memInfo active.
mutable int maxMem_;
//- Is this information currently on the stack?
mutable bool onStack_;
// Private Member Functions
//- Disallow default bitwise copy construct
Information(const Information&) = delete;
//- Disallow default bitwise assignment
void operator=(const Information&) = delete;
protected:
// Friendship
friend class profiling;
// Constructors
//- Construct null - only the master-element
Information();
// Member Functions
//- Mark as being on the stack
void push() const;
//- Mark as being off the stack
void pop() const;
//- Write the profiling times, optionally with additional values
// Use dictionary format.
Ostream& write
(
Ostream& os,
const bool offset = false,
const scalar& elapsedTime = 0,
const scalar& childTime = 0
) const;
public:
// Constructors
//- Construct from components
Information(Information* parent, const string& descr);
//- Destructor
~Information();
// Member Functions
// Access
inline label id() const
{
return id_;
}
inline const string& description() const
{
return description_;
}
inline Information& parent() const
{
return *parent_;
}
inline label calls() const
{
return calls_;
}
inline const scalar& totalTime() const
{
return totalTime_;
}
inline const scalar& childTime() const
{
return childTime_;
}
inline int maxMem() const
{
return maxMem_;
}
inline bool onStack() const
{
return onStack_;
}
// Edit
//- Update it with a new timing information
void update(const scalar& elapsedTime);
// IOstream Operators
friend Ostream& operator<<(Ostream&, const Information&);
};
/*---------------------------------------------------------------------------*\
Class profiling::Trigger Declaration
\*---------------------------------------------------------------------------*/
class profiling::Trigger
{
// Private Data Members
//- The timer for the profiling information
clockTime clock_;
//- The profiling information
Information *ptr_;
// Private Member Functions
//- Disallow default bitwise copy construct
Trigger(const Trigger&) = delete;
//- Disallow default bitwise assignment
void operator=(const Trigger&) = delete;
public:
// Constructors
//- Construct profiling with given description.
// Descriptions beginning with 'application::' are reserved for
// internal use.
Trigger(const char* name);
//- Construct profiling with given description.
// Descriptions beginning with 'application::' are reserved for
// internal use.
Trigger(const string& name);
//- Destructor
~Trigger();
// Member Functions
// Access
//- True if the triggered profiling is active
bool running() const;
// Edit
//- Stop triggered profiling
void stop();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Macros
//- Define profiling with specified name and description string
// This is required if the description contains space, colons etc.
// \sa addProfiling0
// \sa endProfiling
#define addProfiling(name,descr) \
::Foam::profiling::Trigger profilingTriggerFor##name(descr)
//- Define profiling with specified name and description correspond to the name
// \sa addProfiling
// \sa endProfiling
#define addProfiling0(name) \
::Foam::Profiling::Trigger profilingTriggerFor##name(#name)
//- Define profiling with specified name and description correspond to the
// compiler-defined function name string:
// \sa addProfiling
// \sa endProfiling
#ifdef __GNUC__
#define addProfilingInFunction(name) \
::Foam::profiling::Trigger profilingTriggerFor##name(__PRETTY_FUNCTION__)
#else
#define addProfilingInFunction(name) \
::Foam::profiling::Trigger profilingTriggerFor##name(__func__)
#endif
//- Remove profiling with specified name
// \sa addProfiling
// \sa addProfiling0
#define endProfiling(name) profilingTriggerFor##name.stop()
#endif
// ************************************************************************* //

94
src/OpenFOAM/global/profiling/profilingSysInfo.C Normal file
View File

@ -0,0 +1,94 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
\*---------------------------------------------------------------------------*/
#include "profilingSysInfo.H"
#include "demandDrivenData.H"
#include "foamVersion.H"
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
// file-scope function
template<class T>
inline static void writeEntry
(
Foam::Ostream& os, const Foam::word& key, const T& value
)
{
os.writeKeyword(key) << value << Foam::token::END_STATEMENT << '\n';
}
// file-scope function
inline static void printEnv
(
Foam::Ostream& os, const Foam::word& key, const Foam::word& envName
)
{
const std::string value = getEnv(envName);
if (!value.empty())
{
writeEntry(os, key, value);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::profiling::sysInfo::sysInfo()
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::profiling::sysInfo::~sysInfo()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::Ostream& Foam::profiling::sysInfo::write
(
Ostream& os
) const
{
writeEntry(os, "host", hostName(false)); // short name
writeEntry(os, "date", clock::dateTime());
// compile-time information
writeEntry(os, "version", std::string(FOAMversion));
writeEntry(os, "build", std::string(FOAMbuild));
printEnv(os, "arch", "WM_ARCH");
printEnv(os, "compilerType", "WM_COMPILER_TYPE");
printEnv(os, "compiler", "WM_COMPILER");
printEnv(os, "mplib", "WM_MPLIB");
printEnv(os, "options", "WM_OPTIONS");
return os;
}
// ************************************************************************* //

114
src/OpenFOAM/global/profiling/profilingSysInfo.H Normal file
View File

@ -0,0 +1,114 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
Class
Foam::profiling::sysInfo
Description
General system information
SourceFiles
profilingSysInfo.C
\*---------------------------------------------------------------------------*/
#ifndef profilingSysInfo_H
#define profilingSysInfo_H
#include "profiling.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class Ostream;
/*---------------------------------------------------------------------------*\
Class profiling::sysInfo Declaration
\*---------------------------------------------------------------------------*/
class profiling::sysInfo
{
// Private Static Data Members
// Private Data Members
// Private Member Functions
//- Disallow default bitwise copy construct
sysInfo(const sysInfo&) = delete;
//- Disallow default bitwise assignment
void operator=(const sysInfo&) = delete;
protected:
// Friendship
friend class profiling;
// Member Functions
public:
// Constructors
//- Construct from components
sysInfo();
//- Destructor
~sysInfo();
// Member Functions
// Access
// Edit
//- Update it with a new timing information
void update();
//- Write the profiling sys-info, use dictionary format.
Ostream& write(Ostream& os) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

5
src/OpenFOAM/include/addProfilingOption.H Normal file
View File

@ -0,0 +1,5 @@
Foam::argList::addBoolOption
(
"profiling",
"activate application-level profiling"
);

36
src/OpenFOAM/matrices/lduMatrix/doc/lduMatrix.dox Normal file
View File

@ -0,0 +1,36 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
\page pageMatrixSolvers Matrix solvers
\section secSchemes Overview
The available matrix solvers are grouped into the following categories:
- \ref grpLduMatrix
- \ref grpLduMatrixPreconditioners
- \ref grpLduMatrixSmoothers
- \ref grpLduMatrixSolvers
\*---------------------------------------------------------------------------*/

56
src/OpenFOAM/matrices/lduMatrix/doc/lduMatrixDoc.H Normal file
View File

@ -0,0 +1,56 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
\defgroup grpNumerics Numerics
@{
This group contains numerics
@}
\defgroup grpLduMatrix Matrix manipulation and solvers
@{
\ingroup grpNumerics
This group contains matrices
@}
\defgroup grpLduMatrixPreconditioners Preconditioners
@{
\ingroup grpLduMatrix
This group contains matrix preconditioners
@}
\defgroup grpLduMatrixSmoothers Smoothers
@{
\ingroup grpLduMatrix
This group contains matrix smoothers
@}
\defgroup grpLduMatrixSolvers Solvers
@{
\ingroup grpLduMatrix
This group contains matrix solvers
@}
\*---------------------------------------------------------------------------*/

4
src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -59,6 +59,7 @@ SourceFiles
#include "runTimeSelectionTables.H"
#include "solverPerformance.H"
#include "InfoProxy.H"
#include "profiling.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -116,6 +117,7 @@ public:
//- Convergence tolerance relative to the initial
scalar relTol_;
profiling::Trigger profiling_;
// Protected Member Functions

5
src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixSolver.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -147,7 +147,8 @@ Foam::lduMatrix::solver::solver
interfaceBouCoeffs_(interfaceBouCoeffs),
interfaceIntCoeffs_(interfaceIntCoeffs),
interfaces_(interfaces),
controlDict_(solverControls)
controlDict_(solverControls),
profiling_("lduMatrix::solver." + fieldName)
{
readControls();
}

7
src/OpenFOAM/matrices/lduMatrix/solvers/smoothSolver/smoothSolver.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -24,6 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "smoothSolver.H"
#include "profiling.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -87,6 +88,8 @@ Foam::solverPerformance Foam::smoothSolver::solve
// If the nSweeps_ is negative do a fixed number of sweeps
if (nSweeps_ < 0)
{
addProfiling(solve, "lduMatrix::smoother." + fieldName_);
autoPtr<lduMatrix::smoother> smootherPtr = lduMatrix::smoother::New
(
fieldName_,
@ -144,6 +147,8 @@ Foam::solverPerformance Foam::smoothSolver::solve
|| !solverPerf.checkConvergence(tolerance_, relTol_)
)
{
addProfiling(solve, "lduMatrix::smoother." + fieldName_);
autoPtr<lduMatrix::smoother> smootherPtr = lduMatrix::smoother::New
(
fieldName_,

36
src/TurbulenceModels/turbulenceModels/doc/turbulenceModel.dox Normal file
View File

@ -0,0 +1,36 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
\page pageTurbulenceModelling Turbulence modelling
\section secSchemes Overview
The available turbulence models are grouped into the following categories:
- \ref grpTurbulence
- \ref grpRASTurbulence
- \ref grpDESTurbulence
- \ref grpLESTurbulence
\*---------------------------------------------------------------------------*/

14
src/finiteVolume/cfdTools/general/fvOptions/fvOptionListTemplates.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -23,6 +23,8 @@ License
\*---------------------------------------------------------------------------*/
#include "profiling.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
@ -57,6 +59,8 @@ Foam::tmp<Foam::fvMatrix<Type>> Foam::fv::optionList::operator()
if (fieldI != -1)
{
addProfiling(fvopt, "fvOption()." + source.name());
source.setApplied(fieldI);
if (source.isActive())
@ -113,6 +117,8 @@ Foam::tmp<Foam::fvMatrix<Type>> Foam::fv::optionList::operator()
if (fieldI != -1)
{
addProfiling(fvopt, "fvOption()." + source.name());
source.setApplied(fieldI);
if (source.isActive())
@ -172,6 +178,8 @@ Foam::tmp<Foam::fvMatrix<Type>> Foam::fv::optionList::operator()
if (fieldI != -1)
{
addProfiling(fvopt, "fvOption()." + source.name());
source.setApplied(fieldI);
if (source.isActive())
@ -255,6 +263,8 @@ void Foam::fv::optionList::constrain(fvMatrix<Type>& eqn)
if (fieldI != -1)
{
addProfiling(fvopt, "fvOption::constrain." + eqn.psi().name());
source.setApplied(fieldI);
if (source.isActive())
@ -288,6 +298,8 @@ void Foam::fv::optionList::correct
if (fieldI != -1)
{
addProfiling(fvopt, "fvOption::correct." + source.name());
source.setApplied(fieldI);
if (source.isActive())

40
src/finiteVolume/finiteVolume/doc/finiteVolumeSchemes.dox Normal file
View File

@ -0,0 +1,40 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
\page pageFiniteVolumeSchemes Numerical schemes
\section secSchemes Overview
The available numerical schemes are grouped into the following categories:
- \ref grpFvGradSchemes
- \ref grpFvSnGradSchemes
- \ref grpFvDivSchemes
- \ref grpFvLaplacianSchemes
- \ref grpFvDdtSchemes
- \ref grpFvConvectionSchemes
- \ref grpFvSurfaceInterpolationSchemes
- \ref grpFvLimitedSurfaceInterpolationSchemes
\*---------------------------------------------------------------------------*/

5
src/finiteVolume/fvMatrices/fvMatrix/fvMatrixSolve.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -25,6 +25,7 @@ License
#include "LduMatrix.H"
#include "diagTensorField.H"
#include "profiling.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
@ -58,6 +59,8 @@ Foam::SolverPerformance<Type> Foam::fvMatrix<Type>::solve
const dictionary& solverControls
)
{
addProfiling(solve, "fvMatrix::solve." + psi_.name());
if (debug)
{
Info.masterStream(this->mesh().comm())

5
src/finiteVolume/fvMatrices/fvScalarMatrix/fvScalarMatrix.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -25,6 +25,7 @@ License
#include "fvScalarMatrix.H"
#include "extrapolatedCalculatedFvPatchFields.H"
#include "profiling.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
@ -59,6 +60,8 @@ Foam::fvMatrix<Foam::scalar>::solver
const dictionary& solverControls
)
{
addProfiling(solve, "fvMatrix::solve." + psi_.name());
if (debug)
{
Info.masterStream(this->mesh().comm())

5
src/finiteVolume/fvMatrices/solvers/MULES/IMULES.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -24,6 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "IMULES.H"
#include "profiling.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -36,6 +37,8 @@ void Foam::MULES::implicitSolve
const scalar psiMin
)
{
addProfiling(solve, "MULES::implicitSolve");
implicitSolve
(
geometricOneField(),

5
src/finiteVolume/fvMatrices/solvers/MULES/IMULESTemplates.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -29,6 +29,7 @@ License
#include "fvmDdt.H"
#include "fvmSup.H"
#include "fvcDiv.H"
#include "profiling.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -65,6 +66,8 @@ void Foam::MULES::implicitSolve
const scalar psiMin
)
{
addProfiling(solve, "MULES::implicitSolve");
const fvMesh& mesh = psi.mesh();
const dictionary& MULEScontrols = mesh.solverDict(psi.name());

5
src/finiteVolume/fvMatrices/solvers/MULES/MULES.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -24,6 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "MULES.H"
#include "profiling.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -36,6 +37,8 @@ void Foam::MULES::explicitSolve
const scalar psiMin
)
{
addProfiling(solve, "MULES::explicitSolve");
explicitSolve
(
geometricOneField(),

51
src/fvOptions/doc/fvOptionsDoc.H Normal file
View File

@ -0,0 +1,51 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
\defgroup grpFvOptions Finite volume Options
@{
\ingroup grpNumerics
This group contains finite volume options
@}
\defgroup grpFvOptionsSources Sources
@{
\ingroup grpFvOptions
This group contains finite volume sources
@}
\defgroup grpFvOptionsCorrections Corrections
@{
\ingroup grpFvOptions
This group contains finite volume corrections
@}
\defgroup grpFvOptionsConstraints Constraints
@{
\ingroup grpFvOptions
This group contains finite volume constraints
@}
\*---------------------------------------------------------------------------*/

5
src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -33,6 +33,7 @@ License
#include "PatchInteractionModel.H"
#include "StochasticCollisionModel.H"
#include "SurfaceFilmModel.H"
#include "profiling.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
@ -90,6 +91,8 @@ template<class CloudType>
template<class TrackData>
void Foam::KinematicCloud<CloudType>::solve(TrackData& td)
{
addProfiling(prof, "cloud::solve");
if (solution_.steadyState())
{
td.cloud().storeState();

41
src/lagrangian/intermediate/doc/lagrangianIntermediate.dox Normal file
View File

@ -0,0 +1,41 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
\page pageLagrangianIntermediate Lagrangian modelling
\section secSchemes Overview
The available Lagrangian models are grouped into the following categories:
- \ref grpLagrangianIntermediateClouds
- \ref grpLagrangianIntermediateParcels
- \ref grpLagrangianIntermediateSubModels
- \ref grpLagrangianIntermediateKinematicSubModels
- \ref grpLagrangianIntermediateThermoSubModels
- \ref grpLagrangianIntermediateReactingSubModels
- \ref grpLagrangianIntermediateReactingMultiphaseSubModels
- \ref grpLagrangianIntermediateMPPICSubModels
- \ref grpLagrangianIntermediateFunctionObjects
\*---------------------------------------------------------------------------*/

0
src/lagrangian/intermediate/doc/finiteVolumeSchemesDoc.H → src/lagrangian/intermediate/doc/lagrangianIntermediateDoc.H
View File

8
src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C
View File

@ -57,6 +57,7 @@ Description
#include "localPointRegion.H"
#include "externalDisplacementMeshMover.H"
#include "scalarIOField.H"
#include "profiling.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -3399,6 +3400,7 @@ void Foam::snappyLayerDriver::addLayers
// extrudeStatus
//);
addProfiling(grow, "snappyHexMesh::layers::grow");
// Grow out region of non-extrusion
for (label i = 0; i < layerParams.nGrow(); i++)
@ -3749,7 +3751,10 @@ void Foam::snappyLayerDriver::addLayers
);
fvMesh& newMesh = newMeshPtr();
//?neccesary? Update fields
// get timing, but more importantly get memory information
addProfiling(grow, "snappyHexMesh::layers::updateMesh");
//?necessary? Update fields
newMesh.updateMesh(map);
newMesh.setInstance(meshRefiner_.timeName());
@ -4219,6 +4224,7 @@ void Foam::snappyLayerDriver::doLayers
fvMeshDistribute& distributor
)
{
addProfiling(layers, "snappyHexMesh::layers");
const fvMesh& mesh = meshRefiner_.mesh();
Info<< nl

10
src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.C
View File

@ -39,6 +39,7 @@ License
#include "localPointRegion.H"
#include "IOmanip.H"
#include "labelVector.H"
#include "profiling.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -79,6 +80,7 @@ Foam::label Foam::snappyRefineDriver::featureEdgeRefine
const label minRefine
)
{
addProfiling(edge, "snappyHexMesh::refine::edge");
const fvMesh& mesh = meshRefiner_.mesh();
label iter = 0;
@ -188,6 +190,7 @@ Foam::label Foam::snappyRefineDriver::smallFeatureRefine
const label maxIter
)
{
addProfiling(feature, "snappyHexMesh::refine::smallFeature");
const fvMesh& mesh = meshRefiner_.mesh();
@ -310,6 +313,7 @@ Foam::label Foam::snappyRefineDriver::surfaceOnlyRefine
const label maxIter
)
{
addProfiling(surface, "snappyHexMesh::refine::surface");
const fvMesh& mesh = meshRefiner_.mesh();
// Determine the maximum refinement level over all surfaces. This
@ -807,6 +811,7 @@ Foam::label Foam::snappyRefineDriver::danglingCellRefine
const label maxIter
)
{
addProfiling(dangling, "snappyHexMesh::refine::danglingCell");
const fvMesh& mesh = meshRefiner_.mesh();
label iter;
@ -952,6 +957,7 @@ Foam::label Foam::snappyRefineDriver::refinementInterfaceRefine
const label maxIter
)
{
addProfiling(interface, "snappyHexMesh::refine::transition");
const fvMesh& mesh = meshRefiner_.mesh();
label iter = 0;
@ -1342,6 +1348,7 @@ Foam::label Foam::snappyRefineDriver::shellRefine
const label maxIter
)
{
addProfiling(shell, "snappyHexMesh::refine::shell");
const fvMesh& mesh = meshRefiner_.mesh();
// Mark current boundary faces with 0. Have meshRefiner maintain them.
@ -1517,6 +1524,7 @@ void Foam::snappyRefineDriver::baffleAndSplitMesh
const dictionary& motionDict
)
{
addProfiling(split, "snappyHexMesh::refine::splitting");
Info<< nl
<< "Splitting mesh at surface intersections" << nl
<< "---------------------------------------" << nl
@ -1841,6 +1849,7 @@ void Foam::snappyRefineDriver::mergePatchFaces
const dictionary& motionDict
)
{
addProfiling(merge, "snappyHexMesh::refine::merge");
Info<< nl
<< "Merge refined boundary faces" << nl
<< "----------------------------" << nl
@ -1895,6 +1904,7 @@ void Foam::snappyRefineDriver::doRefine
const dictionary& motionDict
)
{
addProfiling(refine, "snappyHexMesh::refine");
Info<< nl
<< "Refinement phase" << nl
<< "----------------" << nl

6
src/mesh/snappyHexMesh/snappyHexMeshDriver/snappySnapDriver.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation | Copyright (C) 2015 OpenCFD Ltd.
\\/ M anipulation | Copyright (C) 2015-2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -45,6 +45,7 @@ Description
#include "localPointRegion.H"
#include "PatchTools.H"
#include "refinementFeatures.H"
#include "profiling.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -832,6 +833,7 @@ void Foam::snappySnapDriver::preSmoothPatch
motionSmoother& meshMover
)
{
addProfiling(smooth, "snappyHexMesh::snap::smoothing");
const fvMesh& mesh = meshRefiner.mesh();
labelList checkFaces;
@ -2168,6 +2170,7 @@ bool Foam::snappySnapDriver::scaleMesh
motionSmoother& meshMover
)
{
addProfiling(scale, "snappyHexMesh::snap::scale");
const fvMesh& mesh = meshRefiner_.mesh();
// Relax displacement until correct mesh
@ -2534,6 +2537,7 @@ void Foam::snappySnapDriver::doSnap
const snapParameters& snapParams
)
{
addProfiling(snap, "snappyHexMesh::snap");
fvMesh& mesh = meshRefiner_.mesh();
Info<< nl

6
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | Copyright (C) 2015 OpenCFD Ltd.
\\/ M anipulation | Copyright (C) 2015-2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -1062,7 +1062,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
);
// weights normalisation
normaliseWeights(AMIPtr->conformal(), true);
AMIPtr->normaliseWeights(true, *this);
// cache maps and reset addresses
List<Map<label>> cMap;
@ -1095,7 +1095,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
tgtWeights_
);
normaliseWeights(AMIPtr->conformal(), true);
AMIPtr->normaliseWeights(true, *this);
}
if (debug)

14
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -372,9 +372,15 @@ public:
//- Return const access to source patch face areas
inline const scalarField& srcMagSf() const;
//- Return access to source patch face areas
inline scalarField& srcMagSf();
//- Return const access to source patch addressing
inline const labelListList& srcAddress() const;
//- Return access to source patch addressing
inline labelListList& srcAddress();
//- Return const access to source patch weights
inline const scalarListList& srcWeights() const;
@ -400,9 +406,15 @@ public:
//- Return const access to target patch face areas
inline const scalarField& tgtMagSf() const;
//- Return access to target patch face areas
inline scalarField& tgtMagSf();
//- Return const access to target patch addressing
inline const labelListList& tgtAddress() const;
//- Return access to target patch addressing
inline labelListList& tgtAddress();
//- Return const access to target patch weights
inline const scalarListList& tgtWeights() const;

34
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolationI.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -56,6 +56,14 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcMagSf() const
}
template<class SourcePatch, class TargetPatch>
inline Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcMagSf()
{
return srcMagSf_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::labelListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcAddress() const
@ -64,6 +72,14 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcAddress() const
}
template<class SourcePatch, class TargetPatch>
inline Foam::labelListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcAddress()
{
return srcAddress_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::scalarListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcWeights() const
@ -112,6 +128,14 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtMagSf() const
}
template<class SourcePatch, class TargetPatch>
inline Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtMagSf()
{
return tgtMagSf_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::labelListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtAddress() const
@ -120,6 +144,14 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtAddress() const
}
template<class SourcePatch, class TargetPatch>
inline Foam::labelListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtAddress()
{
return tgtAddress_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::scalarListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtWeights() const

12
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpcnCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -48,6 +48,8 @@ SourceFiles
namespace Foam
{
template<class SourcePatch, class TargetPatch> class AMIInterpolation;
/*---------------------------------------------------------------------------*\
Class AMIMethod Declaration
\*---------------------------------------------------------------------------*/
@ -238,6 +240,14 @@ public:
label srcFaceI = -1,
label tgtFaceI = -1
) = 0;
//- Normalise the weight. Can optionally subset addressing
// (e.g. for mapNearest)
virtual void normaliseWeights
(
const bool verbose,
AMIInterpolation<SourcePatch, TargetPatch>& inter
) = 0;
};

11
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.C
View File

@ -322,4 +322,15 @@ void Foam::directAMI<SourcePatch, TargetPatch>::calculate
}
template<class SourcePatch, class TargetPatch>
void Foam::directAMI<SourcePatch, TargetPatch>::normaliseWeights
(
const bool verbose,
AMIInterpolation<SourcePatch, TargetPatch>& inter
)
{
inter.normaliseWeights(this->conformal(), verbose);
}
// ************************************************************************* //

8
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.H
View File

@ -135,6 +135,14 @@ public:
label srcFaceI = -1,
label tgtFaceI = -1
);
//- Normalise the weight. Can optionally subset addressing
// (e.g. for mapNearest)
virtual void normaliseWeights
(
const bool verbose,
AMIInterpolation<SourcePatch, TargetPatch>& inter
);
};

11
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C
View File

@ -568,4 +568,15 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
}
template<class SourcePatch, class TargetPatch>
void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::normaliseWeights
(
const bool verbose,
AMIInterpolation<SourcePatch, TargetPatch>& inter
)
{
inter.normaliseWeights(this->conformal(), verbose);
}
// ************************************************************************* //

10
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -167,6 +167,14 @@ public:
label srcFaceI = -1,
label tgtFaceI = -1
);
//- Normalise the weight. Can optionally subset addressing
// (e.g. for mapNearest)
virtual void normaliseWeights
(
const bool verbose,
AMIInterpolation<SourcePatch, TargetPatch>& inter
);
};

112
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/mapNearestAMI/mapNearestAMI.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -322,19 +322,111 @@ void Foam::mapNearestAMI<SourcePatch, TargetPatch>::calculate
// transfer data to persistent storage
forAll(srcAddr, i)
const pointField& srcFc = this->srcPatch_.faceCentres();
const pointField& tgtFc = this->tgtPatch_.faceCentres();
forAll(srcAddr, srcI)
{
scalar magSf = this->srcMagSf_[i];
srcAddress[i].transfer(srcAddr[i]);
srcWeights[i] = scalarList(1, magSf);
}
forAll(tgtAddr, i)
srcAddress[srcI].transfer(srcAddr[srcI]);
const labelList& addr = srcAddress[srcI];
srcWeights[srcI].setSize(addr.size());
const point& srcPt = srcFc[srcI];
forAll(addr, i)
{
scalar magSf = this->tgtMagSf_[i];
tgtAddress[i].transfer(tgtAddr[i]);
tgtWeights[i] = scalarList(1, magSf);
srcWeights[srcI][i] = magSqr(srcPt-tgtFc[addr[i]]);
}
}
forAll(tgtAddr, tgtI)
{
tgtAddress[tgtI].transfer(tgtAddr[tgtI]);
const labelList& addr = tgtAddress[tgtI];
tgtWeights[tgtI].setSize(addr.size());
const point& tgtPt = tgtFc[tgtI];
forAll(addr, i)
{
tgtWeights[tgtI][i] = magSqr(tgtPt-srcFc[addr[i]]);
}
}
}
template<class SourcePatch, class TargetPatch>
void Foam::mapNearestAMI<SourcePatch, TargetPatch>::normaliseWeights
(
const bool verbose,
AMIInterpolation<SourcePatch, TargetPatch>& inter
)
{
{
labelListList& srcAddress = inter.srcAddress();
scalarListList& srcWeights = inter.srcWeights();
forAll(srcAddress, srcI)
{
labelList& addr = srcAddress[srcI];
scalarList& wghts = srcWeights[srcI];
// Choose one with smallest weight (since calculate above returns
// distance)
if (addr.size())
{
label minFaceI = addr[0];
scalar minWeight = wghts[0];
for (label i = 0; i < addr.size(); i++)
{
if (wghts[i] < minWeight)
{
minWeight = wghts[i];
minFaceI = addr[i];
}
}
wghts.setSize(1);
wghts[0] = this->srcMagSf_[srcI];
addr.setSize(1);
addr[0] = minFaceI;
}
}
}
{
labelListList& tgtAddress = inter.tgtAddress();
scalarListList& tgtWeights = inter.tgtWeights();
forAll(tgtAddress, tgtI)
{
labelList& addr = tgtAddress[tgtI];
scalarList& wghts = tgtWeights[tgtI];
// Choose one with smallest weight (since calculate above returns
// distance)
if (addr.size())
{
label minFaceI = addr[0];
scalar minWeight = wghts[0];
for (label i = 0; i < addr.size(); i++)
{
if (wghts[i] < minWeight)
{
minWeight = wghts[i];
minFaceI = addr[i];
}
}
wghts.setSize(1);
wghts[0] = inter.tgtMagSf()[tgtI];
addr.setSize(1);
addr[0] = minFaceI;
}
}
}
inter.normaliseWeights(this->conformal(), verbose);
}
// ************************************************************************* //

10
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/mapNearestAMI/mapNearestAMI.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -139,6 +139,14 @@ public:
label srcFaceI = -1,
label tgtFaceI = -1
);
//- Normalise the weight. Can optionally subset addressing
// (e.g. for mapNearest)
virtual void normaliseWeights
(
const bool verbose,
AMIInterpolation<SourcePatch, TargetPatch>& inter
);
};

2
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.

3
src/postProcessing/functionObjects/doc/functionObjects.dox
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2014 OpenFOAM Foundation
\\/ M anipulation | Copyright (C) 2015 OpenCFD Ltd.
\\/ M anipulation | Copyright (C) 2015-2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -44,6 +44,7 @@ The current range of features comprises of:
- \ref grpIOFunctionObjects
- \ref grpJobControlFunctionObjects
- \ref grpUtilitiesFunctionObjects
- \ref grpThermophysicalFunctionObjects
\linebreak
\subsection secFieldFunctionObjectUsage Using function objects

37
src/postProcessing/functionObjects/graphics/runTimePostProcessing/fieldVisualisationBase.C
View File

@ -29,6 +29,7 @@ License
// VTK includes
#include "vtkArrowSource.h"
#include "vtkCellData.h"
#include "vtkColorTransferFunction.h"
#include "vtkFloatArray.h"
#include "vtkGlyph3D.h"
@ -136,7 +137,7 @@ void Foam::fieldVisualisationBase::addScalarBar
vtkLookupTable* lut
) const
{
// add scalar bar legend
// Add scalar bar legend
if (!scalarBar_.visible_)
{
return;
@ -149,7 +150,7 @@ void Foam::fieldVisualisationBase::addScalarBar
const vector textColour = colours_["text"]->value(position);
// workaround to supply our own scalarbar title
// Work-around to supply our own scalarbar title
vtkSmartPointer<vtkTextActor> titleActor =
vtkSmartPointer<vtkTextActor>::New();
sbar->SetTitle(" ");
@ -212,7 +213,7 @@ void Foam::fieldVisualisationBase::addScalarBar
{
sbar->SetOrientationToHorizontal();
// adjustments since not using scalarbar title property
// Adjustments since not using scalarbar title property
sbar->SetWidth(0.75);
sbar->SetHeight(0.07);
sbar->SetBarRatio(0.5);
@ -257,22 +258,40 @@ void Foam::fieldVisualisationBase::setField
}
case cbField:
{
// create look-up table for colours
// Create look-up table for colours
vtkSmartPointer<vtkLookupTable> lut =
vtkSmartPointer<vtkLookupTable>::New();
setColourMap(lut);
lut->SetVectorMode(vtkScalarsToColors::MAGNITUDE);
// configure the mapper
// Configure the mapper
mapper->SelectColorArray(colourFieldName.c_str());
mapper->SetScalarRange(range_.first(), range_.second());
// Set to use either cell or point data
vtkPolyData* pData = mapper->GetInput();
const char* fieldName = colourFieldName.c_str();
if (pData->GetCellData()->HasArray(fieldName) == 1)
{
mapper->SetScalarModeToUseCellFieldData();
}
else if (pData->GetPointData()->HasArray(fieldName) == 1)
{
mapper->SetScalarModeToUsePointFieldData();
}
else
{
WarningInFunction
<< "Unable to determine cell or point data type "
<< "- assuming point data";
mapper->SetScalarModeToUsePointFieldData();
}
mapper->SetColorModeToMapScalars();
mapper->SetLookupTable(lut);
mapper->ScalarVisibilityOn();
// add the bar
// Add the bar
addScalarBar(position, renderer, lut);
break;
}
@ -313,7 +332,7 @@ void Foam::fieldVisualisationBase::addGlyphs
vtkSmartPointer<vtkSphereSource>::New();
sphere->SetCenter(0, 0, 0);
sphere->SetRadius(0.5);
// setting higher resolution slows the rendering significantly
// Setting higher resolution slows the rendering significantly
// sphere->SetPhiResolution(20);
// sphere->SetThetaResolution(20);
@ -323,7 +342,7 @@ void Foam::fieldVisualisationBase::addGlyphs
{
double range[2];
// can use values to find range
// Can use values to find range
// vtkDataArray* values =
// data->GetPointData()->GetScalars(scaleFieldName.c_str());
// values->GetRange(range);
@ -374,7 +393,7 @@ void Foam::fieldVisualisationBase::addGlyphs
values->GetRange(range);
/*
// attempt to set range for vectors...
// Attempt to set range for vectors...
scalar x0 = sqrt(sqr(range_.first())/3.0);
scalar x1 = sqrt(sqr(range_.second())/3.0);
range[0] = x0;

2
src/postProcessing/functionObjects/utilities/reactionSensitivityAnalysis/reactionsSensitivityAnalysis.H
View File

@ -25,7 +25,7 @@ Class
Foam::reactionsSensitivityAnalysis
Group
grpUtilitiesFunctionObjects
grpUtilitiesFunctionObjects grpThermophysicalFunctionObjects
Description
This function object creates four data files named:

11
src/sampling/meshToMesh/meshToMesh.C
View File

@ -713,7 +713,11 @@ void Foam::meshToMesh::constructNoCuttingPatches
forAll(srcBM, patchI)
{
const polyPatch& pp = srcBM[patchI];
if (!polyPatch::constraintType(pp.type()))
// We want to map all the global patches, including constraint
// patches (since they might have mappable properties, e.g.
// jumpCyclic). We'll fix the value afterwards.
if (!isA<processorPolyPatch>(pp))
{
srcPatchID.append(pp.index());
@ -764,7 +768,10 @@ void Foam::meshToMesh::constructFromCuttingPatches
const polyPatch& srcPatch = srcRegion_.boundaryMesh()[srcPatchName];
if (!polyPatch::constraintType(srcPatch.type()))
// We want to map all the global patches, including constraint
// patches (since they might have mappable properties, e.g.
// jumpCyclic). We'll fix the value afterwards.
if (!isA<processorPolyPatch>(srcPatch))
{
const polyPatch& tgtPatch = tgtRegion_.boundaryMesh()[tgtPatchName];

33
src/thermophysicalModels/doc/thermophysicalModels.dox Normal file
View File

@ -0,0 +1,33 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
\page pageThermophsyicalModels Thermophsyical Models
\section secSchemes Overview
The available thermophysical models are grouped into the following categories:
- \ref grpThermophysicalModels
\*---------------------------------------------------------------------------*/

6
src/thermophysicalModels/doc/thermophysicalModelsDoc.H
View File

@ -28,5 +28,11 @@ License
This group contains thermophysical models
@}
\defgroup grpThermophysicalFunctionObjects Thermophysical function objects
@{
\ingroup grpFunctionObjects
This group contains thermo-based function objects
@}
\*---------------------------------------------------------------------------*/

3
src/thermophysicalModels/reactionThermo/chemistryReaders/chemistryReader/chemistryReader.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::chemistryReader
Group
grpReactionThermophysicalChemistryReaders
Description
Abstract class for reading chemistry

3
src/thermophysicalModels/reactionThermo/chemistryReaders/chemkinReader/chemkinReader.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::chemkinReader
Group
grpReactionThermophysicalChemistryReaders
Description
Foam::chemkinReader

3
src/thermophysicalModels/reactionThermo/chemistryReaders/foamChemistryReader/foamChemistryReader.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::foamChemistryReader
Group
grpReactionThermophysicalChemistryReaders
Description
Chemistry reader for OpenFOAM format

3
src/thermophysicalModels/reactionThermo/derivedFvPatchFields/fixedUnburntEnthalpy/fixedUnburntEnthalpyFvPatchScalarField.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::fixedUnburntEnthalpyFvPatchScalarField
Group
grpThermoBoundaryConditions
Description
Fixed boundary condition for unburnt

3
src/thermophysicalModels/reactionThermo/derivedFvPatchFields/gradientUnburntEnthalpy/gradientUnburntEnthalpyFvPatchScalarField.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::gradientUnburntEnthalpyFvPatchScalarField
Group
grpThermoBoundaryConditions
Description
gradient boundary condition for unburnt

3
src/thermophysicalModels/reactionThermo/derivedFvPatchFields/mixedUnburntEnthalpy/mixedUnburntEnthalpyFvPatchScalarField.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::mixedUnburntEnthalpyFvPatchScalarField
Group
grpThermoBoundaryConditions
Description
Mixed boundary condition for unburnt

43
src/thermophysicalModels/reactionThermo/doc/reactionThermoDoc.H Normal file
View File

@ -0,0 +1,43 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ 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/>.
\defgroup grpReactionThermophysicalModels Reaction thermophysical models
@{
\ingroup grpThermophysicalModels
This group contains reaction thermophysical models
@}
\defgroup grpReactionThermophysicalMixtures Mixtures
@{
\ingroup grpReactionThermophysicalModels
This group contains reaction mixtures
@}
\defgroup grpReactionThermophysicalChemistryReaders Chemistry readers
@{
\ingroup grpReactionThermophysicalModels
This group contains chemistry readers
@}
\*---------------------------------------------------------------------------*/

3
src/thermophysicalModels/reactionThermo/functionObjects/moleFractions/moleFractions.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::moleFractions
Group
grpThermophysicalFunctionObjects
Description
This function object calculates mole-fraction fields from the mass-fraction
fields of the psi/rhoReactionThermo and caches them for output and further

3
src/thermophysicalModels/reactionThermo/mixtures/SpecieMixture/SpecieMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::SpecieMixture
Group
grpReactionThermophysicalMixtures
Description
Foam::SpecieMixture

3
src/thermophysicalModels/reactionThermo/mixtures/basicCombustionMixture/basicCombustionMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::basicCombustionMixture
Group
grpReactionThermophysicalMixtures
Description
Specialization of the basicSpecieMixture for combustion.

3
src/thermophysicalModels/reactionThermo/mixtures/basicMultiComponentMixture/basicMultiComponentMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::basicMultiComponentMixture
Group
grpReactionThermophysicalMixtures
Description
Multi-component mixture.

3
src/thermophysicalModels/reactionThermo/mixtures/basicSpecieMixture/basicSpecieMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::basicSpecieMixture
Group
grpReactionThermophysicalMixtures
Description
Specialization of basicMultiComponentMixture for a mixture consisting
of a number for molecular species.

3
src/thermophysicalModels/reactionThermo/mixtures/egrMixture/egrMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::egrMixture
Group
grpReactionThermophysicalMixtures
Description
Foam::egrMixture

3
src/thermophysicalModels/reactionThermo/mixtures/homogeneousMixture/homogeneousMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::homogeneousMixture
Group
grpReactionThermophysicalMixtures
Description
Foam::homogeneousMixture

3
src/thermophysicalModels/reactionThermo/mixtures/inhomogeneousMixture/inhomogeneousMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::inhomogeneousMixture
Group
grpReactionThermophysicalMixtures
Description
Foam::inhomogeneousMixture

3
src/thermophysicalModels/reactionThermo/mixtures/multiComponentMixture/multiComponentMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::multiComponentMixture
Group
grpReactionThermophysicalMixtures
Description
Foam::multiComponentMixture

3
src/thermophysicalModels/reactionThermo/mixtures/reactingMixture/reactingMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::reactingMixture
Group
grpReactionThermophysicalMixtures
Description
Foam::reactingMixture

3
src/thermophysicalModels/reactionThermo/mixtures/singleStepReactingMixture/singleStepReactingMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::singleStepReactingMixture
Group
grpReactionThermophysicalMixtures
Description
Single step reacting mixture

3
src/thermophysicalModels/reactionThermo/mixtures/veryInhomogeneousMixture/veryInhomogeneousMixture.H
View File

@ -24,6 +24,9 @@ License
Class
Foam::veryInhomogeneousMixture
Group
grpReactionThermophysicalMixtures
Description
Foam::veryInhomogeneousMixture

1
tutorials/compressible/rhoPimpleDyMFoam/annularThermalMixer/Allrun
View File

@ -13,7 +13,6 @@ if [ -d 0 ] ; then
rm -rf 0
fi
runApplication createPatch -overwrite
runApplication createBaffles -overwrite
runApplication mergeOrSplitBaffles -split -overwrite

28
tutorials/compressible/rhoPimpleDyMFoam/annularThermalMixer/system/createPatchDict
View File

@ -1,28 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object createPatchDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Do a synchronisation of coupled points after creation of any patches.
// Note: this does not work with points that are on multiple coupled patches
// with transformations (i.e. cyclics).
pointSync false;
// Patches to create. An empty patch list just removes patches with zero
// faces from $FOAM_CASE/constant/polyMesh/boundary.
patches
(
);
// ************************************************************************* //

2
tutorials/incompressible/pisoFoam/les/motorBike/motorBike/Allrun
View File

@ -15,7 +15,7 @@ runApplication blockMesh
runApplication decomposePar -decomposeParDict system/decomposeParDict.hierarchical
# cp system/decomposeParDict.ptscotch system/decomposeParDict
runParallel snappyHexMesh -decomposeParDict system/decomposeParDict.ptscotch -overwrite -parallel
runParallel snappyHexMesh -decomposeParDict system/decomposeParDict.ptscotch -profiling -overwrite -parallel
find . -type f -iname "*level*" -exec rm {} \;

1
tutorials/incompressible/simpleFoam/rotorDisk/Allrun
View File

@ -8,7 +8,6 @@ cd ${0%/*} || exit 1 # Run from this directory
runApplication blockMesh
runApplication surfaceFeatureExtract
runApplication snappyHexMesh -overwrite
runApplication createPatch -overwrite
runApplication $(getApplication)

29
tutorials/incompressible/simpleFoam/rotorDisk/system/createPatchDict
View File

@ -1,29 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object createPatchDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Do a synchronisation of coupled points after creation of any patches.
// Note: this does not work with points that are on multiple coupled patches
// with transformations (i.e. cyclics).
pointSync false;
// Patches to create. An empty patch list just removes patches with zero
// faces from $FOAM_CASE/constant/polyMesh/boundary.
patches
(
);
// ************************************************************************* //

14
tutorials/incompressible/simpleFoam/rotorDisk/system/snappyHexMeshDict
View File

@ -101,8 +101,9 @@ castellatedMeshControls
}
}
locationInMesh (1e-5 1e-5 1e-5); // Offset from (0 0 0) to avoid
// coinciding with face or edge
locationInMesh (1e-5 -1e-2 1e-5);// Offset from (0 0 0) to avoid
// coinciding with face or edge and keep
// away from disk itself
}
snapControls
@ -120,9 +121,6 @@ addLayersControls
expansionRatio 1.2;
finalLayerThickness 0.5;
minThickness 1e-3;
// firstLayerThickness 0.01;
// maxThicknessToMedialRatio 0.6;
}
meshQualityControls
@ -130,12 +128,6 @@ meshQualityControls
// minTetQuality -1e+30;
}
writeFlags
(
scalarLevels
layerSets
layerFields
);
mergeTolerance 1e-6;

54
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/H2O
View File

@ -1,54 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object H2O;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0.01;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
walls
{
type zeroGradient;
}
outlet
{
type inletOutlet;
inletValue uniform 0.0;
}
inletSides
{
type fixedValue;
value uniform 0.01;
}
inletCentral
{
type fixedValue;
value uniform 0.01;
}
}
// ************************************************************************* //

54
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/T
View File

@ -1,54 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object T;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 473.0;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
walls
{
type zeroGradient;
}
outlet
{
type inletOutlet;
inletValue uniform 473.0;
}
inletSides
{
type fixedValue;
value uniform 473.0;
}
inletCentral
{
type fixedValue;
value uniform 573.0;
}
}
// ************************************************************************* //

56
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/U
View File

@ -1,56 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
location "0";
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
inletCentral
{
type flowRateInletVelocity;
massFlowRate constant 0.00379;
value uniform (0 14.68 0);
}
inletSides
{
type flowRateInletVelocity;
massFlowRate constant 0.00832;
value uniform (0 17.79 0);
}
outlet
{
type inletOutlet;
inletValue uniform (0 0 0);
}
walls
{
type noSlip;
}
}
// ************************************************************************* //

54
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/air
View File

@ -1,54 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0.99;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
walls
{
type zeroGradient;
}
outlet
{
type inletOutlet;
inletValue uniform 1.0;
}
inletSides
{
type fixedValue;
value uniform 0.99;
}
inletCentral
{
type fixedValue;
value uniform 0.99;
}
}
// ************************************************************************* //

56
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/alphat
View File

@ -1,56 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object alphat;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -1 0 0 0 0];
internalField uniform 0;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
inletCentral
{
type calculated;
value uniform 0;
}
inletSides
{
type calculated;
value uniform 0;
}
outlet
{
type calculated;
value uniform 0;
}
walls
{
type compressible::alphatWallFunction;
Prt 0.85;
value uniform 0;
}
}
// ************************************************************************* //

57
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/k
View File

@ -1,57 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object k;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 3.75e-9;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
inletCentral
{
type turbulentIntensityKineticEnergyInlet;
intensity 0.15;
value uniform 3.75e-9;
}
inletSides
{
type turbulentIntensityKineticEnergyInlet;
intensity 0.16;
value uniform 3.75e-9;
}
outlet
{
type inletOutlet;
inletValue uniform 3.75e-9;
}
walls
{
type kqRWallFunction;
value uniform 0;
}
}
// ************************************************************************* //

58
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/nut
View File

@ -1,58 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object nut;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField uniform 0;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
inletCentral
{
type calculated;
value uniform 0;
}
inletSides
{
type calculated;
value uniform 0;
}
outlet
{
type calculated;
value uniform 0;
}
walls
{
type nutkWallFunction;
Cmu 0.09;
kappa 0.41;
E 9.8;
value uniform 0;
}
}
// ************************************************************************* //

62
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/omega
View File

@ -1,62 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object omega;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 -1 0 0 0 0];
internalField uniform 4.5e-3;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
inletCentral
{
type turbulentMixingLengthFrequencyInlet;
mixingLength 0.007;
k k;
value uniform 4.5e-3;
}
inletSides
{
type turbulentMixingLengthFrequencyInlet;
mixingLength 0.007;
k k;
value uniform 4.5e-3;
}
outlet
{
type inletOutlet;
inletValue uniform 4.5e-3;
}
walls
{
type omegaWallFunction;
Cmu 0.09;
kappa 0.41;
E 9.8;
value $internalField;
}
}
// ************************************************************************* //

52
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/0/p
View File

@ -1,52 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField uniform 100000;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
inletCentral
{
type zeroGradient;
}
inletSides
{
type zeroGradient;
}
outlet
{
type fixedValue;
value uniform 100000;
}
walls
{
type zeroGradient;
}
}
// ************************************************************************* //

4
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/Allclean
View File

@ -7,10 +7,6 @@ cd ${0%/*} || exit 1 # Run from this directory
# remove old time and post-processing directories
rm -rf 0 *[1-9]* processor* postProcessing
# copy 0.org to 0
cp -r 0.org 0
cleanCase
#------------------------------------------------------------------------------

20
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/Allrun Executable file
View File

@ -0,0 +1,20 @@
#!/bin/sh
cd ${0%/*} || exit 1 # Run from this directory
# Source tutorial run functions
. $WM_PROJECT_DIR/bin/tools/RunFunctions
# create mesh
runApplication blockMesh
cp -r 0.org 0
# initialise with potentialFoam solution
runApplication potentialFoam
rm -f 0/phi
# run the solver
runApplication `getApplication`
#------------------------------------------------------------------------------

4
tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/system/controlDict
View File

@ -45,6 +45,10 @@ timePrecision 6;
runTimeModifiable yes;
profiling
{
memInfo true;
}
functions
{

3
tutorials/multiphase/interDyMFoam/ras/mixerVesselAMI/Allrun.pre
View File

@ -16,9 +16,6 @@ runApplication snappyHexMesh -overwrite
runApplication createBaffles -overwrite
runApplication mergeOrSplitBaffles -split -overwrite
# Get rid of zero faced patches
runApplication createPatch -overwrite
# Copy fields after meshing to avoind the generation of unnecessary patch fields
\cp -r 0.org 0

Some files were not shown because too many files have changed in this diff Show More