Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
Development
openfoam
Commits
8e598ca1
Commit
8e598ca1
authored
May 25, 2011
by
andy
Browse files
ENH: Added ConeNozzleInjection model (udpated version of NN unitInjector model)
parent
955a0411
Changes
7
Hide whitespace changes
Inline
Side-by-side
src/lagrangian/intermediate/parcels/include/makeParcelInjectionModels.H
View file @
8e598ca1
...
...
@@ -30,6 +30,7 @@ License
#include
"CellZoneInjection.H"
#include
"ConeInjection.H"
#include
"ConeNozzleInjection.H"
#include
"FieldActivatedInjection.H"
#include
"InflationInjection.H"
#include
"KinematicLookupTableInjection.H"
...
...
src/lagrangian/intermediate/parcels/include/makeReactingMultiphaseParcelInjectionModels.H
View file @
8e598ca1
...
...
@@ -30,6 +30,7 @@ License
#include
"CellZoneInjection.H"
#include
"ConeInjection.H"
#include
"ConeNozzleInjection.H"
#include
"FieldActivatedInjection.H"
#include
"ManualInjection.H"
#include
"NoInjection.H"
...
...
src/lagrangian/intermediate/parcels/include/makeReactingParcelInjectionModels.H
View file @
8e598ca1
...
...
@@ -30,6 +30,7 @@ License
#include
"CellZoneInjection.H"
#include
"ConeInjection.H"
#include
"ConeNozzleInjection.H"
#include
"FieldActivatedInjection.H"
#include
"ManualInjection.H"
#include
"NoInjection.H"
...
...
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C
0 → 100644
View file @
8e598ca1
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2011 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 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
"ConeNozzleInjection.H"
#include
"DataEntry.H"
#include
"mathematicalConstants.H"
#include
"distributionModel.H"
using
namespace
Foam
::
constant
;
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template
<
class
CloudType
>
Foam
::
ConeNozzleInjection
<
CloudType
>::
ConeNozzleInjection
(
const
dictionary
&
dict
,
CloudType
&
owner
)
:
InjectionModel
<
CloudType
>
(
dict
,
owner
,
typeName
),
injectionMethod_
(
imPoint
),
outerNozzleDiameter_
(
readScalar
(
this
->
coeffDict
().
lookup
(
"outerNozzleDiameter"
))
),
innerNozzleDiameter_
(
readScalar
(
this
->
coeffDict
().
lookup
(
"innerNozzleDiameter"
))
),
duration_
(
readScalar
(
this
->
coeffDict
().
lookup
(
"duration"
))),
position_
(
this
->
coeffDict
().
lookup
(
"position"
)),
injectorCell_
(
-
1
),
tetFaceI_
(
-
1
),
tetPtI_
(
-
1
),
direction_
(
this
->
coeffDict
().
lookup
(
"direction"
)),
parcelsPerSecond_
(
readScalar
(
this
->
coeffDict
().
lookup
(
"parcelsPerSecond"
))
),
volumeFlowRate_
(
DataEntry
<
scalar
>::
New
(
"volumeFlowRate"
,
this
->
coeffDict
()
)
),
Cd_
(
DataEntry
<
scalar
>::
New
(
"Cd"
,
this
->
coeffDict
()
)
),
thetaInner_
(
DataEntry
<
scalar
>::
New
(
"thetaInner"
,
this
->
coeffDict
()
)
),
thetaOuter_
(
DataEntry
<
scalar
>::
New
(
"thetaOuter"
,
this
->
coeffDict
()
)
),
sizeDistribution_
(
distributionModels
::
distributionModel
::
New
(
this
->
coeffDict
().
subDict
(
"sizeDistribution"
),
owner
.
rndGen
()
)
),
tanVec1_
(
vector
::
zero
),
tanVec2_
(
vector
::
zero
),
normal_
(
vector
::
zero
)
{
if
(
innerNozzleDiameter_
>=
outerNozzleDiameter_
)
{
FatalErrorIn
(
"Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection"
"("
"const dictionary&, "
"CloudType&"
")"
)
<<
"innerNozzleDiameter >= outerNozzleDiameter"
<<
nl
<<
exit
(
FatalError
);
}
word
injectionMethodType
=
this
->
coeffDict
().
lookup
(
"injectionMethod"
);
if
(
injectionMethodType
==
"disc"
)
{
injectionMethod_
=
imDisc
;
}
else
if
(
injectionMethodType
==
"point"
)
{
injectionMethod_
=
imPoint
;
// Set/cache the injector cell
this
->
findCellAtPosition
(
injectorCell_
,
tetFaceI_
,
tetPtI_
,
position_
,
false
);
}
else
{
FatalErrorIn
(
"Foam::InjectionModel<CloudType>::InjectionModel"
"("
"const dictionary&, "
"CloudType&"
")"
)
<<
"injectionMethod must be either 'point' or 'disc'"
<<
nl
<<
exit
(
FatalError
);
}
cachedRandom
&
rndGen
=
this
->
owner
().
rndGen
();
// Normalise direction vector
direction_
/=
mag
(
direction_
);
// Determine direction vectors tangential to direction
vector
tangent
=
vector
::
zero
;
scalar
magTangent
=
0
.
0
;
while
(
magTangent
<
SMALL
)
{
vector
v
=
rndGen
.
sample01
<
vector
>
();
tangent
=
v
-
(
v
&
direction_
)
*
direction_
;
magTangent
=
mag
(
tangent
);
}
tanVec1_
=
tangent
/
magTangent
;
tanVec2_
=
direction_
^
tanVec1_
;
// Set total volume to inject
this
->
volumeTotal_
=
volumeFlowRate_
().
integrate
(
0
.
0
,
duration_
);
}
template
<
class
CloudType
>
Foam
::
ConeNozzleInjection
<
CloudType
>::
ConeNozzleInjection
(
const
ConeNozzleInjection
<
CloudType
>&
im
)
:
InjectionModel
<
CloudType
>
(
im
),
injectionMethod_
(
im
.
injectionMethod_
),
outerNozzleDiameter_
(
im
.
outerNozzleDiameter_
),
innerNozzleDiameter_
(
im
.
innerNozzleDiameter_
),
duration_
(
im
.
duration_
),
position_
(
im
.
position_
),
injectorCell_
(
im
.
injectorCell_
),
direction_
(
im
.
direction_
),
parcelsPerSecond_
(
im
.
parcelsPerSecond_
),
volumeFlowRate_
(
im
.
volumeFlowRate_
().
clone
().
ptr
()),
Cd_
(
im
.
Cd_
().
clone
().
ptr
()),
thetaInner_
(
im
.
thetaInner_
().
clone
().
ptr
()),
thetaOuter_
(
im
.
thetaOuter_
().
clone
().
ptr
()),
sizeDistribution_
(
im
.
sizeDistribution_
().
clone
().
ptr
()),
tanVec1_
(
im
.
tanVec1_
),
tanVec2_
(
im
.
tanVec1_
),
normal_
(
im
.
normal_
)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template
<
class
CloudType
>
Foam
::
ConeNozzleInjection
<
CloudType
>::~
ConeNozzleInjection
()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template
<
class
CloudType
>
Foam
::
scalar
Foam
::
ConeNozzleInjection
<
CloudType
>::
timeEnd
()
const
{
return
this
->
SOI_
+
duration_
;
}
template
<
class
CloudType
>
Foam
::
label
Foam
::
ConeNozzleInjection
<
CloudType
>::
parcelsToInject
(
const
scalar
time0
,
const
scalar
time1
)
{
if
((
time0
>=
0
.
0
)
&&
(
time0
<
duration_
))
{
return
floor
((
time1
-
time0
)
*
parcelsPerSecond_
);
}
else
{
return
0
;
}
}
template
<
class
CloudType
>
Foam
::
scalar
Foam
::
ConeNozzleInjection
<
CloudType
>::
volumeToInject
(
const
scalar
time0
,
const
scalar
time1
)
{
if
((
time0
>=
0
.
0
)
&&
(
time0
<
duration_
))
{
return
volumeFlowRate_
().
integrate
(
time0
,
time1
);
}
else
{
return
0
.
0
;
}
}
template
<
class
CloudType
>
void
Foam
::
ConeNozzleInjection
<
CloudType
>::
setPositionAndCell
(
const
label
,
const
label
,
const
scalar
,
vector
&
position
,
label
&
cellOwner
,
label
&
tetFaceI
,
label
&
tetPtI
)
{
cachedRandom
&
rndGen
=
this
->
owner
().
rndGen
();
scalar
beta
=
mathematical
::
twoPi
*
rndGen
.
sample01
<
scalar
>
();
normal_
=
tanVec1_
*
cos
(
beta
)
+
tanVec2_
*
sin
(
beta
);
switch
(
injectionMethod_
)
{
case
imPoint
:
{
position
=
position_
;
cellOwner
=
injectorCell_
;
tetFaceI
=
tetFaceI_
;
tetPtI
=
tetPtI_
;
break
;
}
case
imDisc
:
{
scalar
frac
=
rndGen
.
sample01
<
scalar
>
();
scalar
dr
=
outerNozzleDiameter_
-
innerNozzleDiameter_
;
scalar
r
=
0
.
5
*
(
innerNozzleDiameter_
+
frac
*
dr
);
position
=
position_
+
r
*
normal_
;
this
->
findCellAtPosition
(
cellOwner
,
tetFaceI
,
tetPtI
,
position
,
false
);
break
;
}
default:
{
FatalErrorIn
(
"void Foam::ConeNozzleInjection<CloudType>::setPositionAndCell"
"("
"const label, "
"const label, "
"const scalar, "
"vector&, "
"label&"
")"
)
<<
"Unknown injectionMethod type"
<<
nl
<<
exit
(
FatalError
);
}
}
}
template
<
class
CloudType
>
void
Foam
::
ConeNozzleInjection
<
CloudType
>::
setProperties
(
const
label
parcelI
,
const
label
,
const
scalar
time
,
typename
CloudType
::
parcelType
&
parcel
)
{
cachedRandom
&
rndGen
=
this
->
owner
().
rndGen
();
// set particle velocity
const
scalar
deg2Rad
=
mathematical
::
pi
/
180
.
0
;
scalar
t
=
time
-
this
->
SOI_
;
scalar
ti
=
thetaInner_
().
value
(
t
);
scalar
to
=
thetaOuter_
().
value
(
t
);
scalar
coneAngle
=
rndGen
.
sample01
<
scalar
>
()
*
(
to
-
ti
)
+
ti
;
coneAngle
*=
deg2Rad
;
scalar
alpha
=
sin
(
coneAngle
);
scalar
dcorr
=
cos
(
coneAngle
);
vector
normal
=
alpha
*
normal_
;
vector
dirVec
=
dcorr
*
direction_
;
dirVec
+=
normal
;
dirVec
/=
mag
(
dirVec
);
scalar
Ao
=
0
.
25
*
mathematical
::
pi
*
outerNozzleDiameter_
*
outerNozzleDiameter_
;
scalar
Ai
=
0
.
25
*
mathematical
::
pi
*
innerNozzleDiameter_
*
innerNozzleDiameter_
;
scalar
massFlowRate
=
this
->
massTotal
()
*
volumeFlowRate_
().
value
(
t
)
/
this
->
volumeTotal
();
scalar
rho
=
this
->
owner
().
constProps
().
rho0
();
// scalar Umag = massFlowRate/(parcel.rho()*Cd_().value(t)*(Ao - Ai));
scalar
Umag
=
massFlowRate
/
(
rho
*
Cd_
().
value
(
t
)
*
(
Ao
-
Ai
));
parcel
.
U
()
=
Umag
*
dirVec
;
// set particle diameter
parcel
.
d
()
=
sizeDistribution_
->
sample
();
}
template
<
class
CloudType
>
bool
Foam
::
ConeNozzleInjection
<
CloudType
>::
fullyDescribed
()
const
{
return
false
;
}
template
<
class
CloudType
>
bool
Foam
::
ConeNozzleInjection
<
CloudType
>::
validInjection
(
const
label
)
{
return
true
;
}
// ************************************************************************* //
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.H
0 → 100644
View file @
8e598ca1
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2011 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 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::ConeNozzleInjection
Description
Cone injection
- User specifies
- time of start of injection
- injector position
- direction (along injection axis)
- parcel flow rate
- discharge coefficient, Cd
- inner and outer cone angles
- Parcel diameters obtained by size distribution model
- Parcel velocity is calculated as:
U = V_dot/(A * Cd), where V_dot is the volume flow rate
Based on the old 'unitInjection' model
SourceFiles
ConeNozzleInjection.C
\*---------------------------------------------------------------------------*/
#ifndef ConeNozzleInjection_H
#define ConeNozzleInjection_H
#include
"InjectionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace
Foam
{
// Forward declaration of classes
template
<
class
Type
>
class
DataEntry
;
class
distributionModel
;
/*---------------------------------------------------------------------------*\
Class ConeNozzleInjection Declaration
\*---------------------------------------------------------------------------*/
template
<
class
CloudType
>
class
ConeNozzleInjection
:
public
InjectionModel
<
CloudType
>
{
public:
//- Injection method enumeration
enum
injectionMethod
{
imPoint
,
imDisc
};
private:
// Private data
//- point/disc injection method
injectionMethod
injectionMethod_
;
//- Outer nozzle diameter [m]
const
scalar
outerNozzleDiameter_
;
//- Inner nozzle diameter [m]
const
scalar
innerNozzleDiameter_
;
//- Injection duration [s]
const
scalar
duration_
;
//- Injector position [m]
vector
position_
;
//- Cell containing injector position []
label
injectorCell_
;
//- Index of tet face for injector cell
label
tetFaceI_
;
//- Index of tet point for injector cell
label
tetPtI_
;
//- Injector direction []
vector
direction_
;
//- Number of parcels to introduce per second []
const
label
parcelsPerSecond_
;
//- Volume flow rate of parcels to introduce relative to SOI [m^3/s]
const
autoPtr
<
DataEntry
<
scalar
>
>
volumeFlowRate_
;
//- Discharge coefficient, relative to SOI [m/s]
const
autoPtr
<
DataEntry
<
scalar
>
>
Cd_
;
//- Inner cone angle relative to SOI [deg]
const
autoPtr
<
DataEntry
<
scalar
>
>
thetaInner_
;
//- Outer cone angle relative to SOI [deg]
const
autoPtr
<
DataEntry
<
scalar
>
>
thetaOuter_
;
//- Parcel size PDF model
const
autoPtr
<
distributionModels
::
distributionModel
>
sizeDistribution_
;
// Tangential vectors to the direction vector
//- First tangential vector
vector
tanVec1_
;
//- Second tangential vector
vector
tanVec2_
;
//- injection vector orthogonal to direction
vector
normal_
;
public:
//- Runtime type information
TypeName
(
"coneNozzleInjection"
);
// Constructors
//- Construct from dictionary
ConeNozzleInjection
(
const
dictionary
&
dict
,
CloudType
&
owner
);
//- Construct copy
ConeNozzleInjection
(
const
ConeNozzleInjection
<
CloudType
>&
im
);
//- Construct and return a clone
virtual
autoPtr
<
InjectionModel
<
CloudType
>
>
clone
()
const
{
return
autoPtr
<
InjectionModel
<
CloudType
>
>
(
new
ConeNozzleInjection
<
CloudType
>
(
*
this
)
);
}