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

boundedBackwardDdtScheme: Removed; it is total nonsense and would cause serious conservation errors

Browse Source
This commit is contained in:
Henry
2013-05-03 15:47:15 +01:00
parent d13c9810e8
commit 000dd24b87
4 changed files with 0 additions and 947 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/finiteVolume/Make/files
View File

@ -321,8 +321,6 @@ $(ddtSchemes)/CoEulerDdtScheme/CoEulerDdtSchemes.C
$(ddtSchemes)/SLTSDdtScheme/SLTSDdtSchemes.C $(ddtSchemes)/SLTSDdtScheme/SLTSDdtSchemes.C
$(ddtSchemes)/localEulerDdtScheme/localEulerDdtSchemes.C $(ddtSchemes)/localEulerDdtScheme/localEulerDdtSchemes.C
$(ddtSchemes)/backwardDdtScheme/backwardDdtSchemes.C $(ddtSchemes)/backwardDdtScheme/backwardDdtSchemes.C
$(ddtSchemes)/boundedBackwardDdtScheme/boundedBackwardDdtScheme.C
$(ddtSchemes)/boundedBackwardDdtScheme/boundedBackwardDdtSchemes.C
$(ddtSchemes)/CrankNicolsonDdtScheme/CrankNicolsonDdtSchemes.C $(ddtSchemes)/CrankNicolsonDdtScheme/CrankNicolsonDdtSchemes.C
$(ddtSchemes)/boundedDdtScheme/boundedDdtSchemes.C $(ddtSchemes)/boundedDdtScheme/boundedDdtSchemes.C

708
src/finiteVolume/finiteVolume/ddtSchemes/boundedBackwardDdtScheme/boundedBackwardDdtScheme.C
View File

@ -1,708 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "boundedBackwardDdtScheme.H"
#include "surfaceInterpolate.H"
#include "fvcDiv.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace fv
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
scalar boundedBackwardDdtScheme::deltaT_() const
{
return mesh().time().deltaTValue();
}
scalar boundedBackwardDdtScheme::deltaT0_() const
{
return mesh().time().deltaT0Value();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
tmp<volScalarField>
boundedBackwardDdtScheme::fvcDdt
(
const dimensionedScalar& dt
)
{
// No change compared to backward
dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
IOobject ddtIOobject
(
"ddt("+dt.name()+')',
mesh().time().timeName(),
mesh()
);
scalar deltaT = deltaT_();
scalar deltaT0 = deltaT0_();
scalar coefft = 1 + deltaT/(deltaT + deltaT0);
scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
scalar coefft0 = coefft + coefft00;
if (mesh().moving())
{
tmp<volScalarField> tdtdt
(
new volScalarField
(
ddtIOobject,
mesh(),
dimensionedScalar
(
"0",
dt.dimensions()/dimTime,
0.0
)
)
);
tdtdt().internalField() = rDeltaT.value()*dt.value()*
(
coefft - (coefft0*mesh().V0() - coefft00*mesh().V00())/mesh().V()
);
return tdtdt;
}
else
{
return tmp<volScalarField>
(
new volScalarField
(
ddtIOobject,
mesh(),
dimensionedScalar
(
"0",
dt.dimensions()/dimTime,
0.0
),
calculatedFvPatchScalarField::typeName
)
);
}
}
tmp<volScalarField>
boundedBackwardDdtScheme::fvcDdt
(
const volScalarField& vf
)
{
dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
IOobject ddtIOobject
(
"ddt("+vf.name()+')',
mesh().time().timeName(),
mesh()
);
scalar deltaT = deltaT_();
scalar deltaT0 = deltaT0_(vf);
// Calculate unboundedness indicator
// Note: all times moved by one because access to internal field
// copies current field into the old-time level.
const volScalarField phict
(
mag
(
vf.oldTime().oldTime()
- vf.oldTime().oldTime().oldTime()
)/
(
mag
(
vf.oldTime()
- vf.oldTime().oldTime()
)
+ dimensionedScalar("small", vf.dimensions(), VSMALL)
)
);
const volScalarField limiter(pos(phict) - pos(phict - scalar(1)));
const volScalarField coefft(scalar(1) + limiter*deltaT/(deltaT + deltaT0));
const volScalarField coefft00
(
limiter*sqr(deltaT)/(deltaT0*(deltaT + deltaT0))
);
const volScalarField coefft0(coefft + coefft00);
if (mesh().moving())
{
return tmp<volScalarField>
(
new volScalarField
(
ddtIOobject,
mesh(),
rDeltaT.dimensions()*vf.dimensions(),
rDeltaT.value()*
(
coefft*vf.internalField() -
(
coefft0.internalField()
*vf.oldTime().internalField()*mesh().V0()
- coefft00.internalField()
*vf.oldTime().oldTime().internalField()
*mesh().V00()
)/mesh().V()
),
rDeltaT.value()*
(
coefft.boundaryField()*vf.boundaryField() -
(
coefft0.boundaryField()*
vf.oldTime().boundaryField()
- coefft00.boundaryField()*
vf.oldTime().oldTime().boundaryField()
)
)
)
);
}
else
{
return tmp<volScalarField>
(
new volScalarField
(
ddtIOobject,
rDeltaT*
(
coefft*vf
- coefft0*vf.oldTime()
+ coefft00*vf.oldTime().oldTime()
)
)
);
}
}
tmp<volScalarField>
boundedBackwardDdtScheme::fvcDdt
(
const dimensionedScalar& rho,
const volScalarField& vf
)
{
dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
IOobject ddtIOobject
(
"ddt("+rho.name()+','+vf.name()+')',
mesh().time().timeName(),
mesh()
);
scalar deltaT = deltaT_();
scalar deltaT0 = deltaT0_(vf);
// Calculate unboundedness indicator
// Note: all times moved by one because access to internal field
// copies current field into the old-time level.
const volScalarField phict
(
mag
(
vf.oldTime().oldTime()
- vf.oldTime().oldTime().oldTime()
)/
(
mag
(
vf.oldTime()
- vf.oldTime().oldTime()
)
+ dimensionedScalar("small", vf.dimensions(), VSMALL)
)
);
const volScalarField limiter(pos(phict) - pos(phict - scalar(1)));
const volScalarField coefft(scalar(1) + limiter*deltaT/(deltaT + deltaT0));
const volScalarField coefft00
(
limiter*sqr(deltaT)/(deltaT0*(deltaT + deltaT0))
);
const volScalarField coefft0(coefft + coefft00);
if (mesh().moving())
{
return tmp<volScalarField>
(
new volScalarField
(
ddtIOobject,
mesh(),
rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
rDeltaT.value()*rho.value()*
(
coefft*vf.internalField() -
(
coefft0.internalField()*
vf.oldTime().internalField()*mesh().V0()
- coefft00.internalField()*
vf.oldTime().oldTime().internalField()
*mesh().V00()
)/mesh().V()
),
rDeltaT.value()*rho.value()*
(
coefft.boundaryField()*vf.boundaryField() -
(
coefft0.boundaryField()*
vf.oldTime().boundaryField()
- coefft00.boundaryField()*
vf.oldTime().oldTime().boundaryField()
)
)
)
);
}
else
{
return tmp<volScalarField>
(
new volScalarField
(
ddtIOobject,
rDeltaT*rho*
(
coefft*vf
- coefft0*vf.oldTime()
+ coefft00*vf.oldTime().oldTime()
)
)
);
}
}
tmp<volScalarField>
boundedBackwardDdtScheme::fvcDdt
(
const volScalarField& rho,
const volScalarField& vf
)
{
dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
IOobject ddtIOobject
(
"ddt("+rho.name()+','+vf.name()+')',
mesh().time().timeName(),
mesh()
);
scalar deltaT = deltaT_();
scalar deltaT0 = deltaT0_(vf);
// Calculate unboundedness indicator
// Note: all times moved by one because access to internal field
// copies current field into the old-time level.
const volScalarField phict
(
mag
(
rho.oldTime().oldTime()*vf.oldTime().oldTime()
- rho.oldTime().oldTime().oldTime()*vf.oldTime().oldTime().oldTime()
)/
(
mag
(
rho.oldTime()*vf.oldTime()
- rho.oldTime().oldTime()*vf.oldTime().oldTime()
)
+ dimensionedScalar("small", rho.dimensions()*vf.dimensions(), VSMALL)
)
);
const volScalarField limiter(pos(phict) - pos(phict - scalar(1)));
const volScalarField coefft(scalar(1) + limiter*deltaT/(deltaT + deltaT0));
const volScalarField coefft00
(
limiter*sqr(deltaT)/(deltaT0*(deltaT + deltaT0))
);
const volScalarField coefft0(coefft + coefft00);
if (mesh().moving())
{
return tmp<volScalarField>
(
new volScalarField
(
ddtIOobject,
mesh(),
rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
rDeltaT.value()*
(
coefft*rho.internalField()*vf.internalField() -
(
coefft0.internalField()*
rho.oldTime().internalField()*
vf.oldTime().internalField()*mesh().V0()
- coefft00.internalField()*
rho.oldTime().oldTime().internalField()
*vf.oldTime().oldTime().internalField()*mesh().V00()
)/mesh().V()
),
rDeltaT.value()*
(
coefft.boundaryField()*vf.boundaryField() -
(
coefft0.boundaryField()*
rho.oldTime().boundaryField()*
vf.oldTime().boundaryField()
- coefft00.boundaryField()*
rho.oldTime().oldTime().boundaryField()*
vf.oldTime().oldTime().boundaryField()
)
)
)
);
}
else
{
return tmp<volScalarField>
(
new volScalarField
(
ddtIOobject,
rDeltaT*
(
coefft*rho*vf
- coefft0*rho.oldTime()*vf.oldTime()
+ coefft00*rho.oldTime().oldTime()*vf.oldTime().oldTime()
)
)
);
}
}
tmp<fvScalarMatrix>
boundedBackwardDdtScheme::fvmDdt
(
const volScalarField& vf
)
{
tmp<fvScalarMatrix> tfvm
(
new fvScalarMatrix
(
vf,
vf.dimensions()*dimVol/dimTime
)
);
fvScalarMatrix& fvm = tfvm();
scalar rDeltaT = 1.0/deltaT_();
scalar deltaT = deltaT_();
scalar deltaT0 = deltaT0_(vf);
// Calculate unboundedness indicator
// Note: all times moved by one because access to internal field
// copies current field into the old-time level.
const scalarField phict
(
mag
(
vf.oldTime().oldTime().internalField()
- vf.oldTime().oldTime().oldTime().internalField()
)/
(
mag
(
vf.oldTime().internalField()
- vf.oldTime().oldTime().internalField()
)
+ VSMALL
)
);
const scalarField limiter(pos(phict) - pos(phict - 1.0));
const scalarField coefft(1.0 + limiter*deltaT/(deltaT + deltaT0));
const scalarField coefft00
(
limiter*deltaT*deltaT/(deltaT0*(deltaT + deltaT0))
);
const scalarField coefft0(coefft + coefft00);
fvm.diag() = (coefft*rDeltaT)*mesh().V();
if (mesh().moving())
{
fvm.source() = rDeltaT*
(
coefft0*vf.oldTime().internalField()*mesh().V0()
- coefft00*vf.oldTime().oldTime().internalField()
*mesh().V00()
);
}
else
{
fvm.source() = rDeltaT*mesh().V()*
(
coefft0*vf.oldTime().internalField()
- coefft00*vf.oldTime().oldTime().internalField()
);
}
return tfvm;
}
tmp<fvScalarMatrix>
boundedBackwardDdtScheme::fvmDdt
(
const dimensionedScalar& rho,
const volScalarField& vf
)
{
tmp<fvScalarMatrix> tfvm
(
new fvScalarMatrix
(
vf,
rho.dimensions()*vf.dimensions()*dimVol/dimTime
)
);
fvScalarMatrix& fvm = tfvm();
scalar rDeltaT = 1.0/deltaT_();
scalar deltaT = deltaT_();
scalar deltaT0 = deltaT0_(vf);
// Calculate unboundedness indicator
// Note: all times moved by one because access to internal field
// copies current field into the old-time level.
const scalarField phict
(
mag
(
vf.oldTime().oldTime().internalField()
- vf.oldTime().oldTime().oldTime().internalField()
)/
(
mag
(
vf.oldTime().internalField()
- vf.oldTime().oldTime().internalField()
)
+ VSMALL
)
);
const scalarField limiter(pos(phict) - pos(phict - 1.0));
const scalarField coefft(1.0 + limiter*deltaT/(deltaT + deltaT0));
const scalarField coefft00
(
limiter*deltaT*deltaT/(deltaT0*(deltaT + deltaT0))
);
const scalarField coefft0(coefft + coefft00);
fvm.diag() = (coefft*rDeltaT*rho.value())*mesh().V();
if (mesh().moving())
{
fvm.source() = rDeltaT*rho.value()*
(
coefft0*vf.oldTime().internalField()*mesh().V0()
- coefft00*vf.oldTime().oldTime().internalField()
*mesh().V00()
);
}
else
{
fvm.source() = rDeltaT*mesh().V()*rho.value()*
(
coefft0*vf.oldTime().internalField()
- coefft00*vf.oldTime().oldTime().internalField()
);
}
return tfvm;
}
tmp<fvScalarMatrix>
boundedBackwardDdtScheme::fvmDdt
(
const volScalarField& rho,
const volScalarField& vf
)
{
tmp<fvScalarMatrix> tfvm
(
new fvScalarMatrix
(
vf,
rho.dimensions()*vf.dimensions()*dimVol/dimTime
)
);
fvScalarMatrix& fvm = tfvm();
scalar rDeltaT = 1.0/deltaT_();
scalar deltaT = deltaT_();
scalar deltaT0 = deltaT0_(vf);
// Calculate unboundedness indicator
// Note: all times moved by one because access to internal field
// copies current field into the old-time level.
const scalarField phict
(
mag
(
rho.oldTime().oldTime().internalField()*
vf.oldTime().oldTime().internalField()
- rho.oldTime().oldTime().oldTime().internalField()*
vf.oldTime().oldTime().oldTime().internalField()
)/
(
mag
(
rho.oldTime().internalField()*
vf.oldTime().internalField()
- rho.oldTime().oldTime().internalField()*
vf.oldTime().oldTime().internalField()
)
+ VSMALL
)
);
const scalarField limiter(pos(phict) - pos(phict - 1.0));
const scalarField coefft(1.0 + limiter*deltaT/(deltaT + deltaT0));
const scalarField coefft00
(
limiter*deltaT*deltaT/(deltaT0*(deltaT + deltaT0))
);
const scalarField coefft0(coefft + coefft00);
fvm.diag() = (coefft*rDeltaT)*rho.internalField()*mesh().V();
if (mesh().moving())
{
fvm.source() = rDeltaT*
(
coefft0*rho.oldTime().internalField()
*vf.oldTime().internalField()*mesh().V0()
- coefft00*rho.oldTime().oldTime().internalField()
*vf.oldTime().oldTime().internalField()*mesh().V00()
);
}
else
{
fvm.source() = rDeltaT*mesh().V()*
(
coefft0*rho.oldTime().internalField()
*vf.oldTime().internalField()
- coefft00*rho.oldTime().oldTime().internalField()
*vf.oldTime().oldTime().internalField()
);
}
return tfvm;
}
tmp<surfaceScalarField> boundedBackwardDdtScheme::fvcDdtPhiCorr
(
const volScalarField& rA,
const volScalarField& U,
const surfaceScalarField& phi
)
{
notImplemented
(
"boundedBackwardDdtScheme::fvcDdtPhiCorr"
);
return surfaceScalarField::null();
}
tmp<surfaceScalarField> boundedBackwardDdtScheme::fvcDdtPhiCorr
(
const volScalarField& rA,
const volScalarField& rho,
const volScalarField& U,
const surfaceScalarField& phi
)
{
notImplemented
(
"boundedBackwardDdtScheme::fvcDdtPhiCorr"
);
return surfaceScalarField::null();
}
tmp<surfaceScalarField> boundedBackwardDdtScheme::meshPhi
(
const volScalarField& vf
)
{
notImplemented
(
"boundedBackwardDdtScheme::meshPhi(const volScalarField& vf)"
);
return surfaceScalarField::null();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace fv
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

193
src/finiteVolume/finiteVolume/ddtSchemes/boundedBackwardDdtScheme/boundedBackwardDdtScheme.H
View File

@ -1,193 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::fv::boundedBackwardDdtScheme
Description
Second-order bounded-backward-differencing ddt using the current and
two previous time-step values.
SourceFiles
boundedBackwardDdtScheme.C
\*---------------------------------------------------------------------------*/
#ifndef boundedBackwardDdtScheme_H
#define boundedBackwardDdtScheme_H
#include "ddtScheme.H"
#include "fvMatrices.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace fv
{
/*---------------------------------------------------------------------------*\
Class boundedBackwardDdtScheme Declaration
\*---------------------------------------------------------------------------*/
class boundedBackwardDdtScheme
:
public fv::ddtScheme<scalar>
{
// Private Member Functions
//- Return the current time-step
scalar deltaT_() const;
//- Return the previous time-step
scalar deltaT0_() const;
//- Return the previous time-step or GREAT if the old timestep field
// wasn't available in which case Euler ddt is used
template<class GeoField>
scalar deltaT0_(const GeoField& vf) const
{
if (vf.oldTime().timeIndex() == vf.oldTime().oldTime().timeIndex())
{
return GREAT;
}
else
{
return deltaT0_();
}
}
//- Disallow default bitwise copy construct
boundedBackwardDdtScheme(const boundedBackwardDdtScheme&);
//- Disallow default bitwise assignment
void operator=(const boundedBackwardDdtScheme&);
public:
//- Runtime type information
TypeName("boundedBackward");
// Constructors
//- Construct from mesh
boundedBackwardDdtScheme(const fvMesh& mesh)
:
ddtScheme<scalar>(mesh)
{}
//- Construct from mesh and Istream
boundedBackwardDdtScheme(const fvMesh& mesh, Istream& is)
:
ddtScheme<scalar>(mesh, is)
{}
// Member Functions
//- Return mesh reference
const fvMesh& mesh() const
{
return fv::ddtScheme<scalar>::mesh();
}
tmp<volScalarField> fvcDdt
(
const dimensionedScalar&
);
tmp<volScalarField> fvcDdt
(
const volScalarField&
);
tmp<volScalarField> fvcDdt
(
const dimensionedScalar&,
const volScalarField&
);
tmp<volScalarField> fvcDdt
(
const volScalarField&,
const volScalarField&
);
tmp<fvScalarMatrix> fvmDdt
(
const volScalarField&
);
tmp<fvScalarMatrix> fvmDdt
(
const dimensionedScalar&,
const volScalarField&
);
tmp<fvScalarMatrix> fvmDdt
(
const volScalarField&,
const volScalarField&
);
tmp<surfaceScalarField> fvcDdtPhiCorr
(
const volScalarField& rA,
const volScalarField& U,
const surfaceScalarField& phi
);
tmp<surfaceScalarField> fvcDdtPhiCorr
(
const volScalarField& rA,
const volScalarField& rho,
const volScalarField& U,
const surfaceScalarField& phi
);
tmp<surfaceScalarField> meshPhi
(
const volScalarField&
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace fv
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/finiteVolume/finiteVolume/ddtSchemes/boundedBackwardDdtScheme/boundedBackwardDdtSchemes.C
View File

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