zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

functionObjects::fieldAverage: Simplified the controls

Browse Source 
Rather than specifying the controls per field it is simpler to use a single set
of controls for all the fields in the list and use separate instances of the
fieldAverage functionObject for different control sets:

    Example of function object specification setting all the optional parameters:
    fieldAverage1
    {
        type                fieldAverage;
        libs                ("libfieldFunctionObjects.so");

        writeControl        writeTime;

        restartOnRestart    false;
        restartOnOutput     false;
        periodicRestart     false;
        restartPeriod       0.002;

        base                time;
        window              10.0;
        windowName          w1;

        mean                yes;
        prime2Mean          yes;

        fields              (U p);
    }

This allows for a simple specification with the optional prime2Mean entry using

    #includeFunc fieldAverage(U, p, prime2Mean = yes)

or if the prime2Mean is not needed just

    #includeFunc fieldAverage(U, p)
This commit is contained in:
Henry Weller
2020-03-17 20:15:17 +00:00
parent fbe98c6e84
commit 0177c7dd59
30 changed files with 213 additions and 535 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/functionObjects/field/fieldAverage/fieldAverage.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "fieldAverage.H"
#include "volFields.H"
#include "fieldAverageItem.H"
#include "addToRunTimeSelectionTable.H"
@ -40,6 +39,20 @@ namespace functionObjects
}
template<>
const char* Foam::NamedEnum
<
Foam::functionObjects::fieldAverage::baseType,
2
>::names[] = { "iteration", "time"};
const Foam::NamedEnum
<
Foam::functionObjects::fieldAverage::baseType,
2
> Foam::functionObjects::fieldAverage::baseTypeNames_;
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
void Foam::functionObjects::fieldAverage::resetFields()
@ -293,6 +306,9 @@ Foam::functionObjects::fieldAverage::fieldAverage
periodicRestart_(false),
restartPeriod_(great),
initialised_(false),
base_(baseType::iter),
window_(-1.0),
windowName_(""),
faItems_(),
totalIter_(),
totalTime_(),
@ -321,7 +337,21 @@ bool Foam::functionObjects::fieldAverage::read(const dictionary& dict)
dict.readIfPresent("restartOnRestart", restartOnRestart_);
dict.readIfPresent("restartOnOutput", restartOnOutput_);
dict.readIfPresent("periodicRestart", periodicRestart_);
dict.lookup("fields") >> faItems_;
mean_ = dict.lookupOrDefault<Switch>("mean", true);
prime2Mean_ = dict.lookupOrDefault<Switch>("prime2Mean", false);
base_ = baseTypeNames_
[
dict.lookupOrDefault<word>("base", "time")
];
window_ = dict.lookupOrDefault<scalar>("window", -1);
windowName_ = dict.lookupOrDefault<word>("windowName", "");
faItems_ = PtrList<fieldAverageItem>
(
dict.lookup("fields"),
fieldAverageItem::iNew(*this)
);
if (periodicRestart_)
{

95
src/functionObjects/field/fieldAverage/fieldAverage.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -61,30 +61,21 @@ Description
type fieldAverage;
libs ("libfieldFunctionObjects.so");
writeControl writeTime;
writeControl writeTime;
restartOnRestart false;
restartOnOutput false;
periodicRestart false;
restartPeriod 0.002;
fields
(
U
{
mean on;
prime2Mean on;
base time;
window 10.0;
windowName w1;
}
p
{
mean on;
prime2Mean on;
base time;
}
);
base time;
window 10.0;
windowName w1;
mean yes;
prime2Mean yes;
fields (U p);
}
\endverbatim
@ -99,7 +90,6 @@ Usage
fields | list of fields and averaging options | yes |
\endtable
Note
To employ the \c prime2Mean option, the \c mean option must be selected.
@ -137,6 +127,17 @@ class fieldAverage
:
public fvMeshFunctionObject
{
public:
//- Enumeration defining the averaging base type
enum class baseType
{
iter,
time
};
protected:
// Protected data
@ -159,9 +160,27 @@ protected:
//- Initialised flag
bool initialised_;
//- Averaging base type names
static const NamedEnum<baseType, 2> baseTypeNames_;
//- Averaging base type
baseType base_;
//- Averaging window - defaults to -1 for 'all iters/time'
scalar window_;
//- Averaging window name - defaults to 'window'
word windowName_;
//- Compute mean flag
Switch mean_;
//- Compute prime-squared mean flag
Switch prime2Mean_;
//- List of field average items, describing what averages to be
// calculated and output
List<fieldAverageItem> faItems_;
PtrList<fieldAverageItem> faItems_;
// Counters
@ -259,6 +278,9 @@ protected:
public:
friend class fieldAverageItem;
//- Runtime type information
TypeName("fieldAverage");
@ -283,6 +305,37 @@ public:
// Member Functions
// Access
//- Return averaging base type name
const word base() const
{
return baseTypeNames_[base_];
}
//- Return true if base is iter
Switch iterBase() const
{
return base_ == baseType::iter;
}
//- Return true if base is time
Switch timeBase() const
{
return base_ == baseType::time;
}
scalar window() const
{
return window_;
}
const word& windowName() const
{
return windowName_;
}
//- Read the field average data
virtual bool read(const dictionary&);

63
src/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItem.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,19 +37,6 @@ const Foam::word Foam::functionObjects::fieldAverageItem::prime2MeanExt
"Prime2Mean"
);
template<>
const char* Foam::NamedEnum
<
Foam::functionObjects::fieldAverageItem::baseType,
2
>::names[] = { "iteration", "time"};
const Foam::NamedEnum
<
Foam::functionObjects::fieldAverageItem::baseType,
2
> Foam::functionObjects::fieldAverageItem::baseTypeNames_;
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -59,26 +46,7 @@ Foam::functionObjects::fieldAverageItem::fieldAverageItem()
mean_(0),
meanFieldName_("unknown"),
prime2Mean_(0),
prime2MeanFieldName_("unknown"),
base_(baseType::iter),
window_(-1.0),
windowName_("")
{}
Foam::functionObjects::fieldAverageItem::fieldAverageItem
(
const fieldAverageItem& faItem
)
:
fieldName_(faItem.fieldName_),
mean_(faItem.mean_),
meanFieldName_(faItem.meanFieldName_),
prime2Mean_(faItem.prime2Mean_),
prime2MeanFieldName_(faItem.prime2MeanFieldName_),
base_(faItem.base_),
window_(faItem.window_),
windowName_(faItem.windowName_)
prime2MeanFieldName_("unknown")
{}
@ -88,31 +56,4 @@ Foam::functionObjects::fieldAverageItem::~fieldAverageItem()
{}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
void Foam::functionObjects::fieldAverageItem::operator=
(
const fieldAverageItem& rhs
)
{
// Check for assignment to self
if (this == &rhs)
{
FatalErrorInFunction
<< "Attempted assignment to self" << nl
<< abort(FatalError);
}
// Set updated values
fieldName_ = rhs.fieldName_;
mean_ = rhs.mean_;
meanFieldName_ = rhs.meanFieldName_;
prime2Mean_ = rhs.prime2Mean_;
prime2MeanFieldName_ = rhs.prime2MeanFieldName_;
base_ = rhs.base_;
window_ = rhs.window_;
windowName_ = rhs.windowName_;
}
// ************************************************************************* //

127
src/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItem.H
View File

@ -60,14 +60,11 @@ namespace Foam
// Forward declaration of classes
class Istream;
class Ostream;
namespace functionObjects
{
// Forward declaration of friend functions and operators
class fieldAverageItem;
Istream& operator>>(Istream&, fieldAverageItem&);
class fieldAverage;
/*---------------------------------------------------------------------------*\
Class fieldAverageItem Declaration
@ -75,18 +72,6 @@ Istream& operator>>(Istream&, fieldAverageItem&);
class fieldAverageItem
{
public:
//- Enumeration defining the averaging base type
enum class baseType
{
iter,
time
};
private:
// Private Data
//- Field name
@ -104,18 +89,6 @@ private:
//- Name of prime-squared mean field
word prime2MeanFieldName_;
//- Averaging base type names
static const NamedEnum<baseType, 2> baseTypeNames_;
//- Averaging base type
baseType base_;
//- Averaging window - defaults to -1 for 'all iters/time'
scalar window_;
//- Averaging window name - defaults to 'window'
word windowName_;
public:
@ -135,11 +108,36 @@ public:
//- Construct null
fieldAverageItem();
//- Construct from Istream
fieldAverageItem(Istream&);
//- Construct from Istream for given fieldAverage
fieldAverageItem(const fieldAverage& fa, Istream& is);
//- Copy constructor
fieldAverageItem(const fieldAverageItem&);
fieldAverageItem(const fieldAverageItem&) = default;
//- Clone function
autoPtr<fieldAverageItem> clone() const
{
return autoPtr<fieldAverageItem>(new fieldAverageItem(*this));
}
//- Class used for the read-construction of
// PtrLists of fieldAverageItem
class iNew
{
const fieldAverage& fa_;
public:
iNew(const fieldAverage& fa)
:
fa_(fa)
{}
autoPtr<fieldAverageItem> operator()(Istream& is) const
{
return autoPtr<fieldAverageItem>(new fieldAverageItem(fa_, is));
}
};
//- Destructor
@ -191,73 +189,6 @@ public:
{
return prime2MeanFieldName_;
}
//- Return averaging base type name
const word base() const
{
return baseTypeNames_[base_];
}
//- Return true if base is iter
Switch iterBase() const
{
return base_ == baseType::iter;
}
//- Return true if base is time
Switch timeBase() const
{
return base_ == baseType::time;
}
scalar window() const
{
return window_;
}
const word& windowName() const
{
return windowName_;
}
// Member Operators
void operator=(const fieldAverageItem&);
// Friend Operators
friend bool operator==
(
const fieldAverageItem& a,
const fieldAverageItem& b
)
{
return
a.fieldName_ == b.fieldName_
&& a.mean_ == b.mean_
&& a.meanFieldName_ == b.meanFieldName_
&& a.prime2Mean_ == b.prime2Mean_
&& a.prime2MeanFieldName_ == b.prime2MeanFieldName_
&& a.base_ == b.base_
&& a.window_ == b.window_
&& a.windowName_ == b.windowName_;
}
friend bool operator!=
(
const fieldAverageItem& a,
const fieldAverageItem& b
)
{
return !(a == b);
}
// IOstream Operators
friend Istream& operator>>(Istream&, fieldAverageItem&);
};

71
src/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItemIO.C
View File

@ -24,32 +24,21 @@ License
\*---------------------------------------------------------------------------*/
#include "fieldAverageItem.H"
#include "dictionaryEntry.H"
#include "IOobject.H"
#include "fieldAverage.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::functionObjects::fieldAverageItem::fieldAverageItem(Istream& is)
Foam::functionObjects::fieldAverageItem::fieldAverageItem
(
const fieldAverage& fa,
Istream& is
)
:
fieldName_("unknown"),
mean_(0),
mean_(false),
meanFieldName_("unknown"),
prime2Mean_(0),
prime2MeanFieldName_("unknown"),
base_(baseType::iter),
window_(-1.0)
{
is >> *this;
}
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
Foam::Istream& Foam::functionObjects::operator>>
(
Istream& is,
fieldAverageItem& faItem
)
prime2Mean_(false),
prime2MeanFieldName_("unknown")
{
is.check
(
@ -58,7 +47,7 @@ Foam::Istream& Foam::functionObjects::operator>>
);
token fieldNameToken(is);
faItem.fieldName_ = fieldNameToken.wordToken();
fieldName_ = fieldNameToken.wordToken();
token nextToken(is);
is.putBack(nextToken);
@ -67,44 +56,36 @@ Foam::Istream& Foam::functionObjects::operator>>
{
const dictionary entry(dictionary::null, is);
faItem.mean_ = entry.lookupOrDefault<Switch>("mean", true);
faItem.prime2Mean_ = entry.lookupOrDefault<Switch>("prime2Mean", false);
faItem.base_ =
faItem.baseTypeNames_[entry.lookupOrDefault<word>("base", "time")];
faItem.window_ = entry.lookupOrDefault<scalar>("window", -1);
faItem.windowName_ = entry.lookupOrDefault<word>("windowName", "");
mean_ = entry.lookupOrDefault<Switch>("mean", fa.mean_);
prime2Mean_ =
entry.lookupOrDefault<Switch>("prime2Mean", fa.prime2Mean_);
}
else
{
faItem.mean_ = true;
faItem.prime2Mean_ = false;
faItem.base_ = faItem.baseTypeNames_["time"];
faItem.window_ = -1;
faItem.windowName_ = "";
mean_ = fa.mean_;
prime2Mean_ = fa.prime2Mean_;
}
faItem.meanFieldName_ = IOobject::groupName
meanFieldName_ = IOobject::groupName
(
IOobject::member(faItem.fieldName_) + fieldAverageItem::meanExt,
IOobject::group(faItem.fieldName_)
IOobject::member(fieldName_) + fieldAverageItem::meanExt,
IOobject::group(fieldName_)
);
faItem.prime2MeanFieldName_ = IOobject::groupName
prime2MeanFieldName_ = IOobject::groupName
(
IOobject::member(faItem.fieldName_) + fieldAverageItem::prime2MeanExt,
IOobject::group(faItem.fieldName_)
IOobject::member(fieldName_) + fieldAverageItem::prime2MeanExt,
IOobject::group(fieldName_)
);
if ((faItem.window_ > 0) && (faItem.windowName_ != ""))
if ((fa.window_ > 0) && (fa.windowName_ != ""))
{
faItem.meanFieldName_ =
faItem.meanFieldName_ + "_" + faItem.windowName_;
meanFieldName_ =
meanFieldName_ + "_" + fa.windowName_;
faItem.prime2MeanFieldName_ =
faItem.prime2MeanFieldName_ + "_" + faItem.windowName_;
prime2MeanFieldName_ =
prime2MeanFieldName_ + "_" + fa.windowName_;
}
return is;
}

15
src/functionObjects/field/fieldAverage/fieldAverageTemplates.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,7 +26,6 @@ License
#include "fieldAverageItem.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "OFstream.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
@ -202,7 +201,7 @@ void Foam::functionObjects::fieldAverage::calculateMeanFieldType
scalar dt = obr_.time().deltaTValue();
scalar Dt = totalTime_[fieldi];
if (faItems_[fieldi].iterBase())
if (iterBase())
{
dt = 1;
Dt = scalar(totalIter_[fieldi]);
@ -210,9 +209,9 @@ void Foam::functionObjects::fieldAverage::calculateMeanFieldType
scalar beta = dt/Dt;
if (faItems_[fieldi].window() > 0)
if (window() > 0)
{
const scalar w = faItems_[fieldi].window();
const scalar w = window();
if (Dt - dt >= w)
{
@ -262,7 +261,7 @@ void Foam::functionObjects::fieldAverage::calculatePrime2MeanFieldType
scalar dt = obr_.time().deltaTValue();
scalar Dt = totalTime_[fieldi];
if (faItems_[fieldi].iterBase())
if (iterBase())
{
dt = 1;
Dt = scalar(totalIter_[fieldi]);
@ -270,9 +269,9 @@ void Foam::functionObjects::fieldAverage::calculatePrime2MeanFieldType
scalar beta = dt/Dt;
if (faItems_[fieldi].window() > 0)
if (window() > 0)
{
const scalar w = faItems_[fieldi].window();
const scalar w = window();
if (Dt - dt >= w)
{