songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

STYLE: fully scope some method names

Browse Source
This commit is contained in:
Mark Olesen 2010-04-29 15:12:44 +02:00
parent 72f7d46f23
commit 1075587fc1
37 changed files with 243 additions and 450 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/cyclicLduInterface.C
View File

@ -28,10 +28,8 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cyclicLduInterface, 0);
}
defineTypeNameAndDebug(Foam::cyclicLduInterface, 0);
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //

14
src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/lduInterface.C
View File

@ -25,23 +25,15 @@ License
#include "lduInterface.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(lduInterface, 0);
defineTypeNameAndDebug(Foam::lduInterface, 0);
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
lduInterface::~lduInterface()
Foam::lduInterface::~lduInterface()
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

5
src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/processorLduInterface.C
View File

@ -27,10 +27,7 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(processorLduInterface, 0);
}
defineTypeNameAndDebug(Foam::processorLduInterface, 0);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //

5
src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/cyclicLduInterfaceField/cyclicLduInterfaceField.C
View File

@ -28,10 +28,7 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cyclicLduInterfaceField, 0);
}
defineTypeNameAndDebug(Foam::cyclicLduInterfaceField, 0);
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //

13
src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/lduInterfaceField/lduInterfaceField.C
View File

@ -25,23 +25,14 @@ License
#include "lduInterfaceField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(lduInterfaceField, 0);
defineTypeNameAndDebug(Foam::lduInterfaceField, 0);
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
lduInterfaceField::~lduInterfaceField()
Foam::lduInterfaceField::~lduInterfaceField()
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

5
src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/processorLduInterfaceField/processorLduInterfaceField.C
View File

@ -28,10 +28,7 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(processorLduInterfaceField, 0);
}
defineTypeNameAndDebug(Foam::processorLduInterfaceField, 0);
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //

5
src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.C
View File

@ -28,10 +28,7 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(lduMatrix, 1);
}
defineTypeNameAndDebug(Foam::lduMatrix, 1);
const Foam::scalar Foam::lduMatrix::great_ = 1.0e+20;
const Foam::scalar Foam::lduMatrix::small_ = 1.0e-20;

5
src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.C
View File

@ -27,10 +27,7 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(pairGAMGAgglomeration, 0);
}
defineTypeNameAndDebug(Foam::pairGAMGAgglomeration, 0);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //

5
src/OpenFOAM/matrices/lduMatrix/solvers/diagonalSolver/diagonalSolver.C
View File

@ -27,10 +27,7 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(diagonalSolver, 0);
}
defineTypeNameAndDebug(Foam::diagonalSolver, 0);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //

27
src/OpenFOAM/matrices/tolerances/tolerances.C
View File

@ -25,14 +25,9 @@ License
#include "tolerances.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
tolerances::tolerances(const Time& t, const fileName& dictName)
Foam::tolerances::tolerances(const Time& t, const fileName& dictName)
:
IOdictionary
(
@ -58,7 +53,7 @@ tolerances::tolerances(const Time& t, const fileName& dictName)
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool tolerances::read()
bool Foam::tolerances::read()
{
if (regIOobject::read())
{
@ -90,34 +85,34 @@ bool tolerances::read()
}
bool tolerances::relax(const word& name) const
bool Foam::tolerances::relax(const word& name) const
{
return relaxationFactors_.found(name);
}
scalar tolerances::relaxationFactor(const word& name) const
Foam::scalar Foam::tolerances::relaxationFactor(const word& name) const
{
return readScalar(relaxationFactors_.lookup(name));
}
scalar tolerances::solverTolerance(const word& name) const
Foam::scalar Foam::tolerances::solverTolerance(const word& name) const
{
return readScalar(solverTolerances_.lookup(name));
}
bool tolerances::solverRelativeTolerances() const
bool Foam::tolerances::solverRelativeTolerances() const
{
return solverRelativeTolerances_.size();
}
scalar tolerances::solverRelativeTolerance(const word& name) const
Foam::scalar Foam::tolerances::solverRelativeTolerance(const word& name) const
{
return readScalar(solverRelativeTolerances_.lookup(name));
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

20
src/OpenFOAM/meshes/pointMesh/pointPatches/basic/generic/genericPointPatch.C
View File

@ -26,26 +26,20 @@ License
#include "genericPointPatch.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(genericPointPatch, 0);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defineTypeNameAndDebug(genericPointPatch, 0);
// Add the patch constructor functions to the hash tables
addToRunTimeSelectionTable
(
// Add the patch constructor functions to the hash tables
addToRunTimeSelectionTable
(
facePointPatch,
genericPointPatch,
polyPatch
);
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

36
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclic/cyclicPointPatch.C
View File

@ -31,20 +31,18 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(cyclicPointPatch, 0);
addToRunTimeSelectionTable
(
namespace Foam
{
defineTypeNameAndDebug(cyclicPointPatch, 0);
addToRunTimeSelectionTable
(
facePointPatch,
cyclicPointPatch,
polyPatch
);
);
}
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
@ -77,22 +75,22 @@ void Foam::cyclicPointPatch::calcGeometry(PstreamBuffers&)
}
void cyclicPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
void Foam::cyclicPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
{}
void cyclicPointPatch::movePoints(PstreamBuffers&, const pointField&)
void Foam::cyclicPointPatch::movePoints(PstreamBuffers&, const pointField&)
{}
void cyclicPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
void Foam::cyclicPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
facePointPatch::initUpdateMesh(pBufs);
cyclicPointPatch::initGeometry(pBufs);
}
void cyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
void Foam::cyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
{
facePointPatch::updateMesh(pBufs);
cyclicPointPatch::calcGeometry(pBufs);
@ -101,7 +99,7 @@ void cyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
cyclicPointPatch::cyclicPointPatch
Foam::cyclicPointPatch::cyclicPointPatch
(
const polyPatch& patch,
const pointBoundaryMesh& bm
@ -114,26 +112,22 @@ cyclicPointPatch::cyclicPointPatch
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
cyclicPointPatch::~cyclicPointPatch()
Foam::cyclicPointPatch::~cyclicPointPatch()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const edgeList& cyclicPointPatch::transformPairs() const
const Foam::edgeList& Foam::cyclicPointPatch::transformPairs() const
{
return cyclicPolyPatch_.coupledPoints();
}
const labelList& cyclicPointPatch::separatedPoints() const
const Foam::labelList& Foam::cyclicPointPatch::separatedPoints() const
{
return separatedPoints_;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

19
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/empty/emptyPointPatch.C
View File

@ -31,22 +31,19 @@ License
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defineTypeNameAndDebug(emptyPointPatch, 0);
addToRunTimeSelectionTable
(
defineTypeNameAndDebug(emptyPointPatch, 0);
addToRunTimeSelectionTable
(
facePointPatch,
emptyPointPatch,
polyPatch
);
);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void emptyPointPatch::applyConstraint
void Foam::emptyPointPatch::applyConstraint
(
const label pointi,
pointConstraint& pc
@ -56,8 +53,4 @@ void emptyPointPatch::applyConstraint
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

39
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.C
View File

@ -31,21 +31,18 @@ License
#include "primitiveFacePatch.H"
#include "emptyPolyPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(processorPointPatch, 0);
addToRunTimeSelectionTable
(
defineTypeNameAndDebug(processorPointPatch, 0);
addToRunTimeSelectionTable
(
facePointPatch,
processorPointPatch,
polyPatch
);
);
}
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
@ -123,22 +120,26 @@ void Foam::processorPointPatch::calcGeometry(PstreamBuffers& pBufs)
}
void processorPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
void Foam::processorPointPatch::initMovePoints
(
PstreamBuffers&,
const pointField&
)
{}
void processorPointPatch::movePoints(PstreamBuffers&, const pointField&)
void Foam::processorPointPatch::movePoints(PstreamBuffers&, const pointField&)
{}
void processorPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
void Foam::processorPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
facePointPatch::initUpdateMesh(pBufs);
processorPointPatch::initGeometry(pBufs);
}
void processorPointPatch::updateMesh(PstreamBuffers& pBufs)
void Foam::processorPointPatch::updateMesh(PstreamBuffers& pBufs)
{
facePointPatch::updateMesh(pBufs);
processorPointPatch::calcGeometry(pBufs);
@ -147,7 +148,7 @@ void processorPointPatch::updateMesh(PstreamBuffers& pBufs)
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
processorPointPatch::processorPointPatch
Foam::processorPointPatch::processorPointPatch
(
const polyPatch& patch,
const pointBoundaryMesh& bm
@ -160,26 +161,22 @@ processorPointPatch::processorPointPatch
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
processorPointPatch::~processorPointPatch()
Foam::processorPointPatch::~processorPointPatch()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const labelList& processorPointPatch::reverseMeshPoints() const
const Foam::labelList& Foam::processorPointPatch::reverseMeshPoints() const
{
return reverseMeshPoints_;
}
const labelList& processorPointPatch::separatedPoints() const
const Foam::labelList& Foam::processorPointPatch::separatedPoints() const
{
return separatedPoints_;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

22
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/symmetry/symmetryPointPatch.C
View File

@ -29,25 +29,25 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defineTypeNameAndDebug(symmetryPointPatch, 0);
namespace Foam
{
defineTypeNameAndDebug(symmetryPointPatch, 0);
// Add the patch constructor functions to the hash tables
addToRunTimeSelectionTable
(
// Add the patch constructor functions to the hash tables
addToRunTimeSelectionTable
(
facePointPatch,
symmetryPointPatch,
polyPatch
);
);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void symmetryPointPatch::applyConstraint
void Foam::symmetryPointPatch::applyConstraint
(
const label pointi,
pointConstraint& pc
@ -57,8 +57,4 @@ void symmetryPointPatch::applyConstraint
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

20
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/wedge/wedgePointPatch.C
View File

@ -34,23 +34,21 @@ Description
namespace Foam
{
defineTypeNameAndDebug(wedgePointPatch, 0);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defineTypeNameAndDebug(wedgePointPatch, 0);
// Add the patch constructor functions to the hash tables
addToRunTimeSelectionTable
(
// Add the patch constructor functions to the hash tables
addToRunTimeSelectionTable
(
facePointPatch,
wedgePointPatch,
polyPatch
);
);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void wedgePointPatch::applyConstraint
void Foam::wedgePointPatch::applyConstraint
(
const label pointi,
pointConstraint& pc
@ -60,8 +58,4 @@ void wedgePointPatch::applyConstraint
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

15
src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.C
View File

@ -26,19 +26,14 @@ License
#include "coupledFacePointPatch.H"
#include "pointBoundaryMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(coupledFacePointPatch, 0);
defineTypeNameAndDebug(Foam::coupledFacePointPatch, 0);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
coupledFacePointPatch::coupledFacePointPatch
Foam::coupledFacePointPatch::coupledFacePointPatch
(
const polyPatch& patch,
const pointBoundaryMesh& bm
@ -52,12 +47,8 @@ coupledFacePointPatch::coupledFacePointPatch
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
coupledFacePointPatch::~coupledFacePointPatch()
Foam::coupledFacePointPatch::~coupledFacePointPatch()
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

6
src/OpenFOAM/meshes/polyMesh/zones/zone/zone.C
View File

@ -29,10 +29,8 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(zone, 0);
}
defineTypeNameAndDebug(Foam::zone, 0);
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //

25
src/dynamicFvMesh/dynamicMotionSolverFvMesh/dynamicMotionSolverFvMesh.C
View File

@ -28,20 +28,23 @@ License
#include "motionSolver.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(dynamicMotionSolverFvMesh, 0);
addToRunTimeSelectionTable
(
dynamicFvMesh,
dynamicMotionSolverFvMesh,
IOobject
);
}
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(dynamicMotionSolverFvMesh, 0);
addToRunTimeSelectionTable(dynamicFvMesh, dynamicMotionSolverFvMesh, IOobject);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
dynamicMotionSolverFvMesh::dynamicMotionSolverFvMesh(const IOobject& io)
Foam::dynamicMotionSolverFvMesh::dynamicMotionSolverFvMesh(const IOobject& io)
:
dynamicFvMesh(io),
motionPtr_(motionSolver::New(*this))
@ -50,13 +53,13 @@ dynamicMotionSolverFvMesh::dynamicMotionSolverFvMesh(const IOobject& io)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
dynamicMotionSolverFvMesh::~dynamicMotionSolverFvMesh()
Foam::dynamicMotionSolverFvMesh::~dynamicMotionSolverFvMesh()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool dynamicMotionSolverFvMesh::update()
bool Foam::dynamicMotionSolverFvMesh::update()
{
fvMesh::movePoints(motionPtr_->newPoints());
@ -71,8 +74,4 @@ bool dynamicMotionSolverFvMesh::update()
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

21
src/dynamicFvMesh/staticFvMesh/staticFvMesh.C
View File

@ -28,19 +28,18 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(staticFvMesh, 0);
namespace Foam
{
defineTypeNameAndDebug(staticFvMesh, 0);
addToRunTimeSelectionTable(dynamicFvMesh, staticFvMesh, IOobject);
}
addToRunTimeSelectionTable(dynamicFvMesh, staticFvMesh, IOobject);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
//- Construct from objectRegistry, and read/write options
staticFvMesh::staticFvMesh(const IOobject& io)
Foam::staticFvMesh::staticFvMesh(const IOobject& io)
:
dynamicFvMesh(io)
{}
@ -48,20 +47,16 @@ staticFvMesh::staticFvMesh(const IOobject& io)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
staticFvMesh::~staticFvMesh()
Foam::staticFvMesh::~staticFvMesh()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool staticFvMesh::update()
bool Foam::staticFvMesh::update()
{
return false;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

11
src/dynamicMesh/setUpdater/setUpdaterTemplates.C
View File

@ -29,15 +29,10 @@ License
#include "mapPolyMesh.H"
#include "IOobjectList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void setUpdater::updateSets(const mapPolyMesh& morphMap) const
void Foam::setUpdater::updateSets(const mapPolyMesh& morphMap) const
{
//
// Update all sets in memory.
@ -106,8 +101,4 @@ void setUpdater::updateSets(const mapPolyMesh& morphMap) const
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

20
src/engine/engineMesh/fvMotionSolverEngineMesh/fvMotionSolverEngineMesh.C
View File

@ -28,20 +28,18 @@ License
#include "fvcMeshPhi.H"
#include "surfaceInterpolate.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(fvMotionSolverEngineMesh, 0);
addToRunTimeSelectionTable(engineMesh, fvMotionSolverEngineMesh, IOobject);
}
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(fvMotionSolverEngineMesh, 0);
addToRunTimeSelectionTable(engineMesh, fvMotionSolverEngineMesh, IOobject);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
fvMotionSolverEngineMesh::fvMotionSolverEngineMesh(const IOobject& io)
Foam::fvMotionSolverEngineMesh::fvMotionSolverEngineMesh(const IOobject& io)
:
engineMesh(io),
pistonLayers_("pistonLayers", dimLength, 0.0),
@ -56,13 +54,13 @@ fvMotionSolverEngineMesh::fvMotionSolverEngineMesh(const IOobject& io)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
fvMotionSolverEngineMesh::~fvMotionSolverEngineMesh()
Foam::fvMotionSolverEngineMesh::~fvMotionSolverEngineMesh()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void fvMotionSolverEngineMesh::move()
void Foam::fvMotionSolverEngineMesh::move()
{
scalar deltaZ = engineDB_.pistonDisplacement().value();
Info<< "deltaZ = " << deltaZ << endl;
@ -125,8 +123,4 @@ void fvMotionSolverEngineMesh::move()
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

22
src/engine/engineMesh/staticEngineMesh/staticEngineMesh.C
View File

@ -26,21 +26,17 @@ License
#include "staticEngineMesh.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(staticEngineMesh, 0);
addToRunTimeSelectionTable(engineMesh, staticEngineMesh, IOobject);
}
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(staticEngineMesh, 0);
addToRunTimeSelectionTable(engineMesh, staticEngineMesh, IOobject);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
//- Construct from objectRegistry, and read/write options
staticEngineMesh::staticEngineMesh(const IOobject& io)
Foam::staticEngineMesh::staticEngineMesh(const IOobject& io)
:
engineMesh(io)
{}
@ -48,18 +44,14 @@ staticEngineMesh::staticEngineMesh(const IOobject& io)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
staticEngineMesh::~staticEngineMesh()
Foam::staticEngineMesh::~staticEngineMesh()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void staticEngineMesh::move()
void Foam::staticEngineMesh::move()
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

12
src/engine/ignition/ignition.C
View File

@ -26,14 +26,10 @@ License
#include "ignition.H"
#include "fvMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool ignition::igniting() const
bool Foam::ignition::igniting() const
{
if (!ignite())
{
@ -54,7 +50,7 @@ bool ignition::igniting() const
}
bool ignition::ignited() const
bool Foam::ignition::ignited() const
{
if (!ignite())
{
@ -75,8 +71,4 @@ bool ignition::ignited() const
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

13
src/engine/ignition/ignitionIO.C
View File

@ -26,14 +26,9 @@ License
#include "engineTime.H"
#include "ignition.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
ignition::ignition
Foam::ignition::ignition
(
const dictionary& combustionProperties,
const Time& db,
@ -59,7 +54,7 @@ ignition::ignition
}
ignition::ignition
Foam::ignition::ignition
(
const dictionary& combustionProperties,
const engineTime& edb,
@ -85,8 +80,4 @@ ignition::ignition
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

19
src/engine/ignition/ignitionSite.C
View File

@ -27,14 +27,9 @@ License
#include "Time.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void ignitionSite::findIgnitionCells(const fvMesh& mesh)
void Foam::ignitionSite::findIgnitionCells(const fvMesh& mesh)
{
// Bit tricky: generate C and V before shortcutting if cannot find
// cell locally. mesh.C generation uses parallel communication.
@ -90,7 +85,7 @@ void ignitionSite::findIgnitionCells(const fvMesh& mesh)
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const labelList& ignitionSite::cells() const
const Foam::labelList& Foam::ignitionSite::cells() const
{
if (mesh_.changing() && timeIndex_ != db_.timeIndex())
{
@ -102,7 +97,7 @@ const labelList& ignitionSite::cells() const
}
bool ignitionSite::igniting() const
bool Foam::ignitionSite::igniting() const
{
scalar curTime = db_.value();
scalar deltaT = db_.deltaTValue();
@ -116,7 +111,7 @@ bool ignitionSite::igniting() const
}
bool ignitionSite::ignited() const
bool Foam::ignitionSite::ignited() const
{
scalar curTime = db_.value();
scalar deltaT = db_.deltaTValue();
@ -127,7 +122,7 @@ bool ignitionSite::ignited() const
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
void ignitionSite::operator=(const ignitionSite& is)
void Foam::ignitionSite::operator=(const ignitionSite& is)
{
location_ = is.location_;
diameter_ = is.diameter_;
@ -139,8 +134,4 @@ void ignitionSite::operator=(const ignitionSite& is)
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

18
src/engine/ignition/ignitionSiteIO.C
View File

@ -26,14 +26,14 @@ License
#include "ignitionSite.H"
#include "engineTime.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
ignitionSite::ignitionSite(Istream& is, const Time& db, const fvMesh& mesh)
Foam::ignitionSite::ignitionSite
(
Istream& is,
const Time& db,
const fvMesh& mesh
)
:
db_(db),
mesh_(mesh),
@ -64,7 +64,7 @@ ignitionSite::ignitionSite(Istream& is, const Time& db, const fvMesh& mesh)
}
ignitionSite::ignitionSite
Foam::ignitionSite::ignitionSite
(
Istream& is,
const engineTime& edb,
@ -100,8 +100,4 @@ ignitionSite::ignitionSite
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

13
src/lagrangian/basic/indexedParticle/indexedParticleCloud.C
View File

@ -25,19 +25,14 @@ License
#include "indexedParticleCloud.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineParticleTypeNameAndDebug(indexedParticle, 0);
defineTemplateTypeNameAndDebug(Cloud<indexedParticle>, 0);
}
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineParticleTypeNameAndDebug(indexedParticle, 0);
defineTemplateTypeNameAndDebug(Cloud<indexedParticle>, 0);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //

12
src/lagrangian/dieselSpray/injector/injector/injectorIO.C
View File

@ -26,14 +26,10 @@ License
#include "injector.H"
#include "dictionary.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
injector::injector(const Time& t, Istream& is)
Foam::injector::injector(const Time& t, Istream& is)
:
injectorDict_(is),
properties_(injectorType::New(t, injectorDict_))
@ -46,7 +42,7 @@ injector::injector(const Time& t, Istream& is)
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
Ostream& operator<<(Ostream& os, const injector& injector)
Foam::Ostream& Foam::operator<<(Ostream& os, const injector& injector)
{
// Check state of Ostream
os.check("Ostream& operator<<(Ostream&, const injector&)");
@ -57,8 +53,4 @@ Ostream& operator<<(Ostream& os, const injector& injector)
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

27
src/lagrangian/dieselSpray/parcel/parcelFunctions.C
View File

@ -26,15 +26,10 @@ License
#include "parcel.H"
#include "mathematicalConstants.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// The diameter based Reynolds number
scalar parcel::Re
Foam::scalar Foam::parcel::Re
(
const vector& U,
const scalar nu
@ -44,7 +39,7 @@ scalar parcel::Re
}
// The diameter based Reynolds number
scalar parcel::Re
Foam::scalar Foam::parcel::Re
(
const scalar rho,
const vector& U,
@ -56,7 +51,7 @@ scalar parcel::Re
}
// The diameter based Weber number
scalar parcel::We
Foam::scalar Foam::parcel::We
(
const vector& U,
const scalar rho,
@ -67,7 +62,7 @@ scalar parcel::We
}
scalar parcel::Sc
Foam::scalar Foam::parcel::Sc
(
const scalar mu,
const scalar rho,
@ -78,7 +73,7 @@ scalar parcel::Sc
}
scalar parcel::Sc
Foam::scalar Foam::parcel::Sc
(
const scalar nu,
const scalar massDiffusion
@ -88,7 +83,7 @@ scalar parcel::Sc
}
scalar parcel::Pr
Foam::scalar Foam::parcel::Pr
(
const scalar cp,
const scalar mu,
@ -99,26 +94,22 @@ scalar parcel::Pr
}
scalar parcel::N(const scalar rho) const
Foam::scalar Foam::parcel::N(const scalar rho) const
{
return 6.0*m_/(rho*pow3(d_)*constant::mathematical::pi);
}
scalar parcel::Vd() const
Foam::scalar Foam::parcel::Vd() const
{
return pow3(d_)*constant::mathematical::pi/6.0;
}
scalar parcel::V(const scalar rho) const
Foam::scalar Foam::parcel::V(const scalar rho) const
{
return m_/rho;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

11
src/lagrangian/dieselSpray/parcel/setRelaxationTimes.C
View File

@ -31,14 +31,10 @@ License
#include "heatTransferModel.H"
#include "basicMultiComponentMixture.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void parcel::setRelaxationTimes
void Foam::parcel::setRelaxationTimes
(
label celli,
scalar& tauMomentum,
@ -55,7 +51,6 @@ void parcel::setRelaxationTimes
const scalar dt
)
{
const liquidMixture& fuels = sDB.fuels();
scalar mCell = rho*sDB.mesh().V()[cell()];
@ -292,8 +287,4 @@ void parcel::setRelaxationTimes
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

36
src/lagrangian/dieselSpray/spray/sprayFunctions.C
View File

@ -26,14 +26,10 @@ License
#include "spray.H"
#include "mathematicalConstants.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
scalar spray::injectedMass(const scalar t) const
Foam::scalar Foam::spray::injectedMass(const scalar t) const
{
scalar sum = 0.0;
@ -46,7 +42,7 @@ scalar spray::injectedMass(const scalar t) const
}
scalar spray::totalMassToInject() const
Foam::scalar Foam::spray::totalMassToInject() const
{
scalar sum = 0.0;
@ -59,7 +55,7 @@ scalar spray::totalMassToInject() const
}
scalar spray::injectedEnthalpy
Foam::scalar Foam::spray::injectedEnthalpy
(
const scalar time
) const
@ -89,7 +85,7 @@ scalar spray::injectedEnthalpy
}
scalar spray::liquidMass() const
Foam::scalar Foam::spray::liquidMass() const
{
scalar sum = 0.0;
@ -109,7 +105,7 @@ scalar spray::liquidMass() const
}
scalar spray::liquidEnthalpy() const
Foam::scalar Foam::spray::liquidEnthalpy() const
{
scalar sum = 0.0;
label Nf = fuels().components().size();
@ -146,7 +142,7 @@ scalar spray::liquidEnthalpy() const
}
scalar spray::liquidTotalEnthalpy() const
Foam::scalar Foam::spray::liquidTotalEnthalpy() const
{
scalar sum = 0.0;
label Nf = fuels().components().size();
@ -186,7 +182,7 @@ scalar spray::liquidTotalEnthalpy() const
}
scalar spray::liquidKineticEnergy() const
Foam::scalar Foam::spray::liquidKineticEnergy() const
{
scalar sum = 0.0;
@ -208,19 +204,19 @@ scalar spray::liquidKineticEnergy() const
}
scalar spray::injectedLiquidKineticEnergy() const
Foam::scalar Foam::spray::injectedLiquidKineticEnergy() const
{
return injectedLiquidKE_;
}
scalar spray::liquidPenetration(const scalar prc) const
Foam::scalar Foam::spray::liquidPenetration(const scalar prc) const
{
return liquidPenetration(0, prc);
}
scalar spray::liquidPenetration
Foam::scalar Foam::spray::liquidPenetration
(
const label nozzlei,
const scalar prc
@ -349,7 +345,7 @@ scalar spray::liquidPenetration
}
scalar spray::smd() const
Foam::scalar Foam::spray::smd() const
{
scalar numerator = 0.0, denominator = VSMALL;
@ -372,7 +368,7 @@ scalar spray::smd() const
}
scalar spray::maxD() const
Foam::scalar Foam::spray::maxD() const
{
scalar maxD = 0.0;
@ -387,20 +383,16 @@ scalar spray::maxD() const
}
void spray::calculateAmbientPressure()
void Foam::spray::calculateAmbientPressure()
{
ambientPressure_ = p_.average().value();
}
void spray::calculateAmbientTemperature()
void Foam::spray::calculateAmbientTemperature()
{
ambientTemperature_ = T_.average().value();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

11
src/lagrangian/dieselSpray/spray/sprayInject.C
View File

@ -31,12 +31,7 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
void spray::inject()
void Foam::spray::inject()
{
scalar time = runTime_.value();
scalar time0 = time0_;
@ -172,8 +167,4 @@ void spray::inject()
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

67
src/lagrangian/molecularDynamics/molecule/interactionLists/referredCell/referredCell.C
View File

@ -26,12 +26,10 @@ License
#include "referredCell.H"
#include "interactionLists.H"
namespace Foam
{
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void referredCell::setConstructionData
void Foam::referredCell::setConstructionData
(
const polyMesh& mesh,
const label sourceCell
@ -92,7 +90,7 @@ void referredCell::setConstructionData
}
void referredCell::locallyMapEdgeList
void Foam::referredCell::locallyMapEdgeList
(
const labelList& points,
const edgeList& sourceCellEdges
@ -125,7 +123,7 @@ void referredCell::locallyMapEdgeList
}
void referredCell::locallyMapFaceList
void Foam::referredCell::locallyMapFaceList
(
const labelList& points,
const labelListList& sourceCellFaces
@ -159,25 +157,31 @@ void referredCell::locallyMapFaceList
}
vector referredCell::referPosition(const vector& positionToRefer)
Foam::vector Foam::referredCell::referPosition(const vector& positionToRefer)
{
return offset_ + (rotation_ & positionToRefer);
}
vectorList referredCell::referPositions(const vectorList& positionsToRefer)
Foam::vectorList Foam::referredCell::referPositions
(
const vectorList& positionsToRefer
)
{
return offset_ + (rotation_ & positionsToRefer);
}
vector referredCell::rotateVector(const vector& vectorToRotate)
Foam::vector Foam::referredCell::rotateVector(const vector& vectorToRotate)
{
return rotation_ & vectorToRotate;
}
vectorList referredCell::rotateVectors(const vectorList& vectorsToRotate)
Foam::vectorList Foam::referredCell::rotateVectors
(
const vectorList& vectorsToRotate
)
{
return rotation_ & vectorsToRotate;
}
@ -185,7 +189,7 @@ vectorList referredCell::rotateVectors(const vectorList& vectorsToRotate)
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
referredCell::referredCell()
Foam::referredCell::referredCell()
:
DynamicList<referredMolecule>(),
sourceProc_(-1),
@ -196,7 +200,7 @@ referredCell::referredCell()
{}
referredCell::referredCell
Foam::referredCell::referredCell
(
const polyMesh& mesh,
const label sourceProc,
@ -215,7 +219,7 @@ referredCell::referredCell
}
referredCell::referredCell
Foam::referredCell::referredCell
(
const label sourceProc,
const label sourceCell,
@ -248,7 +252,7 @@ referredCell::referredCell
}
referredCell::referredCell
Foam::referredCell::referredCell
(
const polyMesh& mesh,
const label sourceProc,
@ -285,13 +289,13 @@ referredCell::referredCell
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
referredCell::~referredCell()
Foam::referredCell::~referredCell()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
referredCell referredCell::reRefer
Foam::referredCell Foam::referredCell::reRefer
(
const vector& cS,
const vector& cD,
@ -325,13 +329,16 @@ referredCell referredCell::reRefer
}
vector referredCell::referPosition(const vector& positionToRefer) const
Foam::vector Foam::referredCell::referPosition
(
const vector& positionToRefer
) const
{
return offset_ + (rotation_ & positionToRefer);
}
vectorList referredCell::referPosition
Foam::vectorList Foam::referredCell::referPosition
(
const vectorList& positionsToRefer
) const
@ -340,19 +347,25 @@ vectorList referredCell::referPosition
}
vector referredCell::rotateVector(const vector& vectorToRotate) const
Foam::vector Foam::referredCell::rotateVector
(
const vector& vectorToRotate
) const
{
return rotation_ & vectorToRotate;
}
vectorList referredCell::rotateVectors(const vectorList& vectorsToRotate) const
Foam::vectorList Foam::referredCell::rotateVectors
(
const vectorList& vectorsToRotate
) const
{
return rotation_ & vectorsToRotate;
}
void referredCell::referInMols(const List<referredMolecule>& incomingMols)
void Foam::referredCell::referInMols(const List<referredMolecule>& incomingMols)
{
clear();
@ -379,7 +392,7 @@ void referredCell::referInMols(const List<referredMolecule>& incomingMols)
}
bool referredCell::duplicate(const referredCell& refCellDupl) const
bool Foam::referredCell::duplicate(const referredCell& refCellDupl) const
{
return
(
@ -390,7 +403,7 @@ bool referredCell::duplicate(const referredCell& refCellDupl) const
}
bool referredCell::duplicate(const label procNo,const label nCells) const
bool Foam::referredCell::duplicate(const label procNo,const label nCells) const
{
return
(
@ -403,9 +416,8 @@ bool referredCell::duplicate(const label procNo,const label nCells) const
// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
Istream& operator>>(Istream& is, referredCell& rC)
Foam::Istream& Foam::operator>>(Istream& is, referredCell& rC)
{
is >> rC.sourceProc_
>> rC.sourceCell_
>> rC.vertexPositions_
@ -422,9 +434,8 @@ Istream& operator>>(Istream& is, referredCell& rC)
}
Ostream& operator<<(Ostream& os, const referredCell& rC)
Foam::Ostream& Foam::operator<<(Ostream& os, const referredCell& rC)
{
os << rC.sourceProc()
<< token::SPACE << rC.sourceCell()
<< token::SPACE << rC.vertexPositions()
@ -441,8 +452,4 @@ Ostream& operator<<(Ostream& os, const referredCell& rC)
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

13
src/lagrangian/molecularDynamics/potential/energyScalingFunction/basic/energyScalingFunction.C
View File

@ -25,15 +25,14 @@ License
#include "energyScalingFunction.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(energyScalingFunction, 0);
defineRunTimeSelectionTable(energyScalingFunction, dictionary);
}
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(energyScalingFunction, 0);
defineRunTimeSelectionTable(energyScalingFunction, dictionary);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -64,8 +63,4 @@ bool Foam::energyScalingFunction::read
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

20
src/transportModels/incompressible/incompressibleTwoPhaseMixture/twoPhaseMixture.C
View File

@ -28,15 +28,11 @@ License
#include "surfaceFields.H"
#include "fvc.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
//- Calculate and return the laminar viscosity
void twoPhaseMixture::calcNu()
void Foam::twoPhaseMixture::calcNu()
{
nuModel1_->correct();
nuModel2_->correct();
@ -54,7 +50,7 @@ void twoPhaseMixture::calcNu()
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
twoPhaseMixture::twoPhaseMixture
Foam::twoPhaseMixture::twoPhaseMixture
(
const volVectorField& U,
const surfaceScalarField& phi,
@ -114,7 +110,7 @@ twoPhaseMixture::twoPhaseMixture
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
tmp<volScalarField> twoPhaseMixture::mu() const
Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixture::mu() const
{
volScalarField limitedAlpha1 = min(max(alpha1_, scalar(0)), scalar(1));
@ -130,7 +126,7 @@ tmp<volScalarField> twoPhaseMixture::mu() const
}
tmp<surfaceScalarField> twoPhaseMixture::muf() const
Foam::tmp<Foam::surfaceScalarField> Foam::twoPhaseMixture::muf() const
{
surfaceScalarField alpha1f =
min(max(fvc::interpolate(alpha1_), scalar(0)), scalar(1));
@ -147,7 +143,7 @@ tmp<surfaceScalarField> twoPhaseMixture::muf() const
}
tmp<surfaceScalarField> twoPhaseMixture::nuf() const
Foam::tmp<Foam::surfaceScalarField> Foam::twoPhaseMixture::nuf() const
{
surfaceScalarField alpha1f =
min(max(fvc::interpolate(alpha1_), scalar(0)), scalar(1));
@ -166,7 +162,7 @@ tmp<surfaceScalarField> twoPhaseMixture::nuf() const
}
bool twoPhaseMixture::read()
bool Foam::twoPhaseMixture::read()
{
if (transportModel::read())
{
@ -193,8 +189,4 @@ bool twoPhaseMixture::read()
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

19
src/transportModels/incompressible/singlePhaseTransportModel/singlePhaseTransportModel.C
View File

@ -27,15 +27,10 @@ License
#include "viscosityModel.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
singlePhaseTransportModel::singlePhaseTransportModel
Foam::singlePhaseTransportModel::singlePhaseTransportModel
(
const volVectorField& U,
const surfaceScalarField& phi
@ -48,25 +43,25 @@ singlePhaseTransportModel::singlePhaseTransportModel
// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
singlePhaseTransportModel::~singlePhaseTransportModel()
Foam::singlePhaseTransportModel::~singlePhaseTransportModel()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
tmp<volScalarField> singlePhaseTransportModel::nu() const
Foam::tmp<Foam::volScalarField> Foam::singlePhaseTransportModel::nu() const
{
return viscosityModelPtr_->nu();
}
void singlePhaseTransportModel::correct()
void Foam::singlePhaseTransportModel::correct()
{
viscosityModelPtr_->correct();
}
bool singlePhaseTransportModel::read()
bool Foam::singlePhaseTransportModel::read()
{
if (regIOobject::read())
{
@ -79,8 +74,4 @@ bool singlePhaseTransportModel::read()
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //