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

tmp: Improved reference count checks to provide better error diagnostics

Browse Source 
in case of tmp misuse.

Simplified tmp reuse pattern in field algebra to use tmp copy and
assignment rather than the complex delayed call to 'ptr()'.

Removed support for unused non-const 'REF' storage of non-tmp objects due to C++
limitation in constructor overloading: if both tmp(T&) and tmp(const T&)
constructors are provided resolution is ambiguous.

The turbulence libraries have been upgraded and '-DCONST_TMP' option
specified in the 'options' file to switch to the new 'tmp' behavior.
This commit is contained in:
Henry Weller
2016-02-24 12:47:36 +00:00
parent 5a74397fe4
commit c02bf70ea7
152 changed files with 677 additions and 789 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
applications/solvers/lagrangian/DPMFoam/DPMTurbulenceModels/Make/options
View File

@ -1,4 +1,4 @@
EXE_INC = \ EXE_INC = -DCONST_TMP \
-I$(LIB_SRC)/transportModels/compressible/lnInclude \ -I$(LIB_SRC)/transportModels/compressible/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \ -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/transportModels \ -I$(LIB_SRC)/transportModels \

2
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/PhaseSystems/MomentumTransferPhaseSystem/MomentumTransferPhaseSystem.C
View File

@ -201,7 +201,7 @@ Foam::MomentumTransferPhaseSystem<BasePhaseSystem>::Kd
{ {
if (phase1 == &phase) if (phase1 == &phase)
{ {
tKd() += K; tKd.ref() += K;
} }
Swap(phase1, phase2); Swap(phase1, phase2);

2
applications/solvers/multiphase/reactingEulerFoam/reactingMultiphaseEulerFoam/multiphaseCompressibleTurbulenceModels/Make/options
View File

@ -1,4 +1,4 @@
EXE_INC = \ EXE_INC = -DCONST_TMP \
-I../multiphaseSystem/lnInclude \ -I../multiphaseSystem/lnInclude \
-I../../phaseSystems/lnInclude \ -I../../phaseSystems/lnInclude \
-I../../interfacialModels/lnInclude\ -I../../interfacialModels/lnInclude\

2
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/Make/options
View File

@ -1,4 +1,4 @@
EXE_INC = \ EXE_INC = -DCONST_TMP \
-I../twoPhaseSystem/lnInclude \ -I../twoPhaseSystem/lnInclude \
-I../../phaseSystems/lnInclude \ -I../../phaseSystems/lnInclude \
-I../../interfacialModels/lnInclude\ -I../../interfacialModels/lnInclude\

6
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/derivedFvPatchFields/alphatPhaseChangeJayatillekeWallFunction/alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2015-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -83,7 +83,7 @@ alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::yPlusTherm
) const ) const
{ {
tmp<scalarField> typsf(new scalarField(this->size())); tmp<scalarField> typsf(new scalarField(this->size()));
scalarField& ypsf = typsf(); scalarField& ypsf = typsf.ref();
forAll(ypsf, faceI) forAll(ypsf, faceI)
{ {
@ -197,7 +197,7 @@ alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::calcAlphat
scalarField yPlusTherm(this->yPlusTherm(P, Prat)); scalarField yPlusTherm(this->yPlusTherm(P, Prat));
tmp<scalarField> talphatConv(new scalarField(this->size())); tmp<scalarField> talphatConv(new scalarField(this->size()));
scalarField& alphatConv = talphatConv(); scalarField& alphatConv = talphatConv.ref();
// Populate boundary values // Populate boundary values
forAll(alphatConv, faceI) forAll(alphatConv, faceI)

4
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/frictionalStressModel/Schaeffer/SchaefferFrictionalStress.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -132,7 +132,7 @@ Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::nu
) )
); );
volScalarField& nuf = tnu(); volScalarField& nuf = tnu.ref();
forAll(D, celli) forAll(D, celli)
{ {

3
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
View File

@ -273,7 +273,8 @@ Foam::RASModels::kineticTheoryModel::pPrime() const
) )
); );
volScalarField::GeometricBoundaryField& bpPrime = tpPrime().boundaryField(); volScalarField::GeometricBoundaryField& bpPrime =
tpPrime.ref().boundaryField();
forAll(bpPrime, patchi) forAll(bpPrime, patchi)
{ {

5
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/phasePressureModel/phasePressureModel.C
View File

@ -164,7 +164,8 @@ Foam::RASModels::phasePressureModel::pPrime() const
) )
); );
volScalarField::GeometricBoundaryField& bpPrime = tpPrime().boundaryField(); volScalarField::GeometricBoundaryField& bpPrime =
tpPrime.ref().boundaryField();
forAll(bpPrime, patchi) forAll(bpPrime, patchi)
{ {
@ -192,7 +193,7 @@ Foam::RASModels::phasePressureModel::pPrimef() const
); );
surfaceScalarField::GeometricBoundaryField& bpPrime = surfaceScalarField::GeometricBoundaryField& bpPrime =
tpPrime().boundaryField(); tpPrime.ref().boundaryField();
forAll(bpPrime, patchi) forAll(bpPrime, patchi)
{ {

2
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/Make/options
View File

@ -1,4 +1,4 @@
EXE_INC = \ EXE_INC = -DCONST_TMP \
-I../twoPhaseSystem/lnInclude \ -I../twoPhaseSystem/lnInclude \
-I../interfacialModels/lnInclude\ -I../interfacialModels/lnInclude\
-I$(LIB_SRC)/transportModels/compressible/lnInclude \ -I$(LIB_SRC)/transportModels/compressible/lnInclude \

4
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/frictionalStressModel/Schaeffer/SchaefferFrictionalStress.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -132,7 +132,7 @@ Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::nu
) )
); );
volScalarField& nuf = tnu(); volScalarField& nuf = tnu.ref();
forAll(D, celli) forAll(D, celli)
{ {

3
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
View File

@ -278,7 +278,8 @@ Foam::RASModels::kineticTheoryModel::pPrime() const
) )
); );
volScalarField::GeometricBoundaryField& bpPrime = tpPrime().boundaryField(); volScalarField::GeometricBoundaryField& bpPrime =
tpPrime.ref().boundaryField();
forAll(bpPrime, patchi) forAll(bpPrime, patchi)
{ {

5
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/phasePressureModel/phasePressureModel.C
View File

@ -170,7 +170,8 @@ Foam::RASModels::phasePressureModel::pPrime() const
) )
); );
volScalarField::GeometricBoundaryField& bpPrime = tpPrime().boundaryField(); volScalarField::GeometricBoundaryField& bpPrime =
tpPrime.ref().boundaryField();
forAll(bpPrime, patchi) forAll(bpPrime, patchi)
{ {
@ -198,7 +199,7 @@ Foam::RASModels::phasePressureModel::pPrimef() const
); );
surfaceScalarField::GeometricBoundaryField& bpPrime = surfaceScalarField::GeometricBoundaryField& bpPrime =
tpPrime().boundaryField(); tpPrime.ref().boundaryField();
forAll(bpPrime, patchi) forAll(bpPrime, patchi)
{ {

4
src/OpenFOAM/db/IOstreams/token/tokenI.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -45,7 +45,7 @@ inline void token::clear()
} }
else if (type_ == COMPOUND) else if (type_ == COMPOUND)
{ {
if (compoundTokenPtr_->okToDelete()) if (compoundTokenPtr_->unique())
{ {
delete compoundTokenPtr_; delete compoundTokenPtr_;
} }

16
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
View File

@ -390,7 +390,7 @@ operator op \
) \ ) \
); \ ); \
\ \
Foam::opFunc(tRes().field(), df1.field(), df2.field()); \ Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -415,7 +415,7 @@ operator op \
df1.dimensions() op df2.dimensions() \ df1.dimensions() op df2.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes().field(), df1.field(), df2.field()); \ Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<productType, Type2, GeoMesh>::clear(tdf2); \ reuseTmpDimensionedField<productType, Type2, GeoMesh>::clear(tdf2); \
\ \
@ -442,7 +442,7 @@ operator op \
df1.dimensions() op df2.dimensions() \ df1.dimensions() op df2.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes().field(), df1.field(), df2.field()); \ Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<productType, Type1, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<productType, Type1, GeoMesh>::clear(tdf1); \
\ \
@ -472,7 +472,7 @@ operator op \
df1.dimensions() op df2.dimensions() \ df1.dimensions() op df2.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes().field(), df1.field(), df2.field()); \ Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpTmpDimensionedField \ reuseTmpTmpDimensionedField \
<productType, Type1, Type1, Type2, GeoMesh>::clear(tdf1, tdf2); \ <productType, Type1, Type1, Type2, GeoMesh>::clear(tdf1, tdf2); \
@ -505,7 +505,7 @@ operator op \
) \ ) \
); \ ); \
\ \
Foam::opFunc(tRes().field(), df1.field(), dvs.value()); \ Foam::opFunc(tRes.ref().field(), df1.field(), dvs.value()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -542,7 +542,7 @@ operator op \
df1.dimensions() op dvs.dimensions() \ df1.dimensions() op dvs.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes().field(), df1.field(), dvs.value()); \ Foam::opFunc(tRes.ref().field(), df1.field(), dvs.value()); \
\ \
reuseTmpDimensionedField<productType, Type, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<productType, Type, GeoMesh>::clear(tdf1); \
\ \
@ -585,7 +585,7 @@ operator op \
) \ ) \
); \ ); \
\ \
Foam::opFunc(tRes().field(), dvs.value(), df1.field()); \ Foam::opFunc(tRes.ref().field(), dvs.value(), df1.field()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -621,7 +621,7 @@ operator op \
dvs.dimensions() op df1.dimensions() \ dvs.dimensions() op df1.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes().field(), dvs.value(), df1.field()); \ Foam::opFunc(tRes.ref().field(), dvs.value(), df1.field()); \
\ \
reuseTmpDimensionedField<productType, Type, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<productType, Type, GeoMesh>::clear(tdf1); \
\ \

40
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
View File

@ -50,7 +50,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), df1.field()); \ Func(tRes.ref().field(), df1.field()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -73,7 +73,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), df1.field()); \ Func(tRes.ref().field(), df1.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \
\ \
@ -106,7 +106,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), df1.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -129,7 +129,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), df1.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \
\ \
@ -163,7 +163,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), df1.field(), df2.field()); \ Func(tRes.ref().field(), df1.field(), df2.field()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -187,7 +187,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), df1.field(), df2.field()); \ Func(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \ reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \
\ \
@ -213,7 +213,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), df1.field(), df2.field()); \ Func(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \
\ \
@ -242,7 +242,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), df1.field(), df2.field()); \ Func(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpTmpDimensionedField<ReturnType, Type1, Type1, Type2, GeoMesh> \ reuseTmpTmpDimensionedField<ReturnType, Type1, Type1, Type2, GeoMesh> \
::clear(tdf1, tdf2); \ ::clear(tdf1, tdf2); \
@ -277,7 +277,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), dt1.value(), df2.field()); \ Func(tRes.ref().field(), dt1.value(), df2.field()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -312,7 +312,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), dt1.value(), df2.field()); \ Func(tRes.ref().field(), dt1.value(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \ reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \
\ \
@ -354,7 +354,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), df1.field(), dt2.value()); \ Func(tRes.ref().field(), df1.field(), dt2.value()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -389,7 +389,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Func(tRes().field(), df1.field(), dt2.value()); \ Func(tRes.ref().field(), df1.field(), dt2.value()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \
\ \
@ -438,7 +438,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), df1.field(), df2.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -462,7 +462,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), df1.field(), df2.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \ reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \
\ \
@ -488,7 +488,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), df1.field(), df2.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \
\ \
@ -517,7 +517,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), df1.field(), df2.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpTmpDimensionedField<ReturnType, Type1, Type1, Type2, GeoMesh>:: \ reuseTmpTmpDimensionedField<ReturnType, Type1, Type1, Type2, GeoMesh>:: \
clear(tdf1, tdf2); \ clear(tdf1, tdf2); \
@ -552,7 +552,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), dt1.value(), df2.field()); \ Foam::OpFunc(tRes.ref().field(), dt1.value(), df2.field()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -587,7 +587,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), dt1.value(), tdf2().field()); \ Foam::OpFunc(tRes.ref().field(), dt1.value(), tdf2().field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \ reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \
\ \
@ -629,7 +629,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), df1.field(), dt2.value()); \ Foam::OpFunc(tRes.ref().field(), df1.field(), dt2.value()); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -664,7 +664,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes().field(), tdf1().field(), dt2.value()); \ Foam::OpFunc(tRes.ref().field(), tdf1().field(), dt2.value()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \
\ \

25
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldReuseFunctions.H
View File

@ -112,10 +112,7 @@ public:
static void clear(const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1) static void clear(const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1)
{ {
if (tdf1.isTmp()) tdf1.clear();
{
tdf1.ptr();
}
} }
}; };
@ -212,10 +209,7 @@ public:
) )
{ {
tdf1.clear(); tdf1.clear();
if (tdf2.isTmp()) tdf2.clear();
{
tdf2.ptr();
}
} }
}; };
@ -267,10 +261,7 @@ public:
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2
) )
{ {
if (tdf1.isTmp()) tdf1.clear();
{
tdf1.ptr();
}
tdf2.clear(); tdf2.clear();
} }
}; };
@ -330,17 +321,9 @@ public:
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1, const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2 const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2
) )
{
if (tdf1.isTmp())
{
tdf1.ptr();
tdf2.clear();
}
else if (tdf2.isTmp())
{ {
tdf1.clear(); tdf1.clear();
tdf2.ptr(); tdf2.clear();
}
} }
}; };

40
src/OpenFOAM/fields/DimensionedFields/DimensionedScalarField/DimensionedScalarField.C
View File

@ -57,7 +57,7 @@ tmp<DimensionedField<scalar, GeoMesh>> stabilise
) )
); );
stabilise(tRes().field(), dsf.field(), ds.value()); stabilise(tRes.ref().field(), dsf.field(), ds.value());
return tRes; return tRes;
} }
@ -80,7 +80,7 @@ tmp<DimensionedField<scalar, GeoMesh>> stabilise
dsf.dimensions() + ds.dimensions() dsf.dimensions() + ds.dimensions()
); );
stabilise(tRes().field(), dsf.field(), ds.value()); stabilise(tRes.ref().field(), dsf.field(), ds.value());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);
@ -126,7 +126,7 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
) )
); );
pow(tPow().field(), dsf1.field(), dsf2.field()); pow(tPow.ref().field(), dsf1.field(), dsf2.field());
return tPow; return tPow;
} }
@ -153,7 +153,7 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
) )
); );
pow(tPow().field(), dsf1.field(), dsf2.field()); pow(tPow.ref().field(), dsf1.field(), dsf2.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf1); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf1);
@ -182,7 +182,7 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
) )
); );
pow(tPow().field(), dsf1.field(), dsf2.field()); pow(tPow.ref().field(), dsf1.field(), dsf2.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2);
@ -213,7 +213,7 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
) )
); );
pow(tPow().field(), dsf1.field(), dsf2.field()); pow(tPow.ref().field(), dsf1.field(), dsf2.field());
reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::clear reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::clear
( (
@ -247,7 +247,7 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
) )
); );
pow(tPow().field(), dsf.field(), ds.value()); pow(tPow.ref().field(), dsf.field(), ds.value());
return tPow; return tPow;
} }
@ -269,7 +269,7 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
pow(dsf.dimensions(), ds) pow(dsf.dimensions(), ds)
); );
pow(tPow().field(), dsf.field(), ds.value()); pow(tPow.ref().field(), dsf.field(), ds.value());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);
@ -319,7 +319,7 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
) )
); );
pow(tPow().field(), ds.value(), dsf.field()); pow(tPow.ref().field(), ds.value(), dsf.field());
return tPow; return tPow;
} }
@ -342,7 +342,7 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
pow(ds, dsf.dimensions()) pow(ds, dsf.dimensions())
); );
pow(tPow().field(), ds.value(), dsf.field()); pow(tPow.ref().field(), ds.value(), dsf.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);
@ -394,7 +394,7 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
) )
); );
atan2(tAtan2().field(), dsf1.field(), dsf2.field()); atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
return tAtan2; return tAtan2;
} }
@ -417,7 +417,7 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
atan2(dsf1.dimensions(), dsf2.dimensions()) atan2(dsf1.dimensions(), dsf2.dimensions())
); );
atan2(tAtan2().field(), dsf1.field(), dsf2.field()); atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf1); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf1);
@ -442,7 +442,7 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
atan2(dsf1.dimensions(), dsf2.dimensions()) atan2(dsf1.dimensions(), dsf2.dimensions())
); );
atan2(tAtan2().field(), dsf1.field(), dsf2.field()); atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2);
@ -469,7 +469,7 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
atan2(dsf1.dimensions(), dsf2.dimensions()) atan2(dsf1.dimensions(), dsf2.dimensions())
); );
atan2(tAtan2().field(), dsf1.field(), dsf2.field()); atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::clear reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::clear
( (
@ -503,7 +503,7 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
) )
); );
atan2(tAtan2().field(), dsf.field(), ds.value()); atan2(tAtan2.ref().field(), dsf.field(), ds.value());
return tAtan2; return tAtan2;
} }
@ -525,7 +525,7 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
atan2(dsf.dimensions(), ds) atan2(dsf.dimensions(), ds)
); );
atan2(tAtan2().field(), dsf.field(), ds.value()); atan2(tAtan2.ref().field(), dsf.field(), ds.value());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);
@ -575,7 +575,7 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
) )
); );
atan2(tAtan2().field(), ds.value(), dsf.field()); atan2(tAtan2.ref().field(), ds.value(), dsf.field());
return tAtan2; return tAtan2;
} }
@ -598,7 +598,7 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
atan2(ds, dsf.dimensions()) atan2(ds, dsf.dimensions())
); );
atan2(tAtan2().field(), ds.value(), dsf.field()); atan2(tAtan2.ref().field(), ds.value(), dsf.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);
@ -698,7 +698,7 @@ tmp<DimensionedField<scalar, GeoMesh>> func \
) \ ) \
); \ ); \
\ \
func(tFunc().field(), n, dsf.field()); \ func(tFunc.ref().field(), n, dsf.field()); \
\ \
return tFunc; \ return tFunc; \
} \ } \
@ -729,7 +729,7 @@ tmp<DimensionedField<scalar, GeoMesh>> func \
) \ ) \
); \ ); \
\ \
func(tFunc().field(), n, dsf.field()); \ func(tFunc.ref().field(), n, dsf.field()); \
\ \
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); \ reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); \
\ \

4
src/OpenFOAM/fields/FieldFields/FieldField/FieldField.C
View File

@ -232,7 +232,7 @@ FieldField<Field, Type>::component
NewCalculatedType(*this) NewCalculatedType(*this)
); );
::Foam::component(Component(), *this, d); ::Foam::component(Component.ref(), *this, d);
return Component; return Component;
} }
@ -274,7 +274,7 @@ tmp<FieldField<Field, Type>> FieldField<Field, Type>::T() const
FieldField<Field, Type>::NewCalculatedType(*this) FieldField<Field, Type>::NewCalculatedType(*this)
); );
::Foam::T(transpose(), *this); ::Foam::T(transpose.ref(), *this);
return transpose; return transpose;
} }

50
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
View File

@ -86,7 +86,7 @@ pow
( (
FieldField<Field, powProductType>::NewCalculatedType(f) FieldField<Field, powProductType>::NewCalculatedType(f)
); );
pow<Type, r>(tRes(), f); pow<Type, r>(tRes.ref(), f);
return tRes; return tRes;
} }
@ -102,7 +102,7 @@ pow
( (
reuseTmpFieldField<Field, powProductType, Type>::New(tf) reuseTmpFieldField<Field, powProductType, Type>::New(tf)
); );
pow<Type, r>(tRes(), tf()); pow<Type, r>(tRes.ref(), tf());
reuseTmpFieldField<Field, powProductType, Type>::clear(tf); reuseTmpFieldField<Field, powProductType, Type>::clear(tf);
return tRes; return tRes;
} }
@ -130,7 +130,7 @@ sqr(const FieldField<Field, Type>& f)
( (
FieldField<Field, outerProductType>::NewCalculatedType(f) FieldField<Field, outerProductType>::NewCalculatedType(f)
); );
sqr(tRes(), f); sqr(tRes.ref(), f);
return tRes; return tRes;
} }
@ -143,7 +143,7 @@ sqr(const tmp<FieldField<Field, Type>>& tf)
( (
reuseTmpFieldField<Field, outerProductType, Type>::New(tf) reuseTmpFieldField<Field, outerProductType, Type>::New(tf)
); );
sqr(tRes(), tf()); sqr(tRes.ref(), tf());
reuseTmpFieldField<Field, outerProductType, Type>::clear(tf); reuseTmpFieldField<Field, outerProductType, Type>::clear(tf);
return tRes; return tRes;
} }
@ -166,7 +166,7 @@ tmp<FieldField<Field, scalar>> magSqr(const FieldField<Field, Type>& f)
FieldField<Field, scalar>::NewCalculatedType(f) FieldField<Field, scalar>::NewCalculatedType(f)
); );
magSqr(tRes(), f); magSqr(tRes.ref(), f);
return tRes; return tRes;
} }
@ -178,7 +178,7 @@ tmp<FieldField<Field, scalar>> magSqr(const tmp<FieldField<Field, Type>>& tf)
reuseTmpFieldField<Field, scalar, Type>::New(tf) reuseTmpFieldField<Field, scalar, Type>::New(tf)
); );
magSqr(tRes(), tf()); magSqr(tRes.ref(), tf());
reuseTmpFieldField<Field, scalar, Type>::clear(tf); reuseTmpFieldField<Field, scalar, Type>::clear(tf);
return tRes; return tRes;
} }
@ -201,7 +201,7 @@ tmp<FieldField<Field, scalar>> mag(const FieldField<Field, Type>& f)
FieldField<Field, scalar>::NewCalculatedType(f) FieldField<Field, scalar>::NewCalculatedType(f)
); );
mag(tRes(), f); mag(tRes.ref(), f);
return tRes; return tRes;
} }
@ -213,7 +213,7 @@ tmp<FieldField<Field, scalar>> mag(const tmp<FieldField<Field, Type>>& tf)
reuseTmpFieldField<Field, scalar, Type>::New(tf) reuseTmpFieldField<Field, scalar, Type>::New(tf)
); );
mag(tRes(), tf()); mag(tRes.ref(), tf());
reuseTmpFieldField<Field, scalar, Type>::clear(tf); reuseTmpFieldField<Field, scalar, Type>::clear(tf);
return tRes; return tRes;
} }
@ -243,7 +243,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
( (
FieldField<Field, cmptType>::NewCalculatedType(f) FieldField<Field, cmptType>::NewCalculatedType(f)
); );
cmptMax(tRes(), f); cmptMax(tRes.ref(), f);
return tRes; return tRes;
} }
@ -258,7 +258,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
( (
reuseTmpFieldField<Field, cmptType, Type>::New(tf) reuseTmpFieldField<Field, cmptType, Type>::New(tf)
); );
cmptMax(tRes(), tf()); cmptMax(tRes.ref(), tf());
reuseTmpFieldField<Field, cmptType, Type>::clear(tf); reuseTmpFieldField<Field, cmptType, Type>::clear(tf);
return tRes; return tRes;
} }
@ -288,7 +288,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
( (
FieldField<Field, cmptType>::NewCalculatedType(f) FieldField<Field, cmptType>::NewCalculatedType(f)
); );
cmptMin(tRes(), f); cmptMin(tRes.ref(), f);
return tRes; return tRes;
} }
@ -303,7 +303,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
( (
reuseTmpFieldField<Field, cmptType, Type>::New(tf) reuseTmpFieldField<Field, cmptType, Type>::New(tf)
); );
cmptMin(tRes(), tf()); cmptMin(tRes.ref(), tf());
reuseTmpFieldField<Field, cmptType, Type>::clear(tf); reuseTmpFieldField<Field, cmptType, Type>::clear(tf);
return tRes; return tRes;
} }
@ -333,7 +333,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
( (
FieldField<Field, cmptType>::NewCalculatedType(f) FieldField<Field, cmptType>::NewCalculatedType(f)
); );
cmptAv(tRes(), f); cmptAv(tRes.ref(), f);
return tRes; return tRes;
} }
@ -348,7 +348,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
( (
reuseTmpFieldField<Field, cmptType, Type>::New(tf) reuseTmpFieldField<Field, cmptType, Type>::New(tf)
); );
cmptAv(tRes(), tf()); cmptAv(tRes.ref(), tf());
reuseTmpFieldField<Field, cmptType, Type>::clear(tf); reuseTmpFieldField<Field, cmptType, Type>::clear(tf);
return tRes; return tRes;
} }
@ -377,7 +377,7 @@ tmp<FieldField<Field, Type>> cmptMag
( (
FieldField<Field, Type>::NewCalculatedType(f) FieldField<Field, Type>::NewCalculatedType(f)
); );
cmptMag(tRes(), f); cmptMag(tRes.ref(), f);
return tRes; return tRes;
} }
@ -391,7 +391,7 @@ tmp<FieldField<Field, Type>> cmptMag
( (
reuseTmpFieldField<Field, Type, Type>::New(tf) reuseTmpFieldField<Field, Type, Type>::New(tf)
); );
cmptMag(tRes(), tf()); cmptMag(tRes.ref(), tf());
reuseTmpFieldField<Field, Type, Type>::clear(tf); reuseTmpFieldField<Field, Type, Type>::clear(tf);
return tRes; return tRes;
} }
@ -667,7 +667,7 @@ operator op \
( \ ( \
FieldField<Field1, productType>::NewCalculatedType(f1) \ FieldField<Field1, productType>::NewCalculatedType(f1) \
); \ ); \
opFunc(tRes(), f1, f2); \ opFunc(tRes.ref(), f1, f2); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -684,7 +684,7 @@ operator op \
( \ ( \
reuseTmpFieldField<Field, productType, Type2>::New(tf2) \ reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
); \ ); \
opFunc(tRes(), f1, tf2()); \ opFunc(tRes.ref(), f1, tf2()); \
reuseTmpFieldField<Field, productType, Type2>::clear(tf2); \ reuseTmpFieldField<Field, productType, Type2>::clear(tf2); \
return tRes; \ return tRes; \
} \ } \
@ -708,7 +708,7 @@ operator op \
( \ ( \
FieldField<Field1, productType>::NewCalculatedType(f1) \ FieldField<Field1, productType>::NewCalculatedType(f1) \
); \ ); \
opFunc(tRes(), f1, tf2()); \ opFunc(tRes.ref(), f1, tf2()); \
tf2.clear(); \ tf2.clear(); \
return tRes; \ return tRes; \
} \ } \
@ -732,7 +732,7 @@ operator op \
( \ ( \
reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \ reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \
); \ ); \
opFunc(tRes(), tf1(), f2); \ opFunc(tRes.ref(), tf1(), f2); \
reuseTmpFieldField<Field1, productType, Type1>::clear(tf1); \ reuseTmpFieldField<Field1, productType, Type1>::clear(tf1); \
return tRes; \ return tRes; \
} \ } \
@ -757,7 +757,7 @@ operator op \
reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::New \ reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::New \
(tf1, tf2) \ (tf1, tf2) \
); \ ); \
opFunc(tRes(), tf1(), tf2()); \ opFunc(tRes.ref(), tf1(), tf2()); \
reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::clear \ reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::clear \
(tf1, tf2); \ (tf1, tf2); \
return tRes; \ return tRes; \
@ -792,7 +792,7 @@ operator op \
( \ ( \
FieldField<Field, productType>::NewCalculatedType(f1) \ FieldField<Field, productType>::NewCalculatedType(f1) \
); \ ); \
opFunc(tRes(), f1, static_cast<const Form&>(vs)); \ opFunc(tRes.ref(), f1, static_cast<const Form&>(vs)); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -810,7 +810,7 @@ operator op \
( \ ( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \ reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \ ); \
opFunc(tRes(), tf1(), static_cast<const Form&>(vs)); \ opFunc(tRes.ref(), tf1(), static_cast<const Form&>(vs)); \
reuseTmpFieldField<Field, productType, Type>::clear(tf1); \ reuseTmpFieldField<Field, productType, Type>::clear(tf1); \
return tRes; \ return tRes; \
} \ } \
@ -844,7 +844,7 @@ operator op \
( \ ( \
FieldField<Field, productType>::NewCalculatedType(f1) \ FieldField<Field, productType>::NewCalculatedType(f1) \
); \ ); \
opFunc(tRes(), static_cast<const Form&>(vs), f1); \ opFunc(tRes.ref(), static_cast<const Form&>(vs), f1); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -862,7 +862,7 @@ operator op \
( \ ( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \ reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \ ); \
opFunc(tRes(), static_cast<const Form&>(vs), tf1()); \ opFunc(tRes.ref(), static_cast<const Form&>(vs), tf1()); \
reuseTmpFieldField<Field, productType, Type>::clear(tf1); \ reuseTmpFieldField<Field, productType, Type>::clear(tf1); \
return tRes; \ return tRes; \
} }

40
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
View File

@ -53,7 +53,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
FieldField<Field, ReturnType>::NewCalculatedType(f) \ FieldField<Field, ReturnType>::NewCalculatedType(f) \
); \ ); \
Func(tRes(), f); \ Func(tRes.ref(), f); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -67,7 +67,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
reuseTmpFieldField<Field, Type, Type>::New(tf) \ reuseTmpFieldField<Field, Type, Type>::New(tf) \
); \ ); \
Func(tRes(), tf()); \ Func(tRes.ref(), tf()); \
reuseTmpFieldField<Field, Type, Type>::clear(tf); \ reuseTmpFieldField<Field, Type, Type>::clear(tf); \
return tRes; \ return tRes; \
} }
@ -100,7 +100,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
FieldField<Field, Type>::NewCalculatedType(f) \ FieldField<Field, Type>::NewCalculatedType(f) \
); \ ); \
OpFunc(tRes(), f); \ OpFunc(tRes.ref(), f); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -114,7 +114,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
reuseTmpFieldField<Field, Type, Type>::New(tf) \ reuseTmpFieldField<Field, Type, Type>::New(tf) \
); \ ); \
OpFunc(tRes(), tf()); \ OpFunc(tRes.ref(), tf()); \
reuseTmpFieldField<Field, Type, Type>::clear(tf); \ reuseTmpFieldField<Field, Type, Type>::clear(tf); \
return tRes; \ return tRes; \
} }
@ -149,7 +149,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
FieldField<Field, Type1>::NewCalculatedType(f1) \ FieldField<Field, Type1>::NewCalculatedType(f1) \
); \ ); \
Func(tRes(), f1, f2); \ Func(tRes.ref(), f1, f2); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -164,7 +164,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \ ); \
Func(tRes(), f1, tf2()); \ Func(tRes.ref(), f1, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \
return tRes; \ return tRes; \
} \ } \
@ -180,7 +180,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \ reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \ ); \
Func(tRes(), tf1(), f2); \ Func(tRes.ref(), tf1(), f2); \
reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \ reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \
return tRes; \ return tRes; \
} \ } \
@ -197,7 +197,7 @@ tmp<FieldField<Field, ReturnType>> Func \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \ reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \ New(tf1, tf2) \
); \ ); \
Func(tRes(), tf1(), tf2()); \ Func(tRes.ref(), tf1(), tf2()); \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \ reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
clear(tf1, tf2); \ clear(tf1, tf2); \
return tRes; \ return tRes; \
@ -233,7 +233,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
FieldField<Field, Type1>::NewCalculatedType(f1) \ FieldField<Field, Type1>::NewCalculatedType(f1) \
); \ ); \
Func(tRes(), f1, s); \ Func(tRes.ref(), f1, s); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -248,7 +248,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \ reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \ ); \
Func(tRes(), tf1(), s); \ Func(tRes.ref(), tf1(), s); \
reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \ reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \
return tRes; \ return tRes; \
} }
@ -281,7 +281,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
FieldField<Field, Type2>::NewCalculatedType(f2) \ FieldField<Field, Type2>::NewCalculatedType(f2) \
); \ ); \
Func(tRes(), s, f2); \ Func(tRes.ref(), s, f2); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -296,7 +296,7 @@ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \ ); \
Func(tRes(), s, tf2()); \ Func(tRes.ref(), s, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \
return tRes; \ return tRes; \
} }
@ -336,7 +336,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
FieldField<Field, ReturnType>::NewCalculatedType(f1) \ FieldField<Field, ReturnType>::NewCalculatedType(f1) \
); \ ); \
OpFunc(tRes(), f1, f2); \ OpFunc(tRes.ref(), f1, f2); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -351,7 +351,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \ ); \
OpFunc(tRes(), f1, tf2()); \ OpFunc(tRes.ref(), f1, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \
return tRes; \ return tRes; \
} \ } \
@ -367,7 +367,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \ reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \ ); \
OpFunc(tRes(), tf1(), f2); \ OpFunc(tRes.ref(), tf1(), f2); \
reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \ reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \
return tRes; \ return tRes; \
} \ } \
@ -384,7 +384,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \ reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \ New(tf1, tf2) \
); \ ); \
OpFunc(tRes(), tf1(), tf2()); \ OpFunc(tRes.ref(), tf1(), tf2()); \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \ reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
clear(tf1, tf2); \ clear(tf1, tf2); \
return tRes; \ return tRes; \
@ -420,7 +420,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
FieldField<Field, Type2>::NewCalculatedType(f2) \ FieldField<Field, Type2>::NewCalculatedType(f2) \
); \ ); \
OpFunc(tRes(), s, f2); \ OpFunc(tRes.ref(), s, f2); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -435,7 +435,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \ ); \
OpFunc(tRes(), s, tf2()); \ OpFunc(tRes.ref(), s, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \
return tRes; \ return tRes; \
} }
@ -468,7 +468,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
FieldField<Field, Type1>::NewCalculatedType(f1) \ FieldField<Field, Type1>::NewCalculatedType(f1) \
); \ ); \
OpFunc(tRes(), f1, s); \ OpFunc(tRes.ref(), f1, s); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -483,7 +483,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \ reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \ ); \
OpFunc(tRes(), tf1(), s); \ OpFunc(tRes.ref(), tf1(), s); \
reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \ reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \
return tRes; \ return tRes; \
} }

27
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H
View File

@ -80,7 +80,7 @@ public:
if (initRet) if (initRet)
{ {
rtf() = tf1(); rtf.ref() = tf1();
} }
return rtf; return rtf;
@ -89,10 +89,7 @@ public:
static void clear(const tmp<FieldField<Field, TypeR>>& tf1) static void clear(const tmp<FieldField<Field, TypeR>>& tf1)
{ {
if (tf1.isTmp()) tf1.clear();
{
tf1.ptr();
}
} }
}; };
@ -164,10 +161,7 @@ public:
) )
{ {
tf1.clear(); tf1.clear();
if (tf2.isTmp()) tf2.clear();
{
tf2.ptr();
}
} }
}; };
@ -202,10 +196,7 @@ public:
const tmp<FieldField<Field, Type2>>& tf2 const tmp<FieldField<Field, Type2>>& tf2
) )
{ {
if (tf1.isTmp()) tf1.clear();
{
tf1.ptr();
}
tf2.clear(); tf2.clear();
} }
}; };
@ -244,17 +235,9 @@ public:
const tmp<FieldField<Field, TypeR>>& tf1, const tmp<FieldField<Field, TypeR>>& tf1,
const tmp<FieldField<Field, TypeR>>& tf2 const tmp<FieldField<Field, TypeR>>& tf2
) )
{
if (tf1.isTmp())
{
tf1.ptr();
tf2.clear();
}
else if (tf2.isTmp())
{ {
tf1.clear(); tf1.clear();
tf2.ptr(); tf2.clear();
}
} }
}; };

5
src/OpenFOAM/fields/Fields/Field/Field.C
View File

@ -690,10 +690,7 @@ void Foam::Field<Type>::operator=(const tmp<Field>& rhs)
<< abort(FatalError); << abort(FatalError);
} }
// This is dodgy stuff, don't try it at home. List<Type>::operator=(rhs());
Field* fieldPtr = rhs.ptr();
List<Type>::transfer(*fieldPtr);
delete fieldPtr;
} }

25
src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
View File

@ -80,10 +80,7 @@ public:
static void clear(const tmp<Field<TypeR>>& tf1) static void clear(const tmp<Field<TypeR>>& tf1)
{ {
if (tf1.isTmp()) tf1.clear();
{
tf1.ptr();
}
} }
}; };
@ -142,10 +139,7 @@ public:
) )
{ {
tf1.clear(); tf1.clear();
if (tf2.isTmp()) tf2.clear();
{
tf2.ptr();
}
} }
}; };
@ -177,10 +171,7 @@ public:
const tmp<Field<Type2>>& tf2 const tmp<Field<Type2>>& tf2
) )
{ {
if (tf1.isTmp()) tf1.clear();
{
tf1.ptr();
}
tf2.clear(); tf2.clear();
} }
}; };
@ -216,17 +207,9 @@ public:
const tmp<Field<TypeR>>& tf1, const tmp<Field<TypeR>>& tf1,
const tmp<Field<TypeR>>& tf2 const tmp<Field<TypeR>>& tf2
) )
{
if (tf1.isTmp())
{
tf1.ptr();
tf2.clear();
}
else if (tf2.isTmp())
{ {
tf1.clear(); tf1.clear();
tf2.ptr(); tf2.clear();
}
} }
}; };

8
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
View File

@ -992,8 +992,8 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::T() const
) )
); );
Foam::T(result().internalField(), internalField()); Foam::T(result.ref().internalField(), internalField());
Foam::T(result().boundaryField(), boundaryField()); Foam::T(result.ref().boundaryField(), boundaryField());
return result; return result;
} }
@ -1029,8 +1029,8 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::component
) )
); );
Foam::component(Component().internalField(), internalField(), d); Foam::component(Component.ref().internalField(), internalField(), d);
Foam::component(Component().boundaryField(), boundaryField(), d); Foam::component(Component.ref().boundaryField(), boundaryField(), d);
return Component; return Component;
} }

36
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
View File

@ -104,7 +104,7 @@ pow
) )
); );
pow<Type, r, PatchField, GeoMesh>(tPow(), gf); pow<Type, r, PatchField, GeoMesh>(tPow.ref(), gf);
return tPow; return tPow;
} }
@ -139,7 +139,7 @@ pow
) )
); );
pow<Type, r, PatchField, GeoMesh>(tPow(), gf); pow<Type, r, PatchField, GeoMesh>(tPow.ref(), gf);
tgf.clear(); tgf.clear();
@ -190,7 +190,7 @@ sqr(const GeometricField<Type, PatchField, GeoMesh>& gf)
) )
); );
sqr(tSqr(), gf); sqr(tSqr.ref(), gf);
return tSqr; return tSqr;
} }
@ -228,7 +228,7 @@ sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
) )
); );
sqr(tSqr(), gf); sqr(tSqr.ref(), gf);
tgf.clear(); tgf.clear();
@ -270,7 +270,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> magSqr
) )
); );
magSqr(tMagSqr(), gf); magSqr(tMagSqr.ref(), gf);
return tMagSqr; return tMagSqr;
} }
@ -300,7 +300,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> magSqr
) )
); );
magSqr(tMagSqr(), gf); magSqr(tMagSqr.ref(), gf);
tgf.clear(); tgf.clear();
@ -342,7 +342,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> mag
) )
); );
mag(tMag(), gf); mag(tMag.ref(), gf);
return tMag; return tMag;
} }
@ -372,7 +372,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> mag
) )
); );
mag(tMag(), gf); mag(tMag.ref(), gf);
tgf.clear(); tgf.clear();
@ -428,7 +428,7 @@ cmptAv(const GeometricField<Type, PatchField, GeoMesh>& gf)
) )
); );
cmptAv(CmptAv(), gf); cmptAv(CmptAv.ref(), gf);
return CmptAv; return CmptAv;
} }
@ -467,7 +467,7 @@ cmptAv(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
) )
); );
cmptAv(CmptAv(), gf); cmptAv(CmptAv.ref(), gf);
tgf.clear(); tgf.clear();
@ -615,7 +615,7 @@ operator op \
) \ ) \
); \ ); \
\ \
Foam::opFunc(tRes(), gf1, gf2); \ Foam::opFunc(tRes.ref(), gf1, gf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -644,7 +644,7 @@ operator op \
gf1.dimensions() op gf2.dimensions() \ gf1.dimensions() op gf2.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes(), gf1, gf2); \ Foam::opFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField<productType, Type2, PatchField, GeoMesh> \ reuseTmpGeometricField<productType, Type2, PatchField, GeoMesh> \
::clear(tgf2); \ ::clear(tgf2); \
@ -676,7 +676,7 @@ operator op \
gf1.dimensions() op gf2.dimensions() \ gf1.dimensions() op gf2.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes(), gf1, gf2); \ Foam::opFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField<productType, Type1, PatchField, GeoMesh> \ reuseTmpGeometricField<productType, Type1, PatchField, GeoMesh> \
::clear(tgf1); \ ::clear(tgf1); \
@ -711,7 +711,7 @@ operator op \
gf1.dimensions() op gf2.dimensions() \ gf1.dimensions() op gf2.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes(), gf1, gf2); \ Foam::opFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpTmpGeometricField \ reuseTmpTmpGeometricField \
<productType, Type1, Type1, Type2, PatchField, GeoMesh> \ <productType, Type1, Type1, Type2, PatchField, GeoMesh> \
@ -762,7 +762,7 @@ operator op \
) \ ) \
); \ ); \
\ \
Foam::opFunc(tRes(), gf1, dvs); \ Foam::opFunc(tRes.ref(), gf1, dvs); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -807,7 +807,7 @@ operator op \
gf1.dimensions() op dvs.dimensions() \ gf1.dimensions() op dvs.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes(), gf1, dvs); \ Foam::opFunc(tRes.ref(), gf1, dvs); \
\ \
reuseTmpGeometricField<productType, Type, PatchField, GeoMesh> \ reuseTmpGeometricField<productType, Type, PatchField, GeoMesh> \
::clear(tgf1); \ ::clear(tgf1); \
@ -875,7 +875,7 @@ operator op \
) \ ) \
); \ ); \
\ \
Foam::opFunc(tRes(), dvs, gf1); \ Foam::opFunc(tRes.ref(), dvs, gf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -919,7 +919,7 @@ operator op \
dvs.dimensions() op gf1.dimensions() \ dvs.dimensions() op gf1.dimensions() \
); \ ); \
\ \
Foam::opFunc(tRes(), dvs, gf1); \ Foam::opFunc(tRes.ref(), dvs, gf1); \
\ \
reuseTmpGeometricField<productType, Type, PatchField, GeoMesh> \ reuseTmpGeometricField<productType, Type, PatchField, GeoMesh> \
::clear(tgf1); \ ::clear(tgf1); \

40
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C
View File

@ -68,7 +68,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), gf1); \ Foam::Func(tRes.ref(), gf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -91,7 +91,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), gf1); \ Foam::Func(tRes.ref(), gf1); \
\ \
reuseTmpGeometricField \ reuseTmpGeometricField \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \ <ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
@ -138,7 +138,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), gf1); \ Foam::OpFunc(tRes.ref(), gf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -161,7 +161,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), gf1); \ Foam::OpFunc(tRes.ref(), gf1); \
\ \
reuseTmpGeometricField \ reuseTmpGeometricField \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \ <ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
@ -210,7 +210,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), gf1, gf2); \ Foam::Func(tRes.ref(), gf1, gf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -234,7 +234,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), gf1, gf2); \ Foam::Func(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField \ reuseTmpGeometricField \
<ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \ <ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \
@ -261,7 +261,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), gf1, gf2); \ Foam::Func(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField \ reuseTmpGeometricField \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \ <ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
@ -292,7 +292,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), gf1, gf2); \ Foam::Func(tRes.ref(), gf1, gf2); \
\ \
reuseTmpTmpGeometricField \ reuseTmpTmpGeometricField \
<ReturnType, Type1, Type1, Type2, PatchField, GeoMesh> \ <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh> \
@ -341,7 +341,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), dt1, gf2); \ Foam::Func(tRes.ref(), dt1, gf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -376,7 +376,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), dt1, gf2); \ Foam::Func(tRes.ref(), dt1, gf2); \
\ \
reuseTmpGeometricField \ reuseTmpGeometricField \
<ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \ <ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \
@ -433,7 +433,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), gf1, dt2); \ Foam::Func(tRes.ref(), gf1, dt2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -468,7 +468,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
) \ ) \
); \ ); \
\ \
Foam::Func(tRes(), gf1, dt2); \ Foam::Func(tRes.ref(), gf1, dt2); \
\ \
reuseTmpGeometricField \ reuseTmpGeometricField \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \ <ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
@ -534,7 +534,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), gf1, gf2); \ Foam::OpFunc(tRes.ref(), gf1, gf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -558,7 +558,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), gf1, gf2); \ Foam::OpFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField \ reuseTmpGeometricField \
<ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \ <ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \
@ -585,7 +585,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), gf1, gf2); \ Foam::OpFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField \ reuseTmpGeometricField \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \ <ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
@ -615,7 +615,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), gf1, gf2); \ Foam::OpFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpTmpGeometricField \ reuseTmpTmpGeometricField \
<ReturnType, Type1, Type1, Type2, PatchField, GeoMesh> \ <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh> \
@ -665,7 +665,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), dt1, gf2); \ Foam::OpFunc(tRes.ref(), dt1, gf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -700,7 +700,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), dt1, gf2); \ Foam::OpFunc(tRes.ref(), dt1, gf2); \
\ \
reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh> \ reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh> \
::clear(tgf2); \ ::clear(tgf2); \
@ -757,7 +757,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), gf1, dt2); \ Foam::OpFunc(tRes.ref(), gf1, dt2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -792,7 +792,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
) \ ) \
); \ ); \
\ \
Foam::OpFunc(tRes(), gf1, dt2); \ Foam::OpFunc(tRes.ref(), gf1, dt2); \
\ \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh> \ reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh> \
::clear(tgf1); \ ::clear(tgf1); \

27
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldReuseFunctions.H
View File

@ -162,7 +162,7 @@ public:
if (initRet) if (initRet)
{ {
rtgf() == tgf1(); rtgf.ref() == tgf1();
} }
return rtgf; return rtgf;
@ -174,10 +174,7 @@ public:
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1 const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1
) )
{ {
if (reusable(tgf1)) tgf1.clear();
{
tgf1.ptr();
}
} }
}; };
@ -290,10 +287,7 @@ public:
) )
{ {
tgf1.clear(); tgf1.clear();
if (reusable(tgf2)) tgf2.clear();
{
tgf2.ptr();
}
} }
}; };
@ -351,10 +345,7 @@ public:
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2
) )
{ {
if (reusable(tgf1)) tgf1.clear();
{
tgf1.ptr();
}
tgf2.clear(); tgf2.clear();
} }
}; };
@ -414,17 +405,9 @@ public:
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1, const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf2 const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf2
) )
{
if (reusable(tgf1))
{
tgf1.ptr();
tgf2.clear();
}
else if (reusable(tgf2))
{ {
tgf1.clear(); tgf1.clear();
tgf2.ptr(); tgf2.clear();
}
} }
}; };

40
src/OpenFOAM/fields/GeometricFields/GeometricScalarField/GeometricScalarField.C
View File

@ -72,7 +72,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> stabilise
) )
); );
stabilise(tRes(), gsf, ds); stabilise(tRes.ref(), gsf, ds);
return tRes; return tRes;
} }
@ -97,7 +97,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> stabilise
) )
); );
stabilise(tRes(), gsf, ds); stabilise(tRes.ref(), gsf, ds);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf);
@ -159,7 +159,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
) )
); );
pow(tPow(), gsf1, gsf2); pow(tPow.ref(), gsf1, gsf2);
return tPow; return tPow;
} }
@ -188,7 +188,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
) )
); );
pow(tPow(), gsf1, gsf2); pow(tPow.ref(), gsf1, gsf2);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf1); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf1);
@ -219,7 +219,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
) )
); );
pow(tPow(), gsf1, gsf2); pow(tPow.ref(), gsf1, gsf2);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf2); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf2);
@ -252,7 +252,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
) )
); );
pow(tPow(), gsf1, gsf2); pow(tPow.ref(), gsf1, gsf2);
reuseTmpTmpGeometricField reuseTmpTmpGeometricField
<scalar, scalar, scalar, scalar, PatchField, GeoMesh> <scalar, scalar, scalar, scalar, PatchField, GeoMesh>
@ -299,7 +299,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
) )
); );
pow(tPow(), gsf, ds); pow(tPow.ref(), gsf, ds);
return tPow; return tPow;
} }
@ -323,7 +323,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
) )
); );
pow(tPow(), gsf, ds); pow(tPow.ref(), gsf, ds);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf);
@ -388,7 +388,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
) )
); );
pow(tPow(), ds, gsf); pow(tPow.ref(), ds, gsf);
return tPow; return tPow;
} }
@ -413,7 +413,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
) )
); );
pow(tPow(), ds, gsf); pow(tPow.ref(), ds, gsf);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf);
@ -480,7 +480,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
) )
); );
atan2(tAtan2(), gsf1, gsf2); atan2(tAtan2.ref(), gsf1, gsf2);
return tAtan2; return tAtan2;
} }
@ -505,7 +505,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
) )
); );
atan2(tAtan2(), gsf1, gsf2); atan2(tAtan2.ref(), gsf1, gsf2);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf1); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf1);
@ -532,7 +532,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
) )
); );
atan2(tAtan2(), gsf1, gsf2); atan2(tAtan2.ref(), gsf1, gsf2);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf2); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf2);
@ -561,7 +561,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
) )
); );
atan2(tAtan2(), gsf1, gsf2); atan2(tAtan2.ref(), gsf1, gsf2);
reuseTmpTmpGeometricField reuseTmpTmpGeometricField
<scalar, scalar, scalar, scalar, PatchField, GeoMesh> <scalar, scalar, scalar, scalar, PatchField, GeoMesh>
@ -608,7 +608,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
) )
); );
atan2(tAtan2(), gsf, ds); atan2(tAtan2.ref(), gsf, ds);
return tAtan2; return tAtan2;
} }
@ -632,7 +632,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
) )
); );
atan2(tAtan2(), gsf, ds); atan2(tAtan2.ref(), gsf, ds);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf);
@ -697,7 +697,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
) )
); );
atan2(tAtan2(), ds, gsf); atan2(tAtan2.ref(), ds, gsf);
return tAtan2; return tAtan2;
} }
@ -722,7 +722,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
) )
); );
atan2(tAtan2(), ds, gsf); atan2(tAtan2.ref(), ds, gsf);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf);
@ -836,7 +836,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> func \
) \ ) \
); \ ); \
\ \
func(tFunc(), n, gsf); \ func(tFunc.ref(), n, gsf); \
\ \
return tFunc; \ return tFunc; \
} \ } \
@ -867,7 +867,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> func \
) \ ) \
); \ ); \
\ \
func(tFunc(), n, gsf); \ func(tFunc.ref(), n, gsf); \
\ \
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh> \ reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh> \
::clear(tgsf); \ ::clear(tgsf); \

6
src/OpenFOAM/fields/GeometricFields/SlicedGeometricField/SlicedGeometricField.C
View File

@ -49,8 +49,7 @@ slicedBoundaryField
( (
new FieldField<PatchField, Type>(mesh.boundary().size()) new FieldField<PatchField, Type>(mesh.boundary().size())
); );
FieldField<PatchField, Type>& bf = tbf.ref();
FieldField<PatchField, Type>& bf = tbf();
forAll(mesh.boundary(), patchi) forAll(mesh.boundary(), patchi)
{ {
@ -126,8 +125,7 @@ slicedBoundaryField
( (
new FieldField<PatchField, Type>(mesh.boundary().size()) new FieldField<PatchField, Type>(mesh.boundary().size())
); );
FieldField<PatchField, Type>& bf = tbf.ref();
FieldField<PatchField, Type>& bf = tbf();
forAll(mesh.boundary(), patchi) forAll(mesh.boundary(), patchi)
{ {

4
src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixTemplates.C
View File

@ -40,7 +40,7 @@ Foam::tmp<Foam::Field<Type>> Foam::lduMatrix::H(const Field<Type>& psi) const
if (lowerPtr_ || upperPtr_) if (lowerPtr_ || upperPtr_)
{ {
Field<Type> & Hpsi = tHpsi(); Field<Type> & Hpsi = tHpsi.ref();
Type* __restrict__ HpsiPtr = Hpsi.begin(); Type* __restrict__ HpsiPtr = Hpsi.begin();
@ -87,7 +87,7 @@ Foam::lduMatrix::faceH(const Field<Type>& psi) const
const labelUList& u = lduAddr().upperAddr(); const labelUList& u = lduAddr().upperAddr();
tmp<Field<Type>> tfaceHpsi(new Field<Type> (Lower.size())); tmp<Field<Type>> tfaceHpsi(new Field<Type> (Lower.size()));
Field<Type> & faceHpsi = tfaceHpsi(); Field<Type> & faceHpsi = tfaceHpsi.ref();
for (label face=0; face<l.size(); face++) for (label face=0; face<l.size(); face++)
{ {

6
src/OpenFOAM/memory/refCount/refCount.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -79,9 +79,9 @@ public:
//- Return true if the reference count is zero //- Return true if the reference count is zero
bool okToDelete() const bool unique() const
{ {
return !count_; return count_ == 0;
} }

9
src/OpenFOAM/memory/tmp/tmp.H
View File

@ -56,7 +56,6 @@ class tmp
enum type enum type
{ {
TMP, TMP,
REF,
CONST_REF CONST_REF
}; };
@ -74,15 +73,9 @@ public:
//- Store object pointer //- Store object pointer
inline explicit tmp(T* = 0); inline explicit tmp(T* = 0);
//- Store object rvalue reference
inline tmp(T&&);
//- Store object const reference //- Store object const reference
inline tmp(const T&); inline tmp(const T&);
//- Construct copy and increment reference count
inline tmp(tmp<T>&&);
//- Construct copy and increment reference count //- Construct copy and increment reference count
inline tmp(const tmp<T>&); inline tmp(const tmp<T>&);
@ -90,7 +83,7 @@ public:
inline tmp(const tmp<T>&, bool allowTransfer); inline tmp(const tmp<T>&, bool allowTransfer);
//- Destructor, delete object when reference count == 0 //- Destructor: deletes temporary object when the reference count is 0
inline ~tmp(); inline ~tmp();

76
src/OpenFOAM/memory/tmp/tmpI.H
View File

@ -36,14 +36,6 @@ inline Foam::tmp<T>::tmp(T* tPtr)
{} {}
template<class T>
inline Foam::tmp<T>::tmp(T&& tRef)
:
type_(REF),
ptr_(&tRef)
{}
template<class T> template<class T>
inline Foam::tmp<T>::tmp(const T& tRef) inline Foam::tmp<T>::tmp(const T& tRef)
: :
@ -52,29 +44,6 @@ inline Foam::tmp<T>::tmp(const T& tRef)
{} {}
template<class T>
inline Foam::tmp<T>::tmp(tmp<T>&& t)
:
type_(t.type_),
ptr_(t.ptr_)
{
if (isTmp())
{
if (ptr_)
{
ptr_->operator++();
}
else
{
FatalErrorInFunction
<< "Attempted copy of a deallocated temporary"
<< " of type " << typeid(T).name()
<< abort(FatalError);
}
}
}
template<class T> template<class T>
inline Foam::tmp<T>::tmp(const tmp<T>& t) inline Foam::tmp<T>::tmp(const tmp<T>& t)
: :
@ -95,10 +64,6 @@ inline Foam::tmp<T>::tmp(const tmp<T>& t)
<< abort(FatalError); << abort(FatalError);
} }
} }
else if (type_ == REF)
{
type_ = CONST_REF;
}
} }
@ -137,7 +102,7 @@ inline Foam::tmp<T>::~tmp()
{ {
if (isTmp() && ptr_) if (isTmp() && ptr_)
{ {
if (ptr_->okToDelete()) if (ptr_->unique())
{ {
delete ptr_; delete ptr_;
ptr_ = 0; ptr_ = 0;
@ -187,13 +152,10 @@ inline T& Foam::tmp<T>::ref()
return *ptr_; return *ptr_;
} }
else if (type_ == REF)
{
return *ptr_;
}
else else
{ {
FatalErrorInFunction << "Const object cast to non-const" FatalErrorInFunction
<< "Attempt to acquire non-const reference to const object"
<< abort(FatalError); << abort(FatalError);
return *ptr_; return *ptr_;
} }
@ -212,11 +174,17 @@ inline T* Foam::tmp<T>::ptr() const
<< abort(FatalError); << abort(FatalError);
} }
if (!ptr_->unique())
{
FatalErrorInFunction
<< "Attempt to acquire pointer to object referred to"
" by multiple 'tmp's"
<< abort(FatalError);
}
T* ptr = ptr_; T* ptr = ptr_;
ptr_ = 0; ptr_ = 0;
ptr->resetRefCount();
return ptr; return ptr;
} }
else else
@ -229,11 +197,19 @@ inline T* Foam::tmp<T>::ptr() const
template<class T> template<class T>
inline void Foam::tmp<T>::clear() const inline void Foam::tmp<T>::clear() const
{ {
if (isTmp() && ptr_) // Skip this bit: && ptr_->okToDelete()) if (isTmp() && ptr_)
{
if (ptr_->unique())
{ {
delete ptr_; delete ptr_;
ptr_ = 0; ptr_ = 0;
} }
else
{
ptr_->operator--();
ptr_ = 0;
}
}
} }
@ -307,10 +283,6 @@ inline T* Foam::tmp<T>::operator->()
return ptr_; return ptr_;
} }
else if (type_ == REF)
{
return ptr_;
}
else else
{ {
FatalErrorInFunction << "Const object cast to non-const" FatalErrorInFunction << "Const object cast to non-const"
@ -346,7 +318,7 @@ inline void Foam::tmp<T>::operator=(T* tPtr)
{ {
if (isTmp() && ptr_) if (isTmp() && ptr_)
{ {
if (ptr_->okToDelete()) if (ptr_->unique())
{ {
delete ptr_; delete ptr_;
ptr_ = 0; ptr_ = 0;
@ -377,7 +349,7 @@ inline void Foam::tmp<T>::operator=(const tmp<T>& t)
{ {
if (isTmp() && ptr_) if (isTmp() && ptr_)
{ {
if (ptr_->okToDelete()) if (ptr_->unique())
{ {
delete ptr_; delete ptr_;
ptr_ = 0; ptr_ = 0;
@ -401,8 +373,8 @@ inline void Foam::tmp<T>::operator=(const tmp<T>& t)
} }
ptr_ = t.ptr_; ptr_ = t.ptr_;
const_cast<tmp<T>&>(t).ptr_ = 0;
ptr_->resetRefCount(); ptr_->operator++();
} }
else else
{ {

2
src/TurbulenceModels/compressible/Make/options
View File

@ -1,4 +1,4 @@
EXE_INC = \ EXE_INC = -DCONST_TMP \
-I../turbulenceModels/lnInclude \ -I../turbulenceModels/lnInclude \
-I$(LIB_SRC)/transportModels/compressible/lnInclude \ -I$(LIB_SRC)/transportModels/compressible/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \ -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \

6
src/TurbulenceModels/compressible/turbulentFluidThermoModels/derivedFvPatchFields/thermalBaffle1D/thermalBaffle1DFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -257,7 +257,7 @@ baffleThickness() const
( (
new scalarField(nbrField.baffleThickness()) new scalarField(nbrField.baffleThickness())
); );
scalarField& thickness = tthickness(); scalarField& thickness = tthickness.ref();
mapDist.distribute(thickness); mapDist.distribute(thickness);
return tthickness; return tthickness;
} }
@ -285,7 +285,7 @@ tmp<scalarField> thermalBaffle1DFvPatchScalarField<solidType>::Qs() const
); );
tmp<scalarField> tQs(new scalarField(nbrField.Qs())); tmp<scalarField> tQs(new scalarField(nbrField.Qs()));
scalarField& Qs = tQs(); scalarField& Qs = tQs.ref();
mapDist.distribute(Qs); mapDist.distribute(Qs);
return tQs; return tQs;
} }

12
src/TurbulenceModels/compressible/turbulentFluidThermoModels/derivedFvPatchFields/turbulentTemperatureCoupledBaffleMixed/turbulentTemperatureCoupledBaffleMixedFvPatchScalarField.C
View File

@ -195,17 +195,17 @@ void turbulentTemperatureCoupledBaffleMixedFvPatchScalarField::updateCoeffs()
if (contactRes_ == 0.0) if (contactRes_ == 0.0)
{ {
nbrIntFld() = nbrField.patchInternalField(); nbrIntFld.ref() = nbrField.patchInternalField();
nbrKDelta() = nbrField.kappa(nbrField)*nbrPatch.deltaCoeffs(); nbrKDelta.ref() = nbrField.kappa(nbrField)*nbrPatch.deltaCoeffs();
} }
else else
{ {
nbrIntFld() = nbrField; nbrIntFld.ref() = nbrField;
nbrKDelta() = contactRes_; nbrKDelta.ref() = contactRes_;
} }
mpp.distribute(nbrIntFld()); mpp.distribute(nbrIntFld.ref());
mpp.distribute(nbrKDelta()); mpp.distribute(nbrKDelta.ref());
tmp<scalarField> myKDelta = kappa(*this)*patch().deltaCoeffs(); tmp<scalarField> myKDelta = kappa(*this)*patch().deltaCoeffs();

2
src/TurbulenceModels/incompressible/Make/options
View File

@ -1,4 +1,4 @@
EXE_INC = \ EXE_INC = -DCONST_TMP \
-I../turbulenceModels/lnInclude \ -I../turbulenceModels/lnInclude \
-I$(LIB_SRC)/transportModels \ -I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \

8
src/TurbulenceModels/incompressible/turbulentTransportModels/RAS/LamBremhorstKE/LamBremhorstKE.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -235,8 +235,8 @@ void LamBremhorstKE::correct()
- fvm::Sp(Ceps2_*f2(Rt)*epsilon_/k_, epsilon_) - fvm::Sp(Ceps2_*f2(Rt)*epsilon_/k_, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
bound(epsilon_, epsilonMin_); bound(epsilon_, epsilonMin_);
@ -250,7 +250,7 @@ void LamBremhorstKE::correct()
G - fvm::Sp(epsilon_/k_, k_) G - fvm::Sp(epsilon_/k_, k_)
); );
kEqn().relax(); kEqn.ref().relax();
solve(kEqn); solve(kEqn);
bound(k_, kMin_); bound(k_, kMin_);

8
src/TurbulenceModels/incompressible/turbulentTransportModels/RAS/LienCubicKE/LienCubicKE.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -404,8 +404,8 @@ void LienCubicKE::correct()
+ E(f2) + E(f2)
); );
epsEqn().relax(); epsEqn.ref().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
bound(epsilon_, epsilonMin_); bound(epsilon_, epsilonMin_);
@ -421,7 +421,7 @@ void LienCubicKE::correct()
- fvm::Sp(epsilon_/k_, k_) - fvm::Sp(epsilon_/k_, k_)
); );
kEqn().relax(); kEqn.ref().relax();
solve(kEqn); solve(kEqn);
bound(k_, kMin_); bound(k_, kMin_);

8
src/TurbulenceModels/incompressible/turbulentTransportModels/RAS/LienLeschziner/LienLeschziner.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -288,8 +288,8 @@ void LienLeschziner::correct()
+ E(f2) + E(f2)
); );
epsEqn().relax(); epsEqn.ref().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
bound(epsilon_, epsilonMin_); bound(epsilon_, epsilonMin_);
@ -305,7 +305,7 @@ void LienLeschziner::correct()
- fvm::Sp(epsilon_/k_, k_) - fvm::Sp(epsilon_/k_, k_)
); );
kEqn().relax(); kEqn.ref().relax();
solve(kEqn); solve(kEqn);
bound(k_, kMin_); bound(k_, kMin_);

8
src/TurbulenceModels/incompressible/turbulentTransportModels/RAS/ShihQuadraticKE/ShihQuadraticKE.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -286,8 +286,8 @@ void ShihQuadraticKE::correct()
- fvm::Sp(Ceps2_*epsilon_/k_, epsilon_) - fvm::Sp(Ceps2_*epsilon_/k_, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
bound(epsilon_, epsilonMin_); bound(epsilon_, epsilonMin_);
@ -303,7 +303,7 @@ void ShihQuadraticKE::correct()
- fvm::Sp(epsilon_/k_, k_) - fvm::Sp(epsilon_/k_, k_)
); );
kEqn().relax(); kEqn.ref().relax();
solve(kEqn); solve(kEqn);
bound(k_, kMin_); bound(k_, kMin_);

14
src/TurbulenceModels/incompressible/turbulentTransportModels/RAS/kkLOmega/kkLOmega.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -698,8 +698,8 @@ void kkLOmega::correct()
)().dimensionedInternalField()/pow3(y_.dimensionedInternalField()) )().dimensionedInternalField()/pow3(y_.dimensionedInternalField())
); );
omegaEqn().relax(); omegaEqn.ref().relax();
omegaEqn().boundaryManipulate(omega_.boundaryField()); omegaEqn.ref().boundaryManipulate(omega_.boundaryField());
solve(omegaEqn); solve(omegaEqn);
bound(omega_, omegaMin_); bound(omega_, omegaMin_);
@ -718,8 +718,8 @@ void kkLOmega::correct()
- fvm::Sp(Rbp + Rnat + Dl/(kl_ + kMin_), kl_) - fvm::Sp(Rbp + Rnat + Dl/(kl_ + kMin_), kl_)
); );
klEqn().relax(); klEqn.ref().relax();
klEqn().boundaryManipulate(kl_.boundaryField()); klEqn.ref().boundaryManipulate(kl_.boundaryField());
solve(klEqn); solve(klEqn);
bound(kl_, kMin_); bound(kl_, kMin_);
@ -739,8 +739,8 @@ void kkLOmega::correct()
- fvm::Sp(omega_ + Dt/(kt_+ kMin_), kt_) - fvm::Sp(omega_ + Dt/(kt_+ kMin_), kt_)
); );
ktEqn().relax(); ktEqn.ref().relax();
ktEqn().boundaryManipulate(kt_.boundaryField()); ktEqn.ref().boundaryManipulate(kt_.boundaryField());
solve(ktEqn); solve(ktEqn);
bound(kt_, kMin_); bound(kt_, kMin_);

6
src/TurbulenceModels/incompressible/turbulentTransportModels/RAS/qZeta/qZeta.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -260,7 +260,7 @@ void qZeta::correct()
+ E + E
); );
zetaEqn().relax(); zetaEqn.ref().relax();
solve(zetaEqn); solve(zetaEqn);
bound(zeta_, zetaMin_); bound(zeta_, zetaMin_);
@ -275,7 +275,7 @@ void qZeta::correct()
G - fvm::Sp(zeta_/q_, q_) G - fvm::Sp(zeta_/q_, q_)
); );
qEqn().relax(); qEqn.ref().relax();
solve(qEqn); solve(qEqn);
bound(q_, qMin_); bound(q_, qMin_);

14
src/TurbulenceModels/phaseCompressible/RAS/mixtureKEpsilon/mixtureKEpsilon.C
View File

@ -615,7 +615,7 @@ void mixtureKEpsilon<BasicTurbulenceModel>::correct()
kl.boundaryField().updateCoeffs(); kl.boundaryField().updateCoeffs();
epsilonl.boundaryField().updateCoeffs(); epsilonl.boundaryField().updateCoeffs();
Gc().checkOut(); Gc.ref().checkOut();
} }
tmp<volScalarField> Gd; tmp<volScalarField> Gd;
@ -635,7 +635,7 @@ void mixtureKEpsilon<BasicTurbulenceModel>::correct()
kg.boundaryField().updateCoeffs(); kg.boundaryField().updateCoeffs();
epsilong.boundaryField().updateCoeffs(); epsilong.boundaryField().updateCoeffs();
Gd().checkOut(); Gd.ref().checkOut();
} }
// Mixture turbulence generation // Mixture turbulence generation
@ -665,9 +665,9 @@ void mixtureKEpsilon<BasicTurbulenceModel>::correct()
+ fvOptions(epsilonm) + fvOptions(epsilonm)
); );
epsEqn().relax(); epsEqn.ref().relax();
fvOptions.constrain(epsEqn()); fvOptions.constrain(epsEqn.ref());
epsEqn().boundaryManipulate(epsilonm.boundaryField()); epsEqn.ref().boundaryManipulate(epsilonm.boundaryField());
solve(epsEqn); solve(epsEqn);
fvOptions.correct(epsilonm); fvOptions.correct(epsilonm);
bound(epsilonm, this->epsilonMin_); bound(epsilonm, this->epsilonMin_);
@ -688,8 +688,8 @@ void mixtureKEpsilon<BasicTurbulenceModel>::correct()
+ fvOptions(km) + fvOptions(km)
); );
kmEqn().relax(); kmEqn.ref().relax();
fvOptions.constrain(kmEqn()); fvOptions.constrain(kmEqn.ref());
solve(kmEqn); solve(kmEqn);
fvOptions.correct(km); fvOptions.correct(km);
bound(km, this->kMin_); bound(km, this->kMin_);

6
src/TurbulenceModels/turbulenceModels/LES/DeardorffDiffStress/DeardorffDiffStress.C
View File

@ -202,9 +202,9 @@ void DeardorffDiffStress<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, R) + fvOptions(alpha, rho, R)
); );
REqn().relax(); REqn.ref().relax();
fvOptions.constrain(REqn()); fvOptions.constrain(REqn.ref());
REqn().solve(); REqn.ref().solve();
fvOptions.correct(R); fvOptions.correct(R);
this->boundNormalStress(R); this->boundNormalStress(R);

4
src/TurbulenceModels/turbulenceModels/LES/LESdeltas/IDDESDelta/IDDESDelta.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -66,7 +66,7 @@ void Foam::LESModels::IDDESDelta::calcDelta()
) )
); );
scalarField& faceToFacenMax = tfaceToFacenMax().internalField(); scalarField& faceToFacenMax = tfaceToFacenMax.ref().internalField();
const cellList& cells = mesh.cells(); const cellList& cells = mesh.cells();
const vectorField& faceCentres = mesh.faceCentres(); const vectorField& faceCentres = mesh.faceCentres();

27
src/TurbulenceModels/turbulenceModels/LES/LESdeltas/maxDeltaxyz/maxDeltaxyz.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -46,24 +46,8 @@ void Foam::LESModels::maxDeltaxyz::calcDelta()
label nD = mesh.nGeometricD(); label nD = mesh.nGeometricD();
tmp<volScalarField> hmax
(
new volScalarField
(
IOobject
(
"hmax",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensionedScalar("zrero", dimLength, 0.0)
)
);
const cellList& cells = mesh.cells(); const cellList& cells = mesh.cells();
scalarField hmax(cells.size());
forAll(cells,cellI) forAll(cells,cellI)
{ {
@ -81,12 +65,13 @@ void Foam::LESModels::maxDeltaxyz::calcDelta()
deltaMaxTmp = tmp; deltaMaxTmp = tmp;
} }
} }
hmax()[cellI] = deltaCoeff_*deltaMaxTmp;
hmax[cellI] = deltaCoeff_*deltaMaxTmp;
} }
if (nD == 3) if (nD == 3)
{ {
delta_.internalField() = hmax(); delta_.internalField() = hmax;
} }
else if (nD == 2) else if (nD == 2)
{ {
@ -94,7 +79,7 @@ void Foam::LESModels::maxDeltaxyz::calcDelta()
<< "Case is 2D, LES is not strictly applicable\n" << "Case is 2D, LES is not strictly applicable\n"
<< endl; << endl;
delta_.internalField() = hmax(); delta_.internalField() = hmax;
} }
else else
{ {

6
src/TurbulenceModels/turbulenceModels/LES/LESfilters/anisotropicFilter/anisotropicFilter.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -190,7 +190,7 @@ Foam::tmp<Foam::volSymmTensorField> Foam::anisotropicFilter::operator()
for (direction d=0; d<symmTensor::nComponents; d++) for (direction d=0; d<symmTensor::nComponents; d++)
{ {
tmpFilteredField().replace tmpFilteredField.ref().replace
( (
d, anisotropicFilter::operator()(unFilteredField().component(d)) d, anisotropicFilter::operator()(unFilteredField().component(d))
); );
@ -224,7 +224,7 @@ Foam::tmp<Foam::volTensorField> Foam::anisotropicFilter::operator()
for (direction d=0; d<tensor::nComponents; d++) for (direction d=0; d<tensor::nComponents; d++)
{ {
tmpFilteredField().replace tmpFilteredField.ref().replace
( (
d, anisotropicFilter::operator()(unFilteredField().component(d)) d, anisotropicFilter::operator()(unFilteredField().component(d))
); );

4
src/TurbulenceModels/turbulenceModels/LES/SpalartAllmarasDDES/SpalartAllmarasDDES.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -56,7 +56,7 @@ tmp<volScalarField> SpalartAllmarasDDES<BasicTurbulenceModel>::rd
scalar(10) scalar(10)
) )
); );
tr().boundaryField() == 0.0; tr.ref().boundaryField() == 0.0;
return tr; return tr;
} }

10
src/TurbulenceModels/turbulenceModels/LES/SpalartAllmarasDES/SpalartAllmarasDES.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -129,7 +129,7 @@ tmp<volScalarField> SpalartAllmarasDES<BasicTurbulenceModel>::r
scalar(10) scalar(10)
) )
); );
tr().boundaryField() == 0.0; tr.ref().boundaryField() == 0.0;
return tr; return tr;
} }
@ -158,7 +158,7 @@ tmp<volScalarField> SpalartAllmarasDES<BasicTurbulenceModel>::dTilda
) const ) const
{ {
tmp<volScalarField> tdTilda(CDES_*this->delta()); tmp<volScalarField> tdTilda(CDES_*this->delta());
min(tdTilda().dimensionedInternalField(), tdTilda(), y_); min(tdTilda.ref().dimensionedInternalField(), tdTilda(), y_);
return tdTilda; return tdTilda;
} }
@ -442,8 +442,8 @@ void SpalartAllmarasDES<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, nuTilda_) + fvOptions(alpha, rho, nuTilda_)
); );
nuTildaEqn().relax(); nuTildaEqn.ref().relax();
fvOptions.constrain(nuTildaEqn()); fvOptions.constrain(nuTildaEqn.ref());
solve(nuTildaEqn); solve(nuTildaEqn);
fvOptions.correct(nuTilda_); fvOptions.correct(nuTilda_);
bound(nuTilda_, dimensionedScalar("0", nuTilda_.dimensions(), 0.0)); bound(nuTilda_, dimensionedScalar("0", nuTilda_.dimensions(), 0.0));

6
src/TurbulenceModels/turbulenceModels/LES/dynamicKEqn/dynamicKEqn.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -274,8 +274,8 @@ void dynamicKEqn<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);

6
src/TurbulenceModels/turbulenceModels/LES/kEqn/kEqn.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -196,8 +196,8 @@ void kEqn<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);

2
src/TurbulenceModels/turbulenceModels/Make/options
View File

@ -1,4 +1,4 @@
EXE_INC = \ EXE_INC = -DCONST_TMP \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude -I$(LIB_SRC)/meshTools/lnInclude

12
src/TurbulenceModels/turbulenceModels/RAS/LRR/LRR.C
View File

@ -307,9 +307,9 @@ void LRR<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, epsilon_) + fvOptions(alpha, rho, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
fvOptions.constrain(epsEqn()); fvOptions.constrain(epsEqn.ref());
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
fvOptions.correct(epsilon_); fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_); bound(epsilon_, this->epsilonMin_);
@ -362,13 +362,13 @@ void LRR<BasicTurbulenceModel>::correct()
Cref1_*R - ((Cref2_*C2_)*(k_/epsilon_))*dev(P) Cref1_*R - ((Cref2_*C2_)*(k_/epsilon_))*dev(P)
); );
REqn() += REqn.ref() +=
((3*pow(Cmu_, 0.75)/kappa_)*(alpha*rho*sqrt(k_)/y_)) ((3*pow(Cmu_, 0.75)/kappa_)*(alpha*rho*sqrt(k_)/y_))
*dev(symm((n_ & reflect)*n_)); *dev(symm((n_ & reflect)*n_));
} }
REqn().relax(); REqn.ref().relax();
fvOptions.constrain(REqn()); fvOptions.constrain(REqn.ref());
solve(REqn); solve(REqn);
fvOptions.correct(R); fvOptions.correct(R);

10
src/TurbulenceModels/turbulenceModels/RAS/LaunderSharmaKE/LaunderSharmaKE.C
View File

@ -280,9 +280,9 @@ void LaunderSharmaKE<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, epsilon_) + fvOptions(alpha, rho, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
fvOptions.constrain(epsEqn()); fvOptions.constrain(epsEqn.ref());
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
fvOptions.correct(epsilon_); fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_); bound(epsilon_, this->epsilonMin_);
@ -301,8 +301,8 @@ void LaunderSharmaKE<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);

10
src/TurbulenceModels/turbulenceModels/RAS/RNGkEpsilon/RNGkEpsilon.C
View File

@ -288,9 +288,9 @@ void RNGkEpsilon<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, epsilon_) + fvOptions(alpha, rho, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
fvOptions.constrain(epsEqn()); fvOptions.constrain(epsEqn.ref());
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
fvOptions.correct(epsilon_); fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_); bound(epsilon_, this->epsilonMin_);
@ -311,8 +311,8 @@ void RNGkEpsilon<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);

10
src/TurbulenceModels/turbulenceModels/RAS/SSG/SSG.C
View File

@ -317,9 +317,9 @@ void SSG<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, epsilon_) + fvOptions(alpha, rho, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
fvOptions.constrain(epsEqn()); fvOptions.constrain(epsEqn.ref());
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
fvOptions.correct(epsilon_); fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_); bound(epsilon_, this->epsilonMin_);
@ -371,8 +371,8 @@ void SSG<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, R) + fvOptions(alpha, rho, R)
); );
REqn().relax(); REqn.ref().relax();
fvOptions.constrain(REqn()); fvOptions.constrain(REqn.ref());
solve(REqn); solve(REqn);
fvOptions.correct(R); fvOptions.correct(R);

4
src/TurbulenceModels/turbulenceModels/RAS/SpalartAllmaras/SpalartAllmaras.C
View File

@ -377,8 +377,8 @@ void SpalartAllmaras<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, nuTilda_) + fvOptions(alpha, rho, nuTilda_)
); );
nuTildaEqn().relax(); nuTildaEqn.ref().relax();
fvOptions.constrain(nuTildaEqn()); fvOptions.constrain(nuTildaEqn.ref());
solve(nuTildaEqn); solve(nuTildaEqn);
fvOptions.correct(nuTilda_); fvOptions.correct(nuTilda_);
bound(nuTilda_, dimensionedScalar("0", nuTilda_.dimensions(), 0.0)); bound(nuTilda_, dimensionedScalar("0", nuTilda_.dimensions(), 0.0));

10
src/TurbulenceModels/turbulenceModels/RAS/kEpsilon/kEpsilon.C
View File

@ -258,9 +258,9 @@ void kEpsilon<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, epsilon_) + fvOptions(alpha, rho, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
fvOptions.constrain(epsEqn()); fvOptions.constrain(epsEqn.ref());
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
fvOptions.correct(epsilon_); fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_); bound(epsilon_, this->epsilonMin_);
@ -279,8 +279,8 @@ void kEpsilon<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);

10
src/TurbulenceModels/turbulenceModels/RAS/kOmega/kOmega.C
View File

@ -221,9 +221,9 @@ void kOmega<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, omega_) + fvOptions(alpha, rho, omega_)
); );
omegaEqn().relax(); omegaEqn.ref().relax();
fvOptions.constrain(omegaEqn()); fvOptions.constrain(omegaEqn.ref());
omegaEqn().boundaryManipulate(omega_.boundaryField()); omegaEqn.ref().boundaryManipulate(omega_.boundaryField());
solve(omegaEqn); solve(omegaEqn);
fvOptions.correct(omega_); fvOptions.correct(omega_);
bound(omega_, this->omegaMin_); bound(omega_, this->omegaMin_);
@ -242,8 +242,8 @@ void kOmega<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);

12
src/TurbulenceModels/turbulenceModels/RAS/kOmegaSST/kOmegaSST.C
View File

@ -101,7 +101,7 @@ tmp<volScalarField> kOmegaSST<BasicTurbulenceModel>::kOmegaSST::F23() const
if (F3_) if (F3_)
{ {
f23() *= F3(); f23.ref() *= F3();
} }
return f23; return f23;
@ -452,9 +452,9 @@ void kOmegaSST<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, omega_) + fvOptions(alpha, rho, omega_)
); );
omegaEqn().relax(); omegaEqn.ref().relax();
fvOptions.constrain(omegaEqn()); fvOptions.constrain(omegaEqn.ref());
omegaEqn().boundaryManipulate(omega_.boundaryField()); omegaEqn.ref().boundaryManipulate(omega_.boundaryField());
solve(omegaEqn); solve(omegaEqn);
fvOptions.correct(omega_); fvOptions.correct(omega_);
bound(omega_, this->omegaMin_); bound(omega_, this->omegaMin_);
@ -474,8 +474,8 @@ void kOmegaSST<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);

10
src/TurbulenceModels/turbulenceModels/RAS/realizableKE/realizableKE.C
View File

@ -304,9 +304,9 @@ void realizableKE<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, epsilon_) + fvOptions(alpha, rho, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
fvOptions.constrain(epsEqn()); fvOptions.constrain(epsEqn.ref());
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
fvOptions.correct(epsilon_); fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_); bound(epsilon_, this->epsilonMin_);
@ -327,8 +327,8 @@ void realizableKE<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);

18
src/TurbulenceModels/turbulenceModels/RAS/v2f/v2f.C
View File

@ -329,9 +329,9 @@ void v2f<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, epsilon_) + fvOptions(alpha, rho, epsilon_)
); );
epsEqn().relax(); epsEqn.ref().relax();
fvOptions.constrain(epsEqn()); fvOptions.constrain(epsEqn.ref());
epsEqn().boundaryManipulate(epsilon_.boundaryField()); epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn); solve(epsEqn);
fvOptions.correct(epsilon_); fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_); bound(epsilon_, this->epsilonMin_);
@ -350,8 +350,8 @@ void v2f<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, k_) + fvOptions(alpha, rho, k_)
); );
kEqn().relax(); kEqn.ref().relax();
fvOptions.constrain(kEqn()); fvOptions.constrain(kEqn.ref());
solve(kEqn); solve(kEqn);
fvOptions.correct(k_); fvOptions.correct(k_);
bound(k_, this->kMin_); bound(k_, this->kMin_);
@ -366,8 +366,8 @@ void v2f<BasicTurbulenceModel>::correct()
- 1.0/L2/k_*(v2fAlpha - C2_*G) - 1.0/L2/k_*(v2fAlpha - C2_*G)
); );
fEqn().relax(); fEqn.ref().relax();
fvOptions.constrain(fEqn()); fvOptions.constrain(fEqn.ref());
solve(fEqn); solve(fEqn);
fvOptions.correct(f_); fvOptions.correct(f_);
bound(f_, fMin_); bound(f_, fMin_);
@ -385,8 +385,8 @@ void v2f<BasicTurbulenceModel>::correct()
+ fvOptions(alpha, rho, v2_) + fvOptions(alpha, rho, v2_)
); );
v2Eqn().relax(); v2Eqn.ref().relax();
fvOptions.constrain(v2Eqn()); fvOptions.constrain(v2Eqn.ref());
solve(v2Eqn); solve(v2Eqn);
fvOptions.correct(v2_); fvOptions.correct(v2_);
bound(v2_, v2Min_); bound(v2_, v2Min_);

2
src/TurbulenceModels/turbulenceModels/ReynoldsStress/ReynoldsStress.C
View File

@ -198,7 +198,7 @@ Foam::tmp<Foam::volScalarField>
Foam::ReynoldsStress<BasicTurbulenceModel>::k() const Foam::ReynoldsStress<BasicTurbulenceModel>::k() const
{ {
tmp<Foam::volScalarField> tk(0.5*tr(R_)); tmp<Foam::volScalarField> tk(0.5*tr(R_));
tk().rename("k"); tk.ref().rename("k");
return tk; return tk;
} }

8
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutURoughWallFunction/nutURoughWallFunctionFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -57,10 +57,10 @@ tmp<scalarField> nutURoughWallFunctionFvPatchScalarField::calcNut() const
const scalarField magUp(mag(Uw.patchInternalField() - Uw)); const scalarField magUp(mag(Uw.patchInternalField() - Uw));
tmp<scalarField> tyPlus = calcYPlus(magUp); tmp<scalarField> tyPlus = calcYPlus(magUp);
scalarField& yPlus = tyPlus(); scalarField& yPlus = tyPlus.ref();
tmp<scalarField> tnutw(new scalarField(patch().size(), 0.0)); tmp<scalarField> tnutw(new scalarField(patch().size(), 0.0));
scalarField& nutw = tnutw(); scalarField& nutw = tnutw.ref();
forAll(yPlus, facei) forAll(yPlus, facei)
{ {
@ -95,7 +95,7 @@ tmp<scalarField> nutURoughWallFunctionFvPatchScalarField::calcYPlus
const scalarField& nuw = tnuw(); const scalarField& nuw = tnuw();
tmp<scalarField> tyPlus(new scalarField(patch().size(), 0.0)); tmp<scalarField> tyPlus(new scalarField(patch().size(), 0.0));
scalarField& yPlus = tyPlus(); scalarField& yPlus = tyPlus.ref();
if (roughnessHeight_ > 0.0) if (roughnessHeight_ > 0.0)
{ {

4
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUSpaldingWallFunction/nutUSpaldingWallFunctionFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -87,7 +87,7 @@ tmp<scalarField> nutUSpaldingWallFunctionFvPatchScalarField::calcUTau
const scalarField& nutw = *this; const scalarField& nutw = *this;
tmp<scalarField> tuTau(new scalarField(patch().size(), 0.0)); tmp<scalarField> tuTau(new scalarField(patch().size(), 0.0));
scalarField& uTau = tuTau(); scalarField& uTau = tuTau.ref();
forAll(uTau, faceI) forAll(uTau, faceI)
{ {

4
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -72,7 +72,7 @@ tmp<scalarField> nutUTabulatedWallFunctionFvPatchScalarField::calcUPlus
) const ) const
{ {
tmp<scalarField> tuPlus(new scalarField(patch().size(), 0.0)); tmp<scalarField> tuPlus(new scalarField(patch().size(), 0.0));
scalarField& uPlus = tuPlus(); scalarField& uPlus = tuPlus.ref();
forAll(uPlus, faceI) forAll(uPlus, faceI)
{ {

8
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUWallFunction/nutUWallFunctionFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -54,10 +54,10 @@ tmp<scalarField> nutUWallFunctionFvPatchScalarField::calcNut() const
const scalarField& nuw = tnuw(); const scalarField& nuw = tnuw();
tmp<scalarField> tyPlus = calcYPlus(magUp); tmp<scalarField> tyPlus = calcYPlus(magUp);
scalarField& yPlus = tyPlus(); scalarField& yPlus = tyPlus.ref();
tmp<scalarField> tnutw(new scalarField(patch().size(), 0.0)); tmp<scalarField> tnutw(new scalarField(patch().size(), 0.0));
scalarField& nutw = tnutw(); scalarField& nutw = tnutw.ref();
forAll(yPlus, facei) forAll(yPlus, facei)
{ {
@ -92,7 +92,7 @@ tmp<scalarField> nutUWallFunctionFvPatchScalarField::calcYPlus
const scalarField& nuw = tnuw(); const scalarField& nuw = tnuw();
tmp<scalarField> tyPlus(new scalarField(patch().size(), 0.0)); tmp<scalarField> tyPlus(new scalarField(patch().size(), 0.0));
scalarField& yPlus = tyPlus(); scalarField& yPlus = tyPlus.ref();
forAll(yPlus, facei) forAll(yPlus, facei)
{ {

4
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutkAtmRoughWallFunction/nutkAtmRoughWallFunctionFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -57,7 +57,7 @@ tmp<scalarField> nutkAtmRoughWallFunctionFvPatchScalarField::calcNut() const
const scalar Cmu25 = pow025(Cmu_); const scalar Cmu25 = pow025(Cmu_);
tmp<scalarField> tnutw(new scalarField(*this)); tmp<scalarField> tnutw(new scalarField(*this));
scalarField& nutw = tnutw(); scalarField& nutw = tnutw.ref();
forAll(nutw, faceI) forAll(nutw, faceI)
{ {

4
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutkRoughWallFunction/nutkRoughWallFunctionFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -80,7 +80,7 @@ tmp<scalarField> nutkRoughWallFunctionFvPatchScalarField::calcNut() const
const scalar Cmu25 = pow025(Cmu_); const scalar Cmu25 = pow025(Cmu_);
tmp<scalarField> tnutw(new scalarField(*this)); tmp<scalarField> tnutw(new scalarField(*this));
scalarField& nutw = tnutw(); scalarField& nutw = tnutw.ref();
forAll(nutw, faceI) forAll(nutw, faceI)
{ {

4
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutkWallFunction/nutkWallFunctionFvPatchScalarField.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -59,7 +59,7 @@ tmp<scalarField> nutkWallFunctionFvPatchScalarField::calcNut() const
const scalar Cmu25 = pow025(Cmu_); const scalar Cmu25 = pow025(Cmu_);
tmp<scalarField> tnutw(new scalarField(patch().size(), 0.0)); tmp<scalarField> tnutw(new scalarField(patch().size(), 0.0));
scalarField& nutw = tnutw(); scalarField& nutw = tnutw.ref();
forAll(nutw, faceI) forAll(nutw, faceI)
{ {

6
src/TurbulenceModels/turbulenceModels/nonlinearEddyViscosity/nonlinearEddyViscosity.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2015-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -83,7 +83,7 @@ Foam::nonlinearEddyViscosity<BasicTurbulenceModel>::R() const
( (
eddyViscosity<BasicTurbulenceModel>::R() eddyViscosity<BasicTurbulenceModel>::R()
); );
tR() += nonlinearStress_; tR.ref() += nonlinearStress_;
return tR; return tR;
} }
@ -96,7 +96,7 @@ Foam::nonlinearEddyViscosity<BasicTurbulenceModel>::devRhoReff() const
( (
eddyViscosity<BasicTurbulenceModel>::devRhoReff() eddyViscosity<BasicTurbulenceModel>::devRhoReff()
); );
tdevRhoReff() += this->rho_*nonlinearStress_; tdevRhoReff.ref() += this->rho_*nonlinearStress_;
return tdevRhoReff; return tdevRhoReff;
} }

2
src/finiteVolume/Make/options
View File

@ -1,4 +1,4 @@
EXE_INC = \ EXE_INC = -DCONST_TMP \
-I$(LIB_SRC)/triSurface/lnInclude \ -I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude \

10
src/finiteVolume/cfdTools/general/MRF/MRFZoneList.C
View File

@ -180,7 +180,7 @@ Foam::tmp<Foam::volVectorField> Foam::MRFZoneList::DDt
dimensionedVector("0", U.dimensions()/dimTime, vector::zero) dimensionedVector("0", U.dimensions()/dimTime, vector::zero)
) )
); );
volVectorField& acceleration = tacceleration(); volVectorField& acceleration = tacceleration.ref();
forAll(*this, i) forAll(*this, i)
{ {
@ -238,7 +238,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::MRFZoneList::relative
) )
); );
makeRelative(rphi()); makeRelative(rphi.ref());
reuseTmpGeometricField<scalar, scalar, fvsPatchField, surfaceMesh> reuseTmpGeometricField<scalar, scalar, fvsPatchField, surfaceMesh>
::clear(tphi); ::clear(tphi);
@ -267,7 +267,7 @@ Foam::MRFZoneList::relative
forAll(*this, i) forAll(*this, i)
{ {
operator[](i).makeRelative(rphi()); operator[](i).makeRelative(rphi.ref());
} }
reuseTmpFieldField<fvsPatchField, scalar, scalar>::clear(tphi); reuseTmpFieldField<fvsPatchField, scalar, scalar>::clear(tphi);
@ -297,7 +297,7 @@ Foam::MRFZoneList::relative
forAll(*this, i) forAll(*this, i)
{ {
operator[](i).makeRelative(rphi(), patchi); operator[](i).makeRelative(rphi.ref(), patchi);
} }
reuseTmp<scalar, scalar>::clear(tphi); reuseTmp<scalar, scalar>::clear(tphi);
@ -361,7 +361,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::MRFZoneList::absolute
) )
); );
makeAbsolute(rphi()); makeAbsolute(rphi.ref());
reuseTmpGeometricField<scalar, scalar, fvsPatchField, surfaceMesh> reuseTmpGeometricField<scalar, scalar, fvsPatchField, surfaceMesh>
::clear(tphi); ::clear(tphi);

6
src/finiteVolume/cfdTools/general/SRF/SRFModel/SRFModel/SRFModel.C
View File

@ -226,7 +226,7 @@ Foam::tmp<Foam::volVectorField> Foam::SRF::SRFModel::Uabs() const
); );
// Add SRF contribution to internal field // Add SRF contribution to internal field
tUabs().internalField() += Urel_.internalField(); tUabs.ref().internalField() += Urel_.internalField();
// Add Urel boundary contributions // Add Urel boundary contributions
const volVectorField::GeometricBoundaryField& bvf = Urel_.boundaryField(); const volVectorField::GeometricBoundaryField& bvf = Urel_.boundaryField();
@ -241,12 +241,12 @@ Foam::tmp<Foam::volVectorField> Foam::SRF::SRFModel::Uabs() const
refCast<const SRFVelocityFvPatchVectorField>(bvf[i]); refCast<const SRFVelocityFvPatchVectorField>(bvf[i]);
if (UrelPatch.relative()) if (UrelPatch.relative())
{ {
tUabs().boundaryField()[i] += Urel_.boundaryField()[i]; tUabs.ref().boundaryField()[i] += Urel_.boundaryField()[i];
} }
} }
else else
{ {
tUabs().boundaryField()[i] += Urel_.boundaryField()[i]; tUabs.ref().boundaryField()[i] += Urel_.boundaryField()[i];
} }
} }

7
src/finiteVolume/cfdTools/general/constrainHbyA/constrainHbyA.C
View File

@ -40,16 +40,15 @@ Foam::tmp<Foam::volVectorField> Foam::constrainHbyA
if (tHbyA.isTmp()) if (tHbyA.isTmp())
{ {
volVectorField* HbyAPtr = tHbyA.ptr(); tHbyANew = tHbyA;
HbyAPtr->rename("HbyA"); tHbyANew.ref().rename("HbyA");
tHbyANew = HbyAPtr;
} }
else else
{ {
tHbyANew = new volVectorField("HbyA", tHbyA); tHbyANew = new volVectorField("HbyA", tHbyA);
} }
volVectorField& HbyA = tHbyANew(); volVectorField& HbyA = tHbyANew.ref();
forAll(U.boundaryField(), patchi) forAll(U.boundaryField(), patchi)
{ {

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

@ -47,7 +47,7 @@ Foam::tmp<Foam::fvMatrix<Type>> Foam::fv::optionList::operator()
const dimensionSet ds = field.dimensions()/dimTime*dimVolume; const dimensionSet ds = field.dimensions()/dimTime*dimVolume;
tmp<fvMatrix<Type>> tmtx(new fvMatrix<Type>(field, ds)); tmp<fvMatrix<Type>> tmtx(new fvMatrix<Type>(field, ds));
fvMatrix<Type>& mtx = tmtx(); fvMatrix<Type>& mtx = tmtx.ref();
forAll(*this, i) forAll(*this, i)
{ {
@ -103,7 +103,7 @@ Foam::tmp<Foam::fvMatrix<Type>> Foam::fv::optionList::operator()
); );
tmp<fvMatrix<Type>> tmtx(new fvMatrix<Type>(field, ds)); tmp<fvMatrix<Type>> tmtx(new fvMatrix<Type>(field, ds));
fvMatrix<Type>& mtx = tmtx(); fvMatrix<Type>& mtx = tmtx.ref();
forAll(*this, i) forAll(*this, i)
{ {
@ -162,7 +162,7 @@ Foam::tmp<Foam::fvMatrix<Type>> Foam::fv::optionList::operator()
); );
tmp<fvMatrix<Type>> tmtx(new fvMatrix<Type>(field, ds)); tmp<fvMatrix<Type>> tmtx(new fvMatrix<Type>(field, ds));
fvMatrix<Type>& mtx = tmtx(); fvMatrix<Type>& mtx = tmtx.ref();
forAll(*this, i) forAll(*this, i)
{ {

4
src/finiteVolume/cfdTools/general/porosityModel/porosityModel/porosityModel.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -158,7 +158,7 @@ Foam::tmp<Foam::vectorField> Foam::porosityModel::porosityModel::force
if (!cellZoneIDs_.empty()) if (!cellZoneIDs_.empty())
{ {
this->calcForce(U, rho, mu, tforce()); this->calcForce(U, rho, mu, tforce.ref());
} }
return tforce; return tforce;

2
src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.C
View File

@ -127,7 +127,7 @@ Foam::cyclicFvPatchField<Type>::patchNeighbourField() const
cyclicPatch().cyclicPatch().neighbPatch().faceCells(); cyclicPatch().cyclicPatch().neighbPatch().faceCells();
tmp<Field<Type>> tpnf(new Field<Type>(this->size())); tmp<Field<Type>> tpnf(new Field<Type>(this->size()));
Field<Type>& pnf = tpnf(); Field<Type>& pnf = tpnf.ref();
if (doTransform()) if (doTransform())

2
src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C
View File

@ -159,7 +159,7 @@ Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField() const
if (doTransform()) if (doTransform())
{ {
tpnf() = transform(forwardT(), tpnf()); tpnf.ref() = transform(forwardT(), tpnf());
} }
return tpnf; return tpnf;

2
src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.C
View File

@ -151,7 +151,7 @@ Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
if (doTransform()) if (doTransform())
{ {
tpnf() = transform(forwardT(), tpnf()); tpnf.ref() = transform(forwardT(), tpnf());
} }
return tpnf; return tpnf;

2
src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.C
View File

@ -98,7 +98,7 @@ Foam::jumpCyclicFvPatchField<Type>::patchNeighbourField() const
this->cyclicPatch().neighbFvPatch().faceCells(); this->cyclicPatch().neighbFvPatch().faceCells();
tmp<Field<Type>> tpnf(new Field<Type>(this->size())); tmp<Field<Type>> tpnf(new Field<Type>(this->size()));
Field<Type>& pnf = tpnf(); Field<Type>& pnf = tpnf.ref();
Field<Type> jf(this->jump()); Field<Type> jf(this->jump());
if (!this->cyclicPatch().owner()) if (!this->cyclicPatch().owner())

2
src/finiteVolume/fields/fvPatchFields/derived/mappedField/mappedPatchFieldBase.C
View File

@ -180,7 +180,7 @@ tmp<Field<Type>> mappedPatchFieldBase<Type>::mappedField() const
// Result of obtaining remote values // Result of obtaining remote values
tmp<Field<Type>> tnewValues(new Field<Type>(0)); tmp<Field<Type>> tnewValues(new Field<Type>(0));
Field<Type>& newValues = tnewValues(); Field<Type>& newValues = tnewValues.ref();
switch (mapper_.mode()) switch (mapper_.mode())
{ {

2
src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchFieldNew.C
View File

@ -80,7 +80,7 @@ Foam::tmp<Foam::fvPatchField<Type>> Foam::fvPatchField<Type>::New
// Check if constraint type override and store patchType if so // Check if constraint type override and store patchType if so
if ((patchTypeCstrIter != patchConstructorTablePtr_->end())) if ((patchTypeCstrIter != patchConstructorTablePtr_->end()))
{ {
tfvp().patchType() = actualPatchType; tfvp.ref().patchType() = actualPatchType;
} }
return tfvp; return tfvp;
} }

4
src/finiteVolume/finiteVolume/convectionSchemes/gaussConvectionScheme/gaussConvectionScheme.C
View File

@ -90,7 +90,7 @@ gaussConvectionScheme<Type>::fvmDiv
faceFlux.dimensions()*vf.dimensions() faceFlux.dimensions()*vf.dimensions()
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
fvm.lower() = -weights.internalField()*faceFlux.internalField(); fvm.lower() = -weights.internalField()*faceFlux.internalField();
fvm.upper() = fvm.lower() + faceFlux.internalField(); fvm.upper() = fvm.lower() + faceFlux.internalField();
@ -128,7 +128,7 @@ gaussConvectionScheme<Type>::fvcDiv
fvc::surfaceIntegrate(flux(faceFlux, vf)) fvc::surfaceIntegrate(flux(faceFlux, vf))
); );
tConvection().rename tConvection.ref().rename
( (
"convection(" + faceFlux.name() + ',' + vf.name() + ')' "convection(" + faceFlux.name() + ',' + vf.name() + ')'
); );

6
src/finiteVolume/finiteVolume/d2dt2Schemes/EulerD2dt2Scheme/EulerD2dt2Scheme.C
View File

@ -247,7 +247,7 @@ EulerD2dt2Scheme<Type>::fvmD2dt2
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar deltaT = mesh().time().deltaTValue(); scalar deltaT = mesh().time().deltaTValue();
scalar deltaT0 = mesh().time().deltaT0Value(); scalar deltaT0 = mesh().time().deltaT0Value();
@ -308,7 +308,7 @@ EulerD2dt2Scheme<Type>::fvmD2dt2
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar deltaT = mesh().time().deltaTValue(); scalar deltaT = mesh().time().deltaTValue();
scalar deltaT0 = mesh().time().deltaT0Value(); scalar deltaT0 = mesh().time().deltaT0Value();
@ -368,7 +368,7 @@ EulerD2dt2Scheme<Type>::fvmD2dt2
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar deltaT = mesh().time().deltaTValue(); scalar deltaT = mesh().time().deltaTValue();
scalar deltaT0 = mesh().time().deltaT0Value(); scalar deltaT0 = mesh().time().deltaT0Value();

12
src/finiteVolume/finiteVolume/ddtSchemes/CoEulerDdtScheme/CoEulerDdtScheme.C
View File

@ -61,7 +61,7 @@ tmp<volScalarField> CoEulerDdtScheme<Type>::CorDeltaT() const
) )
); );
volScalarField& corDeltaT = tcorDeltaT(); volScalarField& corDeltaT = tcorDeltaT.ref();
const labelUList& owner = mesh().owner(); const labelUList& owner = mesh().owner();
const labelUList& neighbour = mesh().neighbour(); const labelUList& neighbour = mesh().neighbour();
@ -183,7 +183,7 @@ CoEulerDdtScheme<Type>::fvcDdt
) )
); );
tdtdt().internalField() = tdtdt.ref().internalField() =
rDeltaT.internalField()*dt.value() rDeltaT.internalField()*dt.value()
*(1.0 - mesh().Vsc0()/mesh().Vsc()); *(1.0 - mesh().Vsc0()/mesh().Vsc());
@ -453,7 +453,7 @@ CoEulerDdtScheme<Type>::fvmDdt
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalarField rDeltaT(CorDeltaT()().internalField()); scalarField rDeltaT(CorDeltaT()().internalField());
@ -488,7 +488,7 @@ CoEulerDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalarField rDeltaT(CorDeltaT()().internalField()); scalarField rDeltaT(CorDeltaT()().internalField());
@ -525,7 +525,7 @@ CoEulerDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalarField rDeltaT(CorDeltaT()().internalField()); scalarField rDeltaT(CorDeltaT()().internalField());
@ -565,7 +565,7 @@ CoEulerDdtScheme<Type>::fvmDdt
alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalarField rDeltaT(CorDeltaT()().internalField()); scalarField rDeltaT(CorDeltaT()().internalField());

10
src/finiteVolume/finiteVolume/ddtSchemes/CrankNicolsonDdtScheme/CrankNicolsonDdtScheme.C
View File

@ -330,7 +330,7 @@ CrankNicolsonDdtScheme<Type>::fvcDdt
)/mesh().V0(); )/mesh().V0();
} }
tdtdt().dimensionedInternalField() = tdtdt.ref().dimensionedInternalField() =
( (
(rDtCoef*dt)*(mesh().V() - mesh().V0()) (rDtCoef*dt)*(mesh().V() - mesh().V0())
- mesh().V0()*offCentre_(ddt0.dimensionedInternalField()) - mesh().V0()*offCentre_(ddt0.dimensionedInternalField())
@ -773,7 +773,7 @@ CrankNicolsonDdtScheme<Type>::fvmDdt
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDtCoef = rDtCoef_(ddt0).value(); scalar rDtCoef = rDtCoef_(ddt0).value();
fvm.diag() = rDtCoef*mesh().V(); fvm.diag() = rDtCoef*mesh().V();
@ -855,7 +855,7 @@ CrankNicolsonDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDtCoef = rDtCoef_(ddt0).value(); scalar rDtCoef = rDtCoef_(ddt0).value();
fvm.diag() = rDtCoef*rho.value()*mesh().V(); fvm.diag() = rDtCoef*rho.value()*mesh().V();
@ -937,7 +937,7 @@ CrankNicolsonDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDtCoef = rDtCoef_(ddt0).value(); scalar rDtCoef = rDtCoef_(ddt0).value();
fvm.diag() = rDtCoef*rho.internalField()*mesh().V(); fvm.diag() = rDtCoef*rho.internalField()*mesh().V();
@ -1028,7 +1028,7 @@ CrankNicolsonDdtScheme<Type>::fvmDdt
alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDtCoef = rDtCoef_(ddt0).value(); scalar rDtCoef = rDtCoef_(ddt0).value();
fvm.diag() = rDtCoef*alpha.internalField()*rho.internalField()*mesh().V(); fvm.diag() = rDtCoef*alpha.internalField()*rho.internalField()*mesh().V();

10
src/finiteVolume/finiteVolume/ddtSchemes/EulerDdtScheme/EulerDdtScheme.C
View File

@ -73,7 +73,7 @@ EulerDdtScheme<Type>::fvcDdt
) )
); );
tdtdt().internalField() = tdtdt.ref().internalField() =
rDeltaT.value()*dt.value()*(1.0 - mesh().Vsc0()/mesh().Vsc()); rDeltaT.value()*dt.value()*(1.0 - mesh().Vsc0()/mesh().Vsc());
return tdtdt; return tdtdt;
@ -342,7 +342,7 @@ EulerDdtScheme<Type>::fvmDdt
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDeltaT = 1.0/mesh().time().deltaTValue(); scalar rDeltaT = 1.0/mesh().time().deltaTValue();
@ -377,7 +377,7 @@ EulerDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDeltaT = 1.0/mesh().time().deltaTValue(); scalar rDeltaT = 1.0/mesh().time().deltaTValue();
@ -414,7 +414,7 @@ EulerDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDeltaT = 1.0/mesh().time().deltaTValue(); scalar rDeltaT = 1.0/mesh().time().deltaTValue();
@ -454,7 +454,7 @@ EulerDdtScheme<Type>::fvmDdt
alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDeltaT = 1.0/mesh().time().deltaTValue(); scalar rDeltaT = 1.0/mesh().time().deltaTValue();

12
src/finiteVolume/finiteVolume/ddtSchemes/SLTSDdtScheme/SLTSDdtScheme.C
View File

@ -111,7 +111,7 @@ tmp<volScalarField> SLTSDdtScheme<Type>::SLrDeltaT() const
) )
); );
volScalarField& rDeltaT = trDeltaT(); volScalarField& rDeltaT = trDeltaT.ref();
relaxedDiag(rDeltaT, phi); relaxedDiag(rDeltaT, phi);
@ -183,7 +183,7 @@ SLTSDdtScheme<Type>::fvcDdt
) )
); );
tdtdt().internalField() = tdtdt.ref().internalField() =
rDeltaT.internalField()*dt.value()*(1.0 - mesh().V0()/mesh().V()); rDeltaT.internalField()*dt.value()*(1.0 - mesh().V0()/mesh().V());
return tdtdt; return tdtdt;
@ -452,7 +452,7 @@ SLTSDdtScheme<Type>::fvmDdt
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalarField rDeltaT(SLrDeltaT()().internalField()); scalarField rDeltaT(SLrDeltaT()().internalField());
@ -487,7 +487,7 @@ SLTSDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalarField rDeltaT(SLrDeltaT()().internalField()); scalarField rDeltaT(SLrDeltaT()().internalField());
@ -524,7 +524,7 @@ SLTSDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalarField rDeltaT(SLrDeltaT()().internalField()); scalarField rDeltaT(SLrDeltaT()().internalField());
@ -564,7 +564,7 @@ SLTSDdtScheme<Type>::fvmDdt
alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalarField rDeltaT(SLrDeltaT()().internalField()); scalarField rDeltaT(SLrDeltaT()().internalField());

10
src/finiteVolume/finiteVolume/ddtSchemes/backwardDdtScheme/backwardDdtScheme.C
View File

@ -111,7 +111,7 @@ backwardDdtScheme<Type>::fvcDdt
) )
); );
tdtdt().internalField() = rDeltaT.value()*dt.value()* tdtdt.ref().internalField() = rDeltaT.value()*dt.value()*
( (
coefft - (coefft0*mesh().V0() - coefft00*mesh().V00())/mesh().V() coefft - (coefft0*mesh().V0() - coefft00*mesh().V00())/mesh().V()
); );
@ -467,7 +467,7 @@ backwardDdtScheme<Type>::fvmDdt
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDeltaT = 1.0/deltaT_(); scalar rDeltaT = 1.0/deltaT_();
@ -518,7 +518,7 @@ backwardDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDeltaT = 1.0/deltaT_(); scalar rDeltaT = 1.0/deltaT_();
@ -569,7 +569,7 @@ backwardDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDeltaT = 1.0/deltaT_(); scalar rDeltaT = 1.0/deltaT_();
@ -624,7 +624,7 @@ backwardDdtScheme<Type>::fvmDdt
alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
scalar rDeltaT = 1.0/deltaT_(); scalar rDeltaT = 1.0/deltaT_();

30
src/finiteVolume/finiteVolume/ddtSchemes/boundedDdtScheme/boundedDdtScheme.C
View File

@ -48,7 +48,7 @@ boundedDdtScheme<Type>::fvcDdt
const dimensioned<Type>& dt const dimensioned<Type>& dt
) )
{ {
return scheme_().fvcDdt(dt); return scheme_.ref().fvcDdt(dt);
} }
@ -59,7 +59,7 @@ boundedDdtScheme<Type>::fvcDdt
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().fvcDdt(vf); return scheme_.ref().fvcDdt(vf);
} }
@ -71,7 +71,7 @@ boundedDdtScheme<Type>::fvcDdt
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().fvcDdt(rho, vf); return scheme_.ref().fvcDdt(rho, vf);
} }
@ -83,7 +83,7 @@ boundedDdtScheme<Type>::fvcDdt
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().fvcDdt(rho, vf) - fvc::ddt(rho)*vf; return scheme_.ref().fvcDdt(rho, vf) - fvc::ddt(rho)*vf;
} }
@ -96,7 +96,7 @@ boundedDdtScheme<Type>::fvcDdt
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().fvcDdt(alpha, rho, vf) - fvc::ddt(alpha, rho)*vf; return scheme_.ref().fvcDdt(alpha, rho, vf) - fvc::ddt(alpha, rho)*vf;
} }
@ -107,7 +107,7 @@ boundedDdtScheme<Type>::fvmDdt
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().fvmDdt(vf); return scheme_.ref().fvmDdt(vf);
} }
@ -119,7 +119,7 @@ boundedDdtScheme<Type>::fvmDdt
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().fvmDdt(rho, vf); return scheme_.ref().fvmDdt(rho, vf);
} }
@ -131,7 +131,7 @@ boundedDdtScheme<Type>::fvmDdt
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().fvmDdt(rho, vf) - fvm::Sp(fvc::ddt(rho), vf); return scheme_.ref().fvmDdt(rho, vf) - fvm::Sp(fvc::ddt(rho), vf);
} }
@ -144,7 +144,9 @@ boundedDdtScheme<Type>::fvmDdt
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().fvmDdt(alpha, rho, vf) - fvm::Sp(fvc::ddt(alpha, rho), vf); return
scheme_.ref().fvmDdt(alpha, rho, vf)
- fvm::Sp(fvc::ddt(alpha, rho), vf);
} }
@ -156,7 +158,7 @@ boundedDdtScheme<Type>::fvcDdtUfCorr
const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
) )
{ {
return scheme_().fvcDdtUfCorr(U, Uf); return scheme_.ref().fvcDdtUfCorr(U, Uf);
} }
@ -168,7 +170,7 @@ boundedDdtScheme<Type>::fvcDdtPhiCorr
const fluxFieldType& phi const fluxFieldType& phi
) )
{ {
return scheme_().fvcDdtPhiCorr(U, phi); return scheme_.ref().fvcDdtPhiCorr(U, phi);
} }
@ -181,7 +183,7 @@ boundedDdtScheme<Type>::fvcDdtUfCorr
const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
) )
{ {
return scheme_().fvcDdtUfCorr(rho, U, Uf); return scheme_.ref().fvcDdtUfCorr(rho, U, Uf);
} }
@ -194,7 +196,7 @@ boundedDdtScheme<Type>::fvcDdtPhiCorr
const fluxFieldType& phi const fluxFieldType& phi
) )
{ {
return scheme_().fvcDdtPhiCorr(rho, U, phi); return scheme_.ref().fvcDdtPhiCorr(rho, U, phi);
} }
@ -204,7 +206,7 @@ tmp<surfaceScalarField> boundedDdtScheme<Type>::meshPhi
const GeometricField<Type, fvPatchField, volMesh>& vf const GeometricField<Type, fvPatchField, volMesh>& vf
) )
{ {
return scheme_().meshPhi(vf); return scheme_.ref().meshPhi(vf);
} }

2
src/finiteVolume/finiteVolume/ddtSchemes/ddtScheme/ddtScheme.C
View File

@ -148,7 +148,7 @@ tmp<surfaceScalarField> ddtScheme<Type>::fvcDdtPhiCoeff
scalar(1) scalar(1)
); );
surfaceScalarField& ddtCouplingCoeff = tddtCouplingCoeff(); surfaceScalarField& ddtCouplingCoeff = tddtCouplingCoeff.ref();
forAll(U.boundaryField(), patchi) forAll(U.boundaryField(), patchi)
{ {

10
src/finiteVolume/finiteVolume/ddtSchemes/localEulerDdtScheme/localEulerDdtScheme.C
View File

@ -79,7 +79,7 @@ localEulerDdtScheme<Type>::fvcDdt
) )
); );
tdtdt().internalField() = tdtdt.ref().internalField() =
rDeltaT.internalField()*dt.value() rDeltaT.internalField()*dt.value()
*(1.0 - mesh().Vsc0()/mesh().Vsc()); *(1.0 - mesh().Vsc0()/mesh().Vsc());
@ -349,7 +349,7 @@ localEulerDdtScheme<Type>::fvmDdt
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
const scalarField& rDeltaT = localRDeltaT().internalField(); const scalarField& rDeltaT = localRDeltaT().internalField();
@ -384,7 +384,7 @@ localEulerDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
const scalarField& rDeltaT = localRDeltaT().internalField(); const scalarField& rDeltaT = localRDeltaT().internalField();
@ -421,7 +421,7 @@ localEulerDdtScheme<Type>::fvmDdt
rho.dimensions()*vf.dimensions()*dimVol/dimTime rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
const scalarField& rDeltaT = localRDeltaT().internalField(); const scalarField& rDeltaT = localRDeltaT().internalField();
@ -461,7 +461,7 @@ localEulerDdtScheme<Type>::fvmDdt
alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
) )
); );
fvMatrix<Type>& fvm = tfvm(); fvMatrix<Type>& fvm = tfvm.ref();
const scalarField& rDeltaT = localRDeltaT().internalField(); const scalarField& rDeltaT = localRDeltaT().internalField();

4
src/finiteVolume/finiteVolume/divSchemes/gaussDivScheme/gaussDivScheme.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 | \\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -62,7 +62,7 @@ gaussDivScheme<Type>::fvcDiv
) )
); );
tDiv().rename("div(" + vf.name() + ')'); tDiv.ref().rename("div(" + vf.name() + ')');
return tDiv; return tDiv;
} }

3
src/finiteVolume/finiteVolume/fvc/fvcAverage.C
View File

@ -65,8 +65,7 @@ average
ssf.dimensions() ssf.dimensions()
) )
); );
GeometricField<Type, fvPatchField, volMesh>& av = taverage.ref();
GeometricField<Type, fvPatchField, volMesh>& av = taverage();
av.internalField() = av.internalField() =
( (

18
src/finiteVolume/finiteVolume/fvc/fvcDdt.C
View File

@ -51,7 +51,7 @@ ddt
( (
mesh, mesh,
mesh.ddtScheme("ddt(" + dt.name() + ')') mesh.ddtScheme("ddt(" + dt.name() + ')')
)().fvcDdt(dt); ).ref().fvcDdt(dt);
} }
@ -66,7 +66,7 @@ ddt
( (
vf.mesh(), vf.mesh(),
vf.mesh().ddtScheme("ddt(" + vf.name() + ')') vf.mesh().ddtScheme("ddt(" + vf.name() + ')')
)().fvcDdt(vf); ).ref().fvcDdt(vf);
} }
@ -82,7 +82,7 @@ ddt
( (
vf.mesh(), vf.mesh(),
vf.mesh().ddtScheme("ddt(" + rho.name() + ',' + vf.name() + ')') vf.mesh().ddtScheme("ddt(" + rho.name() + ',' + vf.name() + ')')
)().fvcDdt(rho, vf); ).ref().fvcDdt(rho, vf);
} }
@ -98,7 +98,7 @@ ddt
( (
vf.mesh(), vf.mesh(),
vf.mesh().ddtScheme("ddt(" + rho.name() + ',' + vf.name() + ')') vf.mesh().ddtScheme("ddt(" + rho.name() + ',' + vf.name() + ')')
)().fvcDdt(rho, vf); ).ref().fvcDdt(rho, vf);
} }
@ -121,7 +121,7 @@ ddt
+ rho.name() + ',' + rho.name() + ','
+ vf.name() + ')' + vf.name() + ')'
) )
)().fvcDdt(alpha, rho, vf); ).ref().fvcDdt(alpha, rho, vf);
} }
@ -161,7 +161,7 @@ ddtCorr
( (
U.mesh(), U.mesh(),
U.mesh().ddtScheme("ddt(" + U.name() + ')') U.mesh().ddtScheme("ddt(" + U.name() + ')')
)().fvcDdtUfCorr(U, Uf); ).ref().fvcDdtUfCorr(U, Uf);
} }
@ -182,7 +182,7 @@ ddtCorr
( (
U.mesh(), U.mesh(),
U.mesh().ddtScheme("ddt(" + U.name() + ')') U.mesh().ddtScheme("ddt(" + U.name() + ')')
)().fvcDdtPhiCorr(U, phi); ).ref().fvcDdtPhiCorr(U, phi);
} }
@ -199,7 +199,7 @@ ddtCorr
( (
U.mesh(), U.mesh(),
U.mesh().ddtScheme("ddt(" + U.name() + ')') U.mesh().ddtScheme("ddt(" + U.name() + ')')
)().fvcDdtUfCorr(rho, U, Uf); ).ref().fvcDdtUfCorr(rho, U, Uf);
} }
@ -221,7 +221,7 @@ ddtCorr
( (
U.mesh(), U.mesh(),
U.mesh().ddtScheme("ddt(" + rho.name() + ',' + U.name() + ')') U.mesh().ddtScheme("ddt(" + rho.name() + ',' + U.name() + ')')
)().fvcDdtPhiCorr(rho, U, phi); ).ref().fvcDdtPhiCorr(rho, U, phi);
} }

4
src/finiteVolume/finiteVolume/fvc/fvcDiv.C
View File

@ -89,7 +89,7 @@ div
return fv::divScheme<Type>::New return fv::divScheme<Type>::New
( (
vf.mesh(), vf.mesh().divScheme(name) vf.mesh(), vf.mesh().divScheme(name)
)().fvcDiv(vf); ).ref().fvcDiv(vf);
} }
@ -167,7 +167,7 @@ div
vf.mesh(), vf.mesh(),
flux, flux,
vf.mesh().divScheme(name) vf.mesh().divScheme(name)
)().fvcDiv(flux, vf); ).ref().fvcDiv(flux, vf);
} }

6
src/finiteVolume/finiteVolume/fvc/fvcLaplacian.C
View File

@ -51,7 +51,7 @@ laplacian
( (
vf.mesh(), vf.mesh(),
vf.mesh().laplacianScheme(name) vf.mesh().laplacianScheme(name)
)().fvcLaplacian(vf); ).ref().fvcLaplacian(vf);
} }
@ -202,7 +202,7 @@ laplacian
( (
vf.mesh(), vf.mesh(),
vf.mesh().laplacianScheme(name) vf.mesh().laplacianScheme(name)
)().fvcLaplacian(gamma, vf); ).ref().fvcLaplacian(gamma, vf);
} }
@ -344,7 +344,7 @@ laplacian
( (
vf.mesh(), vf.mesh(),
vf.mesh().laplacianScheme(name) vf.mesh().laplacianScheme(name)
)().fvcLaplacian(gamma, vf); ).ref().fvcLaplacian(gamma, vf);
} }

3
src/finiteVolume/finiteVolume/fvc/fvcMagSqrGradGrad.C
View File

@ -53,7 +53,8 @@ tmp<volScalarField> magSqrGradGrad
// Loop over other vector field components // Loop over other vector field components
for (direction cmpt = 1; cmpt < pTraits<Type>::nComponents; cmpt++) for (direction cmpt = 1; cmpt < pTraits<Type>::nComponents; cmpt++)
{ {
tMagSqrGradGrad() += magSqr(fvc::grad(fvc::grad(vf.component(cmpt))))(); tMagSqrGradGrad.ref() +=
magSqr(fvc::grad(fvc::grad(vf.component(cmpt))))();
} }
return tMagSqrGradGrad; return tMagSqrGradGrad;

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