-
- literal lookups only for expression strings - code reduction for setExprFields. - changed keyword "condition" to "fieldMask" (option -field-mask). This is a better description of its purpose and avoids possible naming ambiguities with functionObject triggers (for example) if we apply similar syntax elsewhere. BUG: erroneous check in volumeExpr::parseDriver::isResultType() - not triggered since this method is not used anywhere (may remove in future version)
- literal lookups only for expression strings - code reduction for setExprFields. - changed keyword "condition" to "fieldMask" (option -field-mask). This is a better description of its purpose and avoids possible naming ambiguities with functionObject triggers (for example) if we apply similar syntax elsewhere. BUG: erroneous check in volumeExpr::parseDriver::isResultType() - not triggered since this method is not used anywhere (may remove in future version)
exprResult.H 16.79 KiB
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2012-2018 Bernhard Gschaider
Copyright (C) 2019-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::expressions::exprResult
Description
A polymorphic field/result from evaluating an expression
\heading Dictionary parameters
\table
Property | Description | Required | Default
resultType | The type of result | no | exprResult
unsetValue | Create without reading the dictionary | no | false
noReset | Suppress reset on time | no | false
\endtable
When creating with values
\table
Property | Description | Required | Default
valueType | Result value type (scalar, vector,..) | yes |
isSingleValue | A single field value | no | false
isPointValue | Interpret values as point values | no | false
value | The field values | yes |
fieldSize | The size of the field (when not single-value) | no |
\endtable
SourceFiles
exprResult.C
exprResultI.H
\*---------------------------------------------------------------------------*/
#ifndef expressions_exprResult_H
#define expressions_exprResult_H
#include "exprTraits.H"
#include "dimensionedType.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace expressions
{
/*---------------------------------------------------------------------------*\
Class exprResult Declaration
\*---------------------------------------------------------------------------*/
class exprResult
:
public refCount
{
// Private Data
//- The value type as string,
//- normally corresponds to pTraits or typeName
word valType_;
//- Is single, uniform value (can be a non-field)
bool isUniform_;
//- Represents point data
bool isPointData_;
//- Whether or not the variable will be reset
bool noReset_;
//- Allow override of noReset_, but only accessible for subclasses
bool needsReset_;
//- Size (length) of field or object
label size_;
//- A %union of single values, including standard VectorSpace types
union singleValue
{
bool bool_;
label label_;
scalar scalar_;
vector vector_;
tensor tensor_;
symmTensor symmTensor_;
sphericalTensor sphTensor_;
//- Default construct, zero-initialized
singleValue();
//- Copy construct
singleValue(const singleValue& val);
//- Copy assignment
void operator=(const singleValue& val);
//- Return current value for specified type.
template<class T>
inline const T& get() const
{
WarningInFunction
<< "Not implemented for type "
<< pTraits<T>::typeName << nl;
return pTraits<T>::zero;
}
//- Set new value for specified type.
// \return updated value
template<class T>
inline const T& set(const T& val)
{
WarningInFunction
<< "Not implemented for type "
<< pTraits<T>::typeName << nl;
return val;
}
};
//- The single value representation
singleValue single_;
//- Allocated plain field (eg, scalarField)
void *fieldPtr_;
// Private Member Functions
//- Type-checked deletion of the value pointer.
// \return True if the type check was satisfied
template<class Type>
inline bool deleteChecked();
//- Dispatch to type-checked pointer deletion
void uglyDelete();
//- Type-checked creation of field from dictionary
// \return True if the type check was satisfied
template<class Type>
inline bool readChecked
(
const word& key,
const dictionary& dict,
const label len,
const bool uniform
);
//- Type-checked retrieval of uniform field from current results
// \return True if the type check was satisfied
template<class Type>
bool getUniformChecked
(
exprResult& result,
const label size,
const bool noWarn,
const bool parRun
) const;
//- Type-checked retrieval of \c bool uniform field from current result
// \return True if the type check was satisfied
bool getUniformCheckedBool
(
exprResult& result,
const label size,
const bool noWarn,
const bool parRun
) const;
//- Type-checked determination of centre value (min/max)
// \return True if the type check was satisfied
template<class Type>
bool setAverageValueChecked(const bool parRun = Pstream::parRun());
//- Type-checked determination of average bool value
// \return True if the type check was satisfied
bool setAverageValueCheckedBool(const bool parRun = Pstream::parRun());
//- Type-checked copy of field
// \return True if the type check was satisfied
template<class Type>
bool duplicateFieldChecked(const void* ptr);
//- Type-checked writing of the single value (uniform) entry
// \return True if the type check was satisfied
template<class Type>
bool writeSingleValueChecked(Ostream& os) const;
//- Type-checked writing field as entry (if keyword is non-empty)
//- or as plain field (if keyword is empty)
// \return True if the type check was satisfied
template<class Type>
bool writeFieldChecked(const word& keyword, Ostream& os) const;
//- Type-checked forwarding to Field::writeEntry
// \return True if the type check was satisfied
template<class Type>
bool writeEntryChecked(const word& keyword, Ostream& os) const;
//- Type-checked field addition with another expression field
// \return True if the type check was satisfied
template<class Type>
bool plusEqChecked(const exprResult& b);
//- Type-checked field multiplication with a scalar
// \return True if the type check was satisfied
template<class Type>
bool multiplyEqChecked(const scalar& b);
template<class Type>
inline void setResultImpl(Field<Type>*, bool wantPointData=false);
template<class Type>
inline void setResultImpl(const Field<Type>&, bool wantPointData=false);
template<class Type>
inline void setResultImpl(Field<Type>&&, bool wantPointData=false);
template<class Type>
inline void setResultImpl(const Type& val, const label len);
template<class Type>
inline void setSingleValueImpl(const Type& val);
protected:
// Protected Member Functions
//- Simulate virtual templated methods
inline virtual expressions::exprResult& target() { return *this; }
//- Reset at new timestep according to the derived class type
virtual void resetImpl();
//- Reset at new timestep according to type
// \return true if it was actually reset
bool reset(bool force=false);
//- Adjusts the internal needsReset value
void needsReset(bool val) { needsReset_ = val; }
public:
//- An empty result
static const exprResult null;
//- Friendship with globals
friend class exprResultGlobals;
//- Runtime type information
TypeName("exprResult");
declareRunTimeSelectionTable
(
autoPtr,
exprResult,
dictionary,
(
const dictionary& dict
),
(dict)
);
declareRunTimeSelectionTable
(
autoPtr,
exprResult,
empty,
(),
()
);
// Constructors
//- Default construct
exprResult();
//- Copy construct
exprResult(const exprResult& expr);
//- Move construct
exprResult(exprResult&& expr);
//- Construct from a dictionary
explicit exprResult
(
const dictionary& dict,
const bool uniform = false,
const bool needsValue = false
);
//- Construct from Istream as dictionary content
explicit exprResult(Istream& is);
//- Construct by copying a field
template<class Type>
explicit exprResult(const Field<Type>& fld);
//- Construct by moving a field
template<class Type>
explicit exprResult(Field<Type>&& fld);
//- Construct for an IOobject
template<class Type>
explicit exprResult(autoPtr<Type>&& obj);
//- Construct from a dimensioned value
template<class Type>
explicit exprResult(const dimensioned<Type>& dt);
#undef exprResult_Construct
#define exprResult_Construct(Type) \
/*! \brief Construct from single value of Type */ \
explicit exprResult(const Type& val) : exprResult() \
{ \
setSingleValue(val); \
}
exprResult_Construct(bool);
exprResult_Construct(scalar);
exprResult_Construct(vector);
exprResult_Construct(tensor);
exprResult_Construct(symmTensor);
exprResult_Construct(sphericalTensor);
#undef exprResult_Construct
// Selectors
//- Return a reference to the selected value driver
static autoPtr<exprResult> New(const dictionary& dict);
//- Construct from Istream as dictionary content
static autoPtr<exprResult> New(Istream& is);
//- Clone
virtual autoPtr<exprResult> clone() const
{
return autoPtr<exprResult>::New(*this);
}
//- Destructor
virtual ~exprResult();
// Member Functions
// Access
//- Has a value?
inline bool hasValue() const;
//- Basic type for the field or single value
inline const word& valueType() const noexcept;
//- True if representing point data,
//- or test for same value as wantPointData argument
inline bool isPointData(const bool wantPointData=true) const;
//- True if single, uniform value
inline bool isUniform() const;
//- True if valueType corresponds to the given Type
template<class Type>
inline bool isType() const;
//- Return a single value when isUniform() is true,
//- or Zero when it is non-uniform or if the type mismatches,
//- which means that it can generally be considered as failsafe.
template<class Type>
inline Type getValue() const;
//- True if valueType is a bool
inline bool is_bool() const;
//- The field or object size
inline label size() const;
//- The address of the field data content.
// Fatal for unknown types.
// Used, for example, for python integration
const void* dataAddress() const;
// Edit
//- Clear (zero) the result
void clear();
//- Change reset behaviour
void noReset() noexcept { noReset_ = true; }
//- Change reset behaviour
void allowReset() noexcept { noReset_ = false; }
//- Test if field corresponds to a single-value and thus uniform.
// Uses field min/max to establish uniformity.
// Test afterwards with isUniform()
void testIfSingleValue(const bool parRun = Pstream::parRun());
// Set results
//- Set result field, taking ownership of the pointer
template<class Type>
inline void setResult(Field<Type>*, bool wantPointData=false);
//- Set result field, taking copy of the field contents
template<class Type>
inline void setResult(const Field<Type>&, bool wantPointData=false);
//- Set result field, moving field contents
template<class Type>
inline void setResult(Field<Type>&&, bool wantPointData=false);
//- Set uniform result field of given size
template<class Type>
inline void setResult(const Type& val, const label size);
//- Set single-value uniform result
template<class Type>
inline void setSingleValue(const Type& val);
// Access/Get results
//- Return const reference to the field
template<class Type>
inline const Field<Type>& cref() const;
//- Return non-const reference to the field
template<class Type>
inline Field<Type>& ref();
//- Return non-const reference to the field, casting away constness
template<class Type>
inline Field<Type>& constCast() const;
//- Return tmp field of the contents,
//- optionally keeping a copy in cache
template<class Type>
inline tmp<Field<Type>> getResult(bool cacheCopy=false);
//- Construct a uniform field from the current results
// Uses the field average. Optionally warning if the min/max
// deviation is larger than SMALL.
exprResult getUniform
(
const label size,
const bool noWarn,
const bool parRun = Pstream::parRun()
) const;
//- Get a reduced result
template<template<class> class BinaryOp, class Type>
inline Type getReduced
(
const BinaryOp<Type>& bop,
const Type& initial = pTraits<Type>::zero
);
// Write
//- Forwarding to Field::writeEntry
void writeEntry(const word& keyword, Ostream& os) const;
//- Write entry as dictionary contents
void writeDict(Ostream& os, const bool subDict=true) const;
//- Write the field, optionally as an entry
void writeField(Ostream& os, const word& keyword = "") const;
//- Write the single value, or the first value from field
void writeValue(Ostream& os) const;
// Member Operators
//- Copy assignment
virtual void operator=(const exprResult& rhs);
//- Move assignment
virtual void operator=(exprResult&& rhs);
//- Scalar multiplication
exprResult& operator*=(const scalar& b);
//- Addition of results
exprResult& operator+=(const exprResult& b);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace expressions
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Operators
expressions::exprResult operator*
(
const scalar& a,
const expressions::exprResult& b
);
expressions::exprResult operator*
(
const expressions::exprResult& a,
const scalar& b
);
expressions::exprResult operator+
(
const expressions::exprResult& a,
const expressions::exprResult& b
);
// IO Operator
Istream& operator>>(Istream& os, expressions::exprResult& data);
Ostream& operator<<(Ostream& os, const expressions::exprResult& data);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "exprResultI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //