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

templated thermo type

Browse Source
This commit is contained in:
andy
2009-06-01 19:21:21 +01:00
parent b19be17873
commit d07403b308
60 changed files with 798 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -29,7 +29,7 @@ forAll(gasProperties, i)
}
Info<< "\nConstructing reacting cloud" << endl;
basicReactingCloud parcels
BasicReactingCloud<specieReactingProperties> parcels
(
"reactingCloud1",
rho,

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

@ -34,7 +34,7 @@ Description
#include "fvCFD.H"
#include "hCombustionThermo.H"
#include "turbulenceModel.H"
#include "basicReactingCloud.H"
#include "BasicReactingCloud.H"
#include "chemistryModel.H"
#include "chemistrySolver.H"
#include "ReactingCloudThermoTypes.H"

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

@ -1,13 +1,15 @@
PARCELS=parcels
DERIVEDPARCELS=$(PARCELS)/derived
BASEPARCELS=$(PARCELS)/baseClasses
/* Parcels */
$(DERIVEDPARCELS)/basicKinematicParcel/basicKinematicParcel.C
$(DERIVEDPARCELS)/basicThermoParcel/basicThermoParcel.C
$(DERIVEDPARCELS)/basicReactingParcel/basicReactingParcel.C
$(DERIVEDPARCELS)/basicReactingMultiphaseParcel/basicReactingMultiphaseParcel.C
$(DERIVEDPARCELS)/trackedReactingParcel/trackedReactingParcel.C
/* $(DERIVEDPARCELS)/basicReactingParcel/basicReactingParcel.C */
/* $(DERIVEDPARCELS)/basicReactingMultiphaseParcel/basicReactingMultiphaseParcel.C */
/* $(DERIVEDPARCELS)/trackedReactingParcel/trackedReactingParcel.C */
$(BASEPARCELS)/reactingParcel/reactingParcel.C
/* Cloud base classes */
clouds/baseClasses/kinematicCloud/kinematicCloud.C
@ -19,9 +21,9 @@ clouds/baseClasses/reactingMultiphaseCloud/reactingMultiphaseCloud.C
/* Cloud container/injection mechanisms */
clouds/derived/basicKinematicCloud/basicKinematicCloud.C
clouds/derived/basicThermoCloud/basicThermoCloud.C
clouds/derived/basicReactingCloud/basicReactingCloud.C
clouds/derived/basicReactingMultiphaseCloud/basicReactingMultiphaseCloud.C
clouds/derived/trackedReactingCloud/trackedReactingCloud.C
/* clouds/derived/basicReactingCloud/basicReactingCloud.C */
/* clouds/derived/basicReactingMultiphaseCloud/basicReactingMultiphaseCloud.C */
/* clouds/derived/trackedReactingCloud/trackedReactingCloud.C */
/* kinematic parcel sub-models */
@ -46,7 +48,7 @@ $(THERMOPARCEL)/submodels/makeBasicThermoParcelPostProcessingModels.C
/* reacting parcel sub-models */
REACTINGPARCEL=$(DERIVEDPARCELS)/basicReactingParcel
REACTINGPARCEL=$(DERIVEDPARCELS)/BasicReactingParcel
$(REACTINGPARCEL)/defineBasicReactingParcel.C
$(REACTINGPARCEL)/submodels/makeBasicReactingParcelCompositionModels.C
$(REACTINGPARCEL)/submodels/makeBasicReactingParcelDispersionModels.C
@ -59,7 +61,7 @@ $(REACTINGPARCEL)/submodels/makeBasicReactingParcelPostProcessingModels.C
/* reacting multiphase parcel sub-models */
REACTINGMPPARCEL=$(DERIVEDPARCELS)/basicReactingMultiphaseParcel
REACTINGMPPARCEL=$(DERIVEDPARCELS)/BasicReactingMultiphaseParcel
$(REACTINGMPPARCEL)/defineBasicReactingMultiphaseParcel.C
$(REACTINGMPPARCEL)/submodels/makeBasicReactingMultiphaseParcelCompositionModels.C
$(REACTINGMPPARCEL)/submodels/makeBasicReactingMultiphaseParcelDevolatilisationModels.C
@ -74,7 +76,7 @@ $(REACTINGMPPARCEL)/submodels/makeBasicReactingMultiphaseParcelSurfaceReactionMo
/* tracked reacting parcel sub-models */
TRACKEDREACTINGPARCEL=$(DERIVEDPARCELS)/trackedReactingParcel
TRACKEDREACTINGPARCEL=$(DERIVEDPARCELS)/BasicTrackedReactingParcel
$(TRACKEDREACTINGPARCEL)/defineTrackedReactingParcel.C
$(TRACKEDREACTINGPARCEL)/submodels/makeTrackedReactingParcelCompositionModels.C
$(TRACKEDREACTINGPARCEL)/submodels/makeTrackedReactingParcelDispersionModels.C

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

@ -68,7 +68,7 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& carrierSpecies
PtrList<thermoType>& carrierSpecies
)
:
ThermoCloud<ParcelType>(cloudName, rho, U, g, thermo),

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

@ -72,6 +72,14 @@ class ReactingCloud
public ThermoCloud<ParcelType>,
public reactingCloud
{
public:
//- Type of thermodynamics the cloud was instantiated for
typedef typename ParcelType::thermoType thermoType;
private:
// Private Member Functions
//- Disallow default bitwise copy construct
@ -92,7 +100,7 @@ protected:
hCombustionThermo& carrierThermo_;
//- Gas phase properties
PtrList<specieReactingProperties>& carrierSpecies_;
PtrList<thermoType>& carrierSpecies_;
// References to the cloud sub-models
@ -143,7 +151,7 @@ public:
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& carrierSpecies
PtrList<thermoType>& carrierSpecies
);
@ -170,7 +178,7 @@ public:
inline hCombustionThermo& carrierThermo();
//- Gas phase properties
inline const PtrList<specieReactingProperties>& carrierSpecies() const;
inline const PtrList<thermoType>& carrierSpecies() const;
// Sub-models

2
src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloudI.H
View File

@ -51,7 +51,7 @@ Foam::ReactingCloud<ParcelType>::carrierThermo()
template<class ParcelType>
inline const Foam::PtrList<Foam::specieReactingProperties>&
inline const Foam::PtrList<typename ParcelType::thermoType>&
Foam::ReactingCloud<ParcelType>::carrierSpecies() const
{
return carrierSpecies_;

10
src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloudThermoTypes.H
View File

@ -23,7 +23,7 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Typedefs
Foam::cloudThermoTypes
Foam::ReactingCloudThermoTypes
Description
@ -33,8 +33,6 @@ Description
#define ReactingCloudThermoTypes_H
#include "sutherlandTransport.H"
#include "multiComponentMixture.H"
#include "specie.H"
#include "constTransport.H"
#include "specieThermo.H"
#include "hConstThermo.H"
@ -45,12 +43,6 @@ Description
namespace Foam
{
// typedef multiComponentMixture<constTransport<specieThermo<hConstThermo<perfectGas> > > > specieProperties;
// typedef hConstThermo<perfectGas> specieProperties;
// typedef sutherlandTransport<specieThermo<janafThermo<perfectGas> > >
// specieProperties;
typedef sutherlandTransport<specieThermo<janafThermo<perfectGas> > >
specieReactingProperties;

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

@ -39,7 +39,7 @@ Foam::ReactingMultiphaseCloud<ParcelType>::ReactingMultiphaseCloud
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& carrierSpecies
PtrList<typename ReactingCloud<ParcelType>::thermoType>& carrierSpecies
)
:
ReactingCloud<ParcelType>(cloudName, rho, U, g, thermo, carrierSpecies),

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

@ -124,7 +124,8 @@ public:
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& carrierSpecies
PtrList<typename ReactingCloud<ParcelType>::thermoType>&
carrierSpecies
);

2
src/lagrangian/intermediate/clouds/baseClasses/reactingCloud/reactingCloud.H
View File

@ -35,7 +35,7 @@ SourceFiles
#ifndef reactingCloud_H
#define reactingCloud_H
#include "volFields.H"
#include "typeInfo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

2
src/lagrangian/intermediate/clouds/baseClasses/reactingMultiphaseCloud/reactingMultiphaseCloud.H
View File

@ -35,7 +35,7 @@ SourceFiles
#ifndef reactingMultiphaseCloud_H
#define reactingMultiphaseCloud_H
#include "volFields.H"
#include "typeInfo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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

@ -24,29 +24,22 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingCloud.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(basicReactingCloud, 0);
};
#include "BasicReactingCloud.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::basicReactingCloud::basicReactingCloud
template<class ThermoType>
Foam::BasicReactingCloud<ThermoType>::BasicReactingCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& carrierSpecies
PtrList<ThermoType>& carrierSpecies
)
:
ReactingCloud<basicReactingParcel>
ReactingCloud<BasicReactingParcel<ThermoType> >
(
cloudName,
rho,
@ -56,21 +49,23 @@ Foam::basicReactingCloud::basicReactingCloud
carrierSpecies
)
{
basicReactingParcel::readFields(*this);
BasicReactingParcel<ThermoType>::readFields(*this);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::basicReactingCloud::~basicReactingCloud()
template<class ThermoType>
Foam::BasicReactingCloud<ThermoType>::~BasicReactingCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::basicReactingCloud::writeFields() const
template<class ThermoType>
void Foam::BasicReactingCloud<ThermoType>::writeFields() const
{
basicReactingParcel::writeFields(*this);
BasicReactingParcel<ThermoType>::writeFields(*this);
}

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

@ -23,66 +23,71 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::basicReactingCloud
Foam::BasicReactingCloud
Description
Reacting cloud templated on the reacting parcel
SourceFiles
basicReactingCloud.C
BasicReactingCloud.C
\*---------------------------------------------------------------------------*/
#ifndef basicReactingCloud_H
#define basicReactingCloud_H
#ifndef BasicReactingCloud_H
#define BasicReactingCloud_H
#include "ReactingCloud.H"
#include "basicReactingParcel.H"
#include "BasicReactingParcel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
template<class ThermoType>
class BasicReactingCloud;
/*---------------------------------------------------------------------------*\
Class basicReactingCloud Declaration
Class BasicReactingCloud Declaration
\*---------------------------------------------------------------------------*/
class basicReactingCloud
template<class ThermoType>
class BasicReactingCloud
:
public ReactingCloud<basicReactingParcel>
public ReactingCloud<BasicReactingParcel<ThermoType> >
{
// Private Member Functions
//- Disallow default bitwise copy construct
basicReactingCloud(const basicReactingCloud&);
BasicReactingCloud(const BasicReactingCloud&);
//- Disallow default bitwise assignment
void operator=(const basicReactingCloud&);
void operator=(const BasicReactingCloud&);
public:
//- Runtime type information
TypeName("basicReactingCloud");
TypeName("BasicReactingCloud");
// Constructors
//- Construct given carrier gas fields
basicReactingCloud
BasicReactingCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& carrierSpecies
PtrList<ThermoType>& carrierSpecies
);
//- Destructor
~basicReactingCloud();
~BasicReactingCloud();
// Member Functions
@ -98,6 +103,12 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "BasicReactingCloud.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

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

@ -24,29 +24,22 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseCloud.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(basicReactingMultiphaseCloud, 0);
};
#include "BasicReactingMultiphaseCloud.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::basicReactingMultiphaseCloud::basicReactingMultiphaseCloud
template<class ThermoType>
Foam::BasicReactingMultiphaseCloud<ThermoType>::BasicReactingMultiphaseCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& carrierSpecies
PtrList<ThermoType>& carrierSpecies
)
:
ReactingMultiphaseCloud<basicReactingMultiphaseParcel>
ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >
(
cloudName,
rho,
@ -56,21 +49,23 @@ Foam::basicReactingMultiphaseCloud::basicReactingMultiphaseCloud
carrierSpecies
)
{
basicReactingMultiphaseParcel::readFields(*this);
BasicReactingMultiphaseParcel<ThermoType>::readFields(*this);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::basicReactingMultiphaseCloud::~basicReactingMultiphaseCloud()
template<class ThermoType>
Foam::BasicReactingMultiphaseCloud<ThermoType>::~BasicReactingMultiphaseCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::basicReactingMultiphaseCloud::writeFields() const
template<class ThermoType>
void Foam::BasicReactingMultiphaseCloud<ThermoType>::writeFields() const
{
basicReactingMultiphaseParcel::writeFields(*this);
BasicReactingMultiphaseParcel<ThermoType>::writeFields(*this);
}

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

@ -23,66 +23,71 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::basicReactingMultiphaseCloud
Foam::BasicReactingMultiphaseCloud
Description
Reacting multiphase cloud templated on the reacting multiphase parcel
SourceFiles
basicReactingMultiphaseCloud.C
BasicReactingMultiphaseCloud.C
\*---------------------------------------------------------------------------*/
#ifndef basicReactingMultiphaseCloud_H
#define basicReactingMultiphaseCloud_H
#ifndef BasicReactingMultiphaseCloud_H
#define BasicReactingMultiphaseCloud_H
#include "ReactingMultiphaseCloud.H"
#include "basicReactingMultiphaseParcel.H"
#include "BasicReactingMultiphaseParcel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
template<class ThermoType>
class BasicReactingMultiphaseCloud;
/*---------------------------------------------------------------------------*\
Class basicReactingMultiphaseCloud Declaration
Class BasicReactingMultiphaseCloud Declaration
\*---------------------------------------------------------------------------*/
class basicReactingMultiphaseCloud
template<class ThermoType>
class BasicReactingMultiphaseCloud
:
public ReactingMultiphaseCloud<basicReactingMultiphaseParcel>
public ReactingMultiphaseCloud<BasicReactingMultiphaseParcel>
{
// Private Member Functions
//- Disallow default bitwise copy construct
basicReactingMultiphaseCloud(const basicReactingMultiphaseCloud&);
BasicReactingMultiphaseCloud(const BasicReactingMultiphaseCloud&);
//- Disallow default bitwise assignment
void operator=(const basicReactingMultiphaseCloud&);
void operator=(const BasicReactingMultiphaseCloud&);
public:
//- Runtime type information
TypeName("basicReactingMultiphaseCloud");
TypeName("BasicReactingMultiphaseCloud");
// Constructors
//- Construct given carrier gas fields
basicReactingMultiphaseCloud
BasicReactingMultiphaseCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& carrierSpecies
PtrList<ThermoType>& carrierSpecies
);
//- Destructor
~basicReactingMultiphaseCloud();
~BasicReactingMultiphaseCloud();
// Member Functions
@ -98,6 +103,12 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "BasicReactingMultiphaseCloud.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

25
src/lagrangian/intermediate/clouds/derived/BasicTrackedReactingCloud/BasicTrackedReactingCloud.C
View File

@ -26,27 +26,20 @@ License
#include "trackedReactingCloud.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(trackedReactingCloud, 0);
};
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::trackedReactingCloud::trackedReactingCloud
template<class ThermoType>
Foam::trackedReactingCloud<ThermoType>::trackedReactingCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& gases
PtrList<ThermoType>& gases
)
:
ReactingCloud<trackedReactingParcel>
ReactingCloud<BasicTrackedReactingParcel<ThermoType> >
(
cloudName,
rho,
@ -56,21 +49,23 @@ Foam::trackedReactingCloud::trackedReactingCloud
gases
)
{
trackedReactingParcel::readFields(*this);
BasicTrackedReactingParcel<ThermoType>::readFields(*this);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::trackedReactingCloud::~trackedReactingCloud()
template<class ThermoType>
Foam::trackedReactingCloud<ThermoType>::~trackedReactingCloud()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::trackedReactingCloud::writeFields() const
template<class ThermoType>
void Foam::trackedReactingCloud<ThermoType>::writeFields() const
{
trackedReactingParcel::writeFields(*this);
BasicTrackedReactingParcel<ThermoType>::writeFields(*this);
}

17
src/lagrangian/intermediate/clouds/derived/BasicTrackedReactingCloud/BasicTrackedReactingCloud.H
View File

@ -37,20 +37,25 @@ SourceFiles
#define trackedReactingCloud_H
#include "ReactingCloud.H"
#include "trackedReactingParcel.H"
#include "BasicTrackedReactingParcel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
template<class ThermoType>
class trackedReactingCloud;
/*---------------------------------------------------------------------------*\
Class trackedReactingCloud Declaration
\*---------------------------------------------------------------------------*/
template<class ThermoType>
class trackedReactingCloud
:
public ReactingCloud<trackedReactingParcel>
public ReactingCloud<BasicTrackedReactingParcel<ThermoType> >
{
// Private Member Functions
@ -77,7 +82,7 @@ public:
const volVectorField& U,
const dimensionedVector& g,
hCombustionThermo& thermo,
PtrList<specieReactingProperties>& gases
PtrList<ThermoType>& gases
);
@ -98,6 +103,12 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "trackedReactingCloud.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

49
src/lagrangian/intermediate/parcels/baseClasses/reactingParcel/reactingParcel.C Normal file
View File

@ -0,0 +1,49 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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 "reactingParcel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(reactingParcel, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::reactingParcel::reactingParcel()
{}
// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * //
Foam::reactingParcel::~reactingParcel()
{}
// ************************************************************************* //

81
src/lagrangian/intermediate/parcels/baseClasses/reactingParcel/reactingParcel.H Normal file
View File

@ -0,0 +1,81 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Class
Foam::basicReactingParcel
Description
Base class for reacting parcel - simply used to set the contiguous flag
SourceFiles
reactingParcel.C
\*---------------------------------------------------------------------------*/
#ifndef reactingParcel_H
#define reactingParcel_H
#include "typeInfo.H"
#include "contiguous.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class reactingParcel Declaration
\*---------------------------------------------------------------------------*/
class reactingParcel
{
public:
//- Run-time type information
TypeName("reactingParcel");
//- Construct null
reactingParcel();
//- Destructor
virtual ~reactingParcel();
};
template<>
inline bool contiguous<reactingParcel>()
{
return false; // Derived classes include scalar lists/fields
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

48
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/BasicReactingMultiphaseParcel.C
View File

@ -24,28 +24,19 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(basicReactingMultiphaseParcel, 0);
defineParticleTypeNameAndDebug(basicReactingMultiphaseParcel, 0);
defineParcelTypeNameAndDebug(basicReactingMultiphaseParcel, 0);
};
#include "BasicReactingMultiphaseParcel.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
template<class ThermoType>
Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
(
ReactingMultiphaseCloud<basicReactingMultiphaseParcel>& owner,
ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >& owner,
const vector& position,
const label cellI
)
:
ReactingMultiphaseParcel<basicReactingMultiphaseParcel>
ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >
(
owner,
position,
@ -54,9 +45,10 @@ Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
{}
Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
template<class ThermoType>
Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
(
ReactingMultiphaseCloud<basicReactingMultiphaseParcel>& owner,
ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >& owner,
const vector& position,
const label cellI,
const label typeId,
@ -67,10 +59,12 @@ Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
const scalarField& YLiquid0,
const scalarField& YSolid0,
const scalarField& Y0,
const constantProperties& constProps
const typename
ReactingMultiphaseParcel<BasicReactingMultiphaseParcel>::
constantProperties& constProps
)
:
ReactingMultiphaseParcel<basicReactingMultiphaseParcel>
ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >
(
owner,
position,
@ -88,14 +82,15 @@ Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
{}
Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
template<class ThermoType>
Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
(
const Cloud<basicReactingMultiphaseParcel>& cloud,
const Cloud<BasicReactingMultiphaseParcel<ThermoType> >& cloud,
Istream& is,
bool readFields
)
:
ReactingMultiphaseParcel<basicReactingMultiphaseParcel>
ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >
(
cloud,
is,
@ -104,18 +99,21 @@ Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
{}
Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
template<class ThermoType>
Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
(
const basicReactingMultiphaseParcel& p
const BasicReactingMultiphaseParcel<ThermoType>& p
)
:
ReactingMultiphaseParcel<basicReactingMultiphaseParcel>(p)
ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >(p)
{}
// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * //
Foam::basicReactingMultiphaseParcel::~basicReactingMultiphaseParcel()
template<class ThermoType>
Foam::BasicReactingMultiphaseParcel<ThermoType>::
~BasicReactingMultiphaseParcel()
{}

68
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/BasicReactingMultiphaseParcel.H
View File

@ -23,56 +23,67 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::basicReactingMultiphaseParcel
Foam::BasicReactingMultiphaseParcel
Description
SourceFiles
basicReactingMultiphaseParcel.C
basicReactingMultiphaseParcelIO.C
BasicReactingMultiphaseParcel.C
BasicReactingMultiphaseParcelIO.C
\*---------------------------------------------------------------------------*/
#ifndef basicReactingMultiphaseParcel_H
#define basicReactingMultiphaseParcel_H
#ifndef BasicReactingMultiphaseParcel_H
#define BasicReactingMultiphaseParcel_H
#include "ReactingMultiphaseParcel.H"
#include "reactingParcel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
template<class ThermoType>
class BasicReactingMultiphaseParcel;
/*---------------------------------------------------------------------------*\
Class basicReactingMultiphaseParcel Declaration
Class BasicReactingMultiphaseParcel Declaration
\*---------------------------------------------------------------------------*/
class basicReactingMultiphaseParcel
template<class ThermoType>
class BasicReactingMultiphaseParcel
:
public ReactingMultiphaseParcel<basicReactingMultiphaseParcel>
public reactingParcel,
public ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >
{
public:
//- The type of thermodynamics this parcel was instantiated for
typedef ThermoType thermoType;
//- Run-time type information
TypeName("basicReactingMultiphaseParcel");
TypeName("BasicReactingMultiphaseParcel");
// Constructors
//- Construct from owner, position, and cloud owner
// Other properties initialised as null
basicReactingMultiphaseParcel
BasicReactingMultiphaseParcel
(
ReactingMultiphaseCloud<basicReactingMultiphaseParcel>& owner,
ReactingMultiphaseCloud<BasicReactingMultiphaseParcel>& owner,
const vector& position,
const label cellI
);
//- Construct from components
basicReactingMultiphaseParcel
BasicReactingMultiphaseParcel
(
ReactingMultiphaseCloud<basicReactingMultiphaseParcel>& owner,
ReactingMultiphaseCloud<BasicReactingMultiphaseParcel>& owner,
const vector& position,
const label cellI,
const label typeId,
@ -83,49 +94,50 @@ public:
const scalarField& YLiquid0,
const scalarField& YSolid0,
const scalarField& Y0,
const constantProperties& constProps
const typename
ReactingMultiphaseParcel<BasicReactingMultiphaseParcel>::
constantProperties& constProps
);
//- Construct from Istream
basicReactingMultiphaseParcel
BasicReactingMultiphaseParcel
(
const Cloud<basicReactingMultiphaseParcel>& c,
const Cloud<BasicReactingMultiphaseParcel>& c,
Istream& is,
bool readFields = true
);
//- Construct as a copy
basicReactingMultiphaseParcel(const basicReactingMultiphaseParcel& p);
BasicReactingMultiphaseParcel(const BasicReactingMultiphaseParcel& p);
//- Construct and return a clone
autoPtr<basicReactingMultiphaseParcel> clone() const
autoPtr<BasicReactingMultiphaseParcel> clone() const
{
return
autoPtr<basicReactingMultiphaseParcel>
autoPtr<BasicReactingMultiphaseParcel>
(
new basicReactingMultiphaseParcel(*this)
new BasicReactingMultiphaseParcel(*this)
);
}
//- Destructor
virtual ~basicReactingMultiphaseParcel();
virtual ~BasicReactingMultiphaseParcel();
};
template<>
inline bool contiguous<basicReactingMultiphaseParcel>()
{
return false; // Now have scalar lists/fields (mass fractions)
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "BasicReactingMultiphaseParcel.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

45
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/basicReactingMultiphaseParcelTypes.H Normal file
View File

@ -0,0 +1,45 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
\*---------------------------------------------------------------------------*/
#ifndef basicReactingMultiphaseParcelTypes_H
#define basicReactingMultiphaseParcelTypes_H
#include "BasicReactingMultiphaseParcel.H"
#include "ReactingCloudThermoTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef BasicReactingMultiphaseParcel<specieReactingProperties>
bReactingMultiphaseParcel;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

48
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/defineBasicReactingMultiphaseParcel.C
View File

@ -24,72 +24,76 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "ReactingMultiphaseCloud.H"
namespace Foam
{
defineTemplateTypeNameAndDebug(Cloud<basicReactingMultiphaseParcel>, 0);
defineTemplateTypeNameAndDebug(bReactingMultiphaseParcel, 0);
defineTemplateTypeNameAndDebug(Particle<bReactingMultiphaseParcel>, 0);
defineTemplateTypeNameAndDebug(Cloud<bReactingMultiphaseParcel>, 0);
defineParcelTypeNameAndDebug
(
KinematicParcel<basicReactingMultiphaseParcel>,
0
);
// defineTemplateTypeNameAndDebug
// (
// KinematicParcel<basicReactingMultiphaseParcel>,
// 0
// );
defineParcelTypeNameAndDebug
(
ThermoParcel<basicReactingMultiphaseParcel>,
KinematicParcel<bReactingMultiphaseParcel>,
0
);
defineTemplateTypeNameAndDebug
(
ThermoParcel<basicReactingMultiphaseParcel>,
KinematicParcel<bReactingMultiphaseParcel>,
0
);
defineParcelTypeNameAndDebug
(
ReactingParcel<basicReactingMultiphaseParcel>,
ThermoParcel<bReactingMultiphaseParcel>,
0
);
defineTemplateTypeNameAndDebug
(
ReactingParcel<basicReactingMultiphaseParcel>,
ThermoParcel<bReactingMultiphaseParcel>,
0
);
defineParcelTypeNameAndDebug
(
ReactingMultiphaseParcel<basicReactingMultiphaseParcel>,
ReactingParcel<bReactingMultiphaseParcel>,
0
);
defineTemplateTypeNameAndDebug
(
ReactingMultiphaseParcel<basicReactingMultiphaseParcel>,
ReactingParcel<bReactingMultiphaseParcel>,
0
);
defineParcelTypeNameAndDebug
(
ReactingMultiphaseParcel<bReactingMultiphaseParcel>,
0
);
defineTemplateTypeNameAndDebug
(
ReactingMultiphaseParcel<bReactingMultiphaseParcel>,
0
);
defineParcelTypeNameAndDebug
(
KinematicCloud<basicReactingMultiphaseParcel>,
KinematicCloud<bReactingMultiphaseParcel>,
0
);
defineParcelTypeNameAndDebug
(
ThermoCloud<basicReactingMultiphaseParcel>,
ThermoCloud<bReactingMultiphaseParcel>,
0
);
defineParcelTypeNameAndDebug
(
ReactingCloud<basicReactingMultiphaseParcel>,
ReactingCloud<bReactingMultiphaseParcel>,
0
);
defineParcelTypeNameAndDebug
(
ReactingMultiphaseCloud<basicReactingMultiphaseParcel>,
ReactingMultiphaseCloud<bReactingMultiphaseParcel>,
0
);

6
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelCompositionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "ReactingCloud.H"
#include "SingleMixtureFraction.H"
@ -35,7 +35,7 @@ namespace Foam
{
makeCompositionModel
(
ReactingCloud<basicReactingMultiphaseParcel>
ReactingCloud<bReactingMultiphaseParcel>
);
// Add instances of composition model to the table
@ -43,7 +43,7 @@ namespace Foam
(
SingleMixtureFraction,
ReactingCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

10
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelDevolatilisationModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "ReactingMultiphaseCloud.H"
#include "NoDevolatilisation.H"
@ -37,7 +37,7 @@ namespace Foam
{
makeDevolatilisationModel
(
ReactingMultiphaseCloud<basicReactingMultiphaseParcel>
ReactingMultiphaseCloud<bReactingMultiphaseParcel>
);
// Add instances of devolatilisation model to the table
@ -45,19 +45,19 @@ namespace Foam
(
NoDevolatilisation,
ReactingMultiphaseCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makeDevolatilisationModelType
(
ConstantRateDevolatilisation,
ReactingMultiphaseCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makeDevolatilisationModelType
(
SingleKineticRateDevolatilisation,
ReactingMultiphaseCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

12
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelDispersionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "KinematicCloud.H"
#include "NoDispersion.H"
@ -35,11 +35,11 @@ License
namespace Foam
{
makeDispersionModel(KinematicCloud<basicReactingMultiphaseParcel>);
makeDispersionModel(KinematicCloud<bReactingMultiphaseParcel>);
defineNamedTemplateTypeNameAndDebug
(
DispersionRASModel<KinematicCloud<basicReactingMultiphaseParcel> >,
DispersionRASModel<KinematicCloud<bReactingMultiphaseParcel> >,
0
);
@ -48,19 +48,19 @@ namespace Foam
(
NoDispersion,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makeDispersionModelType
(
GradientDispersionRAS,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makeDispersionModelType
(
StochasticDispersionRAS,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

8
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelDragModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "KinematicCloud.H"
#include "NoDrag.H"
@ -34,15 +34,15 @@ License
namespace Foam
{
makeDragModel(KinematicCloud<basicReactingMultiphaseParcel>);
makeDragModel(KinematicCloud<bReactingMultiphaseParcel>);
// Add instances of drag model to the table
makeDragModelType(NoDrag, KinematicCloud, basicReactingMultiphaseParcel);
makeDragModelType(NoDrag, KinematicCloud, bReactingMultiphaseParcel);
makeDragModelType
(
SphereDrag,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

8
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelHeatTransferModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "ThermoCloud.H"
#include "NoHeatTransfer.H"
@ -34,20 +34,20 @@ License
namespace Foam
{
makeHeatTransferModel(ThermoCloud<basicReactingMultiphaseParcel>);
makeHeatTransferModel(ThermoCloud<bReactingMultiphaseParcel>);
// Add instances of heat transfer model to the table
makeHeatTransferModelType
(
NoHeatTransfer,
ThermoCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makeHeatTransferModelType
(
RanzMarshall,
ThermoCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

12
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelInjectionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "ReactingCloud.H"
#include "ConeInjection.H"
@ -36,32 +36,32 @@ License
namespace Foam
{
makeInjectionModel(KinematicCloud<basicReactingMultiphaseParcel>);
makeInjectionModel(KinematicCloud<bReactingMultiphaseParcel>);
// Add instances of injection model to the table
makeInjectionModelType
(
ConeInjection,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makeInjectionModelType
(
FieldActivatedInjection,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makeInjectionModelType
(
ManualInjection,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makeInjectionModelType
(
NoInjection,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

10
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelPatchInteractionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "KinematicCloud.H"
#include "LocalInteraction.H"
@ -35,26 +35,26 @@ License
namespace Foam
{
makePatchInteractionModel(KinematicCloud<basicReactingMultiphaseParcel>);
makePatchInteractionModel(KinematicCloud<bReactingMultiphaseParcel>);
// Add instances of patch interaction model to the table
makePatchInteractionModelType
(
LocalInteraction,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makePatchInteractionModelType
(
Rebound,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makePatchInteractionModelType
(
StandardWallInteraction,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

8
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelPhaseChangeModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "ReactingCloud.H"
#include "NoPhaseChange.H"
@ -36,7 +36,7 @@ namespace Foam
{
makePhaseChangeModel
(
ReactingCloud<basicReactingMultiphaseParcel>
ReactingCloud<bReactingMultiphaseParcel>
);
// Add instances of phase change model to the table
@ -44,13 +44,13 @@ namespace Foam
(
NoPhaseChange,
ReactingCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makePhaseChangeModelType
(
LiquidEvaporation,
ReactingCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

8
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelPostProcessingModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "KinematicCloud.H"
#include "NoPostProcessing.H"
@ -34,20 +34,20 @@ License
namespace Foam
{
makePostProcessingModel(KinematicCloud<basicReactingMultiphaseParcel>);
makePostProcessingModel(KinematicCloud<bReactingMultiphaseParcel>);
// Add instances of post-processing model to the table
makePostProcessingModelType
(
NoPostProcessing,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
makePostProcessingModelType
(
StandardPostProcessing,
KinematicCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

6
src/lagrangian/intermediate/parcels/derived/BasicReactingMultiphaseParcel/submodels/makeBasicReactingMultiphaseParcelSurfaceReactionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "ReactingMultiphaseCloud.H"
#include "NoSurfaceReaction.H"
@ -35,7 +35,7 @@ namespace Foam
{
makeSurfaceReactionModel
(
ReactingMultiphaseCloud<basicReactingMultiphaseParcel>
ReactingMultiphaseCloud<bReactingMultiphaseParcel>
);
// Add instances of surface reaction model to the table
@ -43,7 +43,7 @@ namespace Foam
(
NoSurfaceReaction,
ReactingMultiphaseCloud,
basicReactingMultiphaseParcel
bReactingMultiphaseParcel
);
};

46
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/BasicReactingParcel.C
View File

@ -24,34 +24,26 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(basicReactingParcel, 0);
defineParticleTypeNameAndDebug(basicReactingParcel, 0);
defineParcelTypeNameAndDebug(basicReactingParcel, 0);
};
#include "BasicReactingParcel.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::basicReactingParcel::basicReactingParcel
template<class ThermoType>
Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
(
ReactingCloud<basicReactingParcel>& owner,
ReactingCloud<BasicReactingParcel<ThermoType> >& owner,
const vector& position,
const label cellI
)
:
ReactingParcel<basicReactingParcel>(owner, position, cellI)
ReactingParcel<BasicReactingParcel<ThermoType> >(owner, position, cellI)
{}
Foam::basicReactingParcel::basicReactingParcel
template<class ThermoType>
Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
(
ReactingCloud<basicReactingParcel>& owner,
ReactingCloud<BasicReactingParcel<ThermoType> >& owner,
const vector& position,
const label cellI,
const label typeId,
@ -59,10 +51,11 @@ Foam::basicReactingParcel::basicReactingParcel
const scalar d0,
const vector& U0,
const scalarField& Y0,
const constantProperties& constProps
const typename ReactingParcel<BasicReactingParcel<ThermoType> >::
constantProperties& constProps
)
:
ReactingParcel<basicReactingParcel>
ReactingParcel<BasicReactingParcel<ThermoType> >
(
owner,
position,
@ -77,29 +70,32 @@ Foam::basicReactingParcel::basicReactingParcel
{}
Foam::basicReactingParcel::basicReactingParcel
template<class ThermoType>
Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
(
const Cloud<basicReactingParcel>& cloud,
const Cloud<BasicReactingParcel<ThermoType> >& cloud,
Istream& is,
bool readFields
)
:
ReactingParcel<basicReactingParcel>(cloud, is, readFields)
ReactingParcel<BasicReactingParcel<ThermoType> >(cloud, is, readFields)
{}
Foam::basicReactingParcel::basicReactingParcel
template<class ThermoType>
Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
(
const basicReactingParcel& p
const BasicReactingParcel<ThermoType>& p
)
:
ReactingParcel<basicReactingParcel>(p)
ReactingParcel<BasicReactingParcel>(p)
{}
// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * //
Foam::basicReactingParcel::~basicReactingParcel()
template<class ThermoType>
Foam::BasicReactingParcel<ThermoType>::~BasicReactingParcel()
{}

66
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/BasicReactingParcel.H
View File

@ -23,56 +23,66 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::basicReactingParcel
Foam::BasicReactingParcel
Description
SourceFiles
basicReactingParcel.C
basicReactingParcelIO.C
BasicReactingParcel.C
BasicReactingParcelIO.C
\*---------------------------------------------------------------------------*/
#ifndef basicReactingParcel_H
#define basicReactingParcel_H
#ifndef BasicReactingParcel_H
#define BasicReactingParcel_H
#include "ReactingParcel.H"
#include "reactingParcel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
template<class ThermoType>
class BasicReactingParcel;
/*---------------------------------------------------------------------------*\
Class basicReactingParcel Declaration
Class BasicReactingParcel Declaration
\*---------------------------------------------------------------------------*/
class basicReactingParcel
template<class ThermoType>
class BasicReactingParcel
:
public ReactingParcel<basicReactingParcel>
public reactingParcel,
public ReactingParcel<BasicReactingParcel<ThermoType> >
{
public:
//- The type of thermodynamics this parcel was instantiated for
typedef ThermoType thermoType;
//- Run-time type information
TypeName("basicReactingParcel");
TypeName("BasicReactingParcel");
// Constructors
//- Construct from owner, position, and cloud owner
// Other properties initialised as null
basicReactingParcel
BasicReactingParcel
(
ReactingCloud<basicReactingParcel>& owner,
ReactingCloud<BasicReactingParcel>& owner,
const vector& position,
const label cellI
);
//- Construct from components
basicReactingParcel
BasicReactingParcel
(
ReactingCloud<basicReactingParcel>& owner,
ReactingCloud<BasicReactingParcel>& owner,
const vector& position,
const label cellI,
const label typeId,
@ -80,49 +90,49 @@ public:
const scalar d0,
const vector& U0,
const scalarField& Y0,
const constantProperties& constProps
const typename ReactingParcel<BasicReactingParcel>::
constantProperties& constProps
);
//- Construct from Istream
basicReactingParcel
BasicReactingParcel
(
const Cloud<basicReactingParcel>& c,
const Cloud<BasicReactingParcel>& c,
Istream& is,
bool readFields = true
);
//- Construct as a copy
basicReactingParcel(const basicReactingParcel& p);
BasicReactingParcel(const BasicReactingParcel& p);
//- Construct and return a clone
autoPtr<basicReactingParcel> clone() const
autoPtr<BasicReactingParcel> clone() const
{
return
autoPtr<basicReactingParcel>
autoPtr<BasicReactingParcel>
(
new basicReactingParcel(*this)
new BasicReactingParcel(*this)
);
}
//- Destructor
virtual ~basicReactingParcel();
virtual ~BasicReactingParcel();
};
template<>
inline bool contiguous<basicReactingParcel>()
{
return false; // Now have scalar lists/fields (mass fractions)
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "BasicReactingParcel.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

83
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/basicReactingParcelTypes.H Normal file
View File

@ -0,0 +1,83 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
\*---------------------------------------------------------------------------*/
#ifndef basicReactingParcelTypes_H
#define basicReactingParcelTypes_H
#include "BasicReactingParcel.H"
#include "BasicReactingCloud.H"
#include "ReactingCloudThermoTypes.H"
#include "makeParcelIOList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef BasicReactingParcel<specieReactingProperties> bReactingParcel;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define createReactingParcelType(ParcelType) \
\
createReactingParcelThermoType(ParcelType, specieConstProperties); \
createReactingParcelThermoType(ParcelType, specieReactingProperties);
#define createReactingParcelThermoType(ParcelType, ThermoType) \
\
typedef ParcelType<ThermoType> ParcelType##ThermoType; \
\
makeParcelIOList(ParcelType##ThermoType); \
\
defineTemplateTypeNameAndDebug(BasicReactingCloud<ThermoType>, 0); \
\
defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0); \
defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0); \
defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0); \
\
defineParcelTypeNameAndDebug(KinematicParcel<ParcelType##ThermoType>, 0); \
defineTemplateTypeNameAndDebug \
( \
KinematicParcel<ParcelType##ThermoType>, \
0 \
); \
defineParcelTypeNameAndDebug(ThermoParcel<ParcelType##ThermoType>, 0); \
defineTemplateTypeNameAndDebug(ThermoParcel<ParcelType##ThermoType>, 0); \
defineParcelTypeNameAndDebug(ReactingParcel<ParcelType##ThermoType>, 0); \
defineTemplateTypeNameAndDebug(ReactingParcel<ParcelType##ThermoType>, 0);\
\
defineParcelTypeNameAndDebug(KinematicCloud<ParcelType##ThermoType>, 0); \
defineParcelTypeNameAndDebug(ThermoCloud<ParcelType##ThermoType>, 0); \
defineParcelTypeNameAndDebug(ReactingCloud<ParcelType##ThermoType>, 0);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

24
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/defineBasicReactingParcel.C
View File

@ -24,29 +24,13 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "ReactingCloud.H"
#include "basicReactingParcelTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
defineTemplateTypeNameAndDebug(Cloud<basicReactingParcel>, 0);
defineParcelTypeNameAndDebug(KinematicParcel<basicReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(KinematicParcel<basicReactingParcel>, 0);
defineParcelTypeNameAndDebug(ThermoParcel<basicReactingParcel>, 0);
defineTemplateTypeNameAndDebug(ThermoParcel<basicReactingParcel>, 0);
defineParcelTypeNameAndDebug(ReactingParcel<basicReactingParcel>, 0);
defineTemplateTypeNameAndDebug(ReactingParcel<basicReactingParcel>, 0);
defineParcelTypeNameAndDebug(KinematicCloud<basicReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(KinematicCloud<basicReactingParcel>, 0);
defineParcelTypeNameAndDebug(ThermoCloud<basicReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(ThermoCloud<basicReactingParcel>, 0);
defineParcelTypeNameAndDebug(ReactingCloud<basicReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(ReactingCloud<basicReactingParcel>, 0);
createReactingParcelType(BasicReactingParcel);
};

6
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/submodels/makeBasicReactingParcelCompositionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "basicReactingParcelTypes.H"
#include "ReactingCloud.H"
#include "SinglePhaseMixture.H"
@ -33,14 +33,14 @@ License
namespace Foam
{
makeCompositionModel(ReactingCloud<basicReactingParcel>);
makeCompositionModel(ReactingCloud<bReactingParcel>);
// Add instances of composition model to the table
makeCompositionModelType
(
SinglePhaseMixture,
ReactingCloud,
basicReactingParcel
bReactingParcel
);
};

12
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/submodels/makeBasicReactingParcelDispersionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "basicReactingParcelTypes.H"
#include "KinematicCloud.H"
#include "NoDispersion.H"
@ -35,11 +35,11 @@ License
namespace Foam
{
makeDispersionModel(KinematicCloud<basicReactingParcel>);
makeDispersionModel(KinematicCloud<bReactingParcel>);
defineNamedTemplateTypeNameAndDebug
(
DispersionRASModel<KinematicCloud<basicReactingParcel> >,
DispersionRASModel<KinematicCloud<bReactingParcel> >,
0
);
@ -48,19 +48,19 @@ namespace Foam
(
NoDispersion,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makeDispersionModelType
(
GradientDispersionRAS,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makeDispersionModelType
(
StochasticDispersionRAS,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
};

8
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/submodels/makeBasicReactingParcelDragModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "basicReactingParcelTypes.H"
#include "KinematicCloud.H"
#include "NoDrag.H"
@ -34,11 +34,11 @@ License
namespace Foam
{
makeDragModel(KinematicCloud<basicReactingParcel>);
makeDragModel(KinematicCloud<bReactingParcel>);
// Add instances of drag model to the table
makeDragModelType(NoDrag, KinematicCloud, basicReactingParcel);
makeDragModelType(SphereDrag, KinematicCloud, basicReactingParcel);
makeDragModelType(NoDrag, KinematicCloud, bReactingParcel);
makeDragModelType(SphereDrag, KinematicCloud, bReactingParcel);
};

8
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/submodels/makeBasicReactingParcelHeatTransferModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "basicReactingParcelTypes.H"
#include "ThermoCloud.H"
#include "NoHeatTransfer.H"
@ -34,20 +34,20 @@ License
namespace Foam
{
makeHeatTransferModel(ThermoCloud<basicReactingParcel>);
makeHeatTransferModel(ThermoCloud<bReactingParcel>);
// Add instances of heat transfer model to the table
makeHeatTransferModelType
(
NoHeatTransfer,
ThermoCloud,
basicReactingParcel
bReactingParcel
);
makeHeatTransferModelType
(
RanzMarshall,
ThermoCloud,
basicReactingParcel
bReactingParcel
);
};

14
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/submodels/makeBasicReactingParcelInjectionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "basicReactingParcelTypes.H"
#include "ReactingCloud.H"
#include "ConeInjection.H"
@ -37,38 +37,38 @@ License
namespace Foam
{
makeInjectionModel(KinematicCloud<basicReactingParcel>);
makeInjectionModel(KinematicCloud<bReactingParcel>);
// Add instances of injection model to the table
makeInjectionModelType
(
ConeInjection,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makeInjectionModelType
(
FieldActivatedInjection,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makeInjectionModelType
(
ManualInjection,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makeInjectionModelType
(
NoInjection,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makeInjectionModelType
(
ReactingLookupTableInjection,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
};

10
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/submodels/makeBasicReactingParcelPatchInteractionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "basicReactingParcelTypes.H"
#include "KinematicCloud.H"
#include "LocalInteraction.H"
@ -35,26 +35,26 @@ License
namespace Foam
{
makePatchInteractionModel(KinematicCloud<basicReactingParcel>);
makePatchInteractionModel(KinematicCloud<bReactingParcel>);
// Add instances of patch interaction model to the table
makePatchInteractionModelType
(
LocalInteraction,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makePatchInteractionModelType
(
Rebound,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makePatchInteractionModelType
(
StandardWallInteraction,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
};

8
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/submodels/makeBasicReactingParcelPhaseChangeModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "basicReactingParcelTypes.H"
#include "ReactingCloud.H"
#include "NoPhaseChange.H"
@ -34,20 +34,20 @@ License
namespace Foam
{
makePhaseChangeModel(ReactingCloud<basicReactingParcel>);
makePhaseChangeModel(ReactingCloud<bReactingParcel>);
// Add instances of phase change model to the table
makePhaseChangeModelType
(
NoPhaseChange,
ReactingCloud,
basicReactingParcel
bReactingParcel
);
makePhaseChangeModelType
(
LiquidEvaporation,
ReactingCloud,
basicReactingParcel
bReactingParcel
);
};

8
src/lagrangian/intermediate/parcels/derived/BasicReactingParcel/submodels/makeBasicReactingParcelPostProcessingModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "basicReactingParcel.H"
#include "basicReactingParcelTypes.H"
#include "KinematicCloud.H"
#include "NoPostProcessing.H"
@ -34,20 +34,20 @@ License
namespace Foam
{
makePostProcessingModel(KinematicCloud<basicReactingParcel>);
makePostProcessingModel(KinematicCloud<bReactingParcel>);
// Add instances of post-processing model to the table
makePostProcessingModelType
(
NoPostProcessing,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
makePostProcessingModelType
(
StandardPostProcessing,
KinematicCloud,
basicReactingParcel
bReactingParcel
);
};

57
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/BasicTrackedReactingParcel.C
View File

@ -24,34 +24,31 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(trackedReactingParcel, 0);
defineParticleTypeNameAndDebug(trackedReactingParcel, 0);
defineParcelTypeNameAndDebug(trackedReactingParcel, 0);
}
#include "BasicTrackedReactingParcel.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::trackedReactingParcel::trackedReactingParcel
template<class ThermoType>
Foam::BasicTrackedReactingParcel<ThermoType>::BasicTrackedReactingParcel
(
ReactingCloud<trackedReactingParcel>& owner,
ReactingCloud<BasicTrackedReactingParcel<ThermoType> >& owner,
const vector& position,
const label cellI
)
:
TrackedReactingParcel<trackedReactingParcel>(owner, position, cellI)
TrackedReactingParcel<BasicTrackedReactingParcel<ThermoType> >
(
owner,
position,
cellI
)
{}
Foam::trackedReactingParcel::trackedReactingParcel
template<class ThermoType>
Foam::BasicTrackedReactingParcel<ThermoType>::BasicTrackedReactingParcel
(
ReactingCloud<trackedReactingParcel>& owner,
ReactingCloud<BasicTrackedReactingParcel<ThermoType> >& owner,
const vector& position,
const label cellI,
const label typeId,
@ -59,10 +56,12 @@ Foam::trackedReactingParcel::trackedReactingParcel
const scalar d0,
const vector& U0,
const scalarField& Y0,
const constantProperties& constProps
const typename
TrackedReactingParcel<BasicTrackedReactingParcel<ThermoType> >::
constantProperties& constProps
)
:
TrackedReactingParcel<trackedReactingParcel>
TrackedReactingParcel<BasicTrackedReactingParcel<ThermoType> >
(
owner,
position,
@ -77,29 +76,37 @@ Foam::trackedReactingParcel::trackedReactingParcel
{}
Foam::trackedReactingParcel::trackedReactingParcel
template<class ThermoType>
Foam::BasicTrackedReactingParcel<ThermoType>::BasicTrackedReactingParcel
(
const Cloud<trackedReactingParcel>& cloud,
const Cloud<BasicTrackedReactingParcel<ThermoType> >& cloud,
Istream& is,
bool readFields
)
:
TrackedReactingParcel<trackedReactingParcel>(cloud, is, readFields)
TrackedReactingParcel<BasicTrackedReactingParcel<ThermoType> >
(
cloud,
is,
readFields
)
{}
Foam::trackedReactingParcel::trackedReactingParcel
template<class ThermoType>
Foam::BasicTrackedReactingParcel<ThermoType>::BasicTrackedReactingParcel
(
const trackedReactingParcel& p
const BasicTrackedReactingParcel<ThermoType>& p
)
:
TrackedReactingParcel<trackedReactingParcel>(p)
TrackedReactingParcel<BasicTrackedReactingParcel<ThermoType> >(p)
{}
// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * //
Foam::trackedReactingParcel::~trackedReactingParcel()
template<class ThermoType>
Foam::BasicTrackedReactingParcel<ThermoType>::~BasicTrackedReactingParcel()
{}

67
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/BasicTrackedReactingParcel.H
View File

@ -23,56 +23,66 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::trackedReactingParcel
Foam::BasicTrackedReactingParcel
Description
SourceFiles
trackedReactingParcel.C
trackedReactingParcelIO.C
BasicTrackedReactingParcel.C
BasicTrackedReactingParcelIO.C
\*---------------------------------------------------------------------------*/
#ifndef trackedReactingParcel_H
#define trackedReactingParcel_H
#ifndef BasicTrackedReactingParcel_H
#define BasicTrackedReactingParcel_H
#include "TrackedReactingParcel.H"
#include "reactingParcel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
template<class ThermoType>
class BasicTrackedReactingParcel;
/*---------------------------------------------------------------------------*\
Class trackedReactingParcel Declaration
Class BasicTrackedReactingParcel Declaration
\*---------------------------------------------------------------------------*/
class trackedReactingParcel
template<class ThermoType>
class BasicTrackedReactingParcel
:
public TrackedReactingParcel<trackedReactingParcel>
public reactingParcel,
public TrackedReactingParcel<BasicTrackedReactingParcel<ThermoType> >
{
public:
//- The type of thermodynamics this parcel was instantiated for
typedef ThermoType thermoType;
//- Run-time type information
TypeName("trackedReactingParcel");
TypeName("BasicTrackedReactingParcel");
// Constructors
//- Construct from owner, position, and cloud owner
// Other properties initialised as null
trackedReactingParcel
BasicTrackedReactingParcel
(
ReactingCloud<trackedReactingParcel>& owner,
ReactingCloud<BasicTrackedReactingParcel>& owner,
const vector& position,
const label cellI
);
//- Construct from components
trackedReactingParcel
BasicTrackedReactingParcel
(
ReactingCloud<trackedReactingParcel>& owner,
ReactingCloud<BasicTrackedReactingParcel>& owner,
const vector& position,
const label cellI,
const label typeId,
@ -80,49 +90,50 @@ public:
const scalar d0,
const vector& U0,
const scalarField& Y0,
const constantProperties& constProps
const typename
TrackedReactingParcel<BasicTrackedReactingParcel>::
constantProperties& constProps
);
//- Construct from Istream
trackedReactingParcel
BasicTrackedReactingParcel
(
const Cloud<trackedReactingParcel>& c,
const Cloud<BasicTrackedReactingParcel>& c,
Istream& is,
bool readFields = true
);
//- Construct as a copy
trackedReactingParcel(const trackedReactingParcel& p);
BasicTrackedReactingParcel(const BasicTrackedReactingParcel& p);
//- Construct and return a clone
autoPtr<trackedReactingParcel> clone() const
autoPtr<BasicTrackedReactingParcel> clone() const
{
return
autoPtr<trackedReactingParcel>
autoPtr<BasicTrackedReactingParcel>
(
new trackedReactingParcel(*this)
new BasicTrackedReactingParcel(*this)
);
}
//- Destructor
virtual ~trackedReactingParcel();
virtual ~BasicTrackedReactingParcel();
};
template<>
inline bool contiguous<trackedReactingParcel>()
{
return false; // Now have scalar lists/fields (mass fractions)
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "BasicTrackedReactingParcel.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

45
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/basicTrackedReactingParcelTypes.H Normal file
View File

@ -0,0 +1,45 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
\*---------------------------------------------------------------------------*/
#ifndef basicTrackedReactingParcelTypes_H
#define basicTrackedReactingParcelTypes_H
#include "BasicTrackedReactingParcel.H"
#include "ReactingCloudThermoTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef BasicTrackedReactingParcel<specieReactingProperties>
bTrackedReactingParcel;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

34
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/defineTrackedReactingParcel.C
View File

@ -24,33 +24,35 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "ReactingCloud.H"
#include "basicTrackedReactingParcelTypes.H"
#include "BasicReactingCloud.H"
namespace Foam
{
defineTemplateTypeNameAndDebug(Cloud<trackedReactingParcel>, 0);
defineTemplateTypeNameAndDebug(bTrackedReactingParcel, 0);
defineTemplateTypeNameAndDebug(Particle<bTrackedReactingParcel>, 0);
defineTemplateTypeNameAndDebug(Cloud<bTrackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(KinematicParcel<trackedReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(KinematicParcel<trackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(ThermoParcel<trackedReactingParcel>, 0);
defineTemplateTypeNameAndDebug(ThermoParcel<trackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(ReactingParcel<trackedReactingParcel>, 0);
defineTemplateTypeNameAndDebug(ReactingParcel<trackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(KinematicParcel<bTrackedReactingParcel>, 0);
defineTemplateTypeNameAndDebug(KinematicParcel<bTrackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(ThermoParcel<bTrackedReactingParcel>, 0);
defineTemplateTypeNameAndDebug(ThermoParcel<bTrackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(ReactingParcel<bTrackedReactingParcel>, 0);
defineTemplateTypeNameAndDebug(ReactingParcel<bTrackedReactingParcel>, 0);
defineTemplateTypeNameAndDebug
(
TrackedReactingParcel<trackedReactingParcel>,
TrackedReactingParcel<bTrackedReactingParcel>,
0
);
defineParcelTypeNameAndDebug(KinematicCloud<trackedReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(KinematicCloud<trackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(KinematicCloud<bTrackedReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(KinematicCloud<bTrackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(ThermoCloud<trackedReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(ThermoCloud<trackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(ThermoCloud<bTrackedReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(ThermoCloud<bTrackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(ReactingCloud<trackedReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(ReactingCloud<trackedReactingParcel>, 0);
defineParcelTypeNameAndDebug(ReactingCloud<bTrackedReactingParcel>, 0);
// defineTemplateTypeNameAndDebug(ReactingCloud<bTrackedReactingParcel>, 0);
}

6
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/submodels/makeTrackedReactingParcelCompositionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
#include "ReactingCloud.H"
#include "SinglePhaseMixture.H"
@ -33,14 +33,14 @@ License
namespace Foam
{
makeCompositionModel(ReactingCloud<trackedReactingParcel>);
makeCompositionModel(ReactingCloud<bTrackedReactingParcel>);
// Add instances of composition model to the table
makeCompositionModelType
(
SinglePhaseMixture,
ReactingCloud,
trackedReactingParcel
bTrackedReactingParcel
);
}

12
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/submodels/makeTrackedReactingParcelDispersionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
#include "KinematicCloud.H"
#include "NoDispersion.H"
@ -35,11 +35,11 @@ License
namespace Foam
{
makeDispersionModel(KinematicCloud<trackedReactingParcel>);
makeDispersionModel(KinematicCloud<bTrackedReactingParcel>);
defineNamedTemplateTypeNameAndDebug
(
DispersionRASModel<KinematicCloud<trackedReactingParcel> >,
DispersionRASModel<KinematicCloud<bTrackedReactingParcel> >,
0
);
@ -48,19 +48,19 @@ namespace Foam
(
NoDispersion,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makeDispersionModelType
(
GradientDispersionRAS,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makeDispersionModelType
(
StochasticDispersionRAS,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
}

8
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/submodels/makeTrackedReactingParcelDragModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
#include "KinematicCloud.H"
#include "NoDrag.H"
@ -34,11 +34,11 @@ License
namespace Foam
{
makeDragModel(KinematicCloud<trackedReactingParcel>);
makeDragModel(KinematicCloud<bTrackedReactingParcel>);
// Add instances of drag model to the table
makeDragModelType(NoDrag, KinematicCloud, trackedReactingParcel);
makeDragModelType(SphereDrag, KinematicCloud, trackedReactingParcel);
makeDragModelType(NoDrag, KinematicCloud, bTrackedReactingParcel);
makeDragModelType(SphereDrag, KinematicCloud, bTrackedReactingParcel);
}

8
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/submodels/makeTrackedReactingParcelHeatTransferModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
#include "ThermoCloud.H"
#include "NoHeatTransfer.H"
@ -34,20 +34,20 @@ License
namespace Foam
{
makeHeatTransferModel(ThermoCloud<trackedReactingParcel>);
makeHeatTransferModel(ThermoCloud<bTrackedReactingParcel>);
// Add instances of heat transfer model to the table
makeHeatTransferModelType
(
NoHeatTransfer,
ThermoCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makeHeatTransferModelType
(
RanzMarshall,
ThermoCloud,
trackedReactingParcel
bTrackedReactingParcel
);
}

14
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/submodels/makeTrackedReactingParcelInjectionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
#include "ReactingCloud.H"
#include "ConeInjection.H"
@ -37,38 +37,38 @@ License
namespace Foam
{
makeInjectionModel(KinematicCloud<trackedReactingParcel>);
makeInjectionModel(KinematicCloud<bTrackedReactingParcel>);
// Add instances of injection model to the table
makeInjectionModelType
(
ConeInjection,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makeInjectionModelType
(
FieldActivatedInjection,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makeInjectionModelType
(
ManualInjection,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makeInjectionModelType
(
NoInjection,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makeInjectionModelType
(
ReactingLookupTableInjection,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
}

10
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/submodels/makeTrackedReactingParcelPatchInteractionModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
#include "KinematicCloud.H"
#include "LocalInteraction.H"
@ -35,26 +35,26 @@ License
namespace Foam
{
makePatchInteractionModel(KinematicCloud<trackedReactingParcel>);
makePatchInteractionModel(KinematicCloud<bTrackedReactingParcel>);
// Add instances of patch interaction model to the table
makePatchInteractionModelType
(
LocalInteraction,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makePatchInteractionModelType
(
Rebound,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makePatchInteractionModelType
(
StandardWallInteraction,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
}

8
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/submodels/makeTrackedReactingParcelPhaseChangeModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
#include "ReactingCloud.H"
#include "NoPhaseChange.H"
@ -34,20 +34,20 @@ License
namespace Foam
{
makePhaseChangeModel(ReactingCloud<trackedReactingParcel>);
makePhaseChangeModel(ReactingCloud<bTrackedReactingParcel>);
// Add instances of phase change model to the table
makePhaseChangeModelType
(
NoPhaseChange,
ReactingCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makePhaseChangeModelType
(
LiquidEvaporation,
ReactingCloud,
trackedReactingParcel
bTrackedReactingParcel
);
}

8
src/lagrangian/intermediate/parcels/derived/BasicTrackedReactingParcel/submodels/makeTrackedReactingParcelPostProcessingModels.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
#include "KinematicCloud.H"
#include "NoPostProcessing.H"
@ -34,20 +34,20 @@ License
namespace Foam
{
makePostProcessingModel(KinematicCloud<trackedReactingParcel>);
makePostProcessingModel(KinematicCloud<bTrackedReactingParcel>);
// Add instances of post-processing model to the table
makePostProcessingModelType
(
NoPostProcessing,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
makePostProcessingModelType
(
StandardPostProcessing,
KinematicCloud,
trackedReactingParcel
bTrackedReactingParcel
);
}

10
src/lagrangian/intermediate/submodels/IO/IOList/makeParcelIOLists.C
View File

@ -28,10 +28,9 @@ License
#include "basicKinematicParcel.H"
#include "basicThermoParcel.H"
#include "basicReactingParcel.H"
#include "basicReactingMultiphaseParcel.H"
#include "basicReactingMultiphaseParcelTypes.H"
#include "trackedReactingParcel.H"
#include "basicTrackedReactingParcelTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -39,10 +38,9 @@ namespace Foam
{
makeParcelIOList(basicKinematicParcel);
makeParcelIOList(basicThermoParcel);
makeParcelIOList(basicReactingParcel);
makeParcelIOList(basicReactingMultiphaseParcel);
makeParcelIOList(bReactingMultiphaseParcel);
makeParcelIOList(trackedReactingParcel);
makeParcelIOList(bTrackedReactingParcel);
};

2
src/lagrangian/intermediate/submodels/Reacting/CompositionModel/CompositionModel/CompositionModel.C
View File

@ -110,7 +110,7 @@ Foam::CompositionModel<CloudType>::carrierThermo() const
template<class CloudType>
const Foam::PtrList<Foam::specieReactingProperties>&
const Foam::PtrList<typename CloudType::thermoType>&
Foam::CompositionModel<CloudType>::carrierSpecies() const
{
return carrierSpecies_;

5
src/lagrangian/intermediate/submodels/Reacting/CompositionModel/CompositionModel/CompositionModel.H
View File

@ -78,7 +78,7 @@ class CompositionModel
hCombustionThermo& carrierThermo_;
//- Reference to the carrier phase species
const PtrList<specieReactingProperties>& carrierSpecies_;
const PtrList<typename CloudType::thermoType>& carrierSpecies_;
//- Global (additional) liquid properties data
autoPtr<liquidMixture> liquids_;
@ -152,7 +152,8 @@ public:
// Composition lists
//- Return the carrier species
const PtrList<specieReactingProperties>& carrierSpecies() const;
const PtrList<typename CloudType::thermoType>&
carrierSpecies() const;
//- Return the global (additional) liquids
const liquidMixture& liquids() const;