research/OpenFOAM-4.x-lab
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: research:ReactingDPM
Branches Tags
research:trunk
research:ReactingDPM
research:absoluteThermos
research:coal-MPPIC
research:postSootFoam
research:NOxSOx
research:slfm
research:master
research:kwonwoo-org
research:version-4.1
research:version-4.0
..
compare: research:trunk
Branches Tags
research:ReactingDPM
research:absoluteThermos
research:trunk
research:coal-MPPIC
research:postSootFoam
research:NOxSOx
research:slfm
research:master
research:kwonwoo-org
research:version-4.1
research:version-4.0

No commits in common. "ReactingDPM" and "trunk" have entirely different histories.
ReactingDP ... trunk

14 changed files with 2 additions and 632 deletions
Show stats Expand all files Collapse all files

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

@ -56,12 +56,6 @@ $(THERMOMPPICPARCEL)/defineBasicThermoKinematicMPPICParcel.C
$(THERMOMPPICPARCEL)/makeBasicThermoKinematicMPPICParcelSubmodels.C
/* reacting multiphase & Colliding parcel sub-models */
REACTINGMPCOLLIDINGPARCEL=$(DERIVEDPARCELS)/basicReactingMultiphaseCollidingParcel
$(REACTINGMPCOLLIDINGPARCEL)/defineBasicReactingMultiphaseCollidingParcel.C
$(REACTINGMPCOLLIDINGPARCEL)/makeBasicReactingMultiphaseCollidingParcelSubmodels.C
/* bolt-on models */
RADIATION=submodels/addOns/radiation
$(RADIATION)/absorptionEmission/cloudAbsorptionEmission/cloudAbsorptionEmission.C

2
src/lagrangian/intermediate/Make/options
View file

@ -1,4 +1,4 @@
EXE_INC = -g \
EXE_INC = \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
-I$(LIB_SRC)/transportModels/compressible/lnInclude \

2
src/lagrangian/intermediate/clouds/Templates/CollidingCloud/CollidingCloud.C
View file

@ -108,7 +108,7 @@ Foam::CollidingCloud<CloudType>::CollidingCloud
if (readFields)
{
parcelType::readFields(*this, this->composition());
parcelType::readFields(*this);
}
}
}

58
src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C
View file

@ -143,64 +143,6 @@ Foam::ReactingCloud<CloudType>::ReactingCloud
}
}
template<class CloudType>
Foam::ReactingCloud<CloudType>::ReactingCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g,
bool readFields
)
:
CloudType(cloudName, rho, U, mu, g, false),
reactingCloud(),
cloudCopyPtr_(NULL),
constProps_(this->particleProperties()),
compositionModel_(NULL),
phaseChangeModel_(NULL),
rhoTrans_(this->thermo().carrier().species().size())
{
if (this->solution().active())
{
setModels();
if (readFields)
{
parcelType::readFields(*this, this->composition());
}
}
// Set storage for mass source fields and initialise to zero
forAll(rhoTrans_, i)
{
const word& specieName = this->thermo().carrier().species()[i];
rhoTrans_.set
(
i,
new DimensionedField<scalar, volMesh>
(
IOobject
(
this->name() + ":rhoTrans_" + specieName,
this->db().time().timeName(),
this->db(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
this->mesh(),
dimensionedScalar("zero", dimMass, 0.0)
)
);
}
if (this->solution().resetSourcesOnStartup())
{
resetSourceTerms();
}
}
template<class CloudType>
Foam::ReactingCloud<CloudType>::ReactingCloud

10
src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.H
View file

@ -161,16 +161,6 @@ public:
bool readFields = true
);
ReactingCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g,
bool readFields = true
);
//- Copy constructor with new name
ReactingCloud(ReactingCloud<CloudType>& c, const word& name);

36
src/lagrangian/intermediate/clouds/Templates/ReactingMultiphaseCloud/ReactingMultiphaseCloud.C
View file

@ -107,42 +107,6 @@ Foam::ReactingMultiphaseCloud<CloudType>::ReactingMultiphaseCloud
}
}
template<class CloudType>
Foam::ReactingMultiphaseCloud<CloudType>::ReactingMultiphaseCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g,
bool readFields
)
:
CloudType(cloudName, rho, U, mu, g, false),
reactingMultiphaseCloud(),
cloudCopyPtr_(NULL),
constProps_(this->particleProperties()),
devolatilisationModel_(NULL),
surfaceReactionModel_(NULL),
dMassDevolatilisation_(0.0),
dMassSurfaceReaction_(0.0)
{
if (this->solution().active())
{
setModels();
if (readFields)
{
parcelType::readFields(*this, this->composition());
}
}
if (this->solution().resetSourcesOnStartup())
{
resetSourceTerms();
}
}
template<class CloudType>
Foam::ReactingMultiphaseCloud<CloudType>::ReactingMultiphaseCloud

11
src/lagrangian/intermediate/clouds/Templates/ReactingMultiphaseCloud/ReactingMultiphaseCloud.H
View file

@ -161,17 +161,6 @@ public:
bool readFields = true
);
ReactingMultiphaseCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g,
bool readFields = true
);
//- Copy constructor with new name
ReactingMultiphaseCloud

74
src/lagrangian/intermediate/clouds/derived/basicReactingMultiphaseCollidingColud/basicReactingMultiphaseCollidingCloud.H
View file

@ -1,74 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::basicReactingMultiphaseCollidingCloud
Description
Cloud class to introduce multi-phase reacting parcels
\*---------------------------------------------------------------------------*/
#ifndef basicReactingMultiphaseCollidingCloud_H
#define basicReactingMultiphaseCollidingCloud_H
#include "Cloud.H"
#include "KinematicCloud.H"
#include "ThermoCloud.H"
#include "ReactingCloud.H"
#include "ReactingMultiphaseCloud.H"
#include "basicReactingMultiphaseCollidingParcel.H"
#include "CollidingCloud.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef CollidingCloud
<
ReactingMultiphaseCloud
<
ReactingCloud
<
ThermoCloud
<
KinematicCloud
<
Cloud
<
basicReactingMultiphaseCollidingParcel
>
>
>
>
>
>
basicReactingMultiphaseCollidingCloud;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

BIN
src/lagrangian/intermediate/parcels/Templates/CollidingParcel/.swp
View file

Binary file not shown.

19
src/lagrangian/intermediate/parcels/Templates/CollidingParcel/CollidingParcel.H
View file

@ -292,33 +292,14 @@ public:
// I-O
//- Read
template<class CloudType, class CompositionType>
static void readFields
(
CloudType& c,
const CompositionType& compModel
);
//- Read - no composition
template<class CloudType>
static void readFields(CloudType& c);
//- Write
template<class CloudType, class CompositionType>
static void writeFields
(
const CloudType& c,
const CompositionType& compModel
);
//- Read - composition supplied
template<class CloudType>
static void writeFields(const CloudType& c);
// Ostream Operator
friend Ostream& operator<< <ParcelType>

205
src/lagrangian/intermediate/parcels/Templates/CollidingParcel/CollidingParcelIO.C
View file

@ -180,109 +180,6 @@ void Foam::CollidingParcel<ParcelType>::readFields(CloudType& c)
}
}
template<class ParcelType>
template<class CloudType, class CompositionType>
void Foam::CollidingParcel<ParcelType>::readFields
(
CloudType& c,
const CompositionType& compModel
)
{
if (!c.size())
{
return;
}
ParcelType::readFields(c,compModel);
IOField<vector> f(c.fieldIOobject("f", IOobject::MUST_READ));
c.checkFieldIOobject(c, f);
IOField<vector> angularMomentum
(
c.fieldIOobject("angularMomentum", IOobject::MUST_READ)
);
c.checkFieldIOobject(c, angularMomentum);
IOField<vector> torque(c.fieldIOobject("torque", IOobject::MUST_READ));
c.checkFieldIOobject(c, torque);
labelFieldCompactIOField collisionRecordsPairAccessed
(
c.fieldIOobject("collisionRecordsPairAccessed", IOobject::MUST_READ)
);
c.checkFieldFieldIOobject(c, collisionRecordsPairAccessed);
labelFieldCompactIOField collisionRecordsPairOrigProcOfOther
(
c.fieldIOobject
(
"collisionRecordsPairOrigProcOfOther",
IOobject::MUST_READ
)
);
c.checkFieldFieldIOobject(c, collisionRecordsPairOrigProcOfOther);
labelFieldCompactIOField collisionRecordsPairOrigIdOfOther
(
c.fieldIOobject
(
"collisionRecordsPairOrigIdOfOther",
IOobject::MUST_READ
)
);
c.checkFieldFieldIOobject(c, collisionRecordsPairOrigProcOfOther);
pairDataFieldCompactIOField collisionRecordsPairData
(
c.fieldIOobject("collisionRecordsPairData", IOobject::MUST_READ)
);
c.checkFieldFieldIOobject(c, collisionRecordsPairData);
labelFieldCompactIOField collisionRecordsWallAccessed
(
c.fieldIOobject("collisionRecordsWallAccessed", IOobject::MUST_READ)
);
c.checkFieldFieldIOobject(c, collisionRecordsWallAccessed);
vectorFieldCompactIOField collisionRecordsWallPRel
(
c.fieldIOobject("collisionRecordsWallPRel", IOobject::MUST_READ)
);
c.checkFieldFieldIOobject(c, collisionRecordsWallPRel);
wallDataFieldCompactIOField collisionRecordsWallData
(
c.fieldIOobject("collisionRecordsWallData", IOobject::MUST_READ)
);
c.checkFieldFieldIOobject(c, collisionRecordsWallData);
label i = 0;
forAllIter(typename CloudType, c, iter)
{
CollidingParcel<ParcelType>& p = iter();
p.f_ = f[i];
p.angularMomentum_ = angularMomentum[i];
p.torque_ = torque[i];
p.collisionRecords_ = collisionRecordList
(
collisionRecordsPairAccessed[i],
collisionRecordsPairOrigProcOfOther[i],
collisionRecordsPairOrigIdOfOther[i],
collisionRecordsPairData[i],
collisionRecordsWallAccessed[i],
collisionRecordsWallPRel[i],
collisionRecordsWallData[i]
);
i++;
}
}
template<class ParcelType>
template<class CloudType>
@ -377,108 +274,6 @@ void Foam::CollidingParcel<ParcelType>::writeFields(const CloudType& c)
}
template<class ParcelType>
template<class CloudType, class CompositionType>
void Foam::CollidingParcel<ParcelType>::writeFields
(
const CloudType& c,
const CompositionType& compModel
)
{
ParcelType::writeFields(c, compModel);
label np = c.size();
IOField<vector> f(c.fieldIOobject("f", IOobject::NO_READ), np);
IOField<vector> angularMomentum
(
c.fieldIOobject("angularMomentum", IOobject::NO_READ),
np
);
IOField<vector> torque(c.fieldIOobject("torque", IOobject::NO_READ), np);
labelFieldCompactIOField collisionRecordsPairAccessed
(
c.fieldIOobject("collisionRecordsPairAccessed", IOobject::NO_READ),
np
);
labelFieldCompactIOField collisionRecordsPairOrigProcOfOther
(
c.fieldIOobject
(
"collisionRecordsPairOrigProcOfOther",
IOobject::NO_READ
),
np
);
labelFieldCompactIOField collisionRecordsPairOrigIdOfOther
(
c.fieldIOobject("collisionRecordsPairOrigIdOfOther", IOobject::NO_READ),
np
);
pairDataFieldCompactIOField collisionRecordsPairData
(
c.fieldIOobject("collisionRecordsPairData", IOobject::NO_READ),
np
);
labelFieldCompactIOField collisionRecordsWallAccessed
(
c.fieldIOobject("collisionRecordsWallAccessed", IOobject::NO_READ),
np
);
vectorFieldCompactIOField collisionRecordsWallPRel
(
c.fieldIOobject("collisionRecordsWallPRel", IOobject::NO_READ),
np
);
wallDataFieldCompactIOField collisionRecordsWallData
(
c.fieldIOobject("collisionRecordsWallData", IOobject::NO_READ),
np
);
label i = 0;
forAllConstIter(typename CloudType, c, iter)
{
const CollidingParcel<ParcelType>& p = iter();
f[i] = p.f();
angularMomentum[i] = p.angularMomentum();
torque[i] = p.torque();
collisionRecordsPairAccessed[i] = p.collisionRecords().pairAccessed();
collisionRecordsPairOrigProcOfOther[i] =
p.collisionRecords().pairOrigProcOfOther();
collisionRecordsPairOrigIdOfOther[i] =
p.collisionRecords().pairOrigIdOfOther();
collisionRecordsPairData[i] = p.collisionRecords().pairData();
collisionRecordsWallAccessed[i] = p.collisionRecords().wallAccessed();
collisionRecordsWallPRel[i] = p.collisionRecords().wallPRel();
collisionRecordsWallData[i] = p.collisionRecords().wallData();
i++;
}
f.write();
angularMomentum.write();
torque.write();
collisionRecordsPairAccessed.write();
collisionRecordsPairOrigProcOfOther.write();
collisionRecordsPairOrigIdOfOther.write();
collisionRecordsPairData.write();
collisionRecordsWallAccessed.write();
collisionRecordsWallPRel.write();
collisionRecordsWallData.write();
}
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
template<class ParcelType>

82
src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseCollidingParcel/basicReactingMultiphaseCollidingParcel.H
View file

@ -1,82 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::basicReactingMultiphaseCollidingParcel
Description
Definition of basic reacting parcel
SourceFiles
basicReactingMultiphaseCollidingParcel.C
basicReactingMultiphaseCollidingParcelIO.C
\*---------------------------------------------------------------------------*/
#ifndef basicReactingMultiphaseCollidingParcel_H
#define basicReactingMultiphaseCollidingParcel_H
#include "contiguous.H"
#include "particle.H"
#include "KinematicParcel.H"
#include "ThermoParcel.H"
#include "ReactingParcel.H"
#include "ReactingMultiphaseParcel.H"
#include "CollidingParcel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef CollidingParcel
<
ReactingMultiphaseParcel
<
ReactingParcel
<
ThermoParcel
<
KinematicParcel
<
particle
>
>
>
>
>
basicReactingMultiphaseCollidingParcel;
template<>
inline bool contiguous<basicReactingMultiphaseCollidingParcel>()
{
return true;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

38
src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseCollidingParcel/defineBasicReactingMultiphaseCollidingParcel.C
View file

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

91
src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseCollidingParcel/makeBasicReactingMultiphaseCollidingParcelSubmodels.C
View file

@ -1,91 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseCollidingCloud.H"
#include "makeParcelCloudFunctionObjects.H"
// Kinematic
#include "makeThermoParcelForces.H" // thermo variant
#include "makeParcelDispersionModels.H"
#include "makeReactingMultiphaseParcelInjectionModels.H" // MP variant
#include "makeParcelPatchInteractionModels.H"
#include "makeReactingMultiphaseParcelStochasticCollisionModels.H" // MP variant
#include "makeReactingParcelSurfaceFilmModels.H" // Reacting variant
// Colliding
#include "makeParcelCollisionModels.H"
// Thermodynamic
#include "makeParcelHeatTransferModels.H"
// Reacting
#include "makeReactingMultiphaseParcelCompositionModels.H" // MP Variant
#include "makeReactingParcelPhaseChangeModels.H"
// Reacting multiphase
#include "makeReactingMultiphaseParcelDevolatilisationModels.H"
#include "makeReactingMultiphaseParcelSurfaceReactionModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeParcelCloudFunctionObjects(basicReactingMultiphaseCollidingCloud);
// Kinematic sub-models
makeThermoParcelForces(basicReactingMultiphaseCollidingCloud);
makeParcelDispersionModels(basicReactingMultiphaseCollidingCloud);
makeReactingMultiphaseParcelInjectionModels(basicReactingMultiphaseCollidingCloud);
makeParcelPatchInteractionModels(basicReactingMultiphaseCollidingCloud);
makeReactingMultiphaseParcelStochasticCollisionModels
(
basicReactingMultiphaseCollidingCloud
);
makeReactingParcelSurfaceFilmModels(basicReactingMultiphaseCollidingCloud);
// Colliding sub-models
makeParcelCollisionModels(basicReactingMultiphaseCollidingCloud);
// Thermo sub-models
makeParcelHeatTransferModels(basicReactingMultiphaseCollidingCloud);
// Reacting sub-models
makeReactingMultiphaseParcelCompositionModels
(
basicReactingMultiphaseCollidingCloud
);
makeReactingParcelPhaseChangeModels(basicReactingMultiphaseCollidingCloud);
// Reacting multiphase sub-models
makeReactingMultiphaseParcelDevolatilisationModels
(
basicReactingMultiphaseCollidingCloud
);
makeReactingMultiphaseParcelSurfaceReactionModels
(
basicReactingMultiphaseCollidingCloud
);
// ************************************************************************* //