src/lagrangian/dieselSpray/spraySubModels/injectorModel/definedHollowCone/definedHollowCone.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "definedHollowCone.H"
  28 #include "addToRunTimeSelectionTable.H"
  29 #include "mathematicalConstants.H"
  30
  31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35
  36 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  37
  38 defineTypeNameAndDebug(definedHollowConeInjector, 0);
  39
  40 addToRunTimeSelectionTable
  41 (
  42     injectorModel,
  43     definedHollowConeInjector,
  44     dictionary
  45 );
  46
  47
  48 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  49
  50 // Construct from components
  51 definedHollowConeInjector::definedHollowConeInjector
  52 (
  53     const dictionary& dict,
  54     spray& sm
  55 )
  56 :
  57     injectorModel(dict, sm),
  58     definedHollowConeDict_(dict.subDict(typeName + "Coeffs")),
  59     dropletPDF_
  60     (
  61         pdf::New
  62         (
  63             definedHollowConeDict_.subDict("dropletPDF"),
  64             sm.rndGen()
  65         )
  66     ),
  67     innerConeAngle_(definedHollowConeDict_.lookup("innerConeAngle")),
  68     outerConeAngle_(definedHollowConeDict_.lookup("outerConeAngle"))
  69 {
  70
  71     // convert CA to real time - inner cone angle
  72     forAll(innerConeAngle_, i)
  73     {
  74         innerConeAngle_[i][0] = sm.runTime().userTimeToTime(innerConeAngle_[i][0]);
  75     }
  76     // convert CA to real time - outer cone angle
  77     forAll(outerConeAngle_, i)
  78     {
  79         outerConeAngle_[i][0] = sm.runTime().userTimeToTime(outerConeAngle_[i][0]);
  80     }
  81
  82     // check number of injectors
  83     if (sm.injectors().size() != 1)
  84     {
  85         Info << "Warning!!!\n"
  86              << "definedHollowConeInjector::definedHollowConeInjector"
  87              << "(const dictionary& dict, spray& sm)\n"
  88              << "Same inner/outer cone angle profiles applied to each injector"
  89              << endl;
  90     }
  91
  92     // check number of entries in innerConeAngle list
  93     if (innerConeAngle_.empty())
  94     {
  95         FatalError << "definedHollowConeInjector::definedHollowConeInjector"
  96              << "(const dictionary& dict, spray& sm)\n"
  97              << "Number of entries in innerConeAngle must be greater than zero"
  98              << abort(FatalError);
  99     }
 100
 101     // check number of entries in outerConeAngle list
 102     if (outerConeAngle_.empty())
 103     {
 104         FatalError << "definedHollowConeInjector::definedHollowConeInjector"
 105              << "(const dictionary& dict, spray& sm)\n"
 106              << "Number of entries in outerConeAngle must be greater than zero"
 107              << abort(FatalError);
 108     }
 109
 110     scalar referencePressure = sm.p().average().value();
 111     // correct pressureProfile
 112     forAll(sm.injectors(), i)
 113     {
 114         sm.injectors()[i].properties()->correctProfiles(sm.fuels(), referencePressure);
 115     }
 116
 117 }
 118
 119
 120 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 121
 122 definedHollowConeInjector::~definedHollowConeInjector()
 123 {}
 124
 125
 126 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 127
 128 scalar definedHollowConeInjector::d0
 129 (
 130     const label n,
 131     const scalar t
 132 ) const
 133 {
 134     // swallow function arguments - not used
 135     // return value sampled from PDF
 136     return dropletPDF_->sample();
 137 }
 138
 139
 140 vector definedHollowConeInjector::direction
 141 (
 142     const label n,
 143     const label hole,
 144     const scalar t,
 145     const scalar d
 146 ) const
 147 {
 148
 149     const injectorType& it = injectors_[n].properties();
 150
 151     // interpolate to find inner and outer angles at time, t
 152     scalar angleInner = it.getTableValue(innerConeAngle_, t);
 153     scalar angleOuter = it.getTableValue(outerConeAngle_, t);
 154
 155     // use random number to generate angle between inner/outer cone angles
 156     scalar angle = angleInner + rndGen_.scalar01()*(angleOuter-angleInner);
 157
 158     scalar alpha = sin(angle*mathematicalConstant::pi/360.0);
 159     scalar dcorr = cos(angle*mathematicalConstant::pi/360.0);
 160     scalar beta = 2.0*mathematicalConstant::pi*rndGen_.scalar01();
 161
 162     // randomly distributed vector normal to the injection vector
 163     vector normal = vector::zero;
 164
 165     if (sm_.twoD())
 166     {
 167         scalar reduce = 0.01;
 168         // correct beta if this is a 2D run
 169         // map it onto the 'angleOfWedge'
 170
 171         beta *= (1.0-2.0*reduce)*sm_.angleOfWedge()/(2.0*mathematicalConstant::pi);
 172         beta += reduce*sm_.angleOfWedge();
 173         normal = alpha*
 174         (
 175             sm_.axisOfWedge()*cos(beta) +
 176             sm_.axisOfWedgeNormal()*sin(beta)
 177         );
 178     }
 179     else
 180     {
 181         normal = alpha*
 182         (
 183             injectors_[n].properties()->tan1(hole)*cos(beta) +
 184             injectors_[n].properties()->tan2(hole)*sin(beta)
 185         );
 186     }
 187
 188     // set the direction of injection by adding the normal vector
 189     vector dir = dcorr*injectors_[n].properties()->direction(hole, t) + normal;
 190     // normailse direction vector
 191     dir /= mag(dir);
 192
 193     return dir;
 194
 195 }
 196
 197 scalar definedHollowConeInjector::velocity
 198 (
 199     const label i,
 200     const scalar time
 201 ) const
 202 {
 203     const injectorType& it = sm_.injectors()[i].properties();
 204     if (it.pressureIndependentVelocity())
 205     {
 206         return it.getTableValue(it.velocityProfile(), time);
 207     }
 208     else
 209     {
 210         scalar Pref = sm_.ambientPressure();
 211         scalar Pinj = it.getTableValue(it.injectionPressureProfile(), time);
 212         scalar rho = sm_.fuels().rho(Pinj, it.T(time), it.X());
 213         scalar dp = max(0.0, Pinj - Pref);
 214         return sqrt(2.0*dp/rho);
 215     }
 216 }
 217
 218 scalar definedHollowConeInjector::averageVelocity
 219 (
 220     const label i
 221 ) const
 222 {
 223     const injectorType& it = sm_.injectors()[i].properties();
 224     scalar dt = it.teoi() - it.tsoi();
 225     return it.integrateTable(it.velocityProfile())/dt;
 226 }
 227
 228 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 229
 230 } // End namespace Foam
 231
 232 // ************************************************************************* //