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

Merging, fixing conflicts

Browse Source
This commit is contained in:
graham
2009-09-07 12:27:57 +01:00
parent b93156f142 e10bb9589e
commit 9a71ce6b90
102 changed files with 401 additions and 1989 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
applications/solvers/lagrangian/coalChemistryFoam/coalChemistryFoam.C
View File

@ -38,7 +38,6 @@ Description
#include "CoalCloud.H"
#include "psiChemistryModel.H"
#include "chemistrySolver.H"
#include "thermoPhysicsTypes.H"
#include "timeActivatedExplicitCellSource.H"
#include "radiationModel.H"

2
applications/solvers/lagrangian/coalChemistryFoam/createClouds.H
View File

@ -1,5 +1,5 @@
Info<< "\nConstructing coal cloud" << endl;
CoalCloud<gasThermoPhysics> coalParcels
thermoCoalCloud coalParcels
(
"coalCloud1",
rho,

2
applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/createClouds.H
View File

@ -1,5 +1,5 @@
Info<< "\nConstructing reacting cloud" << endl;
BasicReactingCloud<icoPoly8ThermoPhysics> parcels
icoPoly8ThermoReactingCloud parcels
(
"reactingCloud1",
rho,

1
applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/porousExplicitSourceReactingParcelFoam.C
View File

@ -46,7 +46,6 @@ Description
#include "BasicReactingCloud.H"
#include "rhoChemistryModel.H"
#include "chemistrySolver.H"
#include "thermoPhysicsTypes.H"
#include "radiationModel.H"
#include "porousZones.H"
#include "timeActivatedExplicitMulticomponentPointSource.H"

2
applications/solvers/lagrangian/reactingParcelFoam/createClouds.H
View File

@ -1,5 +1,5 @@
Info<< "\nConstructing reacting cloud" << endl;
BasicReactingCloud<gasThermoPhysics> parcels
thermoReactingCloud parcels
(
"reactingCloud1",
rho,

1
applications/solvers/lagrangian/reactingParcelFoam/reactingParcelFoam.C
View File

@ -37,7 +37,6 @@ Description
#include "BasicReactingCloud.H"
#include "psiChemistryModel.H"
#include "chemistrySolver.H"
#include "thermoPhysicsTypes.H"
#include "radiationModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

7
applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
View File

@ -280,11 +280,14 @@ addLayersControls
nBufferCellsNoExtrude 0;
// Overall max number of layer addition iterations
// Overall max number of layer addition iterations. The mesher will exit
// if it reaches this number of iterations; possibly with an illegal
// mesh.
nLayerIter 50;
// Max number of iterations after which relaxed meshQuality controls
// get used.
// get used. Up to nRelaxIter it uses the settings in meshQualityControls,
// after nRelaxIter it uses the values in meshQualityControls::relaxed.
nRelaxedIter 20;
}

3
applications/utilities/mesh/manipulation/createBaffles/createBaffles.C
View File

@ -125,6 +125,7 @@ label findPatchID(const polyMesh& mesh, const word& name)
int main(int argc, char *argv[])
{
# include "addRegionOption.H"
argList::validArgs.append("faceZone");
argList::validArgs.append("patch");
argList::validOptions.insert("additionalPatches", "(patch2 .. patchN)");
@ -134,7 +135,7 @@ int main(int argc, char *argv[])
# include "setRootCase.H"
# include "createTime.H"
runTime.functionObjects().off();
# include "createMesh.H"
# include "createNamedMesh.H"
const word oldInstance = mesh.pointsInstance();
const polyBoundaryMesh& patches = mesh.boundaryMesh();

8
applications/utilities/mesh/manipulation/createPatch/createPatch.C
View File

@ -516,11 +516,13 @@ void syncPoints
int main(int argc, char *argv[])
{
# include "addRegionOption.H"
argList::validOptions.insert("overwrite", "");
# include "setRootCase.H"
# include "createTime.H"
runTime.functionObjects().off();
# include "createNamedPolyMesh.H"
const bool overwrite = args.optionFound("overwrite");
@ -532,6 +534,11 @@ int main(int argc, char *argv[])
(
"createPatchDict",
runTime.system(),
(
regionName != polyMesh::defaultRegion
? regionName
: word::null
),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
@ -551,7 +558,6 @@ int main(int argc, char *argv[])
coupledPolyPatch::matchTol = tol;
# include "createPolyMesh.H"
const word oldInstance = mesh.pointsInstance();
const polyBoundaryMesh& patches = mesh.boundaryMesh();

3
applications/utilities/mesh/manipulation/setsToZones/setsToZones.C
View File

@ -60,6 +60,7 @@ int main(int argc, char *argv[])
{
argList::validOptions.insert("noFlipMap", "");
# include "addRegionOption.H"
# include "addTimeOptions.H"
# include "setRootCase.H"
# include "createTime.H"
@ -77,7 +78,7 @@ int main(int argc, char *argv[])
runTime.setTime(Times[startTime], startTime);
# include "createPolyMesh.H"
# include "createNamedPolyMesh.H"
// Search for list of objects for the time of the mesh
IOobjectList objects

9
src/OpenFOAM/db/Time/Time.C
View File

@ -115,7 +115,14 @@ void Foam::Time::setControls()
{
if (timeDirs.size())
{
startTime_ = timeDirs[0].value();
if (timeDirs[0].name() == constant() && timeDirs.size() >= 2)
{
startTime_ = timeDirs[1].value();
}
else
{
startTime_ = timeDirs[0].value();
}
}
}
else if (startFrom == "latestTime")

8
src/lagrangian/basic/Cloud/CloudIO.C
View File

@ -139,7 +139,13 @@ void Foam::Cloud<ParticleType>::readFields()
template<class ParticleType>
void Foam::Cloud<ParticleType>::writeFields() const
{}
{
if (this->size())
{
const ParticleType& p = *this->first();
ParticleType::writeFields(p.cloud());
}
}
template<class ParticleType>

2
src/lagrangian/basic/indexedParticle/indexedParticle.H
View File

@ -47,7 +47,7 @@ namespace Foam
{
/*---------------------------------------------------------------------------*\
Class indexedParticle Declaration
Class indexedParticle Declaration
\*---------------------------------------------------------------------------*/
class indexedParticle

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

@ -45,20 +45,17 @@ defineTemplateTypeNameAndDebug(Cloud<indexedParticle>, 0);
Foam::indexedParticleCloud::indexedParticleCloud
(
const polyMesh& mesh,
const word& cloudName
const word& cloudName,
bool readFields
)
:
Cloud<indexedParticle>(mesh, cloudName, false)
{
indexedParticle::readFields(*this);
if (readFields)
{
indexedParticle::readFields(*this);
}
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::indexedParticleCloud::writeFields() const
{
indexedParticle::writeFields(*this);
}
// ************************************************************************* //

11
src/lagrangian/basic/indexedParticle/indexedParticleCloud.H
View File

@ -45,7 +45,7 @@ namespace Foam
{
/*---------------------------------------------------------------------------*\
Class indexedParticleCloud Declaration
Class indexedParticleCloud Declaration
\*---------------------------------------------------------------------------*/
class indexedParticleCloud
@ -69,14 +69,9 @@ public:
indexedParticleCloud
(
const polyMesh&,
const word& cloudName = "defaultCloud"
const word& cloudName = "defaultCloud",
bool readFields = true
);
// Member Functions
//- Write fields
virtual void writeFields() const;
};

22
src/lagrangian/basic/passiveParticle/passiveParticleCloud.C
View File

@ -43,12 +43,16 @@ defineTemplateTypeNameAndDebug(Cloud<passiveParticle>, 0);
Foam::passiveParticleCloud::passiveParticleCloud
(
const polyMesh& mesh,
const word& cloudName
const word& cloudName,
bool readFields
)
:
Cloud<passiveParticle>(mesh, cloudName, false)
{
readFields();
if (readFields)
{
passiveParticle::readFields(*this);
}
}
@ -63,18 +67,4 @@ Foam::passiveParticleCloud::passiveParticleCloud
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::passiveParticleCloud::readFields()
{
passiveParticle::readFields(*this);
}
void Foam::passiveParticleCloud::writeFields() const
{
passiveParticle::writeFields(*this);
}
// ************************************************************************* //

14
src/lagrangian/basic/passiveParticle/passiveParticleCloud.H
View File

@ -45,7 +45,7 @@ namespace Foam
{
/*---------------------------------------------------------------------------*\
Class passiveParticleCloud Declaration
Class passiveParticleCloud Declaration
\*---------------------------------------------------------------------------*/
class passiveParticleCloud
@ -72,7 +72,8 @@ public:
passiveParticleCloud
(
const polyMesh&,
const word& cloudName = "defaultCloud"
const word& cloudName = "defaultCloud",
bool readFields = true
);
//- Construct from mesh, cloud name, and a list of particles
@ -82,15 +83,6 @@ public:
const word& cloudName,
const IDLList<passiveParticle>& particles
);
// Member Functions
//- Read fields
virtual void readFields();
//- Write fields
virtual void writeFields() const;
};

70
src/lagrangian/coalCombustion/CoalCloud/CoalCloud.C
View File

@ -1,70 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2008-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "CoalCloud.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class ThermoType>
Foam::CoalCloud<ThermoType>::CoalCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
)
:
ReactingMultiphaseCloud<CoalParcel<ThermoType> >
(
cloudName,
rho,
U,
g,
thermo
)
{
CoalParcel<ThermoType>::readFields(*this);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class ThermoType>
Foam::CoalCloud<ThermoType>::~CoalCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class ThermoType>
void Foam::CoalCloud<ThermoType>::writeFields() const
{
CoalParcel<ThermoType>::writeFields(*this);
}
// ************************************************************************* //

68
src/lagrangian/coalCombustion/CoalCloud/CoalCloud.H
View File

@ -26,9 +26,7 @@ Class
CoalCloud
Description
SourceFiles
CoalCloud.C
Coal cloud templated on the type of carrier phase thermodynamics
\*---------------------------------------------------------------------------*/
@ -37,69 +35,21 @@ SourceFiles
#include "ReactingMultiphaseCloud.H"
#include "CoalParcel.H"
#include "thermoPhysicsTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef ReactingMultiphaseCloud<CoalParcel<constGasThermoPhysics> >
constThermoCoalCloud;
/*---------------------------------------------------------------------------*\
Class CoalCloud Declaration
\*---------------------------------------------------------------------------*/
typedef ReactingMultiphaseCloud<CoalParcel<gasThermoPhysics> >
thermoCoalCloud;
template<class ThermoType>
class CoalCloud
:
public ReactingMultiphaseCloud<CoalParcel<ThermoType> >
{
// Private Member Functions
//- Disallow default bitwise copy construct
CoalCloud(const CoalCloud&);
//- Disallow default bitwise assignment
void operator=(const CoalCloud&);
public:
//-Runtime type information
TypeName("CoalCloud");
// Constructors
//- Construct given carrier gas fields
CoalCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
);
//- Destructor
~CoalCloud();
// Member Functions
//- Write fields
virtual void writeFields() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "CoalCloud.C"
#endif
typedef ReactingMultiphaseCloud<CoalParcel<icoPoly8ThermoPhysics> >
icoPoly8ThermoCoalCloud;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

38
src/lagrangian/coalCombustion/CoalCloud/defineCoalCloud.C
View File

@ -1,38 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2008-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "createReactingCloudTypes.H"
#include "CoalCloud.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
createReactingCloudType(CoalCloud);
};
// ************************************************************************* //

3
src/lagrangian/coalCombustion/Make/files
View File

@ -1,6 +1,3 @@
/* Coal cloud */
CoalCloud/defineCoalCloud.C
/* Coal parcel and sub-models */
CoalParcel/defineCoalParcel.C
CoalParcel/makeCoalParcelSubmodels.C

3
src/lagrangian/coalCombustion/include/createCoalParcelTypes.H
View File

@ -92,8 +92,7 @@ License
( \
ReactingMultiphaseCloud<ParcelType##ThermoType>, \
0 \
); \
defineParcelTypeNameAndDebug(CoalCloud<ParcelType##ThermoType>, 0);
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

10
src/lagrangian/dieselSpray/parcel/parcelIO.C
View File

@ -96,10 +96,7 @@ Foam::parcel::parcel
}
void Foam::parcel::readFields
(
Cloud<parcel>& c
)
void Foam::parcel::readFields(Cloud<parcel>& c)
{
if (!c.size())
{
@ -195,10 +192,7 @@ void Foam::parcel::readFields
}
void Foam::parcel::writeFields
(
const Cloud<parcel>& c
)
void Foam::parcel::writeFields(const Cloud<parcel>& c)
{
Particle<parcel>::writeFields(c);

16
src/lagrangian/dieselSpray/spray/spray.C
View File

@ -59,7 +59,8 @@ Foam::spray::spray
const basicMultiComponentMixture& composition,
const PtrList<gasThermoPhysics>& gasProperties,
const dictionary&,
const dimensionedVector& g
const dimensionedVector& g,
bool readFields
)
:
Cloud<parcel>(U.mesh(), false), // suppress className checking on positions
@ -345,7 +346,10 @@ Foam::spray::spray
}
}
parcel::readFields(*this);
if (readFields)
{
parcel::readFields(*this);
}
}
@ -355,12 +359,4 @@ Foam::spray::~spray()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::spray::writeFields() const
{
parcel::writeFields(*this);
}
// ************************************************************************* //

9
src/lagrangian/dieselSpray/spray/spray.H
View File

@ -194,7 +194,8 @@ public:
const basicMultiComponentMixture& composition,
const PtrList<gasThermoPhysics>& gasProperties,
const dictionary& thermophysicalProperties,
const dimensionedVector& g
const dimensionedVector& g,
bool readFields = true
);
@ -339,12 +340,6 @@ public:
//- Return Ambient Temperature
void calculateAmbientTemperature();
// I/O
//- Write fields
virtual void writeFields() const;
};

20
src/lagrangian/dsmc/clouds/Templates/DsmcCloud/DsmcCloud.C
View File

@ -28,11 +28,9 @@ License
#include "BinaryCollisionModel.H"
#include "WallInteractionModel.H"
#include "InflowBoundaryModel.H"
#include "constants.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class ParcelType>
Foam::scalar Foam::DsmcCloud<ParcelType>::kb = 1.380650277e-23;
using namespace Foam::constant;
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
@ -596,7 +594,8 @@ template<class ParcelType>
Foam::DsmcCloud<ParcelType>::DsmcCloud
(
const word& cloudName,
const fvMesh& mesh
const fvMesh& mesh,
bool readFields
)
:
Cloud<ParcelType>(mesh, cloudName, false),
@ -805,6 +804,11 @@ Foam::DsmcCloud<ParcelType>::DsmcCloud
{
collisionSelectionRemainder_[i] = rndGen_.scalar01();
}
if (readFields)
{
ParcelType::readFields(*this);
}
}
@ -1116,7 +1120,7 @@ Foam::vector Foam::DsmcCloud<ParcelType>::equipartitionLinearVelocity
)
{
return
sqrt(kb*temperature/mass)
sqrt(physicoChemical::k.value()*temperature/mass)
*vector
(
rndGen_.GaussNormal(),
@ -1142,7 +1146,7 @@ Foam::scalar Foam::DsmcCloud<ParcelType>::equipartitionInternalEnergy
else if (iDof < 2.0 + SMALL && iDof > 2.0 - SMALL)
{
// Special case for iDof = 2, i.e. diatomics;
Ei = -log(rndGen_.scalar01())*kb*temperature;
Ei = -log(rndGen_.scalar01())*physicoChemical::k.value()*temperature;
}
else
{
@ -1160,7 +1164,7 @@ Foam::scalar Foam::DsmcCloud<ParcelType>::equipartitionInternalEnergy
} while (P < rndGen_.scalar01());
Ei = energyRatio*kb*temperature;
Ei = energyRatio*physicoChemical::k.value()*temperature;
}
return Ei;

12
src/lagrangian/dsmc/clouds/Templates/DsmcCloud/DsmcCloud.H
View File

@ -195,12 +195,6 @@ class DsmcCloud
public:
// Static data members
//- Boltzmann constant
static scalar kb;
// Constructors
//- Construct given name and mesh, will read Parcels and fields from
@ -208,7 +202,8 @@ public:
DsmcCloud
(
const word& cloudName,
const fvMesh& mesh
const fvMesh& mesh,
bool readFields = true
);
//- Construct given name, mesh and initialisation dictionary.
@ -406,6 +401,7 @@ public:
scalar mass
) const;
// Sub-models
//- Return reference to binary elastic collision model
@ -476,8 +472,6 @@ public:
//- Clear the Cloud
inline void clear();
};

18
src/lagrangian/dsmc/clouds/Templates/DsmcCloud/DsmcCloudI.H
View File

@ -24,7 +24,9 @@ License
\*---------------------------------------------------------------------------*/
#include "mathConstants.H"
#include "constants.H"
using namespace Foam::constant;
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
@ -352,7 +354,8 @@ inline Foam::scalar Foam::DsmcCloud<ParcelType>::maxwellianAverageSpeed
scalar mass
) const
{
return 2.0*sqrt(2.0*kb*temperature/(constant::math::pi*mass));
return
2.0*sqrt(2.0*physicoChemical::k.value()*temperature/(math::pi*mass));
}
@ -363,7 +366,8 @@ inline Foam::scalarField Foam::DsmcCloud<ParcelType>::maxwellianAverageSpeed
scalar mass
) const
{
return 2.0*sqrt(2.0*kb*temperature/(constant::math::pi*mass));
return
2.0*sqrt(2.0*physicoChemical::k.value()*temperature/(math::pi*mass));
}
@ -374,7 +378,7 @@ inline Foam::scalar Foam::DsmcCloud<ParcelType>::maxwellianRMSSpeed
scalar mass
) const
{
return sqrt(3.0*kb*temperature/mass);
return sqrt(3.0*physicoChemical::k.value()*temperature/mass);
}
@ -385,7 +389,7 @@ inline Foam::scalarField Foam::DsmcCloud<ParcelType>::maxwellianRMSSpeed
scalar mass
) const
{
return sqrt(3.0*kb*temperature/mass);
return sqrt(3.0*physicoChemical::k.value()*temperature/mass);
}
@ -397,7 +401,7 @@ Foam::DsmcCloud<ParcelType>::maxwellianMostProbableSpeed
scalar mass
) const
{
return sqrt(2.0*kb*temperature/mass);
return sqrt(2.0*physicoChemical::k.value()*temperature/mass);
}
@ -409,7 +413,7 @@ Foam::DsmcCloud<ParcelType>::maxwellianMostProbableSpeed
scalar mass
) const
{
return sqrt(2.0*kb*temperature/mass);
return sqrt(2.0*physicoChemical::k.value()*temperature/mass);
}

7
src/lagrangian/dsmc/clouds/derived/dsmcCloud/dsmcCloud.C
View File

@ -65,11 +65,4 @@ Foam::dsmcCloud::~dsmcCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::dsmcCloud::writeFields() const
{
dsmcParcel::writeFields(*this);
}
// ************************************************************************* //

6
src/lagrangian/dsmc/clouds/derived/dsmcCloud/dsmcCloud.H
View File

@ -87,12 +87,6 @@ public:
//- Destructor
~dsmcCloud();
// Member functions
//- Write fields
virtual void writeFields() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/lagrangian/dsmc/parcels/Templates/DsmcParcel/DsmcParcel.H
View File

@ -308,9 +308,9 @@ public:
// I-O
static void readFields(DsmcCloud<ParcelType>& c);
static void readFields(Cloud<ParcelType>& c);
static void writeFields(const DsmcCloud<ParcelType>& c);
static void writeFields(const Cloud<ParcelType>& c);
// Ostream Operator

10
src/lagrangian/dsmc/parcels/Templates/DsmcParcel/DsmcParcelIO.C
View File

@ -74,10 +74,7 @@ Foam::DsmcParcel<ParcelType>::DsmcParcel
template<class ParcelType>
void Foam::DsmcParcel<ParcelType>::readFields
(
DsmcCloud<ParcelType>& c
)
void Foam::DsmcParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
{
if (!c.size())
{
@ -107,10 +104,7 @@ void Foam::DsmcParcel<ParcelType>::readFields
template<class ParcelType>
void Foam::DsmcParcel<ParcelType>::writeFields
(
const DsmcCloud<ParcelType>& c
)
void Foam::DsmcParcel<ParcelType>::writeFields(const Cloud<ParcelType>& c)
{
Particle<ParcelType>::writeFields(c);

10
src/lagrangian/dsmc/submodels/BinaryCollisionModel/LarsenBorgnakkeVariableHardSphere/LarsenBorgnakkeVariableHardSphere.C
View File

@ -25,7 +25,9 @@ License
\*---------------------------------------------------------------------------*/
#include "LarsenBorgnakkeVariableHardSphere.H"
#include "mathConstants.H"
#include "constants.H"
using namespace Foam::constant;
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
@ -157,8 +159,8 @@ Foam::scalar Foam::LarsenBorgnakkeVariableHardSphere<CloudType>::sigmaTcR
// calculating cross section = pi*dPQ^2, where dPQ is from Bird, eq. 4.79
scalar sigmaTPQ =
constant::math::pi*dPQ*dPQ
*pow(2.0*CloudType::kb*Tref_/(mR*cR*cR), omegaPQ - 0.5)
math::pi*dPQ*dPQ
*pow(2.0*physicoChemical::k.value()*Tref_/(mR*cR*cR), omegaPQ - 0.5)
/exp(Foam::lgamma(2.5 - omegaPQ));
return sigmaTPQ*cR;
@ -253,7 +255,7 @@ void Foam::LarsenBorgnakkeVariableHardSphere<CloudType>::collide
scalar sinTheta = sqrt(1.0 - cosTheta*cosTheta);
scalar phi = constant::math::twoPi*rndGen.scalar01();
scalar phi = math::twoPi*rndGen.scalar01();
vector postCollisionRelU =
cR

10
src/lagrangian/dsmc/submodels/BinaryCollisionModel/VariableHardSphere/VariableHardSphere.C
View File

@ -25,7 +25,9 @@ License
\*---------------------------------------------------------------------------*/
#include "VariableHardSphere.H"
#include "mathConstants.H"
#include "constants.H"
using namespace Foam::constant;
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -91,8 +93,8 @@ Foam::scalar Foam::VariableHardSphere<CloudType>::sigmaTcR
// calculating cross section = pi*dPQ^2, where dPQ is from Bird, eq. 4.79
scalar sigmaTPQ =
constant::math::pi*dPQ*dPQ
*pow(2.0*CloudType::kb*Tref_/(mR*cR*cR), omegaPQ - 0.5)
math::pi*dPQ*dPQ
*pow(2.0*physicoChemical::k.value()*Tref_/(mR*cR*cR), omegaPQ - 0.5)
/exp(Foam::lgamma(2.5 - omegaPQ));
return sigmaTPQ*cR;
@ -126,7 +128,7 @@ void Foam::VariableHardSphere<CloudType>::collide
scalar sinTheta = sqrt(1.0 - cosTheta*cosTheta);
scalar phi = constant::math::twoPi*rndGen.scalar01();
scalar phi = math::twoPi*rndGen.scalar01();
vector postCollisionRelU =
cR

8
src/lagrangian/dsmc/submodels/InflowBoundaryModel/FreeStream/FreeStream.C
View File

@ -25,7 +25,9 @@ License
\*---------------------------------------------------------------------------*/
#include "FreeStream.H"
#include "mathConstants.H"
#include "constants.H"
using namespace Foam::constant;
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -131,7 +133,7 @@ void Foam::FreeStream<CloudType>::inflow()
Random& rndGen(cloud.rndGen());
scalar sqrtPi = sqrt(constant::math::pi);
scalar sqrtPi = sqrt(math::pi);
label particlesInserted = 0;
@ -371,7 +373,7 @@ void Foam::FreeStream<CloudType>::inflow()
} while (P < rndGen.scalar01());
vector U =
sqrt(CloudType::kb*faceTemperature/mass)
sqrt(physicoChemical::k.value()*faceTemperature/mass)
*(
rndGen.GaussNormal()*t1
+ rndGen.GaussNormal()*t2

5
src/lagrangian/dsmc/submodels/WallInteractionModel/MaxwellianThermal/MaxwellianThermal.C
View File

@ -25,6 +25,9 @@ License
\*---------------------------------------------------------------------------*/
#include "MaxwellianThermal.H"
#include "constants.H"
using namespace Foam::constant;
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -108,7 +111,7 @@ void Foam::MaxwellianThermal<CloudType>::correct
scalar iDof = cloud.constProps(typeId).internalDegreesOfFreedom();
U =
sqrt(CloudType::kb*T/mass)
sqrt(physicoChemical::k.value()*T/mass)
*(
rndGen.GaussNormal()*tw1
+ rndGen.GaussNormal()*tw2

12
src/lagrangian/dsmc/submodels/WallInteractionModel/MixedDiffuseSpecular/MixedDiffuseSpecular.C
View File

@ -113,12 +113,12 @@ void Foam::MixedDiffuseSpecular<CloudType>::correct
scalar iDof = cloud.constProps(typeId).internalDegreesOfFreedom();
U =
sqrt(CloudType::kb*T/mass)
*(
rndGen.GaussNormal()*tw1
+ rndGen.GaussNormal()*tw2
- sqrt(-2.0*log(max(1 - rndGen.scalar01(), VSMALL)))*nw
);
sqrt(physicoChemical::k.value()*T/mass)
*(
rndGen.GaussNormal()*tw1
+ rndGen.GaussNormal()*tw2
- sqrt(-2.0*log(max(1 - rndGen.scalar01(), VSMALL)))*nw
);
U += cloud.boundaryU().boundaryField()[wppIndex][wppLocalFace];

6
src/lagrangian/intermediate/Make/files
View File

@ -18,13 +18,7 @@ $(BASECLOUDS)/reactingCloud/reactingCloud.C
$(BASECLOUDS)/reactingMultiphaseCloud/reactingMultiphaseCloud.C
/* Cloud container/injection mechanisms */
//$(DERIVEDCLOUDS)/basicKinematicCloud/basicKinematicCloud.C
$(DERIVEDCLOUDS)/basicInteractingKinematicCloud/basicInteractingKinematicCloud.C
$(DERIVEDCLOUDS)/basicThermoCloud/basicThermoCloud.C
$(DERIVEDCLOUDS)/BasicReactingCloud/defineBasicReactingCloud.C
$(DERIVEDCLOUDS)/BasicReactingMultiphaseCloud/defineBasicReactingMultiphaseCloud.C
/* kinematic parcel sub-models */
// KINEMATICPARCEL=$(DERIVEDPARCELS)/basicKinematicParcel

10
src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
View File

@ -43,7 +43,8 @@ Foam::KinematicCloud<ParcelType>::KinematicCloud
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g
const dimensionedVector& g,
bool readFields
)
:
Cloud<ParcelType>(rho.mesh(), cloudName, false),
@ -136,7 +137,12 @@ Foam::KinematicCloud<ParcelType>::KinematicCloud
mesh_,
dimensionedVector("zero", dimMass*dimVelocity, vector::zero)
)
{}
{
if (readFields)
{
ParcelType::readFields(*this);
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //

3
src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.H
View File

@ -204,7 +204,8 @@ public:
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g
const dimensionedVector& g,
bool readFields = true
);

10
src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C
View File

@ -67,10 +67,11 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
basicThermo& thermo,
bool readFields
)
:
ThermoCloud<ParcelType>(cloudName, rho, U, g, thermo),
ThermoCloud<ParcelType>(cloudName, rho, U, g, thermo, false),
reactingCloud(),
constProps_(this->particleProperties()),
mcCarrierThermo_
@ -118,6 +119,11 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
)
);
}
if (readFields)
{
ParcelType::readFields(*this);
}
}

3
src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.H
View File

@ -152,7 +152,8 @@ public:
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
basicThermo& thermo,
bool readFields = true
);

12
src/lagrangian/intermediate/clouds/Templates/ReactingMultiphaseCloud/ReactingMultiphaseCloud.C
View File

@ -38,10 +38,11 @@ Foam::ReactingMultiphaseCloud<ParcelType>::ReactingMultiphaseCloud
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
basicThermo& thermo,
bool readFields
)
:
ReactingCloud<ParcelType>(cloudName, rho, U, g, thermo),
ReactingCloud<ParcelType>(cloudName, rho, U, g, thermo, false),
reactingMultiphaseCloud(),
constProps_(this->particleProperties()),
devolatilisationModel_
@ -61,7 +62,12 @@ Foam::ReactingMultiphaseCloud<ParcelType>::ReactingMultiphaseCloud
)
),
dMassDevolatilisation_(0.0)
{}
{
if (readFields)
{
ParcelType::readFields(*this);
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //

3
src/lagrangian/intermediate/clouds/Templates/ReactingMultiphaseCloud/ReactingMultiphaseCloud.H
View File

@ -134,7 +134,8 @@ public:
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
basicThermo& thermo,
bool readFields = true
);

13
src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.C
View File

@ -39,7 +39,8 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
basicThermo& thermo,
bool readFields
)
:
InteractingKinematicCloud<ParcelType>
@ -48,7 +49,8 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
rho,
U,
thermo.mu(),
g
g,
false
),
thermoCloud(),
constProps_(this->particleProperties()),
@ -98,7 +100,12 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
this->mesh(),
dimensionedScalar("zero", dimensionSet(1, 2, -2, 0, 0), 0.0)
)
{}
{
if (readFields)
{
ParcelType::readFields(*this);
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //

3
src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.H
View File

@ -140,7 +140,8 @@ public:
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
basicThermo& thermo,
bool readFields = true
);

70
src/lagrangian/intermediate/clouds/derived/BasicReactingCloud/BasicReactingCloud.C
View File

@ -1,70 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "BasicReactingCloud.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class ThermoType>
Foam::BasicReactingCloud<ThermoType>::BasicReactingCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
)
:
ReactingCloud<BasicReactingParcel<ThermoType> >
(
cloudName,
rho,
U,
g,
thermo
)
{
BasicReactingParcel<ThermoType>::readFields(*this);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class ThermoType>
Foam::BasicReactingCloud<ThermoType>::~BasicReactingCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class ThermoType>
void Foam::BasicReactingCloud<ThermoType>::writeFields() const
{
BasicReactingParcel<ThermoType>::writeFields(*this);
}
// ************************************************************************* //

68
src/lagrangian/intermediate/clouds/derived/BasicReactingCloud/BasicReactingCloud.H
View File

@ -38,73 +38,21 @@ SourceFiles
#include "ReactingCloud.H"
#include "BasicReactingParcel.H"
#include "thermoPhysicsTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef ReactingCloud<BasicReactingParcel<constGasThermoPhysics> >
constThermoReactingCloud;
// Forward declaration of classes
template<class ThermoType>
class BasicReactingCloud;
typedef ReactingCloud<BasicReactingParcel<gasThermoPhysics> >
thermoReactingCloud;
/*---------------------------------------------------------------------------*\
Class BasicReactingCloud Declaration
\*---------------------------------------------------------------------------*/
template<class ThermoType>
class BasicReactingCloud
:
public ReactingCloud<BasicReactingParcel<ThermoType> >
{
// Private Member Functions
//- Disallow default bitwise copy construct
BasicReactingCloud(const BasicReactingCloud&);
//- Disallow default bitwise assignment
void operator=(const BasicReactingCloud&);
public:
//- Runtime type information
TypeName("BasicReactingCloud");
// Constructors
//- Construct given carrier gas fields
BasicReactingCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
);
//- Destructor
~BasicReactingCloud();
// Member Functions
//- Write fields
virtual void writeFields() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "BasicReactingCloud.C"
#endif
typedef ReactingCloud<BasicReactingParcel<icoPoly8ThermoPhysics> >
icoPoly8ThermoReactingCloud;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

38
src/lagrangian/intermediate/clouds/derived/BasicReactingCloud/defineBasicReactingCloud.C
View File

@ -1,38 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "createReactingCloudTypes.H"
#include "BasicReactingCloud.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
createReactingCloudType(BasicReactingCloud);
};
// ************************************************************************* //

70
src/lagrangian/intermediate/clouds/derived/BasicReactingMultiphaseCloud/BasicReactingMultiphaseCloud.C
View File

@ -1,70 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2008-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "BasicReactingMultiphaseCloud.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class ThermoType>
Foam::BasicReactingMultiphaseCloud<ThermoType>::BasicReactingMultiphaseCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
)
:
ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >
(
cloudName,
rho,
U,
g,
thermo
)
{
BasicReactingMultiphaseParcel<ThermoType>::readFields(*this);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class ThermoType>
Foam::BasicReactingMultiphaseCloud<ThermoType>::~BasicReactingMultiphaseCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class ThermoType>
void Foam::BasicReactingMultiphaseCloud<ThermoType>::writeFields() const
{
BasicReactingMultiphaseParcel<ThermoType>::writeFields(*this);
}
// ************************************************************************* //

74
src/lagrangian/intermediate/clouds/derived/BasicReactingMultiphaseCloud/BasicReactingMultiphaseCloud.H
View File

@ -26,10 +26,8 @@ Class
Foam::BasicReactingMultiphaseCloud
Description
Reacting multiphase cloud templated on the type of carrier phase thermodynamics
SourceFiles
BasicReactingMultiphaseCloud.C
Reacting multiphase cloud templated on the type of carrier phase
thermodynamics
\*---------------------------------------------------------------------------*/
@ -38,73 +36,21 @@ SourceFiles
#include "ReactingMultiphaseCloud.H"
#include "BasicReactingMultiphaseParcel.H"
#include "thermoPhysicsTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef ReactingMultiphaseCloud<BasicReactingParcel<constGasThermoPhysics> >
constThermoReactingMultiphaseCloud;
// Forward declaration of classes
template<class ThermoType>
class BasicReactingMultiphaseCloud;
typedef ReactingMultiphaseCloud<BasicReactingParcel<gasThermoPhysics> >
thermoReactingMultiphaseCloud;
/*---------------------------------------------------------------------------*\
Class BasicReactingMultiphaseCloud Declaration
\*---------------------------------------------------------------------------*/
template<class ThermoType>
class BasicReactingMultiphaseCloud
:
public ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >
{
// Private Member Functions
//- Disallow default bitwise copy construct
BasicReactingMultiphaseCloud(const BasicReactingMultiphaseCloud&);
//- Disallow default bitwise assignment
void operator=(const BasicReactingMultiphaseCloud&);
public:
//- Runtime type information
TypeName("BasicReactingMultiphaseCloud");
// Constructors
//- Construct given carrier gas fields
BasicReactingMultiphaseCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
);
//- Destructor
~BasicReactingMultiphaseCloud();
// Member Functions
//- Write fields
virtual void writeFields() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "BasicReactingMultiphaseCloud.C"
#endif
typedef ReactingMultiphaseCloud<BasicReactingParcel<icoPoly8ThermoPhysics> >
icoPoly8ThermoReactingMultiphaseCloud;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

38
src/lagrangian/intermediate/clouds/derived/BasicReactingMultiphaseCloud/defineBasicReactingMultiphaseCloud.C
View File

@ -1,38 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2008-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "createReactingCloudTypes.H"
#include "BasicReactingMultiphaseCloud.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
createReactingCloudType(BasicReactingMultiphaseCloud);
};
// ************************************************************************* //

68
src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.C
View File

@ -1,68 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "basicKinematicCloud.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(basicKinematicCloud, 0);
};
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::basicKinematicCloud::basicKinematicCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g
)
:
KinematicCloud<basicKinematicParcel>(cloudName, rho, U, mu, g)
{
basicKinematicParcel::readFields(*this);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::basicKinematicCloud::~basicKinematicCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::basicKinematicCloud::writeFields() const
{
basicKinematicParcel::writeFields(*this);
}
// ************************************************************************* //

52
src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.H
View File

@ -43,56 +43,8 @@ SourceFiles
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class basicKinematicCloud Declaration
\*---------------------------------------------------------------------------*/
class basicKinematicCloud
:
public KinematicCloud<basicKinematicParcel>
{
// Private member functions
//- Disallow default bitwise copy construct
basicKinematicCloud(const basicKinematicCloud&);
//- Disallow default bitwise assignment
void operator=(const basicKinematicCloud&);
public:
//- Runtime type information
TypeName("basicKinematicCloud");
// Constructors
//- Construct from components
basicKinematicCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g
);
//- Destructor
~basicKinematicCloud();
// Member functions
//- Write fields
virtual void writeFields() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
typedef KinematicCloud<basicKinematicParcel> basicKinematicCloud;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

68
src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.C
View File

@ -1,68 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "basicThermoCloud.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(basicThermoCloud, 0);
};
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::basicThermoCloud::basicThermoCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
)
:
ThermoCloud<basicThermoParcel>(cloudName, rho, U, g, thermo)
{
basicThermoParcel::readFields(*this);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::basicThermoCloud::~basicThermoCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::basicThermoCloud::writeFields() const
{
basicThermoParcel::writeFields(*this);
}
// ************************************************************************* //

56
src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.H
View File

@ -43,60 +43,8 @@ SourceFiles
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class basicThermoCloud Declaration
\*---------------------------------------------------------------------------*/
class basicThermoCloud
:
public ThermoCloud<basicThermoParcel>
{
// Private Member Functions
//- Disallow default bitwise copy construct
basicThermoCloud
(
const basicThermoCloud&
);
//- Disallow default bitwise assignment
void operator=(const basicThermoCloud&);
public:
//- Runtime type information
TypeName("basicThermoCloud");
// Constructors
//- Construct given carrier gas fields
basicThermoCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
basicThermo& thermo
);
//- Destructor
~basicThermoCloud();
// Member Functions
//- Write fields
virtual void writeFields() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
typedef ThermoCloud<basicThermoParcel> basicThermoCloud;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

50
src/lagrangian/intermediate/clouds/include/createReactingCloudTypes.H
View File

@ -1,50 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2008-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#ifndef createReactingCloudTypes_H
#define createReactingCloudTypes_H
#include "thermoPhysicsTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define createReactingCloudType(CloudType) \
\
createReactingCloudThermoType(CloudType, constGasThermoPhysics); \
createReactingCloudThermoType(CloudType, gasThermoPhysics); \
createReactingCloudThermoType(CloudType, icoPoly8ThermoPhysics);
#define createReactingCloudThermoType(CloudType, ThermoType) \
\
defineTemplateTypeNameAndDebug(CloudType<ThermoType>, 0);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

4
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.H
View File

@ -520,10 +520,10 @@ public:
// I-O
//- Read
static void readFields(KinematicCloud<ParcelType>& c);
static void readFields(Cloud<ParcelType>& c);
//- Write
static void writeFields(const KinematicCloud<ParcelType>& c);
static void writeFields(const Cloud<ParcelType>& c);
// Ostream Operator

10
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelIO.C
View File

@ -103,10 +103,7 @@ Foam::KinematicParcel<ParcelType>::KinematicParcel
template<class ParcelType>
void Foam::KinematicParcel<ParcelType>::readFields
(
KinematicCloud<ParcelType>& c
)
void Foam::KinematicParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
{
if (!c.size())
{
@ -153,10 +150,7 @@ void Foam::KinematicParcel<ParcelType>::readFields
template<class ParcelType>
void Foam::KinematicParcel<ParcelType>::writeFields
(
const KinematicCloud<ParcelType>& c
)
void Foam::KinematicParcel<ParcelType>::writeFields(const Cloud<ParcelType>& c)
{
Particle<ParcelType>::writeFields(c);

7
src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcel.H
View File

@ -399,13 +399,10 @@ public:
// I-O
//- Read
static void readFields(ReactingMultiphaseCloud<ParcelType>& c);
static void readFields(Cloud<ParcelType>& c);
//- Write
static void writeFields
(
const ReactingMultiphaseCloud<ParcelType>& c
);
static void writeFields(const Cloud<ParcelType>& c);
// Ostream Operator

12
src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcelIO.C
View File

@ -94,14 +94,17 @@ Foam::ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel
template<class ParcelType>
void Foam::ReactingMultiphaseParcel<ParcelType>::readFields
(
ReactingMultiphaseCloud<ParcelType>& c
Cloud<ParcelType>& cIn
)
{
if (!c.size())
if (!cIn.size())
{
return;
}
ReactingMultiphaseCloud<ParcelType>& c =
dynamic_cast<ReactingMultiphaseCloud<ParcelType>&>(cIn);
ReactingParcel<ParcelType>::readFields(c);
// Get names and sizes for each Y...
@ -185,9 +188,12 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::readFields
template<class ParcelType>
void Foam::ReactingMultiphaseParcel<ParcelType>::writeFields
(
const ReactingMultiphaseCloud<ParcelType>& c
const Cloud<ParcelType>& cIn
)
{
const ReactingMultiphaseCloud<ParcelType>& c =
dynamic_cast<const ReactingMultiphaseCloud<ParcelType>&>(cIn);
ReactingParcel<ParcelType>::writeFields(c);
label np = c.size();

2
src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcel.C
View File

@ -276,9 +276,9 @@ void Foam::ReactingParcel<ParcelType>::calc
td,
dt,
cellI,
Re,
Ts,
mus/rhos,
Re,
d0,
T0,
mass0,

4
src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcel.H
View File

@ -348,10 +348,10 @@ public:
// I-O
//- Read
static void readFields(ReactingCloud<ParcelType>& c);
static void readFields(Cloud<ParcelType>& c);
//- Write
static void writeFields(const ReactingCloud<ParcelType>& c);
static void writeFields(const Cloud<ParcelType>& c);
// Ostream Operator

17
src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcelIO.C
View File

@ -88,16 +88,16 @@ Foam::ReactingParcel<ParcelType>::ReactingParcel
template<class ParcelType>
void Foam::ReactingParcel<ParcelType>::readFields
(
ReactingCloud<ParcelType>& c
)
void Foam::ReactingParcel<ParcelType>::readFields(Cloud<ParcelType>& cIn)
{
if (!c.size())
if (!cIn.size())
{
return;
}
ReactingCloud<ParcelType>& c =
dynamic_cast<ReactingCloud<ParcelType>&>(cIn);
ThermoParcel<ParcelType>::readFields(c);
IOField<scalar> mass0(c.fieldIOobject("mass0", IOobject::MUST_READ));
@ -152,12 +152,15 @@ void Foam::ReactingParcel<ParcelType>::readFields
template<class ParcelType>
void Foam::ReactingParcel<ParcelType>::writeFields
(
const ReactingCloud<ParcelType>& c
const Cloud<ParcelType>& cIn
)
{
const ReactingCloud<ParcelType>& c =
dynamic_cast<const ReactingCloud<ParcelType>&>(cIn);
ThermoParcel<ParcelType>::writeFields(c);
const label np = c.size();
const label np = c.size();
if (np > 0)
{

4
src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcel.H
View File

@ -359,10 +359,10 @@ public:
// I-O
//- Read
static void readFields(ThermoCloud<ParcelType>& c);
static void readFields(Cloud<ParcelType>& c);
//- Write
static void writeFields(const ThermoCloud<ParcelType>& c);
static void writeFields(const Cloud<ParcelType>& c);
// Ostream Operator

10
src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcelIO.C
View File

@ -79,10 +79,7 @@ Foam::ThermoParcel<ParcelType>::ThermoParcel
template<class ParcelType>
void Foam::ThermoParcel<ParcelType>::readFields
(
ThermoCloud<ParcelType>& c
)
void Foam::ThermoParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
{
if (!c.size())
{
@ -111,10 +108,7 @@ void Foam::ThermoParcel<ParcelType>::readFields
template<class ParcelType>
void Foam::ThermoParcel<ParcelType>::writeFields
(
const ThermoCloud<ParcelType>& c
)
void Foam::ThermoParcel<ParcelType>::writeFields(const Cloud<ParcelType>& c)
{
InteractingKinematicParcel<ParcelType>::writeFields(c);

2
src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporation/LiquidEvaporation.C
View File

@ -58,7 +58,7 @@ Foam::scalar Foam::LiquidEvaporation<CloudType>::Sh
const scalar Sc
) const
{
return 2.0 + 0.6*Foam::sqrt(Re)*pow(Sc, 0.333);
return 2.0 + 0.6*Foam::sqrt(Re)*cbrt(Sc);
}

54
src/lagrangian/intermediate/submodels/Thermodynamic/HeatTransferModel/HeatTransferModel/HeatTransferModel.H
View File

@ -115,42 +115,42 @@ public:
// Member Functions
// Access
// Access
//- Return the cloud dictionary
const dictionary& dict() const;
//- Return the cloud dictionary
const dictionary& dict() const;
//- Return the coefficients dictionary
const dictionary& coeffDict() const;
//- Return the coefficients dictionary
const dictionary& coeffDict() const;
//- Return the owner cloud object
const CloudType& owner() const;
//- Return the owner cloud object
const CloudType& owner() const;
//- Return the Bird htc correction flag
const Switch& BirdCorrection() const;
//- Return the Bird htc correction flag
const Switch& BirdCorrection() const;
//- Flag to indicate whether model activates heat transfer model
virtual bool active() const = 0;
//- Flag to indicate whether model activates heat transfer model
virtual bool active() const = 0;
// Evaluation
// Evaluation
//- Nusselt number
virtual scalar Nu
(
const scalar Re,
const scalar Pr
) const = 0;
//- Nusselt number
virtual scalar Nu
(
const scalar Re,
const scalar Pr
) const = 0;
//- Return heat transfer coefficient
virtual scalar htc
(
const scalar dp,
const scalar Re,
const scalar Pr,
const scalar kappa,
const scalar NCpW
) const;
//- Return heat transfer coefficient
virtual scalar htc
(
const scalar dp,
const scalar Re,
const scalar Pr,
const scalar kappa,
const scalar NCpW
) const;
};

1
src/lagrangian/intermediate/submodels/Thermodynamic/HeatTransferModel/NoHeatTransfer/NoHeatTransfer.H
View File

@ -39,6 +39,7 @@ Description
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class NoHeatTransfer Declaration
\*---------------------------------------------------------------------------*/

4
src/lagrangian/intermediate/submodels/Thermodynamic/HeatTransferModel/RanzMarshall/RanzMarshall.H
View File

@ -39,6 +39,7 @@ Description
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class RanzMarshall Declaration
\*---------------------------------------------------------------------------*/
@ -76,9 +77,6 @@ public:
//- Flag to indicate whether model activates heat transfer model
virtual bool active() const;
//- Return the Bird correction flag
const Switch& BirdCorrection() const;
// Evaluation

8
src/lagrangian/molecularDynamics/molecule/mdTools/temperatureAndPressure.H
View File

@ -57,7 +57,7 @@ if (runTime.outputTime())
averageTemperature =
(
2.0/(moleculeCloud::kb * accumulatedDOFs)
2.0/(physicoChemical::k.value()*accumulatedDOFs)
*
(
accumulatedTotalLinearKE + accumulatedTotalAngularKE
@ -70,10 +70,8 @@ if (runTime.outputTime())
(
(
(accumulatedNMols/nAveragingSteps)
*
moleculeCloud::kb * averageTemperature
+
accumulatedTotalrDotfSum/(6.0 * nAveragingSteps)
*physicoChemical::k.value()*averageTemperature
+ accumulatedTotalrDotfSum/(6.0*nAveragingSteps)
)
/
meshVolume

7
src/lagrangian/molecularDynamics/molecule/molecule/molecule.H
View File

@ -382,9 +382,12 @@ public:
int&
);
static void readFields(moleculeCloud& mC);
static void writeFields(const moleculeCloud& mC);
// I-O
static void readFields(Cloud<molecule>& mC);
static void writeFields(const Cloud<molecule>& mC);
// IOstream Operators

9
src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C
View File

@ -98,7 +98,7 @@ Foam::molecule::molecule
}
void Foam::molecule::readFields(moleculeCloud& mC)
void Foam::molecule::readFields(Cloud<molecule>& mC)
{
if (!mC.size())
{
@ -150,7 +150,7 @@ void Foam::molecule::readFields(moleculeCloud& mC)
}
void Foam::molecule::writeFields(const moleculeCloud& mC)
void Foam::molecule::writeFields(const Cloud<molecule>& mC)
{
Particle<molecule>::writeFields(mC);
@ -241,9 +241,10 @@ void Foam::molecule::writeFields(const moleculeCloud& mC)
orientation2.write();
orientation3.write();
mC.writeXYZ
const moleculeCloud& m = dynamic_cast<const moleculeCloud&>(mC);
m.writeXYZ
(
mC.mesh().time().timePath() + "/lagrangian" + "/moleculeCloud.xmol"
m.mesh().time().timePath() + "/lagrangian" + "/moleculeCloud.xmol"
);
}

82
src/lagrangian/molecularDynamics/molecule/moleculeCloud/moleculeCloud.C
View File

@ -28,6 +28,8 @@ License
#include "fvMesh.H"
#include "mathConstants.H"
using namespace Foam::constant;
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
@ -36,13 +38,6 @@ namespace Foam
defineTemplateTypeNameAndDebug(Cloud<molecule>, 0);
};
Foam::scalar Foam::moleculeCloud::kb = 1.380650277e-23;
Foam::scalar Foam::moleculeCloud::elementaryCharge = 1.602176487e-19;
Foam::scalar Foam::moleculeCloud::vacuumPermittivity = 8.854187817e-12;
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::moleculeCloud::buildConstProps()
@ -103,9 +98,7 @@ void Foam::moleculeCloud::buildConstProps()
void Foam::moleculeCloud::setSiteSizesAndPositions()
{
iterator mol(this->begin());
for (mol = this->begin(); mol != this->end(); ++mol)
forAllIter(moleculeCloud, *this, mol)
{
const molecule::constantProperties& cP = constProps(mol().id());
@ -123,14 +116,7 @@ void Foam::moleculeCloud::buildCellOccupancy()
cellOccupancy_[cO].clear();
}
iterator mol(this->begin());
for
(
mol = this->begin();
mol != this->end();
++mol
)
forAllIter(moleculeCloud, *this, mol)
{
cellOccupancy_[mol().cell()].append(&mol());
}
@ -225,9 +211,7 @@ void Foam::moleculeCloud::calculateTetherForce()
{
const tetherPotentialList& tetherPot(pot_.tetherPotentials());
iterator mol(this->begin());
for (mol = this->begin(); mol != this->end(); ++mol)
forAllIter(moleculeCloud, *this, mol)
{
if (mol().tethered())
{
@ -252,9 +236,7 @@ void Foam::moleculeCloud::calculateTetherForce()
void Foam::moleculeCloud::calculateExternalForce()
{
iterator mol(this->begin());
for (mol = this->begin(); mol != this->end(); ++mol)
forAllIter(moleculeCloud, *this, mol)
{
mol().a() += pot_.gravity();
}
@ -624,11 +606,11 @@ void Foam::moleculeCloud::initialiseMolecules
zoneDict.lookup("orientationAngles")
);
scalar phi(orientationAngles.x()*constant::math::pi/180.0);
scalar phi(orientationAngles.x()*math::pi/180.0);
scalar theta(orientationAngles.y()*constant::math::pi/180.0);
scalar theta(orientationAngles.y()*math::pi/180.0);
scalar psi(orientationAngles.z()*constant::math::pi/180.0);
scalar psi(orientationAngles.z()*math::pi/180.0);
const tensor R
(
@ -994,11 +976,11 @@ void Foam::moleculeCloud::createMolecule
{
pi = equipartitionAngularMomentum(temperature, cP);
scalar phi(rndGen_.scalar01()*constant::math::twoPi);
scalar phi(rndGen_.scalar01()*math::twoPi);
scalar theta(rndGen_.scalar01()*constant::math::twoPi);
scalar theta(rndGen_.scalar01()*math::twoPi);
scalar psi(rndGen_.scalar01()*constant::math::twoPi);
scalar psi(rndGen_.scalar01()*math::twoPi);
Q = tensor
(
@ -1039,9 +1021,7 @@ Foam::label Foam::moleculeCloud::nSites() const
{
label n = 0;
const_iterator mol(this->begin());
for (mol = this->begin(); mol != this->end(); ++mol)
forAllConstIter(moleculeCloud, *this, mol)
{
n += constProps(mol().id()).nSites();
}
@ -1055,7 +1035,8 @@ Foam::label Foam::moleculeCloud::nSites() const
Foam::moleculeCloud::moleculeCloud
(
const polyMesh& mesh,
const potential& pot
const potential& pot,
bool readFields
)
:
Cloud<molecule>(mesh, "moleculeCloud", false),
@ -1066,7 +1047,10 @@ Foam::moleculeCloud::moleculeCloud
constPropList_(),
rndGen_(clock::getTime())
{
molecule::readFields(*this);
if (readFields)
{
molecule::readFields(*this);
}
buildConstProps();
@ -1082,9 +1066,10 @@ Foam::moleculeCloud::moleculeCloud
(
const polyMesh& mesh,
const potential& pot,
const IOdictionary& mdInitialiseDict
const IOdictionary& mdInitialiseDict,
bool readFields
)
:
:
Cloud<molecule>(mesh, "moleculeCloud", false),
mesh_(mesh),
pot_(pot),
@ -1092,7 +1077,10 @@ Foam::moleculeCloud::moleculeCloud
constPropList_(),
rndGen_(clock::getTime())
{
molecule::readFields(*this);
if (readFields)
{
molecule::readFields(*this);
}
clear();
@ -1126,10 +1114,8 @@ void Foam::moleculeCloud::calculateForce()
{
buildCellOccupancy();
iterator mol(this->begin());
// Set accumulated quantities to zero
for (mol = this->begin(); mol != this->end(); ++mol)
forAllIter(moleculeCloud, *this, mol)
{
mol().siteForces() = vector::zero;
@ -1166,9 +1152,7 @@ void Foam::moleculeCloud::applyConstraintsAndThermostats
<< "----------------------------------------"
<< endl;
iterator mol(this->begin());
for (mol = this->begin(); mol != this->end(); ++mol)
forAllIter(moleculeCloud, *this, mol)
{
mol().v() *= temperatureCorrectionFactor;
@ -1177,21 +1161,13 @@ void Foam::moleculeCloud::applyConstraintsAndThermostats
}
void Foam::moleculeCloud::writeFields() const
{
molecule::writeFields(*this);
}
void Foam::moleculeCloud::writeXYZ(const fileName& fName) const
{
OFstream str(fName);
str << nSites() << nl << "moleculeCloud site positions in angstroms" << nl;
const_iterator mol(this->begin());
for (mol = this->begin(); mol != this->end(); ++mol)
forAllConstIter(moleculeCloud, *this, mol)
{
const molecule::constantProperties& cP = constProps(mol().id());

18
src/lagrangian/molecularDynamics/molecule/moleculeCloud/moleculeCloud.H
View File

@ -156,22 +156,14 @@ private:
public:
// Static data members
static scalar kb;
static scalar elementaryCharge;
static scalar vacuumPermittivity;
// Constructors
//- Construct given mesh and potential references
moleculeCloud
(
const polyMesh& mesh,
const potential& pot
const potential& pot,
bool readFields = true
);
//- Construct given mesh, potential and mdInitialiseDict
@ -179,7 +171,8 @@ public:
(
const polyMesh& mesh,
const potential& pot,
const IOdictionary& mdInitialiseDict
const IOdictionary& mdInitialiseDict,
bool readFields = true
);
@ -217,9 +210,6 @@ public:
// Member Operators
//- Write fields
void writeFields() const;
//- Write molecule sites in XYZ format
void writeXYZ(const fileName& fName) const;
};

8
src/lagrangian/molecularDynamics/molecule/moleculeCloud/moleculeCloudI.H
View File

@ -24,6 +24,10 @@ License
\*---------------------------------------------------------------------------*/
#include "constants.H"
using namespace Foam::constant;
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
inline void Foam::moleculeCloud::evaluatePair
@ -576,7 +580,7 @@ inline Foam::vector Foam::moleculeCloud::equipartitionLinearVelocity
scalar mass
)
{
return sqrt(kb*temperature/mass)*vector
return sqrt(physicoChemical::k.value()*temperature/mass)*vector
(
rndGen_.GaussNormal(),
rndGen_.GaussNormal(),
@ -591,7 +595,7 @@ inline Foam::vector Foam::moleculeCloud::equipartitionAngularMomentum
const molecule::constantProperties& cP
)
{
scalar sqrtKbT = sqrt(kb*temperature);
scalar sqrtKbT = sqrt(physicoChemical::k.value()*temperature);
if (cP.linearMolecule())
{

14
src/lagrangian/solidParticle/solidParticleCloud.C
View File

@ -42,7 +42,8 @@ namespace Foam
Foam::solidParticleCloud::solidParticleCloud
(
const fvMesh& mesh,
const word& cloudName
const word& cloudName,
bool readFields
)
:
Cloud<solidParticle>(mesh, cloudName, false),
@ -62,7 +63,10 @@ Foam::solidParticleCloud::solidParticleCloud
e_(dimensionedScalar(particleProperties_.lookup("e")).value()),
mu_(dimensionedScalar(particleProperties_.lookup("mu")).value())
{
solidParticle::readFields(*this);
if (readFields)
{
solidParticle::readFields(*this);
}
}
@ -84,10 +88,4 @@ void Foam::solidParticleCloud::move(const dimensionedVector& g)
}
void Foam::solidParticleCloud::writeFields() const
{
solidParticle::writeFields(*this);
}
// ************************************************************************* //

9
src/lagrangian/solidParticle/solidParticleCloud.H
View File

@ -86,7 +86,8 @@ public:
solidParticleCloud
(
const fvMesh&,
const word& cloudName = "defaultCloud"
const word& cloudName = "defaultCloud",
bool readFields = true
);
@ -106,12 +107,6 @@ public:
//- Move the particles under the influence of the given
// gravitational acceleration
void move(const dimensionedVector& g);
// Write
//- Write fields
virtual void writeFields() const;
};

2
src/meshTools/triSurface/triangleFuncs/triangleFuncs.C
View File

@ -115,7 +115,7 @@ bool Foam::triangleFuncs::intersectAxesBundle
// V10:(-1.285715 8.99165e-16 -1.142858)
// V20:(0 0 -1.678573)
// i0:0
if (Foam::mag(det)/localScale < SMALL)
if (localScale < VSMALL || Foam::mag(det)/localScale < SMALL)
{
// Triangle parallel to dir
return false;

1
src/postProcessing/functionObjects/Allwmake
View File

@ -7,6 +7,5 @@ wmake libso forces
wmake libso IO
wmake libso utilities
wmake libso systemCall
wmake libso zones
# ----------------------------------------------------------------- end-of-file

10
src/postProcessing/functionObjects/field/streamLine/streamLineParticle.C
View File

@ -387,10 +387,7 @@ void Foam::streamLineParticle::hitPatch
{}
void Foam::streamLineParticle::readFields
(
Cloud<streamLineParticle>& c
)
void Foam::streamLineParticle::readFields(Cloud<streamLineParticle>& c)
{
if (!c.size())
{
@ -426,10 +423,7 @@ void Foam::streamLineParticle::readFields
}
void Foam::streamLineParticle::writeFields
(
const Cloud<streamLineParticle>& c
)
void Foam::streamLineParticle::writeFields(const Cloud<streamLineParticle>& c)
{
Particle<streamLineParticle>::writeFields(c);

30
src/postProcessing/functionObjects/field/streamLine/streamLineParticleCloud.C
View File

@ -26,15 +26,11 @@ License
#include "streamLineParticleCloud.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTemplateTypeNameAndDebug(Cloud<streamLineParticle>, 0);
defineTemplateTypeNameAndDebug(Cloud<streamLineParticle>, 0);
};
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -42,12 +38,16 @@ defineTemplateTypeNameAndDebug(Cloud<streamLineParticle>, 0);
Foam::streamLineParticleCloud::streamLineParticleCloud
(
const polyMesh& mesh,
const word& cloudName
const word& cloudName,
bool readFields
)
:
Cloud<streamLineParticle>(mesh, cloudName, false)
{
readFields();
if (readFields)
{
streamLineParticle::readFields(*this);
}
}
@ -62,18 +62,4 @@ Foam::streamLineParticleCloud::streamLineParticleCloud
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::streamLineParticleCloud::readFields()
{
streamLineParticle::readFields(*this);
}
void Foam::streamLineParticleCloud::writeFields() const
{
streamLineParticle::writeFields(*this);
}
// ************************************************************************* //

14
src/postProcessing/functionObjects/field/streamLine/streamLineParticleCloud.H
View File

@ -45,7 +45,7 @@ namespace Foam
{
/*---------------------------------------------------------------------------*\
Class streamLineCloud Declaration
Class streamLineCloud Declaration
\*---------------------------------------------------------------------------*/
class streamLineParticleCloud
@ -72,7 +72,8 @@ public:
streamLineParticleCloud
(
const polyMesh&,
const word& cloudName = "defaultCloud"
const word& cloudName = "defaultCloud",
bool readFields = true
);
//- Construct from mesh, cloud name, and a list of particles
@ -82,15 +83,6 @@ public:
const word& cloudName,
const IDLList<streamLineParticle>& particles
);
// Member Functions
//- Read fields
virtual void readFields();
//- Write fields
virtual void writeFields() const;
};

13
src/postProcessing/functionObjects/utilities/dsmcFields/dsmcFields.C
View File

@ -29,6 +29,10 @@ License
#include "dictionary.H"
#include "dsmcCloud.H"
#include "constants.H"
using namespace Foam::constant;
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
@ -170,7 +174,8 @@ void Foam::dsmcFields::write()
obr_,
IOobject::NO_READ
),
2.0/(3.0*dsmcCloud::kb*rhoNMean)
2.0/(3.0*physicoChemical::k.value()*rhoNMean)
*(linearKEMean - 0.5*rhoMMean*(UMean & UMean))
);
@ -184,7 +189,7 @@ void Foam::dsmcFields::write()
obr_,
IOobject::NO_READ
),
(2.0/dsmcCloud::kb)*(internalEMean/iDofMean)
(2.0/physicoChemical::k.value())*(internalEMean/iDofMean)
);
Info<< " Calculating overallT field." << endl;
@ -197,7 +202,7 @@ void Foam::dsmcFields::write()
obr_,
IOobject::NO_READ
),
2.0/(dsmcCloud::kb*(3.0*rhoNMean + iDofMean))
2.0/(physicoChemical::k.value()*(3.0*rhoNMean + iDofMean))
*(linearKEMean - 0.5*rhoMMean*(UMean & UMean) + internalEMean)
);
@ -211,7 +216,7 @@ void Foam::dsmcFields::write()
obr_,
IOobject::NO_READ
),
dsmcCloud::kb*rhoNMean*translationalT
physicoChemical::k.value()*rhoNMean*translationalT
);
const fvMesh& mesh = fDMean.mesh();

4
src/postProcessing/functionObjects/zones/Make/files
View File

@ -1,4 +0,0 @@
faceZoneIntegration/faceZonesIntegration.C
faceZoneIntegration/faceZonesIntegrationFunctionObject.C
LIB = $(FOAM_LIBBIN)/libzoneFunctionObjects

9
src/postProcessing/functionObjects/zones/Make/options
View File

@ -1,9 +0,0 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude
LIB_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lsampling

50
src/postProcessing/functionObjects/zones/faceZoneIntegration/IOfaceZonesIntegration.H
View File

@ -1,50 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Typedef
Foam::IOfaceZonesIntegration
Description
Instance of the generic IOOutputFilter for faceZonesIntegration.
\*---------------------------------------------------------------------------*/
#ifndef IOfaceZonesIntegration_H
#define IOfaceZonesIntegration_H
#include "faceZonesIntegration.H"
#include "IOOutputFilter.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef IOOutputFilter<faceZonesIntegration> IOfaceZonesIntegration;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

330
src/postProcessing/functionObjects/zones/faceZoneIntegration/faceZonesIntegration.C
View File

@ -1,330 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "faceZonesIntegration.H"
#include "volFields.H"
#include "dictionary.H"
#include "Time.H"
#include "IOmanip.H"
#include "ListListOps.H"
#include "processorPolyPatch.H"
#include "cyclicPolyPatch.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(faceZonesIntegration, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::faceZonesIntegration::faceZonesIntegration
(
const word& name,
const objectRegistry& obr,
const dictionary& dict,
const bool loadFromFiles
)
:
name_(name),
obr_(obr),
active_(true),
log_(false),
zoneNames_(),
fieldNames_(),
filePtr_(NULL)
{
// Check if the available mesh is an fvMesh otherise deactivate
if (!isA<fvMesh>(obr_))
{
active_ = false;
WarningIn
(
"Foam::faceZonesIntegration::faceZonesIntegration"
"("
"const word&, "
"const objectRegistry&, "
"const dictionary&, "
"const bool"
")"
) << "No fvMesh available, deactivating."
<< endl;
}
read(dict);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::faceZonesIntegration::~faceZonesIntegration()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::faceZonesIntegration::read(const dictionary& dict)
{
if (active_)
{
log_ = dict.lookupOrDefault<Switch>("log", false);
dict.lookup("fields") >> fieldNames_;
dict.lookup("faceZones") >> zoneNames_;
}
}
void Foam::faceZonesIntegration::makeFile()
{
// Create the face Zone file if not already created
if (filePtr_.empty())
{
if (debug)
{
Info<< "Creating faceZonesIntegration file." << endl;
}
// File update
if (Pstream::master())
{
fileName faceZonesIntegrationDir;
if (Pstream::parRun())
{
// Put in undecomposed case (Note: gives problems for
// distributed data running)
faceZonesIntegrationDir =
obr_.time().path()/".."/name_/obr_.time().timeName();
}
else
{
faceZonesIntegrationDir =
obr_.time().path()/name_/obr_.time().timeName();
}
// Create directory if does not exist.
mkDir(faceZonesIntegrationDir);
// Open new file at start up
filePtr_.resize(fieldNames_.size());
forAll(fieldNames_, fieldI)
{
const word& fieldName = fieldNames_[fieldI];
OFstream* sPtr = new OFstream
(
faceZonesIntegrationDir/fieldName
);
filePtr_.insert(fieldName, sPtr);
}
// Add headers to output data
writeFileHeader();
}
}
}
void Foam::faceZonesIntegration::writeFileHeader()
{
forAllIter(HashPtrTable<OFstream>, filePtr_, iter)
{
unsigned int w = IOstream::defaultPrecision() + 7;
OFstream& os = *filePtr_[iter.key()];
os << "#Time " << setw(w);
forAll (zoneNames_, zoneI)
{
os << zoneNames_[zoneI] << setw(w);
}
os << nl << endl;
}
}
void Foam::faceZonesIntegration::execute()
{
// Do nothing - only valid on write
}
void Foam::faceZonesIntegration::end()
{
// Do nothing - only valid on write
}
void Foam::faceZonesIntegration::write()
{
if (active_)
{
makeFile();
forAll(fieldNames_, fieldI)
{
const word& fieldName = fieldNames_[fieldI];
const surfaceScalarField& sField =
obr_.lookupObject<surfaceScalarField>(fieldName);
const fvMesh& mesh = sField.mesh();
// 1. integrate over all face zones
scalarField integralVals(zoneNames_.size());
forAll(integralVals, zoneI)
{
const word& name = zoneNames_[zoneI];
label zoneID = mesh.faceZones().findZoneID(name);
const faceZone& fZone = mesh.faceZones()[zoneID];
integralVals[zoneI] = returnReduce
(
calcIntegral(sField, fZone),
sumOp<scalar>()
);
}
unsigned int w = IOstream::defaultPrecision() + 7;
// 2. Write only on master
if (Pstream::master() && filePtr_.found(fieldName))
{
OFstream& os = *filePtr_(fieldName);
os << obr_.time().value();
forAll(integralVals, zoneI)
{
os << ' ' << setw(w) << integralVals[zoneI];
if (log_)
{
Info<< "faceZonesIntegration output:" << nl
<< " Integration[" << zoneI << "] "
<< integralVals[zoneI] << endl;
}
}
os << endl;
}
}
}
}
Foam::scalar Foam::faceZonesIntegration::calcIntegral
(
const surfaceScalarField& sField,
const faceZone& fZone
) const
{
scalar sum = 0.0;
const fvMesh& mesh = sField.mesh();
forAll (fZone, i)
{
label faceI = fZone[i];
if (mesh.isInternalFace(faceI))
{
if (fZone.flipMap()[i])
{
sum -= sField[faceI];
}
else
{
sum += sField[faceI];
}
}
else
{
label patchI = mesh.boundaryMesh().whichPatch(faceI);
const polyPatch& pp = mesh.boundaryMesh()[patchI];
const fvsPatchScalarField& bField = sField.boundaryField()[patchI];
if (isA<processorPolyPatch>(pp))
{
if (refCast<const processorPolyPatch>(pp).owner())
{
label patchFaceI = pp.whichFace(faceI);
if (fZone.flipMap()[i])
{
sum -= bField[patchFaceI];
}
else
{
sum += bField[patchFaceI];
}
}
}
else if (isA<cyclicPolyPatch>(pp))
{
label patchFaceI = faceI - pp.start();
if (patchFaceI < pp.size()/2)
{
if (fZone.flipMap()[i])
{
sum -= bField[patchFaceI];
}
else
{
sum += bField[patchFaceI];
}
}
}
else if (!isA<emptyPolyPatch>(pp))
{
label patchFaceI = faceI - pp.start();
if (fZone.flipMap()[i])
{
sum -= bField[patchFaceI];
}
else
{
sum += bField[patchFaceI];
}
}
}
}
return sum;
}
// ************************************************************************* //

180
src/postProcessing/functionObjects/zones/faceZoneIntegration/faceZonesIntegration.H
View File

@ -1,180 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::faceZonesIntegration
Description
Integrates surfaceScalarFields on faceZones
SourceFiles
faceZonesIntegration.C
IOfaceZonesIntegration.H
\*---------------------------------------------------------------------------*/
#ifndef faceZonesIntegration_H
#define faceZonesIntegration_H
#include "fvCFD.H"
#include "primitiveFieldsFwd.H"
#include "volFieldsFwd.H"
#include "HashPtrTable.H"
#include "OFstream.H"
#include "Switch.H"
#include "pointFieldFwd.H"
#include "polyMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class objectRegistry;
class dictionary;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class faceZonesIntegration Declaration
\*---------------------------------------------------------------------------*/
class faceZonesIntegration
{
protected:
// Protected data
//- Name of this set of face zone integration,
// Also used as the name of the output directory.
word name_;
const objectRegistry& obr_;
// Read from dictionary
//- On/off switch
bool active_;
//- Switch to send output to Info as well as to file
Switch log_;
//- List of face zone names to integrate over
wordList zoneNames_;
//- Names of the surface fields
wordList fieldNames_;
//- Current open files
HashPtrTable<OFstream> filePtr_;
// Protected Member Functions
//- If the integration file has not been created create it
void makeFile();
scalar calcIntegral
(
const surfaceScalarField& sField,
const faceZone& fZone
) const;
//- Disallow default bitwise copy construct
faceZonesIntegration(const faceZonesIntegration&);
//- Disallow default bitwise assignment
void operator=(const faceZonesIntegration&);
//- Output file header information
virtual void writeFileHeader();
public:
//- Runtime type information
TypeName("faceZonesIntegration");
// Constructors
//- Construct for given objectRegistry and dictionary.
// Allow the possibility to load fields from files
faceZonesIntegration
(
const word& name,
const objectRegistry&,
const dictionary&,
const bool loadFromFiles = false
);
//- Destructor
virtual ~faceZonesIntegration();
// Member Functions
//- Return name of the set of zones
virtual const word& name() const
{
return name_;
};
//- Read the zone integration data
virtual void read(const dictionary&);
//- Execute, currently does nothing
virtual void execute();
//- Execute at the final time-loop, currently does nothing
virtual void end();
//- Write the integration
virtual void write();
//- Update for changes of mesh
virtual void updateMesh(const mapPolyMesh&)
{}
//- Update for changes of mesh
virtual void movePoints(const pointField&)
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

43
src/postProcessing/functionObjects/zones/faceZoneIntegration/faceZonesIntegrationFunctionObject.C
View File

@ -1,43 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "faceZonesIntegrationFunctionObject.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineNamedTemplateTypeNameAndDebug(faceZonesIntegrationFunctionObject, 0);
addToRunTimeSelectionTable
(
functionObject,
faceZonesIntegrationFunctionObject,
dictionary
);
}
// ************************************************************************* //

55
src/postProcessing/functionObjects/zones/faceZoneIntegration/faceZonesIntegrationFunctionObject.H
View File

@ -1,55 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Typedef
Foam::faceZonesIntegrationFunctionObject
Description
FunctionObject wrapper around faceZonesIntegration to allow them to be
created via the functions list within controlDict.
SourceFiles
faceZonesIntegrationFunctionObject.C
\*---------------------------------------------------------------------------*/
#ifndef faceZonesIntegrationFunctionObject_H
#define faceZonesIntegrationFunctionObject_H
#include "faceZonesIntegration.H"
#include "OutputFilterFunctionObject.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef OutputFilterFunctionObject<faceZonesIntegration>
faceZonesIntegrationFunctionObject;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

24
src/thermophysicalModels/pdfs/RosinRammler/RosinRammler.C
View File

@ -47,14 +47,15 @@ Foam::RosinRammler::RosinRammler(const dictionary& dict, Random& rndGen)
d_(pdfDict_.lookup("d")),
n_(pdfDict_.lookup("n")),
ls_(d_),
range_(maxValue_-minValue_)
range_(maxValue_ - minValue_)
{
if (minValue_<0)
{
FatalErrorIn
(
"RosinRammler::RosinRammler(const dictionary& dict)"
) << " minValue = " << minValue_ << ", it must be >0." << abort(FatalError);
) << " minValue = " << minValue_ << ", it must be >0." << nl
<< abort(FatalError);
}
if (maxValue_<minValue_)
@ -62,7 +63,8 @@ Foam::RosinRammler::RosinRammler(const dictionary& dict, Random& rndGen)
FatalErrorIn
(
"RosinRammler::RosinRammler(const dictionary& dict)"
) << " maxValue is smaller than minValue." << abort(FatalError);
) << " maxValue is smaller than minValue." << nl
<< abort(FatalError);
}
// find max value so that it can be normalized to 1.0
@ -103,26 +105,20 @@ Foam::scalar Foam::RosinRammler::sample() const
{
scalar y = 0;
scalar x = 0;
label n = d_.size();
bool success = false;
scalar p = 0.0;
while (!success)
do
{
x = minValue_ + range_*rndGen_.scalar01();
y = rndGen_.scalar01();
scalar p = 0.0;
p = 0.0;
for (label i=0; i<n; i++)
forAll(d_, i)
{
scalar xx = pow(x/d_[i], n_[i]);
p += ls_[i]*xx*exp(-xx);
}
if (y<p)
{
success = true;
}
}
} while(y>p);
return x;
}

27
src/thermophysicalModels/pdfs/exponential/exponential.C
View File

@ -46,14 +46,15 @@ Foam::exponential::exponential(const dictionary& dict, Random& rndGen)
maxValue_(readScalar(pdfDict_.lookup("maxValue"))),
lambda_(pdfDict_.lookup("lambda")),
ls_(lambda_),
range_(maxValue_-minValue_)
range_(maxValue_ - minValue_)
{
if (minValue_<0)
{
FatalErrorIn
(
"exponential::exponential(const dictionary& dict)"
) << " minValue = " << minValue_ << ", it must be >0." << abort(FatalError);
) << " minValue = " << minValue_ << ", it must be >0." << nl
<< abort(FatalError);
}
scalar sMax = 0;
@ -73,7 +74,7 @@ Foam::exponential::exponential(const dictionary& dict, Random& rndGen)
sMax = max(sMax, s);
}
for(label i=0; i<n; i++)
for (label i=0; i<n; i++)
{
ls_[i] /= sMax;
}
@ -90,27 +91,21 @@ Foam::exponential::~exponential()
Foam::scalar Foam::exponential::sample() const
{
scalar y = 0;
scalar x = 0;
label n = lambda_.size();
bool success = false;
scalar y = 0.0;
scalar x = 0.0;
scalar p = 0.0;
while (!success)
do
{
x = minValue_ + range_*rndGen_.scalar01();
y = rndGen_.scalar01();
scalar p = 0.0;
p = 0.0;
for(label i=0; i<n; i++)
forAll(lambda_, i)
{
p += ls_[i]*exp(-lambda_[i]*x);
}
if (y<p)
{
success = true;
}
}
} while(p>y);
return x;
}

29
src/thermophysicalModels/pdfs/general/general.C
View File

@ -45,7 +45,7 @@ Foam::general::general(const dictionary& dict, Random& rndGen)
nEntries_(xy_.size()),
minValue_(xy_[0][0]),
maxValue_(xy_[nEntries_-1][0]),
range_(maxValue_-minValue_)
range_(maxValue_ - minValue_)
{
// normalize the pdf
scalar yMax = 0;
@ -72,12 +72,11 @@ Foam::general::~general()
Foam::scalar Foam::general::sample() const
{
scalar y = 0;
scalar x = 0;
scalar x = 0.0;
scalar y = 0.0;
scalar p = 0.0;
bool success = false;
while (!success)
do
{
x = minValue_ + range_*rndGen_.scalar01();
y = rndGen_.scalar01();
@ -87,23 +86,17 @@ Foam::scalar Foam::general::sample() const
while (!intervalFound)
{
i++;
if ( (x>xy_[i][0]) && (x<xy_[i+1][0]) )
if ((x>xy_[i][0]) && (x<xy_[i+1][0]))
{
intervalFound = true;
}
}
scalar p =
xy_[i][1]
+ (x-xy_[i][0])
*(xy_[i+1][1]-xy_[i][1])
/(xy_[i+1][0]-xy_[i][0]);
if (y<p)
{
success = true;
}
}
p = xy_[i][1]
+ (x - xy_[i][0])
*(xy_[i+1][1] - xy_[i][1])
/(xy_[i+1][0] - xy_[i][0]);
} while(p>y);
return x;
}

24
src/thermophysicalModels/pdfs/normal/normal.C
View File

@ -46,7 +46,7 @@ Foam::normal::normal(const dictionary& dict, Random& rndGen)
expectation_(pdfDict_.lookup("expectation")),
variance_(pdfDict_.lookup("variance")),
strength_(pdfDict_.lookup("strength")),
range_(maxValue_-minValue_)
range_(maxValue_ - minValue_)
{
scalar sMax = 0;
label n = strength_.size();
@ -84,31 +84,25 @@ Foam::normal::~normal()
Foam::scalar Foam::normal::sample() const
{
scalar y = 0;
scalar x = 0;
label n = expectation_.size();
bool success = false;
scalar x = 0.0;
scalar y = 0.0;
scalar p = 0.0;
while (!success)
do
{
x = minValue_ + range_*rndGen_.scalar01();
y = rndGen_.scalar01();
scalar p = 0.0;
p = 0.0;
for (label i=0; i<n; i++)
forAll(expectation_, i)
{
scalar nu = expectation_[i];
scalar sigma = variance_[i];
scalar s = strength_[i];
scalar v = (x-nu)/sigma;
scalar v = (x - nu)/sigma;
p += s*exp(-0.5*v*v);
}
if (y<p)
{
success = true;
}
}
} while (p>y);
return x;
}

2
src/thermophysicalModels/pdfs/uniform/uniform.C
View File

@ -43,7 +43,7 @@ Foam::uniform::uniform(const dictionary& dict, Random& rndGen)
pdfDict_(dict.subDict(typeName + "PDF")),
minValue_(readScalar(pdfDict_.lookup("minValue"))),
maxValue_(readScalar(pdfDict_.lookup("maxValue"))),
range_(maxValue_-minValue_)
range_(maxValue_ - minValue_)
{}

32
src/turbulenceModels/compressible/RAS/LaunderSharmaKE/LaunderSharmaKE.C
View File

@ -145,7 +145,7 @@ LaunderSharmaKE::LaunderSharmaKE
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateK("k", mesh_)
mesh_
),
epsilon_
@ -158,21 +158,10 @@ LaunderSharmaKE::LaunderSharmaKE
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateEpsilon("epsilon", mesh_)
mesh_
),
mut_
(
IOobject
(
"mut",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
autoCreateMut("mut", mesh_)
),
mut_(rho_*Cmu_*fMu()*sqr(k_)/(epsilon_ + epsilonSmall_)),
alphat_
(
@ -187,9 +176,6 @@ LaunderSharmaKE::LaunderSharmaKE
autoCreateAlphat("alphat", mesh_)
)
{
mut_ = rho_*Cmu_*fMu()*sqr(k_)/(epsilon_ + epsilonSmall_);
mut_.correctBoundaryConditions();
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
@ -275,8 +261,7 @@ void LaunderSharmaKE::correct()
if (!turbulence_)
{
// Re-calculate viscosity
mut_ = rho_*Cmu_*fMu()*sqr(k_)/(epsilon_ + epsilonSmall_);
mut_.correctBoundaryConditions();
mut_ == rho_*Cmu_*fMu()*sqr(k_)/(epsilon_ + epsilonSmall_);
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
@ -304,8 +289,6 @@ void LaunderSharmaKE::correct()
volScalarField G("RASModel::G", mut_*(tgradU() && dev(twoSymm(tgradU()))));
tgradU.clear();
// Update espsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
@ -322,9 +305,6 @@ void LaunderSharmaKE::correct()
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilon0_);
@ -348,8 +328,8 @@ void LaunderSharmaKE::correct()
// Re-calculate viscosity
mut_ = Cmu_*fMu()*rho_*sqr(k_)/(epsilon_ + epsilonSmall_);
mut_.correctBoundaryConditions();
mut_ == Cmu_*fMu()*rho_*sqr(k_)/(epsilon_ + epsilonSmall_);
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;

27
src/turbulenceModels/incompressible/RAS/LamBremhorstKE/LamBremhorstKE.C
View File

@ -114,7 +114,7 @@ LamBremhorstKE::LamBremhorstKE
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
autoCreateEpsilon("epsilon", mesh_)
mesh_
),
y_(mesh_),
@ -127,22 +127,8 @@ LamBremhorstKE::LamBremhorstKE
*(scalar(1) + 20.5/(Rt_ + SMALL))
),
nut_
(
IOobject
(
"nut",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateNut("nut", mesh_)
)
nut_(Cmu_*fMu_*sqr(k_)/(epsilon_ + epsilonSmall_))
{
nut_ = Cmu_*fMu_*sqr(k_)/(epsilon_ + epsilonSmall_);
nut_.correctBoundaryConditions();
printCoeffs();
}
@ -234,6 +220,7 @@ void LamBremhorstKE::correct()
volScalarField G("RASModel::G", nut_*2*magSqr(symm(fvc::grad(U_))));
// Calculate parameters and coefficients for low-Reynolds number model
Rt_ = sqr(k_)/(nu()*epsilon_);
@ -244,8 +231,6 @@ void LamBremhorstKE::correct()
volScalarField f1 = scalar(1) + pow(0.05/(fMu_ + SMALL), 3);
volScalarField f2 = scalar(1) - exp(-sqr(Rt_));
// Update espsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
@ -260,9 +245,6 @@ void LamBremhorstKE::correct()
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilon0_);
@ -284,8 +266,7 @@ void LamBremhorstKE::correct()
// Re-calculate viscosity
nut_ = Cmu_*fMu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
nut_ == Cmu_*fMu_*sqr(k_)/epsilon_;
}

2
src/turbulenceModels/incompressible/RAS/LamBremhorstKE/LamBremhorstKE.H
View File

@ -50,7 +50,7 @@ namespace RASModels
{
/*---------------------------------------------------------------------------*\
Class LamBremhorstKE Declaration
Class LamBremhorstKE Declaration
\*---------------------------------------------------------------------------*/
class LamBremhorstKE

21
src/turbulenceModels/incompressible/RAS/LaunderSharmaKE/LaunderSharmaKE.C
View File

@ -133,22 +133,8 @@ LaunderSharmaKE::LaunderSharmaKE
mesh_
),
nut_
(
IOobject
(
"nut",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateNut("nut", mesh_)
)
nut_(Cmu_*fMu()*sqr(k_)/(epsilonTilda_ + epsilonSmall_))
{
nut_ = Cmu_*fMu()*sqr(k_)/(epsilonTilda_ + epsilonSmall_);
nut_.correctBoundaryConditions();
printCoeffs();
}
@ -235,7 +221,7 @@ void LaunderSharmaKE::correct()
volScalarField S2 = 2*magSqr(symm(fvc::grad(U_)));
volScalarField G = nut_*S2;
volScalarField G("RASModel::G", nut_*S2);
volScalarField E = 2.0*nu()*nut_*fvc::magSqrGradGrad(U_);
volScalarField D = 2.0*nu()*magSqr(fvc::grad(sqrt(k_)));
@ -276,8 +262,7 @@ void LaunderSharmaKE::correct()
// Re-calculate viscosity
nut_ = Cmu_*fMu()*sqr(k_)/epsilonTilda_;
nut_.correctBoundaryConditions();
nut_ == Cmu_*fMu()*sqr(k_)/epsilonTilda_;
}

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