src/lagrangian/dieselSpray/injector/unitInjector/unitInjector.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "unitInjector.H"
  27 #include "addToRunTimeSelectionTable.H"
  28 #include "Random.H"
  29 #include "mathematicalConstants.H"
  30
  31 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35     defineTypeNameAndDebug(unitInjector, 0);
  36
  37     addToRunTimeSelectionTable
  38     (
  39         injectorType,
  40         unitInjector,
  41         dictionary
  42     );
  43 }
  44
  45
  46 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  47
  48 // Construct from components
  49 Foam::unitInjector::unitInjector
  50 (
  51     const Foam::Time& t,
  52     const Foam::dictionary& dict
  53 )
  54 :
  55     injectorType(t, dict),
  56     propsDict_(dict.subDict(typeName + "Props")),
  57     position_(propsDict_.lookup("position")),
  58     direction_(propsDict_.lookup("direction")),
  59     d_(readScalar(propsDict_.lookup("diameter"))),
  60     Cd_(readScalar(propsDict_.lookup("Cd"))),
  61     mass_(readScalar(propsDict_.lookup("mass"))),
  62     nParcels_(readLabel(propsDict_.lookup("nParcels"))),
  63     X_(propsDict_.lookup("X")),
  64     massFlowRateProfile_(propsDict_.lookup("massFlowRateProfile")),
  65     velocityProfile_(massFlowRateProfile_),
  66     injectionPressureProfile_(massFlowRateProfile_),
  67     CdProfile_(massFlowRateProfile_),
  68     TProfile_(propsDict_.lookup("temperatureProfile")),
  69     averageParcelMass_(mass_/nParcels_),
  70     pressureIndependentVelocity_(true)
  71 {
  72
  73     // check if time entries for soi and eoi match
  74     if (mag(massFlowRateProfile_[0][0]-TProfile_[0][0]) > SMALL)
  75     {
  76         FatalErrorIn
  77         (
  78             "unitInjector::unitInjector(const time& t, const dictionary dict)"
  79         )<< "start-times do not match for TemperatureProfile and "
  80          << " massFlowRateProfile." << nl << exit (FatalError);
  81     }
  82
  83     if
  84     (
  85         mag(massFlowRateProfile_[massFlowRateProfile_.size()-1][0]
  86       - TProfile_[TProfile_.size()-1][0])
  87       > SMALL
  88     )
  89     {
  90         FatalErrorIn
  91         (
  92             "unitInjector::unitInjector(const time& t, const dictionary dict)"
  93         )<< "end-times do not match for TemperatureProfile and "
  94          << "massFlowRateProfile." << nl << exit(FatalError);
  95     }
  96
  97     // convert CA to real time
  98     forAll (massFlowRateProfile_, i)
  99     {
 100         massFlowRateProfile_[i][0] =
 101             t.userTimeToTime(massFlowRateProfile_[i][0]);
 102         velocityProfile_[i][0] = massFlowRateProfile_[i][0];
 103         injectionPressureProfile_[i][0] = massFlowRateProfile_[i][0];
 104     }
 105
 106     forAll (TProfile_, i)
 107     {
 108         TProfile_[i][0] = t.userTimeToTime(TProfile_[i][0]);
 109     }
 110
 111     scalar integratedMFR = integrateTable(massFlowRateProfile_);
 112
 113     forAll (massFlowRateProfile_, i)
 114     {
 115         // correct the massFlowRateProfile to match the injected mass
 116         massFlowRateProfile_[i][1] *= mass_/integratedMFR;
 117
 118         CdProfile_[i][0] = massFlowRateProfile_[i][0];
 119         CdProfile_[i][1] = Cd_;
 120     }
 121
 122     // Normalize the direction vector
 123     direction_ /= mag(direction_);
 124
 125     setTangentialVectors();
 126
 127     // Check molar fractions
 128     scalar Xsum = 0.0;
 129     forAll (X_, i)
 130     {
 131         Xsum += X_[i];
 132     }
 133
 134     if (mag(Xsum - 1.0) > SMALL)
 135     {
 136         WarningIn("unitInjector::unitInjector(const time& t, Istream& is)")
 137             << "X does not sum to 1.0, correcting molar fractions."
 138             << nl << endl;
 139         forAll (X_, i)
 140         {
 141             X_[i] /= Xsum;
 142         }
 143     }
 144
 145 }
 146
 147 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 148
 149 Foam::unitInjector::~unitInjector()
 150 {}
 151
 152
 153 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 154
 155 void Foam::unitInjector::setTangentialVectors()
 156 {
 157     Random rndGen(label(0));
 158     scalar magV = 0.0;
 159     vector tangent;
 160
 161     while (magV < SMALL)
 162     {
 163         vector testThis = rndGen.vector01();
 164
 165         tangent = testThis - (testThis & direction_)*direction_;
 166         magV = mag(tangent);
 167     }
 168
 169     tangentialInjectionVector1_ = tangent/magV;
 170     tangentialInjectionVector2_ = direction_ ^ tangentialInjectionVector1_;
 171
 172 }
 173
 174
 175 Foam::label Foam::unitInjector::nParcelsToInject
 176 (
 177     const scalar time0,
 178     const scalar time1
 179 ) const
 180 {
 181     scalar mInj = mass_*
 182     (
 183         fractionOfInjection(time1)
 184       - fractionOfInjection(time0)
 185     );
 186
 187     label nParcels = label(mInj/averageParcelMass_ + 0.49);
 188
 189     return nParcels;
 190 }
 191
 192
 193 const Foam::vector Foam::unitInjector::position(const label n) const
 194 {
 195     return position_;
 196 }
 197
 198
 199 Foam::vector Foam::unitInjector::position
 200 (
 201     const label n,
 202     const scalar time,
 203     const bool twoD,
 204     const scalar angleOfWedge,
 205     const vector& axisOfSymmetry,
 206     const vector& axisOfWedge,
 207     const vector& axisOfWedgeNormal,
 208     Random& rndGen
 209 ) const
 210 {
 211     if (twoD)
 212     {
 213         scalar is = position_ & axisOfSymmetry;
 214         scalar magInj = mag(position_ - is*axisOfSymmetry);
 215
 216         vector halfWedge =
 217             axisOfWedge*cos(0.5*angleOfWedge)
 218           + axisOfWedgeNormal*sin(0.5*angleOfWedge);
 219         halfWedge /= mag(halfWedge);
 220
 221         return (is*axisOfSymmetry + magInj*halfWedge);
 222     }
 223     else
 224     {
 225         // otherwise, disc injection
 226         scalar iRadius = d_*rndGen.scalar01();
 227         scalar iAngle = 2.0*mathematicalConstant::pi*rndGen.scalar01();
 228
 229         return
 230         (
 231             position_
 232           + iRadius
 233           * (
 234               tangentialInjectionVector1_*cos(iAngle)
 235             + tangentialInjectionVector2_*sin(iAngle)
 236           )
 237         );
 238
 239     }
 240
 241     return position_;
 242 }
 243
 244
 245 Foam::label Foam::unitInjector::nHoles() const
 246 {
 247     return 1;
 248 }
 249
 250
 251 Foam::scalar Foam::unitInjector::d() const
 252 {
 253     return d_;
 254 }
 255
 256
 257 const Foam::vector& Foam::unitInjector::direction
 258 (
 259     const label i,
 260     const scalar time
 261 ) const
 262 {
 263     return direction_;
 264 }
 265
 266
 267 Foam::scalar Foam::unitInjector::mass
 268 (
 269     const scalar time0,
 270     const scalar time1,
 271     const bool twoD,
 272     const scalar angleOfWedge
 273 ) const
 274 {
 275     scalar mInj = mass_*(fractionOfInjection(time1)-fractionOfInjection(time0));
 276
 277     // correct mass if calculation is 2D
 278     if (twoD)
 279     {
 280         mInj *= 0.5*angleOfWedge/mathematicalConstant::pi;
 281     }
 282
 283     return mInj;
 284 }
 285
 286
 287 Foam::scalar Foam::unitInjector::mass() const
 288 {
 289     return mass_;
 290 }
 291
 292
 293 const Foam::scalarField& Foam::unitInjector::X() const
 294 {
 295     return X_;
 296 }
 297
 298
 299 Foam::List<Foam::unitInjector::pair> Foam::unitInjector::T() const
 300 {
 301     return TProfile_;
 302 }
 303
 304
 305 Foam::scalar Foam::unitInjector::T(const scalar time) const
 306 {
 307     return getTableValue(TProfile_, time);
 308 }
 309
 310
 311 Foam::scalar Foam::unitInjector::tsoi() const
 312 {
 313     return massFlowRateProfile_[0][0];
 314 }
 315
 316
 317 Foam::scalar Foam::unitInjector::teoi() const
 318 {
 319     return massFlowRateProfile_[massFlowRateProfile_.size()-1][0];
 320 }
 321
 322
 323 Foam::scalar Foam::unitInjector::massFlowRate(const scalar time) const
 324 {
 325     return getTableValue(massFlowRateProfile_, time);
 326 }
 327
 328
 329 Foam::scalar Foam::unitInjector::injectionPressure(const scalar time) const
 330 {
 331     return getTableValue(injectionPressureProfile_, time);
 332 }
 333
 334
 335 Foam::scalar Foam::unitInjector::velocity(const scalar time) const
 336 {
 337     return getTableValue(velocityProfile_, time);
 338 }
 339
 340
 341 Foam::List<Foam::unitInjector::pair> Foam::unitInjector::CdProfile() const
 342 {
 343     return CdProfile_;
 344 }
 345
 346
 347 Foam::scalar Foam::unitInjector::Cd(const scalar time) const
 348 {
 349     return Cd_;
 350 }
 351
 352
 353 Foam::scalar Foam::unitInjector::fractionOfInjection(const scalar time) const
 354 {
 355     return integrateTable(massFlowRateProfile_, time)/mass_;
 356 }
 357
 358
 359 Foam::scalar Foam::unitInjector::injectedMass(const scalar t) const
 360 {
 361     return mass_*fractionOfInjection(t);
 362 }
 363
 364
 365 void Foam::unitInjector::correctProfiles
 366 (
 367     const liquidMixture& fuel,
 368     const scalar referencePressure
 369 )
 370 {
 371     scalar A = 0.25*mathematicalConstant::pi*pow(d_, 2.0);
 372     scalar pDummy = 1.0e+5;
 373
 374     forAll (velocityProfile_, i)
 375     {
 376         scalar time = velocityProfile_[i][0];
 377         scalar rho = fuel.rho(pDummy, T(time), X_);
 378         scalar v = massFlowRateProfile_[i][1]/(Cd_*rho*A);
 379         velocityProfile_[i][1] = v;
 380         injectionPressureProfile_[i][1] = referencePressure + 0.5*rho*v*v;
 381     }
 382 }
 383
 384
 385 Foam::vector Foam::unitInjector::tan1(const label) const
 386 {
 387     return tangentialInjectionVector1_;
 388 }
 389
 390
 391 Foam::vector Foam::unitInjector::tan2(const label) const
 392 {
 393     return tangentialInjectionVector2_;
 394 }
 395
 396
 397 // ************************************************************************* //