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

Function1: Generalisation and removal of unused code

Browse Source 
Function1 has been generalised in order to provide functionality
previously provided by some near-duplicate pieces of code.

The interpolationTable and tableReader classes have been removed and
their usage cases replaced by Function1. The interfaces to Function1,
Table and TableFile has been improved for the purpose of using it
internally; i.e., without user input.

Some boundary conditions, fvOptions and function objects which
previously used interpolationTable or other low-level interpolation
classes directly have been changed to use Function1 instead. These
changes may not be backwards compatible. See header documentation for
details.

In addition, the timeVaryingUniformFixedValue boundary condition has
been removed as its functionality is duplicated entirely by
uniformFixedValuePointPatchField.
This commit is contained in:
Will Bainbridge
2019-10-17 19:11:05 +01:00
parent 64da7a2cc9
commit 7ab73932cf
130 changed files with 1156 additions and 2863 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/saturationModels/function1/function1.H
View File

@ -52,16 +52,16 @@ Description
\verbatim \verbatim
type function1; type function1;
function tableFile;
function csvFile;
functionCoeffs functionCoeffs
{ {
file "filename.csv";
format csv;
nHeaderLine 1; nHeaderLine 1;
refColumn 0; refColumn 0;
componentColumns (1); componentColumns (1);
separator ","; separator ",";
mergeSeparators no; mergeSeparators no;
file "filename.csv";
outOfBounds clamp; outOfBounds clamp;
interpolationScheme linear; interpolationScheme linear;
}; };

32
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/populationBalanceModel/binaryBreakupModels/LuoSvendsen/LuoSvendsen.C
View File

@ -26,6 +26,7 @@ License
#include "LuoSvendsen.H" #include "LuoSvendsen.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
#include "phaseCompressibleTurbulenceModel.H" #include "phaseCompressibleTurbulenceModel.H"
#include "linearInterpolationWeights.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -116,27 +117,30 @@ Foam::diameterModels::binaryBreakupModels::LuoSvendsen::LuoSvendsen
} }
gammaUpperReg2by11_ = gammaUpperReg2by11_ =
new interpolationTable<scalar> new Function1s::Table<scalar>
( (
gammaUpperReg2by11Table, "gamma2by11",
interpolationTable<scalar>::CLAMP, Function1s::tableBase::boundsHandling::clamp,
"gamma2by11" linearInterpolationWeights::typeName,
gammaUpperReg2by11Table
); );
gammaUpperReg5by11_ = gammaUpperReg5by11_ =
new interpolationTable<scalar> new Function1s::Table<scalar>
( (
gammaUpperReg5by11Table, "gamma5by11",
interpolationTable<scalar>::CLAMP, Function1s::tableBase::boundsHandling::clamp,
"gamma5by11" linearInterpolationWeights::typeName,
gammaUpperReg5by11Table
); );
gammaUpperReg8by11_ = gammaUpperReg8by11_ =
new interpolationTable<scalar> new Function1s::Table<scalar>
( (
gammaUpperReg8by11Table, "gamma8by11",
interpolationTable<scalar>::CLAMP, Function1s::tableBase::boundsHandling::clamp,
"gamma8by11" linearInterpolationWeights::typeName,
gammaUpperReg8by11Table
); );
} }
@ -194,8 +198,8 @@ Foam::diameterModels::binaryBreakupModels::LuoSvendsen::addToBinaryBreakupRate
integral[celli] *= integral[celli] *=
2.0*pow(b[celli], 3.0/11.0)*tgamma(5.0/11.0) 2.0*pow(b[celli], 3.0/11.0)*tgamma(5.0/11.0)
*( *(
gammaUpperReg5by11_()(b[celli]) gammaUpperReg5by11_->value(b[celli])
- gammaUpperReg5by11_()(tMin[celli]) - gammaUpperReg5by11_->value(tMin[celli])
); );
} }

8
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/populationBalanceModel/binaryBreakupModels/LuoSvendsen/LuoSvendsen.H
View File

@ -135,7 +135,7 @@ SourceFiles
#define LuoSvendsen_H #define LuoSvendsen_H
#include "binaryBreakupModel.H" #include "binaryBreakupModel.H"
#include "interpolationTable.H" #include "Table.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -159,13 +159,13 @@ private:
// Private Data // Private Data
//- Interpolation table of Q(a,z) for a=2/11 //- Interpolation table of Q(a,z) for a=2/11
autoPtr<interpolationTable<scalar>> gammaUpperReg2by11_; autoPtr<Function1s::Table<scalar>> gammaUpperReg2by11_;
//- Interpolation table of Q(a,z) for a=5/11 //- Interpolation table of Q(a,z) for a=5/11
autoPtr<interpolationTable<scalar>> gammaUpperReg5by11_; autoPtr<Function1s::Table<scalar>> gammaUpperReg5by11_;
//- Interpolation table of Q(a,z) for a=8/11 //- Interpolation table of Q(a,z) for a=8/11
autoPtr<interpolationTable<scalar>> gammaUpperReg8by11_; autoPtr<Function1s::Table<scalar>> gammaUpperReg8by11_;
//- Empirical constant, defaults to 0.923 //- Empirical constant, defaults to 0.923
dimensionedScalar C4_; dimensionedScalar C4_;

10
applications/utilities/postProcessing/noise/noise.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -30,7 +30,7 @@ Description
Control settings are read from the $FOAM_CASE/system/noiseDict dictionary, Control settings are read from the $FOAM_CASE/system/noiseDict dictionary,
or user-specified dictionary using the -dict option. Pressure data is or user-specified dictionary using the -dict option. Pressure data is
read using a CSV reader: read using a TableFile Function1:
Usage Usage
\verbatim \verbatim
@ -72,7 +72,7 @@ Usage
- one-third-octave-band pressure spectrum - one-third-octave-band pressure spectrum
See also See also
CSV.H TableFile.H
noiseFFT.H noiseFFT.H
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -81,7 +81,7 @@ See also
#include "noiseFFT.H" #include "noiseFFT.H"
#include "argList.H" #include "argList.H"
#include "Time.H" #include "Time.H"
#include "CSV.H" #include "TableFile.H"
#include "IOdictionary.H" #include "IOdictionary.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -134,7 +134,7 @@ int main(int argc, char *argv[])
#include "createFields.H" #include "createFields.H"
Info<< "Reading data file" << endl; Info<< "Reading data file" << endl;
FieldFunction1<Function1Types::CSV<scalar>> pData Function1s::TableFile<scalar> pData
( (
"pressure", "pressure",
dict.subDict("pressureData") dict.subDict("pressureData")

3
etc/controlDict
View File

@ -839,10 +839,7 @@ DebugSwitches
thermophysicalFunction 0; thermophysicalFunction 0;
time 0; time 0;
timeVaryingAlphaContactAngle 0; timeVaryingAlphaContactAngle 0;
timeVaryingFlowRateInletVelocity 0;
timeVaryingMappedFixedValue 0; timeVaryingMappedFixedValue 0;
timeVaryingTotalPressure 0;
timeVaryingUniformFixedValue 0;
timer 0; timer 0;
topoAction 0; topoAction 0;
topoCellLooper 0; topoCellLooper 0;

7
src/OpenFOAM/Make/files
View File

@ -90,7 +90,6 @@ primitives/triad/triad.C
/* Run-time selectable functions */ /* Run-time selectable functions */
primitives/functions/Function1/makeFunction1s.C primitives/functions/Function1/makeFunction1s.C
primitives/functions/Function1/ramp/ramp.C
primitives/functions/Function1/reverseRamp/reverseRamp.C primitives/functions/Function1/reverseRamp/reverseRamp.C
primitives/functions/Function1/linearRamp/linearRamp.C primitives/functions/Function1/linearRamp/linearRamp.C
primitives/functions/Function1/quadraticRamp/quadraticRamp.C primitives/functions/Function1/quadraticRamp/quadraticRamp.C
@ -98,6 +97,7 @@ primitives/functions/Function1/quarterSineRamp/quarterSineRamp.C
primitives/functions/Function1/quarterCosineRamp/quarterCosineRamp.C primitives/functions/Function1/quarterCosineRamp/quarterCosineRamp.C
primitives/functions/Function1/halfCosineRamp/halfCosineRamp.C primitives/functions/Function1/halfCosineRamp/halfCosineRamp.C
primitives/functions/Function1/Table/tableBase.C primitives/functions/Function1/Table/tableBase.C
primitives/functions/Function1/TableFile/TableReader/makeTableReaders.C
primitives/subModelBase/subModelBase.C primitives/subModelBase/subModelBase.C
@ -681,7 +681,6 @@ derivedPointPatchFields = $(pointPatchFields)/derived
$(derivedPointPatchFields)/slip/slipPointPatchFields.C $(derivedPointPatchFields)/slip/slipPointPatchFields.C
$(derivedPointPatchFields)/fixedNormalSlip/fixedNormalSlipPointPatchFields.C $(derivedPointPatchFields)/fixedNormalSlip/fixedNormalSlipPointPatchFields.C
$(derivedPointPatchFields)/uniformFixedValue/uniformFixedValuePointPatchFields.C $(derivedPointPatchFields)/uniformFixedValue/uniformFixedValuePointPatchFields.C
$(derivedPointPatchFields)/timeVaryingUniformFixedValue/timeVaryingUniformFixedValuePointPatchFields.C
$(derivedPointPatchFields)/codedFixedValue/codedFixedValuePointPatchFields.C $(derivedPointPatchFields)/codedFixedValue/codedFixedValuePointPatchFields.C
fields/GeometricFields/pointFields/pointFields.C fields/GeometricFields/pointFields/pointFields.C
@ -693,10 +692,6 @@ interpolations = interpolations
interpolation = $(interpolations)/interpolation interpolation = $(interpolations)/interpolation
$(interpolations)/patchToPatchInterpolation/PatchToPatchInterpolationName.C $(interpolations)/patchToPatchInterpolation/PatchToPatchInterpolationName.C
$(interpolations)/interpolationTable/tableReaders/tableReaders.C
$(interpolations)/interpolationTable/tableReaders/openFoam/openFoamTableReaders.C
$(interpolations)/interpolationTable/tableReaders/csv/csvTableReaders.C
interpolationWeights = $(interpolations)/interpolationWeights interpolationWeights = $(interpolations)/interpolationWeights
$(interpolationWeights)/interpolationWeights/interpolationWeights.C $(interpolationWeights)/interpolationWeights/interpolationWeights.C
$(interpolationWeights)/linearInterpolationWeights/linearInterpolationWeights.C $(interpolationWeights)/linearInterpolationWeights/linearInterpolationWeights.C

132
src/OpenFOAM/fields/pointPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValuePointPatchField.C
View File

@ -1,132 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "timeVaryingUniformFixedValuePointPatchField.H"
#include "Time.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::
timeVaryingUniformFixedValuePointPatchField<Type>::
timeVaryingUniformFixedValuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF
)
:
fixedValuePointPatchField<Type>(p, iF)
{}
template<class Type>
Foam::
timeVaryingUniformFixedValuePointPatchField<Type>::
timeVaryingUniformFixedValuePointPatchField
(
const timeVaryingUniformFixedValuePointPatchField<Type>& ptf,
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const pointPatchFieldMapper& mapper
)
:
fixedValuePointPatchField<Type>(ptf, p, iF, mapper),
timeSeries_(ptf.timeSeries_)
{
this->operator==(timeSeries_(this->db().time().timeOutputValue()));
}
template<class Type>
Foam::
timeVaryingUniformFixedValuePointPatchField<Type>::
timeVaryingUniformFixedValuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchField<Type>(p, iF),
timeSeries_(dict)
{
this->operator==(timeSeries_(this->db().time().timeOutputValue()));
}
template<class Type>
Foam::
timeVaryingUniformFixedValuePointPatchField<Type>::
timeVaryingUniformFixedValuePointPatchField
(
const timeVaryingUniformFixedValuePointPatchField<Type>& ptf
)
:
fixedValuePointPatchField<Type>(ptf),
timeSeries_(ptf.timeSeries_)
{}
template<class Type>
Foam::
timeVaryingUniformFixedValuePointPatchField<Type>::
timeVaryingUniformFixedValuePointPatchField
(
const timeVaryingUniformFixedValuePointPatchField<Type>& ptf,
const DimensionedField<Type, pointMesh>& iF
)
:
fixedValuePointPatchField<Type>(ptf, iF),
timeSeries_(ptf.timeSeries_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::timeVaryingUniformFixedValuePointPatchField<Type>::updateCoeffs()
{
if (this->updated())
{
return;
}
this->operator==(timeSeries_(this->db().time().timeOutputValue()));
fixedValuePointPatchField<Type>::updateCoeffs();
}
template<class Type>
void Foam::timeVaryingUniformFixedValuePointPatchField<Type>::write
(
Ostream& os
) const
{
fixedValuePointPatchField<Type>::write(os);
timeSeries_.write(os);
}
// ************************************************************************* //

167
src/OpenFOAM/fields/pointPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValuePointPatchField.H
View File

@ -1,167 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::timeVaryingUniformFixedValuePointPatchField
Description
A time-varying form of a uniform fixed value boundary condition.
See also
Foam::timeVaryingUniformFixedValueFvField
SourceFiles
timeVaryingUniformFixedValuePointPatchField.C
\*---------------------------------------------------------------------------*/
#ifndef timeVaryingUniformFixedValuePointPatchField_H
#define timeVaryingUniformFixedValuePointPatchField_H
#include "fixedValuePointPatchField.H"
#include "interpolationTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class timeVaryingUniformFixedValuePointPatchField Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class timeVaryingUniformFixedValuePointPatchField
:
public fixedValuePointPatchField<Type>
{
// Private Data
//- The time series being used, including the bounding treatment
interpolationTable<Type> timeSeries_;
public:
//- Runtime type information
TypeName("timeVaryingUniformFixedValue");
// Constructors
//- Construct from patch and internal field
timeVaryingUniformFixedValuePointPatchField
(
const pointPatch&,
const DimensionedField<Type, pointMesh>&
);
//- Construct from patch, internal field and dictionary
timeVaryingUniformFixedValuePointPatchField
(
const pointPatch&,
const DimensionedField<Type, pointMesh>&,
const dictionary&
);
//- Construct by mapping given patch field onto a new patch
timeVaryingUniformFixedValuePointPatchField
(
const timeVaryingUniformFixedValuePointPatchField<Type>&,
const pointPatch&,
const DimensionedField<Type, pointMesh>&,
const pointPatchFieldMapper&
);
//- Copy constructor
timeVaryingUniformFixedValuePointPatchField
(
const timeVaryingUniformFixedValuePointPatchField<Type>&
);
//- Construct and return a clone
virtual autoPtr<pointPatchField<Type>> clone() const
{
return autoPtr<pointPatchField<Type>>
(
new timeVaryingUniformFixedValuePointPatchField<Type>(*this)
);
}
//- Copy constructor setting internal field reference
timeVaryingUniformFixedValuePointPatchField
(
const timeVaryingUniformFixedValuePointPatchField<Type>&,
const DimensionedField<Type, pointMesh>&
);
//- Construct and return a clone setting internal field reference
virtual autoPtr<pointPatchField<Type>> clone
(
const DimensionedField<Type, pointMesh>& iF
) const
{
return autoPtr<pointPatchField<Type>>
(
new timeVaryingUniformFixedValuePointPatchField<Type>(*this, iF)
);
}
// Member Functions
// Access
//- Return the time series used
const interpolationTable<Type>& timeSeries() const
{
return timeSeries_;
}
// Evaluation functions
//- Update the coefficients associated with the patch field
virtual void updateCoeffs();
//- Write
virtual void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "timeVaryingUniformFixedValuePointPatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

43
src/OpenFOAM/fields/pointPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValuePointPatchFields.C
View File

@ -1,43 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "timeVaryingUniformFixedValuePointPatchFields.H"
#include "pointPatchFields.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makePointPatchFields(timeVaryingUniformFixedValue);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

57
src/OpenFOAM/fields/pointPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValuePointPatchFields.H
View File

@ -1,57 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
InClass
Foam::timeVaryingUniformFixedValuePointPatchFields
Description
SourceFiles
timeVaryingUniformFixedValuePointPatchFields.C
\*---------------------------------------------------------------------------*/
#ifndef timeVaryingUniformFixedValuePointPatchFields_H
#define timeVaryingUniformFixedValuePointPatchFields_H
#include "timeVaryingUniformFixedValuePointPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makePointPatchFieldTypedefs(timeVaryingUniformFixedValue);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

42
src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.C
View File

@ -23,31 +23,7 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
//#include "IFstream.H" #include "FoamTableReader.H"
#include "openFoamTableReader.H"
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class Type>
void Foam::interpolation2DTable<Type>::readTable()
{
fileName fName(fileName_);
fName.expand();
// Read data from file
reader_()(fName, *this);
if (this->empty())
{
FatalErrorInFunction
<< "table read from " << fName << " is empty" << nl
<< exit(FatalError);
}
// Check that the data are in ascending order
checkOrder();
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -56,7 +32,7 @@ Foam::interpolation2DTable<Type>::interpolation2DTable()
: :
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>(), List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>(),
boundsHandling_(interpolation2DTable::WARN), boundsHandling_(interpolation2DTable::WARN),
fileName_("fileNameIsUndefined"), fileName_(fileName::null),
reader_(nullptr) reader_(nullptr)
{} {}
@ -82,9 +58,10 @@ Foam::interpolation2DTable<Type>::interpolation2DTable(const fileName& fName)
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>(), List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>(),
boundsHandling_(interpolation2DTable::WARN), boundsHandling_(interpolation2DTable::WARN),
fileName_(fName), fileName_(fName),
reader_(new openFoamTableReader<Type>(dictionary())) reader_(new TableReaders::Foam<Type>(dictionary()))
{ {
readTable(); reader_()(fileName_, *this);
checkOrder();
} }
@ -94,9 +71,10 @@ Foam::interpolation2DTable<Type>::interpolation2DTable(const dictionary& dict)
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>(), List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>(),
boundsHandling_(wordToBoundsHandling(dict.lookup("outOfBounds"))), boundsHandling_(wordToBoundsHandling(dict.lookup("outOfBounds"))),
fileName_(dict.lookup("file")), fileName_(dict.lookup("file")),
reader_(tableReader<Type>::New(dict)) reader_(new TableReaders::Foam<Type>(dictionary()))
{ {
readTable(); reader_()(fileName_, *this);
checkOrder();
} }
@ -108,8 +86,7 @@ Foam::interpolation2DTable<Type>::interpolation2DTable
: :
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>(interpTable), List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>(interpTable),
boundsHandling_(interpTable.boundsHandling_), boundsHandling_(interpTable.boundsHandling_),
fileName_(interpTable.fileName_), fileName_(interpTable.fileName_)
reader_(interpTable.reader_) // note: steals reader. Used in write().
{} {}
@ -450,6 +427,7 @@ void Foam::interpolation2DTable<Type>::write(Ostream& os) const
{ {
writeEntry(os, "file", fileName_); writeEntry(os, "file", fileName_);
writeEntry(os, "outOfBounds", boundsHandlingToWord(boundsHandling_)); writeEntry(os, "outOfBounds", boundsHandlingToWord(boundsHandling_));
reader_.write(os);
*this >> os; *this >> os;
} }

9
src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.H
View File

@ -38,7 +38,7 @@ SourceFiles
#include "List.H" #include "List.H"
#include "Tuple2.H" #include "Tuple2.H"
#include "tableReader.H" #include "TableReader.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -80,15 +80,12 @@ private:
//- File name //- File name
fileName fileName_; fileName fileName_;
//- The actual reader //- The reader
autoPtr<tableReader<Type>> reader_; autoPtr<TableReader<Type>> reader_;
// Private Member Functions // Private Member Functions
//- Read the table of data from file
void readTable();
//- Return interpolated value in List //- Return interpolated value in List
Type interpolateValue Type interpolateValue
( (

634
src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
View File

@ -1,634 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "interpolationTable.H"
#include "openFoamTableReader.H"
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class Type>
void Foam::interpolationTable<Type>::readTable()
{
// preserve the original (unexpanded) fileName to avoid absolute paths
// appearing subsequently in the write() method
fileName fName(fileName_);
fName.expand();
// Read data from file
reader_()(fName, *this);
if (this->empty())
{
FatalErrorInFunction
<< "table read from " << fName << " is empty" << nl
<< exit(FatalError);
}
// Check that the data are okay
check();
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::interpolationTable<Type>::interpolationTable()
:
List<Tuple2<scalar, Type>>(),
boundsHandling_(interpolationTable::WARN),
fileName_("fileNameIsUndefined"),
reader_(nullptr)
{}
template<class Type>
Foam::interpolationTable<Type>::interpolationTable
(
const List<Tuple2<scalar, Type>>& values,
const boundsHandling bounds,
const fileName& fName
)
:
List<Tuple2<scalar, Type>>(values),
boundsHandling_(bounds),
fileName_(fName),
reader_(nullptr)
{}
template<class Type>
Foam::interpolationTable<Type>::interpolationTable(const fileName& fName)
:
List<Tuple2<scalar, Type>>(),
boundsHandling_(interpolationTable::WARN),
fileName_(fName),
reader_(new openFoamTableReader<Type>(dictionary()))
{
readTable();
}
template<class Type>
Foam::interpolationTable<Type>::interpolationTable(const dictionary& dict)
:
List<Tuple2<scalar, Type>>(),
boundsHandling_(wordToBoundsHandling(dict.lookup("outOfBounds"))),
fileName_(dict.lookup("file")),
reader_(tableReader<Type>::New(dict))
{
readTable();
}
template<class Type>
Foam::interpolationTable<Type>::interpolationTable
(
const interpolationTable& interpTable
)
:
List<Tuple2<scalar, Type>>(interpTable),
boundsHandling_(interpTable.boundsHandling_),
fileName_(interpTable.fileName_),
reader_(interpTable.reader_) // note: steals reader. Used in write().
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
Foam::word Foam::interpolationTable<Type>::boundsHandlingToWord
(
const boundsHandling& bound
) const
{
word enumName("warn");
switch (bound)
{
case interpolationTable::ERROR:
{
enumName = "error";
break;
}
case interpolationTable::WARN:
{
enumName = "warn";
break;
}
case interpolationTable::CLAMP:
{
enumName = "clamp";
break;
}
case interpolationTable::REPEAT:
{
enumName = "repeat";
break;
}
}
return enumName;
}
template<class Type>
typename Foam::interpolationTable<Type>::boundsHandling
Foam::interpolationTable<Type>::wordToBoundsHandling
(
const word& bound
) const
{
if (bound == "error")
{
return interpolationTable::ERROR;
}
else if (bound == "warn")
{
return interpolationTable::WARN;
}
else if (bound == "clamp")
{
return interpolationTable::CLAMP;
}
else if (bound == "repeat")
{
return interpolationTable::REPEAT;
}
else
{
WarningInFunction
<< "bad outOfBounds specifier " << bound << " using 'warn'" << endl;
return interpolationTable::WARN;
}
}
template<class Type>
typename Foam::interpolationTable<Type>::boundsHandling
Foam::interpolationTable<Type>::outOfBounds
(
const boundsHandling& bound
)
{
boundsHandling prev = boundsHandling_;
boundsHandling_ = bound;
return prev;
}
template<class Type>
void Foam::interpolationTable<Type>::check() const
{
label n = this->size();
scalar prevValue = List<Tuple2<scalar, Type>>::operator[](0).first();
for (label i=1; i<n; ++i)
{
const scalar currValue =
List<Tuple2<scalar, Type>>::operator[](i).first();
// avoid duplicate values (divide-by-zero error)
if (currValue <= prevValue)
{
FatalErrorInFunction
<< "out-of-order value: "
<< currValue << " at index " << i << nl
<< exit(FatalError);
}
prevValue = currValue;
}
}
template<class Type>
void Foam::interpolationTable<Type>::write(Ostream& os) const
{
writeEntry(os, "file", fileName_);
writeEntry(os, "outOfBounds", boundsHandlingToWord(boundsHandling_));
if (reader_.valid())
{
reader_->write(os);
}
}
template<class Type>
Type Foam::interpolationTable<Type>::rateOfChange(const scalar value) const
{
label n = this->size();
if (n <= 1)
{
// There are not enough entries to provide a rate of change
return 0;
}
scalar minLimit = List<Tuple2<scalar, Type>>::operator[](0).first();
scalar maxLimit = List<Tuple2<scalar, Type>>::operator[](n-1).first();
scalar lookupValue = value;
if (lookupValue < minLimit)
{
switch (boundsHandling_)
{
case interpolationTable::ERROR:
{
FatalErrorInFunction
<< "value (" << lookupValue << ") underflow" << nl
<< exit(FatalError);
break;
}
case interpolationTable::WARN:
{
WarningInFunction
<< "value (" << lookupValue << ") underflow" << nl
<< " Zero rate of change."
<< endl;
// fall-through to 'CLAMP'
[[fallthrough]];
}
case interpolationTable::CLAMP:
{
return 0;
break;
}
case interpolationTable::REPEAT:
{
// adjust lookupValue to >= minLimit
scalar span = maxLimit-minLimit;
lookupValue = fmod(lookupValue-minLimit, span) + minLimit;
break;
}
}
}
else if (lookupValue >= maxLimit)
{
switch (boundsHandling_)
{
case interpolationTable::ERROR:
{
FatalErrorInFunction
<< "value (" << lookupValue << ") overflow" << nl
<< exit(FatalError);
break;
}
case interpolationTable::WARN:
{
WarningInFunction
<< "value (" << lookupValue << ") overflow" << nl
<< " Zero rate of change."
<< endl;
// fall-through to 'CLAMP'
[[fallthrough]];
}
case interpolationTable::CLAMP:
{
return 0;
break;
}
case interpolationTable::REPEAT:
{
// adjust lookupValue <= maxLimit
scalar span = maxLimit-minLimit;
lookupValue = fmod(lookupValue-minLimit, span) + minLimit;
break;
}
}
}
label lo = 0;
label hi = 0;
// look for the correct range
for (label i = 0; i < n; ++i)
{
if (lookupValue >= List<Tuple2<scalar, Type>>::operator[](i).first())
{
lo = hi = i;
}
else
{
hi = i;
break;
}
}
if (lo == hi)
{
// we are at the end of the table - or there is only a single entry
return 0;
}
else if (hi == 0)
{
// this treatment should should only occur under these conditions:
// -> the 'REPEAT' treatment
// -> (0 <= value <= minLimit)
// -> minLimit > 0
// Use the value at maxLimit as the value for value=0
lo = n - 1;
return
(
(
List<Tuple2<scalar, Type>>::operator[](hi).second()
- List<Tuple2<scalar, Type>>::operator[](lo).second()
)
/(
List<Tuple2<scalar, Type>>::operator[](hi).first()
+ minLimit
- List<Tuple2<scalar, Type>>::operator[](lo).first()
)
);
}
else
{
// normal rate of change
return
(
(
List<Tuple2<scalar, Type>>::operator[](hi).second()
- List<Tuple2<scalar, Type>>::operator[](lo).second()
)
/(
List<Tuple2<scalar, Type>>::operator[](hi).first()
- List<Tuple2<scalar, Type>>::operator[](lo).first()
)
);
}
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class Type>
void Foam::interpolationTable<Type>::operator=
(
const interpolationTable& interpTable
)
{
List<Tuple2<scalar, Type>>::operator=(interpTable);
boundsHandling_ = interpTable.boundsHandling_;
fileName_ = interpTable.fileName_;
reader_ = interpTable.reader_; // note: steals reader. Used in write().
}
template<class Type>
const Foam::Tuple2<Foam::scalar, Type>&
Foam::interpolationTable<Type>::operator[](const label i) const
{
label ii = i;
label n = this->size();
if (n <= 1)
{
ii = 0;
}
else if (ii < 0)
{
switch (boundsHandling_)
{
case interpolationTable::ERROR:
{
FatalErrorInFunction
<< "index (" << ii << ") underflow" << nl
<< exit(FatalError);
break;
}
case interpolationTable::WARN:
{
WarningInFunction
<< "index (" << ii << ") underflow" << nl
<< " Continuing with the first entry"
<< endl;
// fall-through to 'CLAMP'
[[fallthrough]];
}
case interpolationTable::CLAMP:
{
ii = 0;
break;
}
case interpolationTable::REPEAT:
{
while (ii < 0)
{
ii += n;
}
break;
}
}
}
else if (ii >= n)
{
switch (boundsHandling_)
{
case interpolationTable::ERROR:
{
FatalErrorInFunction
<< "index (" << ii << ") overflow" << nl
<< exit(FatalError);
break;
}
case interpolationTable::WARN:
{
WarningInFunction
<< "index (" << ii << ") overflow" << nl
<< " Continuing with the last entry"
<< endl;
// fall-through to 'CLAMP'
[[fallthrough]];
}
case interpolationTable::CLAMP:
{
ii = n - 1;
break;
}
case interpolationTable::REPEAT:
{
while (ii >= n)
{
ii -= n;
}
break;
}
}
}
return List<Tuple2<scalar, Type>>::operator[](ii);
}
template<class Type>
Type Foam::interpolationTable<Type>::operator()(const scalar value) const
{
label n = this->size();
if (n <= 1)
{
return List<Tuple2<scalar, Type>>::operator[](0).second();
}
scalar minLimit = List<Tuple2<scalar, Type>>::operator[](0).first();
scalar maxLimit = List<Tuple2<scalar, Type>>::operator[](n-1).first();
scalar lookupValue = value;
if (lookupValue < minLimit)
{
switch (boundsHandling_)
{
case interpolationTable::ERROR:
{
FatalErrorInFunction
<< "value (" << lookupValue << ") underflow" << nl
<< exit(FatalError);
break;
}
case interpolationTable::WARN:
{
WarningInFunction
<< "value (" << lookupValue << ") underflow" << nl
<< " Continuing with the first entry"
<< endl;
// fall-through to 'CLAMP'
[[fallthrough]];
}
case interpolationTable::CLAMP:
{
return List<Tuple2<scalar, Type>>::operator[](0).second();
break;
}
case interpolationTable::REPEAT:
{
// adjust lookupValue to >= minLimit
scalar span = maxLimit-minLimit;
lookupValue = fmod(lookupValue-minLimit, span) + minLimit;
break;
}
}
}
else if (lookupValue >= maxLimit)
{
switch (boundsHandling_)
{
case interpolationTable::ERROR:
{
FatalErrorInFunction
<< "value (" << lookupValue << ") overflow" << nl
<< exit(FatalError);
break;
}
case interpolationTable::WARN:
{
WarningInFunction
<< "value (" << lookupValue << ") overflow" << nl
<< " Continuing with the last entry"
<< endl;
// fall-through to 'CLAMP'
[[fallthrough]];
}
case interpolationTable::CLAMP:
{
return List<Tuple2<scalar, Type>>::operator[](n-1).second();
break;
}
case interpolationTable::REPEAT:
{
// adjust lookupValue <= maxLimit
scalar span = maxLimit-minLimit;
lookupValue = fmod(lookupValue-minLimit, span) + minLimit;
break;
}
}
}
label lo = 0;
label hi = 0;
// look for the correct range
for (label i = 0; i < n; ++i)
{
if (lookupValue >= List<Tuple2<scalar, Type>>::operator[](i).first())
{
lo = hi = i;
}
else
{
hi = i;
break;
}
}
if (lo == hi)
{
// we are at the end of the table - or there is only a single entry
return List<Tuple2<scalar, Type>>::operator[](hi).second();
}
else if (hi == 0)
{
// this treatment should should only occur under these conditions:
// -> the 'REPEAT' treatment
// -> (0 <= value <= minLimit)
// -> minLimit > 0
// Use the value at maxLimit as the value for value=0
lo = n - 1;
return
(
List<Tuple2<scalar, Type>>::operator[](lo).second()
+ (
List<Tuple2<scalar, Type>>::operator[](hi).second()
- List<Tuple2<scalar, Type>>::operator[](lo).second()
)
*(lookupValue / minLimit)
);
}
else
{
// normal interpolation
return
(
List<Tuple2<scalar, Type>>::operator[](lo).second()
+ (
List<Tuple2<scalar, Type>>::operator[](hi).second()
- List<Tuple2<scalar, Type>>::operator[](lo).second()
)
*(
lookupValue
- List<Tuple2<scalar, Type>>::operator[](lo).first()
)
/(
List<Tuple2<scalar, Type>>::operator[](hi).first()
- List<Tuple2<scalar, Type>>::operator[](lo).first()
)
);
}
}
// ************************************************************************* //

194
src/OpenFOAM/interpolations/interpolationTable/interpolationTable.H
View File

@ -1,194 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::interpolationTable
Description
An interpolation/look-up table of scalar vs \<Type\> values.
The reference scalar values must be monotonically increasing.
The handling of out-of-bounds values depends on the current setting
of \c outOfBounds.
If \c repeat is chosen for the out-of-bounds handling, the final time
value is treated as being equivalent to time=0 for the following periods.
The construct from dictionary reads a filename from a dictionary and
has an optional readerType. Default is to read OpenFOAM format. The only
other format is csv (comma separated values):
Read csv format:
\verbatim
readerType csv;
file "$FOAM_CASE/constant/p0vsTime.csv";
hasHeaderLine true; // skip first line
timeColumn 0; // time is in column 0
valueColumns (1); // value starts in column 1
\endverbatim
Note
- Accessing an empty list results in an error.
- Accessing a list with a single element always returns the same value.
SourceFiles
interpolationTable.C
\*---------------------------------------------------------------------------*/
#ifndef interpolationTable_H
#define interpolationTable_H
#include "List.H"
#include "Tuple2.H"
#include "tableReader.H"
#include "autoPtr.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class interpolationTable Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class interpolationTable
:
public List<Tuple2<scalar, Type>>
{
public:
// Public data types
//- Enumeration for handling out-of-bound values
enum boundsHandling
{
ERROR, //!< Exit with a FatalError
WARN, //!< Issue warning and clamp value (default)
CLAMP, //!< Clamp value to the start/end value
REPEAT //!< Treat as a repeating list
};
private:
// Private Data
//- Enumeration for handling out-of-bound values
boundsHandling boundsHandling_;
//- File name
fileName fileName_;
//- The actual reader
autoPtr<tableReader<Type>> reader_;
// Private Member Functions
//- Read the table of data from file
void readTable();
public:
// Constructors
//- Construct null
interpolationTable();
//- Construct from components
interpolationTable
(
const List<Tuple2<scalar, Type>>& values,
const boundsHandling bounds,
const fileName& fName
);
//- Construct given the name of the file containing the table of data
interpolationTable(const fileName& fName);
//- Construct by reading the fileName and boundsHandling from dictionary
// and read the table from that file.
// This is a specialised constructor used by patchFields
interpolationTable(const dictionary& dict);
//- Construct copy
interpolationTable(const interpolationTable& interpTable);
// Member Functions
//- Return the out-of-bounds handling as a word
word boundsHandlingToWord(const boundsHandling& bound) const;
//- Return the out-of-bounds handling as an enumeration
boundsHandling wordToBoundsHandling(const word& bound) const;
//- Set the out-of-bounds handling from enum, return previous setting
boundsHandling outOfBounds(const boundsHandling& bound);
//- Check that list is monotonically increasing
// Exit with a FatalError if there is a problem
void check() const;
//- Write
void write(Ostream& os) const;
//- Return the rate of change at the interpolation location
// for the give value
Type rateOfChange(const scalar) const;
// Member Operators
//- Disallow default bitwise assignment
void operator=(const interpolationTable&);
//- Return an element of constant Tuple2<scalar, Type>
const Tuple2<scalar, Type>& operator[](const label) const;
//- Return an interpolated value
Type operator()(const scalar) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "interpolationTable.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

196
src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.C
View File

@ -1,196 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "csvTableReader.H"
#include "fileOperation.H"
#include "DynamicList.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::csvTableReader<Type>::csvTableReader(const dictionary& dict)
:
tableReader<Type>(dict),
headerLine_(readBool(dict.lookup("hasHeaderLine"))),
timeColumn_(readLabel(dict.lookup("timeColumn"))),
componentColumns_(dict.lookup("valueColumns")),
separator_(dict.lookupOrDefault<string>("separator", string(","))[0])
{
if (componentColumns_.size() != pTraits<Type>::nComponents)
{
FatalErrorInFunction
<< componentColumns_ << " does not have the expected length "
<< pTraits<Type>::nComponents << endl
<< exit(FatalError);
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::csvTableReader<Type>::~csvTableReader()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
namespace Foam
{
// doesn't recognize specialization otherwise
template<>
scalar csvTableReader<scalar>::readValue(const List<string>& split)
{
if (componentColumns_[0] >= split.size())
{
FatalErrorInFunction
<< "No column " << componentColumns_[0] << " in "
<< split << endl
<< exit(FatalError);
}
return readScalar(IStringStream(split[componentColumns_[0]])());
}
template<class Type>
Type csvTableReader<Type>::readValue(const List<string>& split)
{
Type result;
for(label i = 0;i < pTraits<Type>::nComponents; i++)
{
if (componentColumns_[i] >= split.size())
{
FatalErrorInFunction
<< "No column " << componentColumns_[i] << " in "
<< split << endl
<< exit(FatalError);
}
result[i] = readScalar
(
IStringStream(split[componentColumns_[i]])()
);
}
return result;
}
}
template<class Type>
void Foam::csvTableReader<Type>::operator()
(
const fileName& fName,
List<Tuple2<scalar, Type>>& data
)
{
// IFstream in(fName);
autoPtr<ISstream> inPtr(fileHandler().NewIFstream(fName));
ISstream& in = inPtr();
DynamicList<Tuple2<scalar, Type>> values;
// Skip header
if (headerLine_)
{
string line;
in.getLine(line);
}
while (in.good())
{
string line;
in.getLine(line);
DynamicList<string> split;
std::size_t pos = 0;
while (pos != std::string::npos)
{
std::size_t nPos = line.find(separator_, pos);
if (nPos == std::string::npos)
{
split.append(line.substr(pos));
pos=nPos;
}
else
{
split.append(line.substr(pos, nPos-pos));
pos=nPos+1;
}
}
if (split.size() <= 1)
{
break;
}
scalar time = readScalar(IStringStream(split[timeColumn_])());
Type value = readValue(split);
values.append(Tuple2<scalar,Type>(time, value));
}
data.transfer(values);
}
template<class Type>
void Foam::csvTableReader<Type>::operator()
(
const fileName& fName,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>& data
)
{
NotImplemented;
}
template<class Type>
void Foam::csvTableReader<Type>::write(Ostream& os) const
{
tableReader<Type>::write(os);
writeEntry(os, "hasHeaderLine", headerLine_);
writeEntry(os, "timeColumn", timeColumn_);
// Force writing labelList in ascii
writeKeyword(os, "valueColumns");
if (os.format() == IOstream::BINARY)
{
os.format(IOstream::ASCII);
os << componentColumns_;
os.format(IOstream::BINARY);
}
os << token::END_STATEMENT << nl;
writeEntry(os, "separator", string(separator_));
}
// ************************************************************************* //

37
src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReaders.C
View File

@ -1,37 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "openFoamTableReader.H"
#include "tableReaders.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeTableReaders(openFoamTableReader);
}
// ************************************************************************* //

50
src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReaders.C
View File

@ -1,50 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "tableReaders.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
#define defineTableReaderType(dataType) \
defineNamedTemplateTypeNameAndDebug(tableReader<dataType >, 0); \
defineTemplatedRunTimeSelectionTable(tableReader, dictionary, dataType);
defineTableReaderType(scalar);
defineTableReaderType(vector);
defineTableReaderType(sphericalTensor);
defineTableReaderType(symmTensor);
defineTableReaderType(tensor);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

75
src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReaders.H
View File

@ -1,75 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
SourceFiles
tableReaders.C
\*---------------------------------------------------------------------------*/
#ifndef tableReaders_H
#define tableReaders_H
#include "tableReader.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Only used internally
#define makeTypeTableReadersTypeName(typeTableReader, dataType) \
\
defineNamedTemplateTypeNameAndDebug(typeTableReader<dataType>, 0)
// Sometimes used externally
#define makeTableReadersTypeName(typeTableReader) \
\
makeTypeTableReadersTypeName(typeTableReader, scalar); \
makeTypeTableReadersTypeName(typeTableReader, vector); \
makeTypeTableReadersTypeName(typeTableReader, sphericalTensor); \
makeTypeTableReadersTypeName(typeTableReader, symmTensor); \
makeTypeTableReadersTypeName(typeTableReader, tensor)
// Define type info for single dataType template instantiation (eg, vector)
#define makeTableReaderType(typeTableReader, dataType) \
\
defineNamedTemplateTypeNameAndDebug(typeTableReader<dataType>, 0); \
addTemplatedToRunTimeSelectionTable \
( \
tableReader, typeTableReader, dataType, dictionary \
)
// Define type info for scalar, vector etc. instantiations
#define makeTableReaders(typeTableReader) \
\
makeTableReaderType(typeTableReader, scalar); \
makeTableReaderType(typeTableReader, vector); \
makeTableReaderType(typeTableReader, sphericalTensor); \
makeTableReaderType(typeTableReader, symmTensor); \
makeTableReaderType(typeTableReader, tensor)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

169
src/OpenFOAM/primitives/functions/Function1/CSV/CSV.H
View File

@ -1,169 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::Function1Types::CSV
Description
Templated CSV function.
Reference column is always a scalar, e.g. time.
Usage:
\verbatim
<entryName> csvFile;
<entryName>Coeffs
{
nHeaderLine 4; // number of header lines
refColumn 0; // reference column index
componentColumns (1 2 3); // component column indices
separator ","; // optional (defaults to ",")
mergeSeparators no; // merge multiple separators
file "fileXYZ"; // name of csv data file
outOfBounds clamp; // optional out-of-bounds handling
interpolationScheme linear; // optional interpolation scheme
}
\endverbatim
SourceFiles
CSV.C
\*---------------------------------------------------------------------------*/
#ifndef CSV_H
#define CSV_H
#include "Function1.H"
#include "TableBase.H"
#include "Tuple2.H"
#include "labelList.H"
#include "ISstream.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace Function1Types
{
/*---------------------------------------------------------------------------*\
Class CSV Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class CSV
:
public TableBase<Type>
{
// Private Data
//- Number header lines
label nHeaderLine_;
//- Column of the time
label refColumn_;
//- Labels of the components
labelList componentColumns_;
//- Separator character
char separator_;
//- Merge separators flag, e.g. ',,,' becomes ','
bool mergeSeparators_;
//- File name for csv table
fileName fName_;
// Private Member Functions
//- Read csv data table
void read();
//- Read the next value from the split string
Type readValue(const List<string>&);
public:
//- Runtime type information
TypeName("csvFile");
// Constructors
//- Construct from entry name and dictionary
CSV
(
const word& entryName,
const dictionary& dict
);
//- Copy constructor
CSV(const CSV<Type>& tbl);
//- Destructor
virtual ~CSV();
// Member Functions
//- Return const access to the file name
virtual const fileName& fName() const;
//- Write in dictionary format
virtual void writeData(Ostream& os) const;
// Member Operators
//- Disallow default bitwise assignment
void operator=(const CSV<Type>&) = delete;
};
template<>
label CSV<label>::readValue(const List<string>& split);
template<>
Foam::scalar CSV<scalar>::readValue(const List<string>& split);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "CSV.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

45
src/OpenFOAM/primitives/functions/Function1/Constant/Constant.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,25 +28,25 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Constant<Type>::Constant Foam::Function1s::Constant<Type>::Constant
( (
const word& entryName, const word& entryName,
const Type& val const Type& val
) )
: :
Function1<Type>(entryName), FieldFunction1<Type, Constant<Type>>(entryName),
value_(val) value_(val)
{} {}
template<class Type> template<class Type>
Foam::Function1Types::Constant<Type>::Constant Foam::Function1s::Constant<Type>::Constant
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
Function1<Type>(entryName), FieldFunction1<Type, Constant<Type>>(entryName),
value_(Zero) value_(Zero)
{ {
Istream& is(dict.lookup(entryName)); Istream& is(dict.lookup(entryName));
@ -56,21 +56,21 @@ Foam::Function1Types::Constant<Type>::Constant
template<class Type> template<class Type>
Foam::Function1Types::Constant<Type>::Constant Foam::Function1s::Constant<Type>::Constant
( (
const word& entryName, const word& entryName,
Istream& is Istream& is
) )
: :
Function1<Type>(entryName), FieldFunction1<Type, Constant<Type>>(entryName),
value_(pTraits<Type>(is)) value_(pTraits<Type>(is))
{} {}
template<class Type> template<class Type>
Foam::Function1Types::Constant<Type>::Constant(const Constant<Type>& cnst) Foam::Function1s::Constant<Type>::Constant(const Constant<Type>& cnst)
: :
Function1<Type>(cnst), FieldFunction1<Type, Constant<Type>>(cnst),
value_(cnst.value_) value_(cnst.value_)
{} {}
@ -78,35 +78,14 @@ Foam::Function1Types::Constant<Type>::Constant(const Constant<Type>& cnst)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Constant<Type>::~Constant() Foam::Function1s::Constant<Type>::~Constant()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::Function1Types::Constant<Type>::value void Foam::Function1s::Constant<Type>::writeData(Ostream& os) const
(
const scalarField& x
) const
{
return tmp<Field<Type>>(new Field<Type>(x.size(), value_));
}
template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::Function1Types::Constant<Type>::integrate
(
const scalarField& x1,
const scalarField& x2
) const
{
return (x2 - x1)*value_;
}
template<class Type>
void Foam::Function1Types::Constant<Type>::writeData(Ostream& os) const
{ {
Function1<Type>::writeData(os); Function1<Type>::writeData(os);
@ -114,4 +93,4 @@ void Foam::Function1Types::Constant<Type>::writeData(Ostream& os) const
} }
// ************************************************************************* // // ************************************************************************* i/

26
src/OpenFOAM/primitives/functions/Function1/Constant/Constant.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::Constant Foam::Function1s::Constant
Description Description
Templated function that returns a constant value. Templated function that returns a constant value.
@ -46,7 +46,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -56,7 +56,7 @@ namespace Function1Types
template<class Type> template<class Type>
class Constant class Constant
: :
public Function1<Type> public FieldFunction1<Type, Constant<Type>>
{ {
// Private Data // Private Data
@ -105,16 +105,6 @@ public:
//- Integrate between two values //- Integrate between two values
virtual inline Type integrate(const scalar x1, const scalar x2) const; virtual inline Type integrate(const scalar x1, const scalar x2) const;
//- Return value as a function of (scalar) independent variable
virtual tmp<Field<Type>> value(const scalarField& x) const;
//- Integrate between two (scalar) values
virtual tmp<Field<Type>> integrate
(
const scalarField& x1,
const scalarField& x2
) const;
//- Write in dictionary format //- Write in dictionary format
virtual void writeData(Ostream& os) const; virtual void writeData(Ostream& os) const;
@ -126,17 +116,9 @@ public:
}; };
template<>
tmp<Field<label>> Function1Types::Constant<label>::integrate
(
const scalarField& x1,
const scalarField& x2
) const;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

6
src/OpenFOAM/primitives/functions/Function1/Constant/ConstantI.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,14 +28,14 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
inline Type Foam::Function1Types::Constant<Type>::value(const scalar x) const inline Type Foam::Function1s::Constant<Type>::value(const scalar x) const
{ {
return value_; return value_;
} }
template<class Type> template<class Type>
inline Type Foam::Function1Types::Constant<Type>::integrate inline Type Foam::Function1s::Constant<Type>::integrate
( (
const scalar x1, const scalar x1,
const scalar x2 const scalar x2

101
src/OpenFOAM/primitives/functions/Function1/Function1/Function1.C
View File

@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "Function1.H" #include "Function1.H"
#include "Time.H"
// * * * * * * * * * * * * * * * * Constructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructor * * * * * * * * * * * * * * * //
@ -43,6 +42,37 @@ Foam::Function1<Type>::Function1(const Function1<Type>& de)
{} {}
template<class Type, class Function1Type>
Foam::FieldFunction1<Type, Function1Type>::FieldFunction1
(
const word& entryName
)
:
Function1<Type>(entryName)
{}
template<class Type, class Function1Type>
Foam::FieldFunction1<Type, Function1Type>::FieldFunction1
(
const FieldFunction1<Type, Function1Type>& ff1
)
:
Function1<Type>(ff1)
{}
template<class Type, class Function1Type>
Foam::tmp<Foam::Function1<Type>>
Foam::FieldFunction1<Type, Function1Type>::clone() const
{
return tmp<Function1<Type>>
(
new Function1Type(refCast<const Function1Type>(*this))
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
@ -50,6 +80,11 @@ Foam::Function1<Type>::~Function1()
{} {}
template<class Type, class Function1Type>
Foam::FieldFunction1<Type, Function1Type>::~FieldFunction1()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
@ -60,30 +95,14 @@ const Foam::word& Foam::Function1<Type>::name() const
template<class Type> template<class Type>
Type Foam::Function1<Type>::value(const scalar x) const void Foam::Function1<Type>::writeData(Ostream& os) const
{ {
FatalErrorInFunction writeKeyword(os, name_) << type();
<< "Evaluation is not defined for " << type() << " functions"
<< exit(FatalError);
return Zero;
} }
template<class Type> template<class Type, class Function1Type>
Type Foam::Function1<Type>::integrate(const scalar x1, const scalar x2) const Foam::tmp<Foam::Field<Type>> Foam::FieldFunction1<Type, Function1Type>::value
{
FatalErrorInFunction
<< "Integration is not defined for " << type() << " functions"
<< exit(FatalError);
return Zero;
}
template<class Function1Type>
Foam::tmp<Foam::Field<typename Function1Type::returnType>>
Foam::FieldFunction1<Function1Type>::value
( (
const scalarField& x const scalarField& x
) const ) const
@ -93,37 +112,16 @@ Foam::FieldFunction1<Function1Type>::value
forAll(x, i) forAll(x, i)
{ {
fld[i] = Function1Type::value(x[i]); fld[i] = refCast<const Function1Type>(*this).value(x[i]);
} }
return tfld; return tfld;
} }
template<class Function1Type> template<class Type, class Function1Type>
Foam::FieldFunction1<Function1Type>::FieldFunction1 Foam::tmp<Foam::Field<Type>>
( Foam::FieldFunction1<Type, Function1Type>::integrate
const word& entryName,
const dictionary& dict
)
:
Function1Type(entryName, dict)
{}
template<class Function1Type>
Foam::tmp<Foam::Function1<typename Function1Type::returnType>>
Foam::FieldFunction1<Function1Type>::clone() const
{
return tmp<Function1<Type>>
(
new FieldFunction1<Function1Type>(*this)
);
}
template<class Function1Type>
Foam::tmp<Foam::Field<typename Function1Type::returnType>>
Foam::FieldFunction1<Function1Type>::integrate
( (
const scalarField& x1, const scalarField& x1,
const scalarField& x2 const scalarField& x2
@ -134,20 +132,13 @@ Foam::FieldFunction1<Function1Type>::integrate
forAll(x1, i) forAll(x1, i)
{ {
fld[i] = Function1Type::integrate(x1[i], x2[i]); fld[i] = refCast<const Function1Type>(*this).integrate(x1[i], x2[i]);
} }
return tfld; return tfld;
} }
template<class Type>
void Foam::Function1<Type>::writeData(Ostream& os) const
{
writeKeyword(os, name_) << type();
}
// * * * * * * * * * * * * * * * IOstream Functions * * * * * * * * * * * * // // * * * * * * * * * * * * * * * IOstream Functions * * * * * * * * * * * * //
template<class Type> template<class Type>

46
src/OpenFOAM/primitives/functions/Function1/Function1/Function1.H
View File

@ -40,6 +40,8 @@ SourceFiles
#define Function1_H #define Function1_H
#include "dictionary.H" #include "dictionary.H"
#include "tmp.H"
#include "typeInfo.H"
#include "Field.H" #include "Field.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -47,9 +49,6 @@ SourceFiles
namespace Foam namespace Foam
{ {
// Forward declarations
class Time;
// Forward declaration of friend functions and operators // Forward declaration of friend functions and operators
template<class Type> class Function1; template<class Type> class Function1;
template<class Type> Ostream& operator<<(Ostream&, const Function1<Type>&); template<class Type> Ostream& operator<<(Ostream&, const Function1<Type>&);
@ -128,13 +127,13 @@ public:
// Evaluation // Evaluation
//- Return value as a function of (scalar) independent variable //- Return value as a function of (scalar) independent variable
virtual Type value(const scalar x) const; virtual Type value(const scalar x) const = 0;
//- Return value as a function of (scalar) independent variable //- Return value as a function of (scalar) independent variable
virtual tmp<Field<Type>> value(const scalarField& x) const = 0; virtual tmp<Field<Type>> value(const scalarField& x) const = 0;
//- Integrate between two (scalar) values //- Integrate between two (scalar) values
virtual Type integrate(const scalar x1, const scalar x2) const; virtual Type integrate(const scalar x1, const scalar x2) const = 0;
//- Integrate between two (scalar) values //- Integrate between two (scalar) values
virtual tmp<Field<Type>> integrate virtual tmp<Field<Type>> integrate
@ -172,41 +171,43 @@ void writeEntry(Ostream& os, const Function1<Type>& f1);
Class FieldFunction1 Declaration Class FieldFunction1 Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class Function1Type> template<class Type, class Function1Type>
class FieldFunction1 class FieldFunction1
: :
public Function1Type public Function1<Type>
{ {
public: public:
typedef typename Function1Type::returnType Type;
// Constructors // Constructors
//- Construct from entry name and dictionary //- Construct from entry name
FieldFunction1(const word& entryName, const dictionary& dict); FieldFunction1(const word& entryName);
//- Copy constructor
FieldFunction1(const FieldFunction1<Type, Function1Type>& ff1);
//- Construct and return a clone //- Construct and return a clone
virtual tmp<Function1<Type>> clone() const; virtual tmp<Function1<Type>> clone() const;
//- Destructor //- Destructor
virtual ~FieldFunction1() virtual ~FieldFunction1();
{}
// Member Functions // Member Functions
// Evaluation // Evaluation
using Function1Type::value; //- Return value as a function of (scalar) independent variable
using Function1Type::integrate; virtual Type value(const scalar x) const = 0;
//- Return value as a function of (scalar) independent variable //- Return value as a function of (scalar) independent variable
virtual tmp<Field<Type>> value(const scalarField& x) const; virtual tmp<Field<Type>> value(const scalarField& x) const;
//- Integrate between two (scalar) values
virtual Type integrate(const scalar x1, const scalar x2) const = 0;
//- Integrate between two (scalar) values //- Integrate between two (scalar) values
virtual tmp<Field<Type>> integrate virtual tmp<Field<Type>> integrate
( (
@ -226,19 +227,14 @@ public:
\ \
defineNamedTemplateTypeNameAndDebug(Function1<Type>, 0); \ defineNamedTemplateTypeNameAndDebug(Function1<Type>, 0); \
\ \
defineTemplateRunTimeSelectionTable \ defineTemplateRunTimeSelectionTable(Function1<Type>, dictionary);
( \
Function1<Type>, \
dictionary \
);
#define makeFunction1Type(SS, Type) \ #define makeFunction1Type(SS, Type) \
\ \
defineNamedTemplateTypeNameAndDebug(Function1Types::SS<Type>, 0); \ defineNamedTemplateTypeNameAndDebug(Function1s::SS<Type>, 0); \
\ \
Function1<Type>::adddictionaryConstructorToTable \ Function1<Type>::adddictionaryConstructorToTable<Function1s::SS<Type>> \
<FieldFunction1<Function1Types::SS<Type>>> \
add##SS##Type##ConstructorToTable_; add##SS##Type##ConstructorToTable_;
@ -246,7 +242,7 @@ public:
\ \
defineTypeNameAndDebug(SS, 0); \ defineTypeNameAndDebug(SS, 0); \
\ \
Function1<scalar>::adddictionaryConstructorToTable<FieldFunction1<SS>> \ Function1<scalar>::adddictionaryConstructorToTable<SS> \
add##SS##ConstructorToTable_; add##SS##ConstructorToTable_;

4
src/OpenFOAM/primitives/functions/Function1/Function1/Function1New.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -68,7 +68,7 @@ Foam::autoPtr<Foam::Function1<Type>> Foam::Function1<Type>::New
is.putBack(firstToken); is.putBack(firstToken);
return autoPtr<Function1<Type>> return autoPtr<Function1<Type>>
( (
new Function1Types::Constant<Type>(entryName, is) new Function1s::Constant<Type>(entryName, is)
); );
} }
else else

35
src/OpenFOAM/primitives/functions/Function1/One/OneConstant.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,55 +28,34 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::OneConstant<Type>::OneConstant(const word& entryName) Foam::Function1s::OneConstant<Type>::OneConstant(const word& entryName)
: :
Function1<Type>(entryName) FieldFunction1<Type, OneConstant<Type>>(entryName)
{} {}
template<class Type> template<class Type>
Foam::Function1Types::OneConstant<Type>::OneConstant Foam::Function1s::OneConstant<Type>::OneConstant
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
Function1<Type>(entryName) FieldFunction1<Type, OneConstant<Type>>(entryName)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::OneConstant<Type>::~OneConstant() Foam::Function1s::OneConstant<Type>::~OneConstant()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::Function1Types::OneConstant<Type>::value void Foam::Function1s::OneConstant<Type>::writeData(Ostream& os) const
(
const scalarField& x
) const
{
return tmp<Field<Type>>(new Field<Type>(x.size(), pTraits<Type>::one));
}
template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::Function1Types::OneConstant<Type>::integrate
(
const scalarField& x1,
const scalarField& x2
) const
{
return (x2 - x1)*pTraits<Type>::one;
}
template<class Type>
void Foam::Function1Types::OneConstant<Type>::writeData(Ostream& os) const
{ {
Function1<Type>::writeData(os); Function1<Type>::writeData(os);

24
src/OpenFOAM/primitives/functions/Function1/One/OneConstant.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::OneConstant Foam::Function1s::OneConstant
Description Description
Templated function that returns the corresponding 1 (one). Templated function that returns the corresponding 1 (one).
@ -46,7 +46,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -56,7 +56,7 @@ namespace Function1Types
template<class Type> template<class Type>
class OneConstant class OneConstant
: :
public Function1<Type> public FieldFunction1<Type, OneConstant<Type>>
{ {
public: public:
@ -73,12 +73,6 @@ public:
//- Construct from entry name and dictionary //- Construct from entry name and dictionary
OneConstant(const word& entryName, const dictionary& dict); OneConstant(const word& entryName, const dictionary& dict);
//- Construct and return a clone
virtual tmp<Function1<Type>> clone() const
{
return tmp<Function1<Type>>(new OneConstant<Type>(*this));
}
//- Destructor //- Destructor
virtual ~OneConstant(); virtual ~OneConstant();
@ -92,16 +86,6 @@ public:
//- Integrate between two values //- Integrate between two values
virtual inline Type integrate(const scalar x1, const scalar x2) const; virtual inline Type integrate(const scalar x1, const scalar x2) const;
//- Return value as a function of (scalar) independent variable
virtual tmp<Field<Type>> value(const scalarField& x) const;
//- Integrate between two (scalar) values
virtual tmp<Field<Type>> integrate
(
const scalarField& x1,
const scalarField& x2
) const;
//- Write in dictionary format //- Write in dictionary format
virtual void writeData(Ostream& os) const; virtual void writeData(Ostream& os) const;
@ -115,7 +99,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

6
src/OpenFOAM/primitives/functions/Function1/One/OneConstantI.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,14 +28,14 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
inline Type Foam::Function1Types::OneConstant<Type>::value(const scalar x) const inline Type Foam::Function1s::OneConstant<Type>::value(const scalar x) const
{ {
return pTraits<Type>::one; return pTraits<Type>::one;
} }
template<class Type> template<class Type>
inline Type Foam::Function1Types::OneConstant<Type>::integrate inline Type Foam::Function1s::OneConstant<Type>::integrate
( (
const scalar x1, const scalar x1,
const scalar x2 const scalar x2

20
src/OpenFOAM/primitives/functions/Function1/PolynomialEntry/PolynomialEntry.C
View File

@ -28,13 +28,13 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Polynomial<Type>::Polynomial Foam::Function1s::Polynomial<Type>::Polynomial
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
Function1<Type>(entryName), FieldFunction1<Type, Polynomial<Type>>(entryName),
coeffs_(), coeffs_(),
canIntegrate_(true) canIntegrate_(true)
{ {
@ -72,13 +72,13 @@ Foam::Function1Types::Polynomial<Type>::Polynomial
template<class Type> template<class Type>
Foam::Function1Types::Polynomial<Type>::Polynomial Foam::Function1s::Polynomial<Type>::Polynomial
( (
const word& entryName, const word& entryName,
const List<Tuple2<Type, Type>>& coeffs const List<Tuple2<Type, Type>>& coeffs
) )
: :
Function1<Type>(entryName), FieldFunction1<Type, Polynomial<Type>>(entryName),
coeffs_(coeffs), coeffs_(coeffs),
canIntegrate_(true) canIntegrate_(true)
{ {
@ -111,9 +111,9 @@ Foam::Function1Types::Polynomial<Type>::Polynomial
template<class Type> template<class Type>
Foam::Function1Types::Polynomial<Type>::Polynomial(const Polynomial& poly) Foam::Function1s::Polynomial<Type>::Polynomial(const Polynomial& poly)
: :
Function1<Type>(poly), FieldFunction1<Type, Polynomial<Type>>(poly),
coeffs_(poly.coeffs_), coeffs_(poly.coeffs_),
canIntegrate_(poly.canIntegrate_) canIntegrate_(poly.canIntegrate_)
{} {}
@ -122,14 +122,14 @@ Foam::Function1Types::Polynomial<Type>::Polynomial(const Polynomial& poly)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Polynomial<Type>::~Polynomial() Foam::Function1s::Polynomial<Type>::~Polynomial()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
Type Foam::Function1Types::Polynomial<Type>::value(const scalar x) const Type Foam::Function1s::Polynomial<Type>::value(const scalar x) const
{ {
Type y(Zero); Type y(Zero);
forAll(coeffs_, i) forAll(coeffs_, i)
@ -146,7 +146,7 @@ Type Foam::Function1Types::Polynomial<Type>::value(const scalar x) const
template<class Type> template<class Type>
Type Foam::Function1Types::Polynomial<Type>::integrate Type Foam::Function1s::Polynomial<Type>::integrate
( (
const scalar x1, const scalar x1,
const scalar x2 const scalar x2
@ -184,7 +184,7 @@ Type Foam::Function1Types::Polynomial<Type>::integrate
template<class Type> template<class Type>
void Foam::Function1Types::Polynomial<Type>::writeData(Ostream& os) const void Foam::Function1s::Polynomial<Type>::writeData(Ostream& os) const
{ {
Function1<Type>::writeData(os); Function1<Type>::writeData(os);

8
src/OpenFOAM/primitives/functions/Function1/PolynomialEntry/PolynomialEntry.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::Polynomial Foam::Function1s::Polynomial
Description Description
PolynomialEntry container data entry for scalars. Items are stored in a PolynomialEntry container data entry for scalars. Items are stored in a
@ -53,7 +53,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -63,7 +63,7 @@ namespace Function1Types
template<class Type> template<class Type>
class Polynomial class Polynomial
: :
public Function1<Type> public FieldFunction1<Type, Polynomial<Type>>
{ {
// Private Data // Private Data
@ -123,7 +123,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

16
src/OpenFOAM/primitives/functions/Function1/ramp/ramp.C → src/OpenFOAM/primitives/functions/Function1/Ramp/Ramp.C
View File

@ -23,24 +23,26 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "ramp.H" #include "Ramp.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
void Foam::Function1Types::ramp::read(const dictionary& coeffs) template <class Function1Type>
void Foam::Function1s::Ramp<Function1Type>::read(const dictionary& coeffs)
{ {
start_ = coeffs.lookupOrDefault<scalar>("start", 0); start_ = coeffs.lookupOrDefault<scalar>("start", 0);
duration_ = coeffs.lookupType<scalar>("duration"); duration_ = coeffs.lookupType<scalar>("duration");
} }
Foam::Function1Types::ramp::ramp template <class Function1Type>
Foam::Function1s::Ramp<Function1Type>::Ramp
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
Function1<scalar>(entryName) FieldFunction1<scalar, Function1Type>(entryName)
{ {
read(dict); read(dict);
} }
@ -48,13 +50,15 @@ Foam::Function1Types::ramp::ramp
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::Function1Types::ramp::~ramp() template <class Function1Type>
Foam::Function1s::Ramp<Function1Type>::~Ramp()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::Function1Types::ramp::writeData(Ostream& os) const template <class Function1Type>
void Foam::Function1s::Ramp<Function1Type>::writeData(Ostream& os) const
{ {
Function1<scalar>::writeData(os); Function1<scalar>::writeData(os);
os << token::END_STATEMENT << nl; os << token::END_STATEMENT << nl;

31
src/OpenFOAM/primitives/functions/Function1/ramp/ramp.H → src/OpenFOAM/primitives/functions/Function1/Ramp/Ramp.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::ramp Foam::Function1s::Ramp
Description Description
Ramp function base class for the set of scalar functions starting from 0 and Ramp function base class for the set of scalar functions starting from 0 and
@ -59,12 +59,12 @@ See also
Foam::Function1 Foam::Function1
SourceFiles SourceFiles
ramp.C Ramp.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef ramp_H #ifndef Ramp_H
#define ramp_H #define Ramp_H
#include "Function1.H" #include "Function1.H"
@ -72,16 +72,17 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class ramp Declaration Class Ramp Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
class ramp template <class Function1Type>
class Ramp
: :
public Function1<scalar> public FieldFunction1<scalar, Function1Type>
{ {
protected: protected:
@ -127,7 +128,7 @@ public:
// Constructors // Constructors
//- Construct from entry name and dictionary //- Construct from entry name and dictionary
ramp Ramp
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
@ -135,7 +136,7 @@ public:
//- Destructor //- Destructor
virtual ~ramp(); virtual ~Ramp();
// Member Functions // Member Functions
@ -150,17 +151,23 @@ public:
// Member Operators // Member Operators
//- Disallow default bitwise assignment //- Disallow default bitwise assignment
void operator=(const ramp&) = delete; void operator=(const Ramp<Function1Type>&) = delete;
}; };
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "Ramp.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif #endif
// ************************************************************************* // // ************************************************************************* //

14
src/OpenFOAM/primitives/functions/Function1/Scale/Scale.C
View File

@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::Scale<Type>::read(const dictionary& coeffs) void Foam::Function1s::Scale<Type>::read(const dictionary& coeffs)
{ {
scale_ = Function1<scalar>::New("scale", coeffs); scale_ = Function1<scalar>::New("scale", coeffs);
xScale_ = xScale_ =
@ -50,22 +50,22 @@ void Foam::Function1Types::Scale<Type>::read(const dictionary& coeffs)
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Scale<Type>::Scale Foam::Function1s::Scale<Type>::Scale
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
Function1<Type>(entryName) FieldFunction1<Type, Scale<Type>>(entryName)
{ {
read(dict); read(dict);
} }
template<class Type> template<class Type>
Foam::Function1Types::Scale<Type>::Scale(const Scale<Type>& se) Foam::Function1s::Scale<Type>::Scale(const Scale<Type>& se)
: :
Function1<Type>(se), FieldFunction1<Type, Scale<Type>>(se),
scale_(se.scale_, false), scale_(se.scale_, false),
xScale_(se.xScale_, false), xScale_(se.xScale_, false),
value_(se.value_, false), value_(se.value_, false),
@ -77,14 +77,14 @@ Foam::Function1Types::Scale<Type>::Scale(const Scale<Type>& se)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Scale<Type>::~Scale() Foam::Function1s::Scale<Type>::~Scale()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::Scale<Type>::writeData(Ostream& os) const void Foam::Function1s::Scale<Type>::writeData(Ostream& os) const
{ {
Function1<Type>::writeData(os); Function1<Type>::writeData(os);
os << token::END_STATEMENT << nl; os << token::END_STATEMENT << nl;

12
src/OpenFOAM/primitives/functions/Function1/Scale/Scale.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::Scale Foam::Function1s::Scale
Description Description
Function1 which scales a given 'value' function by a 'scale' scalar function Function1 which scales a given 'value' function by a 'scale' scalar function
@ -108,8 +108,8 @@ Description
\endtable \endtable
See also See also
Foam::Function1Types::ramp Foam::Function1s::ramp
Foam::Function1Types::reverseRamp Foam::Function1s::reverseRamp
SourceFiles SourceFiles
Scale.C Scale.C
@ -125,7 +125,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -135,7 +135,7 @@ namespace Function1Types
template<class Type> template<class Type>
class Scale class Scale
: :
public Function1<Type> public FieldFunction1<Type, Scale<Type>>
{ {
// Private Data // Private Data
@ -205,7 +205,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/primitives/functions/Function1/Scale/ScaleI.H
View File

@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
inline Type Foam::Function1Types::Scale<Type>::value(const scalar x) const inline Type Foam::Function1s::Scale<Type>::value(const scalar x) const
{ {
const scalar sx = xScale_->value(x)*x; const scalar sx = xScale_->value(x)*x;
return scale_->value(sx)*value_->value(sx); return scale_->value(sx)*value_->value(sx);
@ -36,7 +36,7 @@ inline Type Foam::Function1Types::Scale<Type>::value(const scalar x) const
template<class Type> template<class Type>
inline Type Foam::Function1Types::Scale<Type>::integrate inline Type Foam::Function1s::Scale<Type>::integrate
( (
const scalar x1, const scalar x1,
const scalar x2 const scalar x2

14
src/OpenFOAM/primitives/functions/Function1/Sine/Sine.C
View File

@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::Sine<Type>::read(const dictionary& coeffs) void Foam::Function1s::Sine<Type>::read(const dictionary& coeffs)
{ {
amplitude_ = Function1<Type>::New("amplitude", coeffs); amplitude_ = Function1<Type>::New("amplitude", coeffs);
frequency_ = readScalar(coeffs.lookup("frequency")); frequency_ = readScalar(coeffs.lookup("frequency"));
@ -44,22 +44,22 @@ void Foam::Function1Types::Sine<Type>::read(const dictionary& coeffs)
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Sine<Type>::Sine Foam::Function1s::Sine<Type>::Sine
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
Function1<Type>(entryName) FieldFunction1<Type, Sine<Type>>(entryName)
{ {
read(dict); read(dict);
} }
template<class Type> template<class Type>
Foam::Function1Types::Sine<Type>::Sine(const Sine<Type>& se) Foam::Function1s::Sine<Type>::Sine(const Sine<Type>& se)
: :
Function1<Type>(se), FieldFunction1<Type, Sine<Type>>(se),
amplitude_(se.amplitude_, false), amplitude_(se.amplitude_, false),
frequency_(se.frequency_), frequency_(se.frequency_),
start_(se.start_), start_(se.start_),
@ -71,14 +71,14 @@ Foam::Function1Types::Sine<Type>::Sine(const Sine<Type>& se)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Sine<Type>::~Sine() Foam::Function1s::Sine<Type>::~Sine()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::Sine<Type>::writeData(Ostream& os) const void Foam::Function1s::Sine<Type>::writeData(Ostream& os) const
{ {
Function1<Type>::writeData(os); Function1<Type>::writeData(os);
os << token::END_STATEMENT << nl; os << token::END_STATEMENT << nl;

8
src/OpenFOAM/primitives/functions/Function1/Sine/Sine.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::Sine Foam::Function1s::Sine
Description Description
Templated sine function with support for an offset level. Templated sine function with support for an offset level.
@ -79,7 +79,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -89,7 +89,7 @@ namespace Function1Types
template<class Type> template<class Type>
class Sine class Sine
: :
public Function1<Type> public FieldFunction1<Type, Sine<Type>>
{ {
// Private Data // Private Data
@ -159,7 +159,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/primitives/functions/Function1/Sine/SineI.H
View File

@ -29,7 +29,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
inline Type Foam::Function1Types::Sine<Type>::value(const scalar x) const inline Type Foam::Function1s::Sine<Type>::value(const scalar x) const
{ {
const scalar phi = constant::mathematical::twoPi*frequency_*(x - start_); const scalar phi = constant::mathematical::twoPi*frequency_*(x - start_);
@ -38,7 +38,7 @@ inline Type Foam::Function1Types::Sine<Type>::value(const scalar x) const
template<class Type> template<class Type>
inline Type Foam::Function1Types::Sine<Type>::integrate inline Type Foam::Function1s::Sine<Type>::integrate
( (
const scalar x1, const scalar x1,
const scalar x2 const scalar x2

14
src/OpenFOAM/primitives/functions/Function1/Square/Square.C
View File

@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::Square<Type>::read(const dictionary& coeffs) void Foam::Function1s::Square<Type>::read(const dictionary& coeffs)
{ {
amplitude_ = Function1<Type>::New("amplitude", coeffs); amplitude_ = Function1<Type>::New("amplitude", coeffs);
frequency_ = readScalar(coeffs.lookup("frequency")); frequency_ = readScalar(coeffs.lookup("frequency"));
@ -45,22 +45,22 @@ void Foam::Function1Types::Square<Type>::read(const dictionary& coeffs)
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Square<Type>::Square Foam::Function1s::Square<Type>::Square
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
Function1<Type>(entryName) FieldFunction1<Type, Square<Type>>(entryName)
{ {
read(dict); read(dict);
} }
template<class Type> template<class Type>
Foam::Function1Types::Square<Type>::Square(const Square<Type>& se) Foam::Function1s::Square<Type>::Square(const Square<Type>& se)
: :
Function1<Type>(se), FieldFunction1<Type, Square<Type>>(se),
amplitude_(se.amplitude_, false), amplitude_(se.amplitude_, false),
frequency_(se.frequency_), frequency_(se.frequency_),
start_(se.start_), start_(se.start_),
@ -73,14 +73,14 @@ Foam::Function1Types::Square<Type>::Square(const Square<Type>& se)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Square<Type>::~Square() Foam::Function1s::Square<Type>::~Square()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::Square<Type>::writeData(Ostream& os) const void Foam::Function1s::Square<Type>::writeData(Ostream& os) const
{ {
Function1<Type>::writeData(os); Function1<Type>::writeData(os);
os << token::END_STATEMENT << nl; os << token::END_STATEMENT << nl;

8
src/OpenFOAM/primitives/functions/Function1/Square/Square.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::Square Foam::Function1s::Square
Description Description
Templated square-wave function with support for an offset level. Templated square-wave function with support for an offset level.
@ -85,7 +85,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -95,7 +95,7 @@ namespace Function1Types
template<class Type> template<class Type>
class Square class Square
: :
public Function1<Type> public FieldFunction1<Type, Square<Type>>
{ {
// Private Data // Private Data
@ -170,7 +170,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/primitives/functions/Function1/Square/SquareI.H
View File

@ -29,7 +29,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
inline Type Foam::Function1Types::Square<Type>::value(const scalar x) const inline Type Foam::Function1s::Square<Type>::value(const scalar x) const
{ {
const scalar markFraction = markSpace_/(1 + markSpace_); const scalar markFraction = markSpace_/(1 + markSpace_);
@ -43,7 +43,7 @@ inline Type Foam::Function1Types::Square<Type>::value(const scalar x) const
template<class Type> template<class Type>
inline Type Foam::Function1Types::Square<Type>::integrate inline Type Foam::Function1s::Square<Type>::integrate
( (
const scalar x1, const scalar x1,
const scalar x2 const scalar x2

44
src/OpenFOAM/primitives/functions/Function1/Table/Table.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,33 +28,63 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Table<Type>::Table Foam::Function1s::Table<Type>::Table
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
TableBase<Type>(entryName, dict) TableBase<Type, Table<Type>>(entryName, dict)
{ {
Istream& is(dict.lookup(entryName)); Istream& is(dict.lookup(entryName));
word entryType(is); word entryType(is);
is >> this->table_; is >> this->table_;
TableBase<Type>::check(); TableBase<Type, Table<Type>>::check();
} }
template<class Type> template<class Type>
Foam::Function1Types::Table<Type>::Table(const Table<Type>& tbl) Foam::Function1s::Table<Type>::Table
(
const word& name,
const tableBase::boundsHandling boundsHandling,
const word& interpolationScheme,
const List<Tuple2<scalar, Type>>& table
)
: :
TableBase<Type>(tbl) TableBase<Type, Table<Type>>
(
name,
boundsHandling,
interpolationScheme,
table
)
{}
template<class Type>
Foam::Function1s::Table<Type>::Table(const Table<Type>& tbl)
:
TableBase<Type, Table<Type>>(tbl)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Table<Type>::~Table() Foam::Function1s::Table<Type>::~Table()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::Function1s::Table<Type>::writeData(Ostream& os) const
{
Function1<Type>::writeData(os);
os << nl << indent << this->table_ << token::END_STATEMENT << nl;
TableBase<Type, Table<Type>>::writeCoeffDict(os);
}
// ************************************************************************* // // ************************************************************************* //

26
src/OpenFOAM/primitives/functions/Function1/Table/Table.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::Table Foam::Function1s::Table
Description Description
Templated table container function. Templated table container function.
@ -47,14 +47,13 @@ SourceFiles
#ifndef Table_H #ifndef Table_H
#define Table_H #define Table_H
#include "Function1.H" #include "TableBase.H"
#include "Tuple2.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -64,7 +63,7 @@ namespace Function1Types
template<class Type> template<class Type>
class Table class Table
: :
public TableBase<Type> public TableBase<Type, Table<Type>>
{ {
public: public:
@ -78,6 +77,15 @@ public:
//- Construct from entry name and Istream //- Construct from entry name and Istream
Table(const word& entryName, const dictionary& dict); Table(const word& entryName, const dictionary& dict);
//- Construct from components
Table
(
const word& name,
const tableBase::boundsHandling boundsHandling,
const word& interpolationScheme,
const List<Tuple2<scalar, Type>>& table
);
//- Copy constructor //- Copy constructor
Table(const Table<Type>& tbl); Table(const Table<Type>& tbl);
@ -86,6 +94,12 @@ public:
virtual ~Table(); virtual ~Table();
// Member Functions
//- Write all table data in dictionary format
virtual void writeData(Ostream& os) const;
// Member Operators // Member Operators
//- Disallow default bitwise assignment //- Disallow default bitwise assignment
@ -95,7 +109,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

142
src/OpenFOAM/primitives/functions/Function1/Table/TableBase.C
View File

@ -25,13 +25,13 @@ License
#include "TableBase.H" #include "TableBase.H"
#include "Time.H" #include "Time.H"
#include "interpolationWeights.H" #include "linearInterpolationWeights.H"
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * // // * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
template<class Type> template<class Type, class Function1Type>
const Foam::interpolationWeights& const Foam::interpolationWeights&
Foam::Function1Types::TableBase<Type>::interpolator() const Foam::Function1s::TableBase<Type, Function1Type>::interpolator() const
{ {
if (interpolatorPtr_.empty()) if (interpolatorPtr_.empty())
{ {
@ -53,8 +53,8 @@ Foam::Function1Types::TableBase<Type>::interpolator() const
} }
template<class Type> template<class Type, class Function1Type>
void Foam::Function1Types::TableBase<Type>::check() const void Foam::Function1s::TableBase<Type, Function1Type>::check() const
{ {
if (!table_.size()) if (!table_.size())
{ {
@ -82,8 +82,11 @@ void Foam::Function1Types::TableBase<Type>::check() const
} }
template<class Type> template<class Type, class Function1Type>
Foam::scalar Foam::Function1Types::TableBase<Type>::bound(const scalar x) const Foam::scalar Foam::Function1s::TableBase<Type, Function1Type>::bound
(
const scalar x
) const
{ {
const bool under = x < table_.first().first(); const bool under = x < table_.first().first();
const bool over = x > table_.last().first(); const bool over = x > table_.last().first();
@ -130,15 +133,15 @@ Foam::scalar Foam::Function1Types::TableBase<Type>::bound(const scalar x) const
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type, class Function1Type>
Foam::Function1Types::TableBase<Type>::TableBase Foam::Function1s::TableBase<Type, Function1Type>::TableBase
( (
const word& name, const word& name,
const dictionary& dict const dictionary& dict
) )
: :
tableBase(), tableBase(),
Function1<Type>(name), FieldFunction1<Type, Function1Type>(name),
name_(name), name_(name),
boundsHandling_ boundsHandling_
( (
@ -148,17 +151,42 @@ Foam::Function1Types::TableBase<Type>::TableBase
), ),
interpolationScheme_ interpolationScheme_
( (
dict.lookupOrDefault<word>("interpolationScheme", "linear") dict.lookupOrDefault<word>
(
"interpolationScheme",
linearInterpolationWeights::typeName
)
), ),
table_() table_()
{} {}
template<class Type> template<class Type, class Function1Type>
Foam::Function1Types::TableBase<Type>::TableBase(const TableBase<Type>& tbl) Foam::Function1s::TableBase<Type, Function1Type>::TableBase
(
const word& name,
const tableBase::boundsHandling boundsHandling,
const word& interpolationScheme,
const List<Tuple2<scalar, Type>>& table
)
: :
tableBase(), tableBase(),
Function1<Type>(tbl), FieldFunction1<Type, Function1Type>(name),
name_(name),
boundsHandling_(boundsHandling),
interpolationScheme_(interpolationScheme),
table_(table)
{}
template<class Type, class Function1Type>
Foam::Function1s::TableBase<Type, Function1Type>::TableBase
(
const TableBase<Type, Function1Type>& tbl
)
:
tableBase(),
FieldFunction1<Type, Function1Type>(tbl),
name_(tbl.name_), name_(tbl.name_),
boundsHandling_(tbl.boundsHandling_), boundsHandling_(tbl.boundsHandling_),
interpolationScheme_(tbl.interpolationScheme_), interpolationScheme_(tbl.interpolationScheme_),
@ -170,15 +198,18 @@ Foam::Function1Types::TableBase<Type>::TableBase(const TableBase<Type>& tbl)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type, class Function1Type>
Foam::Function1Types::TableBase<Type>::~TableBase() Foam::Function1s::TableBase<Type, Function1Type>::~TableBase()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type, class Function1Type>
Type Foam::Function1Types::TableBase<Type>::value(const scalar x) const Type Foam::Function1s::TableBase<Type, Function1Type>::value
(
const scalar x
) const
{ {
const scalar bx = bound(x); const scalar bx = bound(x);
@ -194,8 +225,8 @@ Type Foam::Function1Types::TableBase<Type>::value(const scalar x) const
} }
template<class Type> template<class Type, class Function1Type>
Type Foam::Function1Types::TableBase<Type>::integrate Type Foam::Function1s::TableBase<Type, Function1Type>::integrate
( (
const scalar x1, const scalar x1,
const scalar x2 const scalar x2
@ -236,8 +267,9 @@ Type Foam::Function1Types::TableBase<Type>::integrate
} }
template<class Type> template<class Type, class Function1Type>
Foam::tmp<Foam::scalarField> Foam::Function1Types::TableBase<Type>::x() const Foam::tmp<Foam::scalarField>
Foam::Function1s::TableBase<Type, Function1Type>::x() const
{ {
tmp<scalarField> tfld(new scalarField(table_.size(), 0.0)); tmp<scalarField> tfld(new scalarField(table_.size(), 0.0));
scalarField& fld = tfld.ref(); scalarField& fld = tfld.ref();
@ -251,8 +283,9 @@ Foam::tmp<Foam::scalarField> Foam::Function1Types::TableBase<Type>::x() const
} }
template<class Type> template<class Type, class Function1Type>
Foam::tmp<Foam::Field<Type>> Foam::Function1Types::TableBase<Type>::y() const Foam::tmp<Foam::Field<Type>>
Foam::Function1s::TableBase<Type, Function1Type>::y() const
{ {
tmp<Field<Type>> tfld(new Field<Type>(table_.size(), Zero)); tmp<Field<Type>> tfld(new Field<Type>(table_.size(), Zero));
Field<Type>& fld = tfld.ref(); Field<Type>& fld = tfld.ref();
@ -266,31 +299,58 @@ Foam::tmp<Foam::Field<Type>> Foam::Function1Types::TableBase<Type>::y() const
} }
template<class Type> template<class Type, class Function1Type>
void Foam::Function1Types::TableBase<Type>::writeEntries(Ostream& os) const void Foam::Function1s::TableBase<Type, Function1Type>::writeEntries
(
Ostream& os
) const
{ {
if (boundsHandling_ != tableBase::boundsHandling::clamp) writeEntryIfDifferent
(
os,
"outOfBounds",
tableBase::boundsHandlingNames_[tableBase::boundsHandling::clamp],
tableBase::boundsHandlingNames_[boundsHandling_]
);
writeEntryIfDifferent
(
os,
"interpolationScheme",
linearInterpolationWeights::typeName,
interpolationScheme_
);
}
template<class Type, class Function1Type>
void Foam::Function1s::TableBase<Type, Function1Type>::writeCoeffDict
(
Ostream& os
) const
{
OStringStream oss;
writeEntries(oss);
if (oss.str().size())
{ {
writeEntry os << indent << word(this->name() + "Coeffs") << nl;
( os << indent << token::BEGIN_BLOCK << incrIndent << nl;
os, writeEntries(os);
"outOfBounds", os << decrIndent << indent << token::END_BLOCK << endl;
tableBase::boundsHandlingNames_[boundsHandling_]
);
}
if (interpolationScheme_ != "linear")
{
writeEntry(os, "interpolationScheme", interpolationScheme_);
} }
} }
template<class Type> template<class Type, class Function1Type>
void Foam::Function1Types::TableBase<Type>::writeData(Ostream& os) const void Foam::Function1s::TableBase<Type, Function1Type>::writeData
(
Ostream& os
) const
{ {
Function1<Type>::writeData(os); Function1<Type>::writeData(os);
os << nl << indent << table_ << token::END_STATEMENT << nl; os << token::END_STATEMENT << nl;
writeEntries(os); writeCoeffDict(os);
} }

45
src/OpenFOAM/primitives/functions/Function1/Table/TableBase.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::TableBase Foam::Function1s::TableBase
Description Description
Base class for table with bounds handling, interpolation and integration Base class for table with bounds handling, interpolation and integration
@ -46,18 +46,18 @@ namespace Foam
class interpolationWeights; class interpolationWeights;
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class TableBase Declaration Class TableBase Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class Type> template<class Type, class Function1Type>
class TableBase class TableBase
: :
public tableBase, public tableBase,
public Function1<Type> public FieldFunction1<Type, Function1Type>
{ {
protected: protected:
@ -102,21 +102,24 @@ protected:
scalar bound(const scalar x) const; scalar bound(const scalar x) const;
private:
//- Disallow default bitwise assignment
void operator=(const TableBase<Type>&) = delete;
public: public:
// Constructors // Constructors
//- Construct from dictionary - note table is not populated //- Construct from dictionary. Table is not populated.
TableBase(const word& name, const dictionary& dict); TableBase(const word& name, const dictionary& dict);
//- Copy constructor. Note: steals interpolator, tableSamples //- Construct from components
TableBase(const TableBase<Type>& tbl); TableBase
(
const word& name,
const tableBase::boundsHandling boundsHandling,
const word& interpolationScheme,
const List<Tuple2<scalar, Type>>& table
);
//- Copy constructor. Note: Steals interpolator and tableSamples.
TableBase(const TableBase<Type, Function1Type>& tbl);
//- Destructor //- Destructor
@ -137,18 +140,26 @@ public:
//- Return the dependent values //- Return the dependent values
virtual tmp<Field<Type>> y() const; virtual tmp<Field<Type>> y() const;
//- Write entries only in dictionary format
virtual void writeEntries(Ostream& os) const;
//- Write the coeff dict in dictionary format
virtual void writeCoeffDict(Ostream& os) const;
//- Write all table data in dictionary format //- Write all table data in dictionary format
virtual void writeData(Ostream& os) const; virtual void writeData(Ostream& os) const;
//- Write keywords only in dictionary format. Used for non-inline
// table types // Member Operators
virtual void writeEntries(Ostream& os) const;
//- Disallow default bitwise assignment
void operator=(const TableBase<Type, Function1Type>&) = delete;
}; };
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

10
src/OpenFOAM/primitives/functions/Function1/Table/tableBase.C
View File

@ -31,23 +31,23 @@ namespace Foam
{ {
template<> template<>
const char* const char*
NamedEnum<Function1Types::tableBase::boundsHandling, 4>::names[] = NamedEnum<Function1s::tableBase::boundsHandling, 4>::names[] =
{"error", "warn", "clamp", "repeat"}; {"error", "warn", "clamp", "repeat"};
} }
const Foam::NamedEnum<Foam::Function1Types::tableBase::boundsHandling, 4> const Foam::NamedEnum<Foam::Function1s::tableBase::boundsHandling, 4>
Foam::Function1Types::tableBase::boundsHandlingNames_; Foam::Function1s::tableBase::boundsHandlingNames_;
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::Function1Types::tableBase::tableBase() Foam::Function1s::tableBase::tableBase()
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::Function1Types::tableBase::~tableBase() Foam::Function1s::tableBase::~tableBase()
{} {}

4
src/OpenFOAM/primitives/functions/Function1/Table/tableBase.H
View File

@ -38,7 +38,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -77,7 +77,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // namespace Function1Types } // namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

62
src/OpenFOAM/primitives/functions/Function1/TableFile/TableFile.C
View File

@ -28,68 +28,58 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::TableFile<Type>::TableFile Foam::Function1s::TableFile<Type>::TableFile
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
TableBase<Type>(entryName, dict), TableBase<Type, TableFile<Type>>(entryName, dict),
fName_("none") fName_(dict.lookup("file")),
{ reader_
dict.lookup("file") >> fName_; (
TableReader<Type>::New
fileName expandedFile(fName_);
// IFstream is(expandedFile.expand());
autoPtr<ISstream> isPtr(fileHandler().NewIFstream(expandedFile.expand()));
ISstream& is = isPtr();
if (!is.good())
{
FatalIOErrorInFunction
( (
is dict.lookupOrDefault<word>
) << "Cannot open file." << exit(FatalIOError); (
} "format",
TableReaders::Foam<Type>::typeName
),
dict
)
)
{
reader_()(fName_, this->table_);
is >> this->table_; TableBase<Type, TableFile<Type>>::check();
TableBase<Type>::check();
} }
template<class Type> template<class Type>
Foam::Function1Types::TableFile<Type>::TableFile(const TableFile<Type>& tbl) Foam::Function1s::TableFile<Type>::TableFile(const TableFile<Type>& tbl)
: :
TableBase<Type>(tbl), TableBase<Type, TableFile<Type>>(tbl),
fName_(tbl.fName_) fName_(tbl.fName_),
reader_(tbl.reader_, false)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::TableFile<Type>::~TableFile() Foam::Function1s::TableFile<Type>::~TableFile()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::TableFile<Type>::writeData(Ostream& os) const void Foam::Function1s::TableFile<Type>::writeEntries(Ostream& os) const
{ {
Function1<Type>::writeData(os); TableBase<Type, TableFile<Type>>::writeEntries(os);
os << token::END_STATEMENT << nl
<< indent << word(this->name() + "Coeffs") << nl
<< indent << token::BEGIN_BLOCK << nl << incrIndent;
// Note: for TableBase write the dictionary entries it needs but not
// the values themselves
TableBase<Type>::writeEntries(os);
writeEntry(os, "file", fName_); writeEntry(os, "file", fName_);
os << decrIndent << indent << token::END_BLOCK << endl; writeEntry(os, "format", reader_->type());
reader_->write(os);
} }

54
src/OpenFOAM/primitives/functions/Function1/TableFile/TableFile.H
View File

@ -22,10 +22,13 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::TableFile Foam::Function1s::TableFile
Description Description
Templated table container function where data is read from file. Templated table container function where data is read from file. Data is
stored as a list of Tuple2's. The first column is scalar. Data is read in
the form specified by the format entry, which defaults to the native
OpenFOAM format.
Usage: Usage:
\verbatim \verbatim
@ -33,37 +36,32 @@ Description
<entryName>Coeffs <entryName>Coeffs
{ {
file dataFile; // name of data file file dataFile; // name of data file
format foam; // data format (optional)
outOfBounds clamp; // optional out-of-bounds handling outOfBounds clamp; // optional out-of-bounds handling
interpolationScheme linear; // optional interpolation method interpolationScheme linear; // optional interpolation method
} }
\endverbatim \endverbatim
Data is stored as a list of Tuple2's. First column is always stored as
scalar entries. Data is read in the form, e.g. for an entry \<entryName\>
that is (scalar, vector):
\verbatim
(
(0.0 (1 2 3))
(1.0 (4 5 6))
);
\endverbatim
SourceFiles SourceFiles
TableFile.C TableFile.C
See also
FoamTableReader.C
CsvTableReader.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef TableFile_H #ifndef TableFile_H
#define TableFile_H #define TableFile_H
#include "Function1.H" #include "TableBase.H"
#include "Tuple2.H" #include "TableReader.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -73,12 +71,15 @@ namespace Function1Types
template<class Type> template<class Type>
class TableFile class TableFile
: :
public TableBase<Type> public TableBase<Type, TableFile<Type>>
{ {
// Private Data // Private Data
//- File name for csv table (optional) //- File name for table
fileName fName_; const fileName fName_;
//- Table reader
const autoPtr<TableReader<Type>> reader_;
public: public:
@ -89,7 +90,7 @@ public:
// Constructors // Constructors
//- Construct from entry name and Istream //- Construct from entry name and dictionary
TableFile(const word& entryName, const dictionary& dict); TableFile(const word& entryName, const dictionary& dict);
//- Copy constructor //- Copy constructor
@ -100,10 +101,19 @@ public:
virtual ~TableFile(); virtual ~TableFile();
// Access
//- Return the file name
inline const fileName& fName() const
{
return fName_;
}
// I/O // I/O
//- Write in dictionary format //- Write entries only in dictionary format
virtual void writeData(Ostream& os) const; virtual void writeEntries(Ostream& os) const;
// Member Operators // Member Operators
@ -115,7 +125,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

131
src/OpenFOAM/primitives/functions/Function1/CSV/CSV.C → src/OpenFOAM/primitives/functions/Function1/TableFile/TableReader/Csv/CsvTableReader.C
View File

@ -23,16 +23,19 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "CSV.H" #include "CsvTableReader.H"
#include "DynamicList.H" #include "DynamicList.H"
#include "Field.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<> template<>
Foam::label Foam::Function1Types::CSV<Foam::label>::readValue label TableReaders::Csv<label>::readValue(const List<string>& split) const
(
const List<string>& split
)
{ {
if (componentColumns_[0] >= split.size()) if (componentColumns_[0] >= split.size())
{ {
@ -47,10 +50,7 @@ Foam::label Foam::Function1Types::CSV<Foam::label>::readValue
template<> template<>
Foam::scalar Foam::Function1Types::CSV<Foam::scalar>::readValue scalar TableReaders::Csv<scalar>::readValue(const List<string>& split) const
(
const List<string>& split
)
{ {
if (componentColumns_[0] >= split.size()) if (componentColumns_[0] >= split.size())
{ {
@ -65,11 +65,11 @@ Foam::scalar Foam::Function1Types::CSV<Foam::scalar>::readValue
template<class Type> template<class Type>
Type Foam::Function1Types::CSV<Type>::readValue(const List<string>& split) Type TableReaders::Csv<Type>::readValue(const List<string>& split) const
{ {
Type result; Type result;
for (label i = 0; i < pTraits<Type>::nComponents; i++) for(label i = 0;i < pTraits<Type>::nComponents; i++)
{ {
if (componentColumns_[i] >= split.size()) if (componentColumns_[i] >= split.size())
{ {
@ -79,28 +79,28 @@ Type Foam::Function1Types::CSV<Type>::readValue(const List<string>& split)
<< exit(FatalError); << exit(FatalError);
} }
result[i] = result[i] = readScalar
readScalar(IStringStream(split[componentColumns_[i]])()); (
IStringStream(split[componentColumns_[i]])()
);
} }
return result; return result;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::CSV<Type>::read() void Foam::TableReaders::Csv<Type>::read
(
ISstream& is,
List<Tuple2<scalar, Type>>& data
) const
{ {
fileName expandedFile(fName_);
autoPtr<ISstream> isPtr(fileHandler().NewIFstream(expandedFile.expand()));
ISstream& is = isPtr();
if (!is.good())
{
FatalIOErrorInFunction(is)
<< "Cannot open CSV file for reading."
<< exit(FatalIOError);
}
DynamicList<Tuple2<scalar, Type>> values; DynamicList<Tuple2<scalar, Type>> values;
// Skip header // Skip header
@ -118,7 +118,6 @@ void Foam::Function1Types::CSV<Type>::read()
string line; string line;
is.getLine(line); is.getLine(line);
label n = 0; label n = 0;
std::size_t pos = 0; std::size_t pos = 0;
DynamicList<string> split; DynamicList<string> split;
@ -181,7 +180,6 @@ void Foam::Function1Types::CSV<Type>::read()
} }
} }
if (split.size() <= 1) if (split.size() <= 1)
{ {
break; break;
@ -193,90 +191,69 @@ void Foam::Function1Types::CSV<Type>::read()
values.append(Tuple2<scalar,Type>(x, value)); values.append(Tuple2<scalar,Type>(x, value));
} }
this->table_.transfer(values); data.transfer(values);
}
template<class Type>
void Foam::TableReaders::Csv<Type>::read
(
ISstream&,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>& data
) const
{
NotImplemented;
} }
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::CSV<Type>::CSV Foam::TableReaders::Csv<Type>::Csv(const dictionary& dict)
(
const word& entryName,
const dictionary& dict
)
: :
TableBase<Type>(entryName, dict), TableReader<Type>(dict),
nHeaderLine_(readLabel(dict.lookup("nHeaderLine"))), nHeaderLine_(readLabel(dict.lookup("nHeaderLine"))),
refColumn_(readLabel(dict.lookup("refColumn"))), refColumn_(readLabel(dict.lookup("refColumn"))),
componentColumns_(dict.lookup("componentColumns")), componentColumns_(dict.lookup("componentColumns")),
separator_(dict.lookupOrDefault<string>("separator", string(","))[0]), separator_(dict.lookupOrDefault<string>("separator", string(","))[0]),
mergeSeparators_(readBool(dict.lookup("mergeSeparators"))), mergeSeparators_(readBool(dict.lookup("mergeSeparators")))
fName_(dict.lookup("file"))
{ {
if (componentColumns_.size() != pTraits<Type>::nComponents) if (componentColumns_.size() != pTraits<Type>::nComponents)
{ {
FatalErrorInFunction FatalErrorInFunction
<< componentColumns_ << " does not have the expected length of " << componentColumns_ << " does not have the expected length "
<< pTraits<Type>::nComponents << endl << pTraits<Type>::nComponents << endl
<< exit(FatalError); << exit(FatalError);
} }
read();
TableBase<Type>::check();
} }
template<class Type>
Foam::Function1Types::CSV<Type>::CSV(const CSV<Type>& tbl)
:
TableBase<Type>(tbl),
nHeaderLine_(tbl.nHeaderLine_),
refColumn_(tbl.refColumn_),
componentColumns_(tbl.componentColumns_),
separator_(tbl.separator_),
mergeSeparators_(tbl.mergeSeparators_),
fName_(tbl.fName_)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::CSV<Type>::~CSV() Foam::TableReaders::Csv<Type>::~Csv()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
const Foam::fileName& Foam::Function1Types::CSV<Type>::fName() const void Foam::TableReaders::Csv<Type>::write(Ostream& os) const
{ {
return fName_; TableReader<Type>::write(os);
}
template<class Type>
void Foam::Function1Types::CSV<Type>::writeData(Ostream& os) const
{
Function1<Type>::writeData(os);
os << token::END_STATEMENT << nl;
os << indent << word(this->name() + "Coeffs") << nl;
os << indent << token::BEGIN_BLOCK << incrIndent << nl;
// Note: for TableBase write the dictionary entries it needs but not
// the values themselves
TableBase<Type>::writeEntries(os);
writeEntry(os, "nHeaderLine", nHeaderLine_); writeEntry(os, "nHeaderLine", nHeaderLine_);
writeEntry(os, "refColumn", refColumn_); writeEntry(os, "refColumn", refColumn_);
writeEntry(os, "componentColumns", componentColumns_); if (os.format() == IOstream::BINARY)
{
os.format(IOstream::ASCII);
writeEntry(os, "componentColumns", componentColumns_);
os.format(IOstream::BINARY);
}
else
{
writeEntry(os, "componentColumns", componentColumns_);
}
writeEntry(os, "separator", string(separator_)); writeEntry(os, "separator", string(separator_));
writeEntry(os, "mergeSeparators", mergeSeparators_); writeEntry(os, "mergeSeparators", mergeSeparators_);
writeEntry(os, "file", fName_);
os << decrIndent << indent << token::END_BLOCK << endl;
} }

90
src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.H → src/OpenFOAM/primitives/functions/Function1/TableFile/TableReader/Csv/CsvTableReader.H
View File

@ -22,53 +22,84 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::csvTableReader Foam::TableReaders::Csv
Description Description
Reads an interpolation table from a file - CSV-format Reads an interpolation table from a file in CSV-format. Entries govern the
layout of the CSV file. The index of the first (x) column of the table is
given by the refColumn entry, and is always scalar. The indices of the
components of the second (y) column are given by the componentColumns
entry.
Usage:
\verbatim
nHeaderLine 4; // number of header lines
refColumn 0; // reference column index
componentColumns (1 2 3); // component column indices
separator ","; // optional (defaults to ",")
mergeSeparators no; // merge multiple separators
\endverbatim
SourceFiles SourceFiles
tableReader.C CsvTableReader.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef csvTableReader_H #ifndef CsvTableReader_H
#define csvTableReader_H #define CsvTableReader_H
#include "tableReader.H" #include "TableReader.H"
#include "labelList.H" #include "labelList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace TableReaders
{
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class csvTableReader Declaration Class Csv Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class Type> template<class Type>
class csvTableReader class Csv
: :
public tableReader<Type> public TableReader<Type>
{ {
// Private Data // Private Data
//- Does the file have a header line? //- Number of header lines
const bool headerLine_; const label nHeaderLine_;
//- Column of the time //- Reference column
const label timeColumn_; const label refColumn_;
//- Labels of the components //- Labels of the components
const labelList componentColumns_; const labelList componentColumns_;
//- Read the next value from the split string
Type readValue(const List<string>&);
//- Separator character //- Separator character
const char separator_; const char separator_;
//- Merge separators flag; e.g. ',,,' becomes ','
bool mergeSeparators_;
// Private Member functions
//- Read the next value from the split string
Type readValue(const List<string>&) const;
//- Read a 1D table
virtual void read(ISstream&, List<Tuple2<scalar, Type>>&) const;
//- Read a 2D table
virtual void read
(
ISstream&,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>&
) const;
public: public:
@ -79,37 +110,21 @@ public:
// Constructors // Constructors
//- Construct from dictionary //- Construct from dictionary
csvTableReader(const dictionary& dict); Csv(const dictionary& dict);
//- Construct and return a copy //- Construct and return a copy
virtual autoPtr<tableReader<Type>> clone() const virtual autoPtr<TableReader<Type>> clone() const
{ {
return autoPtr<tableReader<Type>> return autoPtr<TableReader<Type>>(new Csv<Type>(*this));
(
new csvTableReader<Type>
(
*this
)
);
} }
//- Destructor //- Destructor
virtual ~csvTableReader(); virtual ~Csv();
// Member Functions // Member Functions
//- Read the table
virtual void operator()(const fileName&, List<Tuple2<scalar, Type>>&);
//- Read 2D table
virtual void operator()
(
const fileName&,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>&
);
//- Write the remaining parameters //- Write the remaining parameters
virtual void write(Ostream& os) const; virtual void write(Ostream& os) const;
}; };
@ -117,12 +132,13 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace TableReaders
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository #ifdef NoRepository
#include "csvTableReader.C" #include "CsvTableReader.C"
#endif #endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

61
src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.C → src/OpenFOAM/primitives/functions/Function1/TableFile/TableReader/Foam/FoamTableReader.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -23,49 +23,46 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "openFoamTableReader.H" #include "FoamTableReader.H"
#include "fileOperation.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class Type>
void Foam::TableReaders::Foam<Type>::read
(
ISstream& is,
List<Tuple2<scalar, Type>>& data
) const
{
is >> data;
}
template<class Type>
void Foam::TableReaders::Foam<Type>::read
(
ISstream& is,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>& data
) const
{
is >> data;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::openFoamTableReader<Type>::openFoamTableReader(const dictionary& dict) Foam::TableReaders::Foam<Type>::Foam(const dictionary& dict)
: :
tableReader<Type>(dict) TableReader<Type>(dict)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::openFoamTableReader<Type>::~openFoamTableReader() Foam::TableReaders::Foam<Type>::~Foam()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::openFoamTableReader<Type>::operator()
(
const fileName& fName,
List<Tuple2<scalar, Type>>& data
)
{
// Read data from file
fileHandler().NewIFstream(fName)()() >> data;
}
template<class Type>
void Foam::openFoamTableReader<Type>::operator()
(
const fileName& fName,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>& data
)
{
// Read data from file
fileHandler().NewIFstream(fName)()() >> data;
}
// ************************************************************************* // // ************************************************************************* //

74
src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.H → src/OpenFOAM/primitives/functions/Function1/TableFile/TableReader/Foam/FoamTableReader.H
View File

@ -22,89 +22,93 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::openFoamTableReader Foam::TableReaders::Foam
Description Description
Reads an interpolation table from a file - OpenFOAM-format Reads an interpolation table from a file in OpenFOAM-format. This is a list
of Tuple2's where the first (x) column is scalar, and the second (y) column
is the type to be interpolated.
Usage:
\verbatim
(
(0.0 (1 2 3))
(1.0 (4 5 6))
);
\endverbatim
SourceFiles SourceFiles
openFoamTableReader.C FoamTableReader.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef openFoamTableReader_H #ifndef FoamTableReader_H
#define openFoamTableReader_H #define FoamTableReader_H
#include "tableReader.H" #include "TableReader.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace TableReaders
{
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class openFoamTableReader Declaration Class Foam Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class Type> template<class Type>
class openFoamTableReader class Foam
: :
public tableReader<Type> public TableReader<Type>
{ {
// Private Member Functions
//- Read a 1D table
virtual void read(ISstream&, List<Tuple2<scalar, Type>> &) const;
//- Read a 2D table
virtual void read
(
ISstream&,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>&
) const;
public: public:
//- Runtime type information //- Runtime type information
TypeName("openFoam"); TypeName("foam");
// Constructors // Constructors
//- Construct from dictionary //- Construct from dictionary
openFoamTableReader(const dictionary &dict); Foam(const dictionary &dict);
//- Construct and return a copy //- Construct and return a copy
virtual autoPtr<tableReader<Type>> clone() const virtual autoPtr<TableReader<Type>> clone() const
{ {
return autoPtr<tableReader<Type>> return autoPtr<TableReader<Type>>(new Foam<Type>(*this));
(
new openFoamTableReader<Type>
(
*this
)
);
} }
//- Destructor //- Destructor
virtual ~openFoamTableReader(); virtual ~Foam();
// Member Functions
//- Read the table
virtual void operator()(const fileName&, List<Tuple2<scalar, Type>> &);
//- Read 2D table
virtual void operator()
(
const fileName&,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>&
);
}; };
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace TableReaders
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository #ifdef NoRepository
#include "openFoamTableReader.C" #include "FoamTableReader.C"
#endif #endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif #endif

63
src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.C → src/OpenFOAM/primitives/functions/Function1/TableFile/TableReader/TableReader/TableReader.C
View File

@ -23,25 +23,20 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "tableReader.H" #include "TableReader.H"
#include "fileOperation.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::autoPtr<Foam::tableReader<Type>> Foam::tableReader<Type>::New Foam::autoPtr<Foam::TableReader<Type>> Foam::TableReader<Type>::New
( (
const dictionary& spec const word& readerType,
const dictionary& dict
) )
{ {
const word readerType = spec.lookupOrDefault<word>
(
"readerType",
"openFoam"
);
typename dictionaryConstructorTable::iterator cstrIter = typename dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_ dictionaryConstructorTablePtr_->find(readerType);
->find(readerType);
if (cstrIter == dictionaryConstructorTablePtr_->end()) if (cstrIter == dictionaryConstructorTablePtr_->end())
{ {
@ -53,32 +48,64 @@ Foam::autoPtr<Foam::tableReader<Type>> Foam::tableReader<Type>::New
<< exit(FatalError); << exit(FatalError);
} }
return autoPtr<tableReader<Type>>(cstrIter()(spec)); return autoPtr<TableReader<Type>>(cstrIter()(dict));
} }
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::tableReader<Type>::tableReader(const dictionary&) Foam::TableReader<Type>::TableReader(const dictionary&)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::tableReader<Type>::~tableReader() Foam::TableReader<Type>::~TableReader()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::tableReader<Type>::write(Ostream& os) const void Foam::TableReader<Type>::write(Ostream& os) const
{}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class Type>
template<class TableType>
void Foam::TableReader<Type>::operator()
(
const fileName& fName,
TableType& data
) const
{ {
if (this->type() != "openFoam") // Expand the file
fileName fNameExpanded(fName);
fNameExpanded.expand();
// Open a stream and check it
autoPtr<ISstream> isPtr(fileHandler().NewIFstream(fNameExpanded));
ISstream& is = isPtr();
if (!is.good())
{ {
writeEntry(os, "readerType", this->type()); FatalIOErrorInFunction(is)
<< "Cannot open file" << fName << nl
<< exit(FatalIOError);
}
// Read data from the stream
read(is, data);
// Check something was read
if (data.empty())
{
FatalIOErrorInFunction(is)
<< "Table read from " << fName << " is empty" << nl
<< exit(FatalIOError);
} }
} }

99
src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.H → src/OpenFOAM/primitives/functions/Function1/TableFile/TableReader/TableReader/TableReader.H
View File

@ -22,27 +22,22 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::tableReader Foam::TableReader
Description Description
Base class to read table data for the interpolationTable Base class to read table data for tables
SourceFiles SourceFiles
tableReader.C TableReader.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef tableReader_H #ifndef TableReader_H
#define tableReader_H #define TableReader_H
#include "fileName.H"
#include "wordList.H"
#include "vector.H"
#include "tensor.H"
#include "typeInfo.H"
#include "runTimeSelectionTables.H"
#include "autoPtr.H"
#include "dictionary.H" #include "dictionary.H"
#include "fieldTypes.H"
#include "runTimeSelectionTables.H"
#include "Tuple2.H" #include "Tuple2.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -51,24 +46,42 @@ namespace Foam
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class tableReader Declaration Class TableReader Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class Type> template<class Type>
class tableReader class TableReader
{ {
private:
// Private Member Functions
//- Read a 1D table
virtual void read
(
ISstream&,
List<Tuple2<scalar, Type>>&
) const = 0;
//- Read a 2D table
virtual void read
(
ISstream&,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>&
) const = 0;
public: public:
//- Runtime type information //- Runtime type information
TypeName("tableReader"); TypeName("TableReader");
// Declare run-time constructor selection table // Declare run-time constructor selection table
declareRunTimeSelectionTable declareRunTimeSelectionTable
( (
autoPtr, autoPtr,
tableReader, TableReader,
dictionary, dictionary,
(const dictionary& dict), (const dictionary& dict),
(dict) (dict)
@ -78,37 +91,29 @@ public:
// Constructors // Constructors
//- Construct from dictionary //- Construct from dictionary
tableReader(const dictionary& dict); TableReader(const dictionary& dict);
//- Construct and return a clone //- Construct and return a clone
virtual autoPtr<tableReader<Type>> clone() const = 0; virtual autoPtr<TableReader<Type>> clone() const = 0;
// Selectors // Selector
static autoPtr<TableReader<Type>> New
//- Return a reference to the selected tableReader (
static autoPtr<tableReader> New(const dictionary& spec); const word& readerType,
const dictionary& dict
);
//- Destructor //- Destructor
virtual ~tableReader(); virtual ~TableReader();
// Member Functions // Member Functions
//- Read the table //- Read a table
virtual void operator() template<class TableType>
( void operator()(const fileName&, TableType&) const;
const fileName&,
List<Tuple2<scalar, Type>>&
) = 0;
//- Read the 2D table
virtual void operator()
(
const fileName&,
List<Tuple2<scalar, List<Tuple2<scalar, Type>>>>&
) = 0;
//- Write additional information //- Write additional information
virtual void write(Ostream& os) const; virtual void write(Ostream& os) const;
@ -121,11 +126,27 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository #define defineTableReader(Type) \
#include "tableReader.C" \
#endif defineNamedTemplateTypeNameAndDebug(TableReader<Type>, 0); \
\
defineTemplateRunTimeSelectionTable(TableReader<Type>, dictionary);
#define makeTableReader(SS, Type) \
\
defineNamedTemplateTypeNameAndDebug(TableReaders::SS<Type>, 0); \
\
TableReader<Type>::adddictionaryConstructorToTable<TableReaders::SS<Type>> \
add##SS##Type##ConstructorToTable_;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "TableReader.C"
#include "FoamTableReader.H"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif #endif

18
src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReaders.C → src/OpenFOAM/primitives/functions/Function1/TableFile/TableReader/makeTableReaders.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -23,15 +23,25 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "csvTableReader.H" #include "FoamTableReader.H"
#include "tableReaders.H" #include "CsvTableReader.H"
#include "fieldTypes.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define makeTableReaders(Type) \
defineTableReader(Type); \
makeTableReader(Foam, Type); \
makeTableReader(Csv, Type)
namespace Foam namespace Foam
{ {
makeTableReaders(csvTableReader); makeTableReaders(scalar);
makeTableReaders(vector);
makeTableReaders(sphericalTensor);
makeTableReaders(symmTensor);
makeTableReaders(tensor);
} }
// ************************************************************************* // // ************************************************************************* //

4
src/OpenFOAM/primitives/functions/Function1/Uniform/Uniform.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::Uniform<Type>::Uniform Foam::Function1s::Uniform<Type>::Uniform
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict

6
src/OpenFOAM/primitives/functions/Function1/Uniform/Uniform.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::Uniform Foam::Function1s::Uniform
Description Description
Templated function that returns a constant value. Templated function that returns a constant value.
@ -49,7 +49,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -83,7 +83,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

10
src/OpenFOAM/primitives/functions/Function1/Zero/ZeroConstant.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,27 +28,27 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::ZeroConstant<Type>::ZeroConstant Foam::Function1s::ZeroConstant<Type>::ZeroConstant
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
Function1<Type>(entryName) FieldFunction1<Type, ZeroConstant<Type>>(entryName)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type> template<class Type>
Foam::Function1Types::ZeroConstant<Type>::~ZeroConstant() Foam::Function1s::ZeroConstant<Type>::~ZeroConstant()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
void Foam::Function1Types::ZeroConstant<Type>::writeData(Ostream& os) const void Foam::Function1s::ZeroConstant<Type>::writeData(Ostream& os) const
{ {
Function1<Type>::writeData(os); Function1<Type>::writeData(os);

8
src/OpenFOAM/primitives/functions/Function1/Zero/ZeroConstant.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::ZeroConstant Foam::Function1s::ZeroConstant
Description Description
Templated function that returns the corresponding 0 (zero). Templated function that returns the corresponding 0 (zero).
@ -46,7 +46,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -56,7 +56,7 @@ namespace Function1Types
template<class Type> template<class Type>
class ZeroConstant class ZeroConstant
: :
public Function1<Type> public FieldFunction1<Type, ZeroConstant<Type>>
{ {
public: public:
@ -96,7 +96,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

6
src/OpenFOAM/primitives/functions/Function1/Zero/ZeroConstantI.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type> template<class Type>
inline Type Foam::Function1Types::ZeroConstant<Type>::value inline Type Foam::Function1s::ZeroConstant<Type>::value
( (
const scalar x const scalar x
) const ) const
@ -38,7 +38,7 @@ inline Type Foam::Function1Types::ZeroConstant<Type>::value
template<class Type> template<class Type>
inline Type Foam::Function1Types::ZeroConstant<Type>::integrate inline Type Foam::Function1s::ZeroConstant<Type>::integrate
( (
const scalar x1, const scalar x1,
const scalar x2 const scalar x2

10
src/OpenFOAM/primitives/functions/Function1/halfCosineRamp/halfCosineRamp.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -29,7 +29,7 @@ License
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
makeScalarFunction1(halfCosineRamp); makeScalarFunction1(halfCosineRamp);
} }
@ -38,19 +38,19 @@ namespace Function1Types
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::Function1Types::halfCosineRamp::halfCosineRamp Foam::Function1s::halfCosineRamp::halfCosineRamp
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
ramp(entryName, dict) Ramp<halfCosineRamp>(entryName, dict)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::Function1Types::halfCosineRamp::~halfCosineRamp() Foam::Function1s::halfCosineRamp::~halfCosineRamp()
{} {}

12
src/OpenFOAM/primitives/functions/Function1/halfCosineRamp/halfCosineRamp.H
View File

@ -22,14 +22,14 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::halfCosineRamp Foam::Function1s::halfCosineRamp
Description Description
Half-cosine ramp function starting from 0 and increasing to 1 from \c start Half-cosine ramp function starting from 0 and increasing to 1 from \c start
over the \c duration and remaining at 1 thereafter. over the \c duration and remaining at 1 thereafter.
See also See also
Foam::Function1Types::ramp Foam::Function1s::Ramp
SourceFiles SourceFiles
halfCosineRamp.C halfCosineRamp.C
@ -39,13 +39,13 @@ SourceFiles
#ifndef halfCosineRamp_H #ifndef halfCosineRamp_H
#define halfCosineRamp_H #define halfCosineRamp_H
#include "ramp.H" #include "Ramp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -54,7 +54,7 @@ namespace Function1Types
class halfCosineRamp class halfCosineRamp
: :
public ramp public Ramp<halfCosineRamp>
{ {
public: public:
@ -99,7 +99,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/primitives/functions/Function1/halfCosineRamp/halfCosineRampI.H
View File

@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::scalar Foam::Function1Types::halfCosineRamp::value inline Foam::scalar Foam::Function1s::halfCosineRamp::value
( (
const scalar t const scalar t
) const ) const
@ -37,7 +37,7 @@ inline Foam::scalar Foam::Function1Types::halfCosineRamp::value
} }
inline Foam::scalar Foam::Function1Types::halfCosineRamp::integrate inline Foam::scalar Foam::Function1s::halfCosineRamp::integrate
( (
const scalar t1, const scalar t1,
const scalar t2 const scalar t2

10
src/OpenFOAM/primitives/functions/Function1/linearRamp/linearRamp.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -29,7 +29,7 @@ License
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
makeScalarFunction1(linearRamp); makeScalarFunction1(linearRamp);
} }
@ -38,19 +38,19 @@ namespace Function1Types
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::Function1Types::linearRamp::linearRamp Foam::Function1s::linearRamp::linearRamp
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
ramp(entryName, dict) Ramp<linearRamp>(entryName, dict)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::Function1Types::linearRamp::~linearRamp() Foam::Function1s::linearRamp::~linearRamp()
{} {}

12
src/OpenFOAM/primitives/functions/Function1/linearRamp/linearRamp.H
View File

@ -22,14 +22,14 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::linearRamp Foam::Function1s::linearRamp
Description Description
Linear ramp function starting from 0 and increasing linearRamply to 1 from Linear ramp function starting from 0 and increasing linearRamply to 1 from
\c start over the \c duration and remaining at 1 thereafter. \c start over the \c duration and remaining at 1 thereafter.
See also See also
Foam::Function1Types::ramp Foam::Function1s::Ramp
SourceFiles SourceFiles
linearRamp.C linearRamp.C
@ -39,13 +39,13 @@ SourceFiles
#ifndef linearRamp_H #ifndef linearRamp_H
#define linearRamp_H #define linearRamp_H
#include "ramp.H" #include "Ramp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -54,7 +54,7 @@ namespace Function1Types
class linearRamp class linearRamp
: :
public ramp public Ramp<linearRamp>
{ {
public: public:
@ -99,7 +99,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

9
src/OpenFOAM/primitives/functions/Function1/linearRamp/linearRampI.H
View File

@ -27,22 +27,23 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::scalar Foam::Function1Types::linearRamp::value inline Foam::scalar Foam::Function1s::linearRamp::value
( (
const scalar t const scalar t
) const ) const
{ {
return ramp::linearRamp(t); return Ramp<linearRamp>::linearRamp(t);
} }
inline Foam::scalar Foam::Function1Types::linearRamp::integrate inline Foam::scalar Foam::Function1s::linearRamp::integrate
( (
const scalar t1, const scalar t1,
const scalar t2 const scalar t2
) const ) const
{ {
const scalar l1 = ramp::linearRamp(t1), l2 = ramp::linearRamp(t2); const scalar l1 = Ramp<linearRamp>::linearRamp(t1);
const scalar l2 = Ramp<linearRamp>::linearRamp(t2);
return return
(sqr(l2) - sqr(l1))/2/dLinearRampDt() (sqr(l2) - sqr(l1))/2/dLinearRampDt()

18
src/OpenFOAM/primitives/functions/Function1/makeFunction1s.C
View File

@ -30,7 +30,6 @@ License
#include "PolynomialEntry.H" #include "PolynomialEntry.H"
#include "Sine.H" #include "Sine.H"
#include "Square.H" #include "Square.H"
#include "CSV.H"
#include "Table.H" #include "Table.H"
#include "TableFile.H" #include "TableFile.H"
#include "Scale.H" #include "Scale.H"
@ -48,7 +47,6 @@ License
makeFunction1Type(Polynomial, Type); \ makeFunction1Type(Polynomial, Type); \
makeFunction1Type(Sine, Type); \ makeFunction1Type(Sine, Type); \
makeFunction1Type(Square, Type); \ makeFunction1Type(Square, Type); \
makeFunction1Type(CSV, Type); \
makeFunction1Type(Table, Type); \ makeFunction1Type(Table, Type); \
makeFunction1Type(TableFile, Type); \ makeFunction1Type(TableFile, Type); \
makeFunction1Type(Scale, Type); makeFunction1Type(Scale, Type);
@ -66,20 +64,4 @@ namespace Foam
} }
template<>
Foam::tmp<Foam::Field<Foam::label>>
Foam::Function1Types::Constant<Foam::label>::integrate
(
const scalarField& x1,
const scalarField& x2
) const
{
FatalErrorInFunction
<< "Evaluation is not defined for " << type() << " functions"
<< exit(FatalError);
return tmp<Field<label>>(new Field<label>(x1.size()));
}
// ************************************************************************* // // ************************************************************************* //

10
src/OpenFOAM/primitives/functions/Function1/quadraticRamp/quadraticRamp.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -29,7 +29,7 @@ License
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
makeScalarFunction1(quadraticRamp); makeScalarFunction1(quadraticRamp);
} }
@ -38,19 +38,19 @@ namespace Function1Types
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::Function1Types::quadraticRamp::quadraticRamp Foam::Function1s::quadraticRamp::quadraticRamp
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
ramp(entryName, dict) Ramp<quadraticRamp>(entryName, dict)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::Function1Types::quadraticRamp::~quadraticRamp() Foam::Function1s::quadraticRamp::~quadraticRamp()
{} {}

12
src/OpenFOAM/primitives/functions/Function1/quadraticRamp/quadraticRamp.H
View File

@ -22,14 +22,14 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::quadraticRamp Foam::Function1s::quadraticRamp
Description Description
Quadratic ramp function starting from 0 and increasing quadraticRampally Quadratic ramp function starting from 0 and increasing quadraticRampally
to 1 from \c t_0 over the \c duration and remaining at 1 thereafter. to 1 from \c t_0 over the \c duration and remaining at 1 thereafter.
See also See also
Foam::Function1Types::ramp Foam::Function1s::Ramp
SourceFiles SourceFiles
quadraticRamp.C quadraticRamp.C
@ -39,13 +39,13 @@ SourceFiles
#ifndef quadraticRamp_H #ifndef quadraticRamp_H
#define quadraticRamp_H #define quadraticRamp_H
#include "ramp.H" #include "Ramp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -54,7 +54,7 @@ namespace Function1Types
class quadraticRamp class quadraticRamp
: :
public ramp public Ramp<quadraticRamp>
{ {
public: public:
@ -99,7 +99,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/primitives/functions/Function1/quadraticRamp/quadraticRampI.H
View File

@ -27,7 +27,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::scalar Foam::Function1Types::quadraticRamp::value inline Foam::scalar Foam::Function1s::quadraticRamp::value
( (
const scalar t const scalar t
) const ) const
@ -36,7 +36,7 @@ inline Foam::scalar Foam::Function1Types::quadraticRamp::value
} }
inline Foam::scalar Foam::Function1Types::quadraticRamp::integrate inline Foam::scalar Foam::Function1s::quadraticRamp::integrate
( (
const scalar t1, const scalar t1,
const scalar t2 const scalar t2

10
src/OpenFOAM/primitives/functions/Function1/quarterCosineRamp/quarterCosineRamp.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -29,7 +29,7 @@ License
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
makeScalarFunction1(quarterCosineRamp); makeScalarFunction1(quarterCosineRamp);
} }
@ -38,19 +38,19 @@ namespace Function1Types
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::Function1Types::quarterCosineRamp::quarterCosineRamp Foam::Function1s::quarterCosineRamp::quarterCosineRamp
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
ramp(entryName, dict) Ramp<quarterCosineRamp>(entryName, dict)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::Function1Types::quarterCosineRamp::~quarterCosineRamp() Foam::Function1s::quarterCosineRamp::~quarterCosineRamp()
{} {}

12
src/OpenFOAM/primitives/functions/Function1/quarterCosineRamp/quarterCosineRamp.H
View File

@ -22,14 +22,14 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::quarterCosineRamp Foam::Function1s::quarterCosineRamp
Description Description
Quarter-cosine ramp function starting from 0 and increasing to 1 from \c Quarter-cosine ramp function starting from 0 and increasing to 1 from \c
start over the \c duration and remaining at 1 thereafter. start over the \c duration and remaining at 1 thereafter.
See also See also
Foam::Function1Types::ramp Foam::Function1s::Ramp
SourceFiles SourceFiles
quarterCosineRamp.C quarterCosineRamp.C
@ -39,13 +39,13 @@ SourceFiles
#ifndef quarterCosineRamp_H #ifndef quarterCosineRamp_H
#define quarterCosineRamp_H #define quarterCosineRamp_H
#include "ramp.H" #include "Ramp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -54,7 +54,7 @@ namespace Function1Types
class quarterCosineRamp class quarterCosineRamp
: :
public ramp public Ramp<quarterCosineRamp>
{ {
public: public:
@ -99,7 +99,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/primitives/functions/Function1/quarterCosineRamp/quarterCosineRampI.H
View File

@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::scalar Foam::Function1Types::quarterCosineRamp::value inline Foam::scalar Foam::Function1s::quarterCosineRamp::value
( (
const scalar t const scalar t
) const ) const
@ -37,7 +37,7 @@ inline Foam::scalar Foam::Function1Types::quarterCosineRamp::value
} }
inline Foam::scalar Foam::Function1Types::quarterCosineRamp::integrate inline Foam::scalar Foam::Function1s::quarterCosineRamp::integrate
( (
const scalar t1, const scalar t1,
const scalar t2 const scalar t2

10
src/OpenFOAM/primitives/functions/Function1/quarterSineRamp/quarterSineRamp.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -29,7 +29,7 @@ License
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
makeScalarFunction1(quarterSineRamp); makeScalarFunction1(quarterSineRamp);
} }
@ -38,19 +38,19 @@ namespace Function1Types
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::Function1Types::quarterSineRamp::quarterSineRamp Foam::Function1s::quarterSineRamp::quarterSineRamp
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
ramp(entryName, dict) Ramp<quarterSineRamp>(entryName, dict)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::Function1Types::quarterSineRamp::~quarterSineRamp() Foam::Function1s::quarterSineRamp::~quarterSineRamp()
{} {}

12
src/OpenFOAM/primitives/functions/Function1/quarterSineRamp/quarterSineRamp.H
View File

@ -22,14 +22,14 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::quarterSineRamp Foam::Function1s::quarterSineRamp
Description Description
Quarter-sine ramp function starting from 0 and increasing to 1 from \c start Quarter-sine ramp function starting from 0 and increasing to 1 from \c start
over the \c duration and remaining at 1 thereafter. over the \c duration and remaining at 1 thereafter.
See also See also
Foam::Function1Types::ramp Foam::Function1s::Ramp
SourceFiles SourceFiles
quarterSineRamp.C quarterSineRamp.C
@ -39,13 +39,13 @@ SourceFiles
#ifndef quarterSineRamp_H #ifndef quarterSineRamp_H
#define quarterSineRamp_H #define quarterSineRamp_H
#include "ramp.H" #include "Ramp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -54,7 +54,7 @@ namespace Function1Types
class quarterSineRamp class quarterSineRamp
: :
public ramp public Ramp<quarterSineRamp>
{ {
public: public:
@ -99,7 +99,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/primitives/functions/Function1/quarterSineRamp/quarterSineRampI.H
View File

@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::scalar Foam::Function1Types::quarterSineRamp::value inline Foam::scalar Foam::Function1s::quarterSineRamp::value
( (
const scalar t const scalar t
) const ) const
@ -37,7 +37,7 @@ inline Foam::scalar Foam::Function1Types::quarterSineRamp::value
} }
inline Foam::scalar Foam::Function1Types::quarterSineRamp::integrate inline Foam::scalar Foam::Function1s::quarterSineRamp::integrate
( (
const scalar t1, const scalar t1,
const scalar t2 const scalar t2

30
src/OpenFOAM/primitives/functions/Function1/ramp/rampI.H
View File

@ -1,30 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "hmm.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// ************************************************************************* //

16
src/OpenFOAM/primitives/functions/Function1/reverseRamp/reverseRamp.C
View File

@ -29,7 +29,7 @@ License
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
makeScalarFunction1(reverseRamp); makeScalarFunction1(reverseRamp);
} }
@ -38,38 +38,38 @@ namespace Function1Types
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::Function1Types::reverseRamp::reverseRamp Foam::Function1s::reverseRamp::reverseRamp
( (
const word& entryName, const word& entryName,
const dictionary& dict const dictionary& dict
) )
: :
ramp(entryName, dict), Ramp<reverseRamp>(entryName, dict),
ramp_(Function1<scalar>::New("ramp", dict)) ramp_(Function1<scalar>::New("ramp", dict))
{} {}
Foam::Function1Types::reverseRamp::reverseRamp Foam::Function1s::reverseRamp::reverseRamp
( (
const reverseRamp& rr const reverseRamp& rr
) )
: :
ramp(rr), Ramp<reverseRamp>(rr),
ramp_(rr.ramp_, false) ramp_(rr.ramp_, false)
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::Function1Types::reverseRamp::~reverseRamp() Foam::Function1s::reverseRamp::~reverseRamp()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::Function1Types::reverseRamp::writeData(Ostream& os) const void Foam::Function1s::reverseRamp::writeData(Ostream& os) const
{ {
ramp::writeData(os); Ramp<reverseRamp>::writeData(os);
os << token::END_STATEMENT << nl; os << token::END_STATEMENT << nl;
os << indent << word(this->name() + "Coeffs") << nl; os << indent << word(this->name() + "Coeffs") << nl;
os << indent << token::BEGIN_BLOCK << incrIndent << nl; os << indent << token::BEGIN_BLOCK << incrIndent << nl;

12
src/OpenFOAM/primitives/functions/Function1/reverseRamp/reverseRamp.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::Function1Types::reverseRamp Foam::Function1s::reverseRamp
Description Description
A wrapper class to reverse any ramp function such that the result starts A wrapper class to reverse any ramp function such that the result starts
@ -56,7 +56,7 @@ Description
\endverbatim \endverbatim
See also See also
Foam::Function1Types::ramp Foam::Function1s::Ramp
SourceFiles SourceFiles
reverseRamp.C reverseRamp.C
@ -66,13 +66,13 @@ SourceFiles
#ifndef reverseRamp_H #ifndef reverseRamp_H
#define reverseRamp_H #define reverseRamp_H
#include "ramp.H" #include "Ramp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
namespace Function1Types namespace Function1s
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -81,7 +81,7 @@ namespace Function1Types
class reverseRamp class reverseRamp
: :
public ramp public Ramp<reverseRamp>
{ {
//- Standard ramp function to reverse //- Standard ramp function to reverse
autoPtr<Function1<scalar>> ramp_; autoPtr<Function1<scalar>> ramp_;
@ -135,7 +135,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types } // End namespace Function1s
} // End namespace Foam } // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/primitives/functions/Function1/reverseRamp/reverseRampI.H
View File

@ -27,7 +27,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::scalar Foam::Function1Types::reverseRamp::value inline Foam::scalar Foam::Function1s::reverseRamp::value
( (
const scalar t const scalar t
) const ) const
@ -36,7 +36,7 @@ inline Foam::scalar Foam::Function1Types::reverseRamp::value
} }
inline Foam::scalar Foam::Function1Types::reverseRamp::integrate inline Foam::scalar Foam::Function1s::reverseRamp::integrate
( (
const scalar t1, const scalar t1,
const scalar t2 const scalar t2

6
src/dynamicMesh/motionSolvers/displacement/layeredSolver/displacementLayeredMotionMotionSolver.C
View File

@ -29,7 +29,7 @@ License
#include "pointFields.H" #include "pointFields.H"
#include "PointEdgeWave.H" #include "PointEdgeWave.H"
#include "syncTools.H" #include "syncTools.H"
#include "interpolationTable.H" #include "TableFile.H"
#include "pointConstraints.H" #include "pointConstraints.H"
#include "mapPolyMesh.H" #include "mapPolyMesh.H"
@ -233,9 +233,9 @@ Foam::displacementLayeredMotionMotionSolver::faceZoneEvaluate
} }
else if (type == "timeVaryingUniformFixedValue") else if (type == "timeVaryingUniformFixedValue")
{ {
interpolationTable<vector> timeSeries(dict); Function1s::TableFile<vector> timeSeries(word::null, dict);
fld = timeSeries(mesh().time().timeOutputValue()); fld = timeSeries.value(mesh().time().timeOutputValue());
} }
else if (type == "slip") else if (type == "slip")
{ {

2
src/finiteVolume/fields/fvPatchFields/derived/cylindricalInletVelocity/cylindricalInletVelocityFvPatchVectorField.H
View File

@ -59,7 +59,7 @@ Note
See also See also
Foam::fixedValueFvPatchField Foam::fixedValueFvPatchField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
cylindricalInletVelocityFvPatchVectorField.C cylindricalInletVelocityFvPatchVectorField.C

12
src/finiteVolume/fields/fvPatchFields/derived/fanPressure/fanPressureFvPatchScalarField.C
View File

@ -74,7 +74,7 @@ Foam::fanPressureFvPatchScalarField::fanPressureFvPatchScalarField
) )
: :
totalPressureFvPatchScalarField(ptf, p, iF, mapper), totalPressureFvPatchScalarField(ptf, p, iF, mapper),
fanCurve_(ptf.fanCurve_), fanCurve_(ptf.fanCurve_, false),
direction_(ptf.direction_) direction_(ptf.direction_)
{} {}
@ -87,7 +87,7 @@ Foam::fanPressureFvPatchScalarField::fanPressureFvPatchScalarField
) )
: :
totalPressureFvPatchScalarField(p, iF, dict), totalPressureFvPatchScalarField(p, iF, dict),
fanCurve_(dict), fanCurve_(Function1<scalar>::New("fanCurve", dict)),
direction_(fanFlowDirectionNames_.read(dict.lookup("direction"))) direction_(fanFlowDirectionNames_.read(dict.lookup("direction")))
{} {}
@ -98,7 +98,7 @@ Foam::fanPressureFvPatchScalarField::fanPressureFvPatchScalarField
) )
: :
totalPressureFvPatchScalarField(pfopsf), totalPressureFvPatchScalarField(pfopsf),
fanCurve_(pfopsf.fanCurve_), fanCurve_(pfopsf.fanCurve_, false),
direction_(pfopsf.direction_) direction_(pfopsf.direction_)
{} {}
@ -110,7 +110,7 @@ Foam::fanPressureFvPatchScalarField::fanPressureFvPatchScalarField
) )
: :
totalPressureFvPatchScalarField(pfopsf, iF), totalPressureFvPatchScalarField(pfopsf, iF),
fanCurve_(pfopsf.fanCurve_), fanCurve_(pfopsf.fanCurve_, false),
direction_(pfopsf.direction_) direction_(pfopsf.direction_)
{} {}
@ -157,7 +157,7 @@ void Foam::fanPressureFvPatchScalarField::updateCoeffs()
} }
// Pressure drop for this flow rate // Pressure drop for this flow rate
const scalar pdFan = fanCurve_(max(volFlowRate, 0.0)); const scalar pdFan = fanCurve_->value(max(volFlowRate, 0.0));
totalPressureFvPatchScalarField::updateCoeffs totalPressureFvPatchScalarField::updateCoeffs
( (
@ -170,7 +170,7 @@ void Foam::fanPressureFvPatchScalarField::updateCoeffs()
void Foam::fanPressureFvPatchScalarField::write(Ostream& os) const void Foam::fanPressureFvPatchScalarField::write(Ostream& os) const
{ {
totalPressureFvPatchScalarField::write(os); totalPressureFvPatchScalarField::write(os);
fanCurve_.write(os); writeEntry(os, fanCurve_());
writeEntry(os, "direction", fanFlowDirectionNames_[direction_]); writeEntry(os, "direction", fanFlowDirectionNames_[direction_]);
} }

52
src/finiteVolume/fields/fvPatchFields/derived/fanPressure/fanPressureFvPatchScalarField.H
View File

@ -31,9 +31,7 @@ Description
Usage Usage
\table \table
Property | Description | Required | Default value Property | Description | Required | Default value
file | fan curve file name | yes | fanCurve | fan curve file name | yes |
outOfBounds | out of bounds handling | yes |
direction | direction of flow through fan [in/out] | yes |
p0 | environmental total pressure | yes | p0 | environmental total pressure | yes |
\endtable \endtable
@ -42,8 +40,19 @@ Usage
inlet inlet
{ {
type fanPressure; type fanPressure;
file "fanCurve"; fanCurve tableFile;
outOfBounds clamp; tableFileCoeffs
{
file "$FOAM_CASE/constant/pressureVsQ";
format csv;
nHeaderLine 1;
refColumn 0;
componentColumns 1(1);
separator ",";
mergeSeparators no;
outOfBounds clamp;
interpolationScheme linear;
}
direction in; direction in;
p0 uniform 0; p0 uniform 0;
value uniform 0; value uniform 0;
@ -52,18 +61,31 @@ Usage
outlet outlet
{ {
type fanPressure; type fanPressure;
file "fanCurve"; fanCurve tableFile;
outOfBounds clamp; tableFileCoeffs
{
file "$FOAM_CASE/constant/pressureVsQ";
format csv;
nHeaderLine 1;
refColumn 0;
componentColumns 1(1);
separator ",";
mergeSeparators no;
outOfBounds clamp;
interpolationScheme linear;
}
direction out; direction out;
p0 uniform 0; p0 uniform 0;
value uniform 0; value uniform 0;
} }
\endverbatim \endverbatim
The above example shows the use of a comma separated (CSV) file to specify
the condition.
See also See also
Foam::fanFvPatchField
Foam::totalPressureFvPatchScalarField Foam::totalPressureFvPatchScalarField
Foam::interpolationTable Foam::Function1s
SourceFiles SourceFiles
fanPressureFvPatchScalarField.C fanPressureFvPatchScalarField.C
@ -74,7 +96,7 @@ SourceFiles
#define fanPressureFvPatchScalarField_H #define fanPressureFvPatchScalarField_H
#include "totalPressureFvPatchScalarField.H" #include "totalPressureFvPatchScalarField.H"
#include "interpolationTable.H" #include "TableFile.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -89,9 +111,10 @@ class fanPressureFvPatchScalarField
: :
public totalPressureFvPatchScalarField public totalPressureFvPatchScalarField
{ {
public: public:
// Public Enumerations
//- Fan flow direction //- Fan flow direction
enum fanFlowDirection enum fanFlowDirection
{ {
@ -107,8 +130,8 @@ private:
// Private Data // Private Data
//- Tabulated fan curve //- Fan curve
interpolationTable<scalar> fanCurve_; autoPtr<Function1<scalar>> fanCurve_;
//- Direction of flow through the fan relative to patch //- Direction of flow through the fan relative to patch
fanFlowDirection direction_; fanFlowDirection direction_;
@ -137,8 +160,7 @@ public:
const dictionary& const dictionary&
); );
//- Construct by mapping given //- Construct by mapping given fanPressureFvPatchScalarField
// fanPressureFvPatchScalarField
// onto a new patch // onto a new patch
fanPressureFvPatchScalarField fanPressureFvPatchScalarField
( (

24
src/finiteVolume/fields/fvPatchFields/derived/fanPressureJump/fanPressureJumpFvPatchScalarField.H
View File

@ -39,10 +39,10 @@ Description
Usage Usage
\table \table
Property | Description | Required | Default value Property | Description | Required | Default value
patchType | underlying patch type should be \c cyclic| yes | patchType | underlying patch type (should be \c cyclic) | yes |
fanCurve | fan curve, e.g. \c csvFile | yes | fanCurve | fan curve function | yes |
jumpTable | jump data (backward compatibility mode) | no | jumpTable | jump table function (backward compatibility mode) | no |
reverse | reverse jump direction | no | false reverse | reverse jump direction | no | false
phi | flux field name | no | phi phi | flux field name | no | phi
rho | density field name | no | rho rho | density field name | no | rho
\endtable \endtable
@ -51,16 +51,20 @@ Usage
\verbatim \verbatim
<patchName> <patchName>
{ {
type fan; type fanPressureJump;
patchType cyclic; patchType cyclic;
fanCurve csvFile; fanCurve tableFile;
csvFileCoeffs tableFileCoeffs
{ {
hasHeaderLine 1; file "$FOAM_CASE/constant/pressureVsQ";
format csv;
nHeaderLine 1;
refColumn 0; refColumn 0;
componentColumns 1(1); componentColumns 1(1);
separator ","; separator ",";
file "$FOAM_CASE/constant/pressureVsQ"; mergeSeparators no;
outOfBounds clamp;
interpolationScheme linear;
} }
value uniform 0; value uniform 0;
} }
@ -73,7 +77,7 @@ Note
The underlying \c patchType should be set to \c cyclic The underlying \c patchType should be set to \c cyclic
See also See also
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
fanPressureJumpFvPatchScalarField.C fanPressureJumpFvPatchScalarField.C

2
src/finiteVolume/fields/fvPatchFields/derived/fixedMean/fixedMeanFvPatchField.H
View File

@ -46,7 +46,7 @@ Usage
See also See also
Foam::fixedValueFvPatchField Foam::fixedValueFvPatchField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
fixedMeanFvPatchField.C fixedMeanFvPatchField.C

2
src/finiteVolume/fields/fvPatchFields/derived/fixedMeanOutletInlet/fixedMeanOutletInletFvPatchField.H
View File

@ -54,7 +54,7 @@ Usage
See also See also
Foam::fixedMeanFvPatchField Foam::fixedMeanFvPatchField
Foam::outletInletFvPatchField Foam::outletInletFvPatchField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
fixedMeanOutletInletFvPatchField.C fixedMeanOutletInletFvPatchField.C

39
src/finiteVolume/fields/fvPatchFields/derived/fixedProfile/fixedProfileFvPatchField.C
View File

@ -36,8 +36,8 @@ Foam::fixedProfileFvPatchField<Type>::fixedProfileFvPatchField
: :
fixedValueFvPatchField<Type>(p, iF), fixedValueFvPatchField<Type>(p, iF),
profile_(), profile_(),
dir_(Zero), origin_(0),
origin_(0) direction_(Zero)
{} {}
@ -51,8 +51,8 @@ Foam::fixedProfileFvPatchField<Type>::fixedProfileFvPatchField
: :
fixedValueFvPatchField<Type>(p, iF, fld), fixedValueFvPatchField<Type>(p, iF, fld),
profile_(), profile_(),
dir_(Zero), origin_(0),
origin_(0) direction_(Zero)
{} {}
@ -66,18 +66,18 @@ Foam::fixedProfileFvPatchField<Type>::fixedProfileFvPatchField
: :
fixedValueFvPatchField<Type>(p, iF, dict, false), fixedValueFvPatchField<Type>(p, iF, dict, false),
profile_(Function1<Type>::New("profile", dict)), profile_(Function1<Type>::New("profile", dict)),
dir_(dict.lookup("direction")), origin_(readScalar(dict.lookup("origin"))),
origin_(readScalar(dict.lookup("origin"))) direction_(dict.lookup("direction"))
{ {
if (mag(dir_) < small) if (mag(direction_) == 0)
{ {
FatalErrorInFunction FatalErrorInFunction
<< "magnitude Direction must be greater than zero" << "The direction must be non-zero"
<< abort(FatalError); << abort(FatalError);
} }
// Ensure direction vector is normalized // Normalise the direction
dir_ /= mag(dir_); direction_ /= mag(direction_);
// Evaluate profile // Evaluate profile
this->evaluate(); this->evaluate();
@ -93,10 +93,10 @@ Foam::fixedProfileFvPatchField<Type>::fixedProfileFvPatchField
const fvPatchFieldMapper& mapper const fvPatchFieldMapper& mapper
) )
: :
fixedValueFvPatchField<Type>(p, iF), // Don't map fixedValueFvPatchField<Type>(p, iF), // Don't map
profile_(ptf.profile_, false), profile_(ptf.profile_, false),
dir_(ptf.dir_), origin_(ptf.origin_),
origin_(ptf.origin_) direction_(ptf.direction_)
{ {
// Evaluate profile since value not mapped // Evaluate profile since value not mapped
this->evaluate(); this->evaluate();
@ -111,8 +111,8 @@ Foam::fixedProfileFvPatchField<Type>::fixedProfileFvPatchField
: :
fixedValueFvPatchField<Type>(ptf), fixedValueFvPatchField<Type>(ptf),
profile_(ptf.profile_, false), profile_(ptf.profile_, false),
dir_(ptf.dir_), origin_(ptf.origin_),
origin_(ptf.origin_) direction_(ptf.direction_)
{} {}
@ -125,8 +125,8 @@ Foam::fixedProfileFvPatchField<Type>::fixedProfileFvPatchField
: :
fixedValueFvPatchField<Type>(ptf, iF), fixedValueFvPatchField<Type>(ptf, iF),
profile_(ptf.profile_, false), profile_(ptf.profile_, false),
dir_(ptf.dir_), origin_(ptf.origin_),
origin_(ptf.origin_) direction_(ptf.direction_)
{ {
// Evaluate the profile if defined // Evaluate the profile if defined
if (ptf.profile_.valid()) if (ptf.profile_.valid())
@ -146,7 +146,8 @@ void Foam::fixedProfileFvPatchField<Type>::updateCoeffs()
return; return;
} }
const scalarField dirCmpt((dir_ & this->patch().Cf()) - origin_); const scalarField dirCmpt((direction_ & this->patch().Cf()) - origin_);
fvPatchField<Type>::operator==(profile_->value(dirCmpt)); fvPatchField<Type>::operator==(profile_->value(dirCmpt));
fixedValueFvPatchField<Type>::updateCoeffs(); fixedValueFvPatchField<Type>::updateCoeffs();
@ -158,7 +159,7 @@ void Foam::fixedProfileFvPatchField<Type>::write(Ostream& os) const
{ {
fvPatchField<Type>::write(os); fvPatchField<Type>::write(os);
writeEntry(os, profile_()); writeEntry(os, profile_());
writeEntry(os, "direction", dir_); writeEntry(os, "direction", direction_);
writeEntry(os, "origin", origin_); writeEntry(os, "origin", origin_);
writeEntry(os, "value", *this); writeEntry(os, "value", *this);
} }

51
src/finiteVolume/fields/fvPatchFields/derived/fixedProfile/fixedProfileFvPatchField.H
View File

@ -29,10 +29,12 @@ Description
Usage Usage
\table \table
Property | Description | Required | Default value Property | Description | Required | Default value
profile | Profile Function1 | yes | profile | Profile function | yes |
direction | Profile direction | yes | direction | Direction of the line along which the profile is \\
origin | Profile origin | yes | evaluated | yes |
origin | Origin of the line along which the profile is \\
evaluated | yes |
\endtable \endtable
Example of the boundary condition specification: Example of the boundary condition specification:
@ -40,30 +42,29 @@ Usage
<patchName> <patchName>
{ {
type fixedProfile; type fixedProfile;
profile csvFile; profile tableFile;
profileCoeffs profileCoeffs
{ {
nHeaderLine 0; // Number of header lines file "UProfile";
refColumn 0; // Reference column index format csv;
componentColumns (1 2 3); // Component column indices nHeaderLine 0;
separator ","; // Optional (defaults to ",") refColumn 0;
mergeSeparators no; // Merge multiple separators componentColumns (1 2 3);
file "Uprofile.csv"; // name of csv data file separator ",";
outOfBounds clamp; // Optional out-of-bounds handling mergeSeparators no;
interpolationScheme linear; // Optional interpolation scheme outOfBounds clamp;
interpolationScheme linear;
} }
direction (0 1 0); direction (0 1 0);
origin 0; origin 0;
} }
\endverbatim \endverbatim
Example setting a parabolic inlet profile for the PitzDaily case: Example setting a parabolic inlet profile for the pitzDaily case:
\verbatim \verbatim
inlet inlet
{ {
type fixedProfile; type fixedProfile;
profile polynomial profile polynomial
( (
((1 0 0) (0 0 0)) ((1 0 0) (0 0 0))
@ -74,14 +75,8 @@ Usage
} }
\endverbatim \endverbatim
Note
The profile entry is a Function1 type. The example above gives the
usage for supplying csv file.
See also See also
Foam::fixedValueFvPatchField Foam::Function1s
Foam::Function1Types
Foam::timeVaryingMappedFixedValueFvPatchField
SourceFiles SourceFiles
fixedProfileFvPatchField.C fixedProfileFvPatchField.C
@ -110,15 +105,15 @@ class fixedProfileFvPatchField
{ {
// Private Data // Private Data
//- Profile data //- Profile function
autoPtr<Function1<Type>> profile_; autoPtr<Function1<Type>> profile_;
//- Profile direction //- Origin of the line along which the profile is evaluated
vector dir_;
//- Profile origin
scalar origin_; scalar origin_;
//- Direction of the line along which the profile is evaluated
vector direction_;
public: public:

4
src/finiteVolume/fields/fvPatchFields/derived/flowRateInletVelocity/flowRateInletVelocityFvPatchVectorField.H
View File

@ -73,7 +73,7 @@ Usage
} }
\endverbatim \endverbatim
The \c flowRate entry is a \c Function1 of time, see Foam::Function1Types. The \c flowRate entry is a \c Function1 of time, see Foam::Function1s.
Note Note
- \c rhoInlet is required for the case of a mass flow rate, where the - \c rhoInlet is required for the case of a mass flow rate, where the
@ -84,7 +84,7 @@ Note
See also See also
Foam::fixedValueFvPatchField Foam::fixedValueFvPatchField
Foam::Function1Types Foam::Function1s
Foam::flowRateOutletVelocityFvPatchVectorField Foam::flowRateOutletVelocityFvPatchVectorField
SourceFiles SourceFiles

4
src/finiteVolume/fields/fvPatchFields/derived/flowRateOutletVelocity/flowRateOutletVelocityFvPatchVectorField.H
View File

@ -68,7 +68,7 @@ Usage
} }
\endverbatim \endverbatim
The \c flowRate entry is a \c Function1 of time, see Foam::Function1Types. The \c flowRate entry is a \c Function1 of time, see Foam::Function1s.
Note Note
- \c rhoOutlet is required for the case of a mass flow rate, where the - \c rhoOutlet is required for the case of a mass flow rate, where the
@ -79,7 +79,7 @@ Note
See also See also
Foam::fixedValueFvPatchField Foam::fixedValueFvPatchField
Foam::Function1Types Foam::Function1s
Foam::flowRateInletVelocityFvPatchVectorField Foam::flowRateInletVelocityFvPatchVectorField
SourceFiles SourceFiles

2
src/finiteVolume/fields/fvPatchFields/derived/pressureInletOutletVelocity/pressureInletOutletVelocityFvPatchVectorField.H
View File

@ -51,7 +51,7 @@ Usage
\endverbatim \endverbatim
The \c tangentialVelocity entry is a Function1 of time, see The \c tangentialVelocity entry is a Function1 of time, see
Foam::Function1Types. Foam::Function1s.
Note Note
Sign conventions: Sign conventions:

2
src/finiteVolume/fields/fvPatchFields/derived/rotatingPressureInletOutletVelocity/rotatingPressureInletOutletVelocityFvPatchVectorField.H
View File

@ -60,7 +60,7 @@ Note
See also See also
Foam::pressureInletOutletVelocityFvPatchVectorField Foam::pressureInletOutletVelocityFvPatchVectorField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
rotatingPressureInletOutletVelocityFvPatchVectorField.C rotatingPressureInletOutletVelocityFvPatchVectorField.C

2
src/finiteVolume/fields/fvPatchFields/derived/rotatingTotalPressure/rotatingTotalPressureFvPatchScalarField.H
View File

@ -60,7 +60,7 @@ Usage
See also See also
Foam::totalPressureFvPatchScalarField Foam::totalPressureFvPatchScalarField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
rotatingTotalPressureFvPatchScalarField.C rotatingTotalPressureFvPatchScalarField.C

4
src/finiteVolume/fields/fvPatchFields/derived/rotatingWallVelocity/rotatingWallVelocityFvPatchVectorField.H
View File

@ -46,11 +46,11 @@ Usage
} }
\endverbatim \endverbatim
The \c omega entry is a Function1 of time, see Foam::Function1Types. The \c omega entry is a Function1 of time, see Foam::Function1s.
See also See also
Foam::fixedValueFvPatchField Foam::fixedValueFvPatchField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
rotatingWallVelocityFvPatchVectorField.C rotatingWallVelocityFvPatchVectorField.C

2
src/finiteVolume/fields/fvPatchFields/derived/swirlFlowRateInletVelocity/swirlFlowRateInletVelocityFvPatchVectorField.H
View File

@ -63,7 +63,7 @@ Note
See also See also
Foam::fixedValueFvPatchField Foam::fixedValueFvPatchField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
swirlFlowRateInletVelocityFvPatchVectorField.C swirlFlowRateInletVelocityFvPatchVectorField.C

2
src/finiteVolume/fields/fvPatchFields/derived/swirlInletVelocity/swirlInletVelocityFvPatchVectorField.H
View File

@ -59,7 +59,7 @@ Note
See also See also
Foam::fixedValueFvPatchField Foam::fixedValueFvPatchField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
swirlInletVelocityFvPatchVectorField.C swirlInletVelocityFvPatchVectorField.C

2
src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFixedValueFvPatchField.H
View File

@ -90,7 +90,7 @@ Usage
See also See also
Foam::fixedValueFvPatchField Foam::fixedValueFvPatchField
Foam::timeVaryingMappedFvPatchField Foam::timeVaryingMappedFvPatchField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
timeVaryingMappedFixedValueFvPatchField.C timeVaryingMappedFixedValueFvPatchField.C

2
src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFvPatchField/timeVaryingMappedFvPatchField.H
View File

@ -72,7 +72,7 @@ Usage
See also See also
Foam::timeVaryingMappedFixedValueFvPatchField Foam::timeVaryingMappedFixedValueFvPatchField
Foam::Function1Types Foam::Function1s
SourceFiles SourceFiles
timeVaryingMappedFvPatchField.C timeVaryingMappedFvPatchField.C

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