src/lagrangian/dieselSpray/spray/sprayInject.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 "spray.H"
  28 #include "breakupModel.H"
  29 #include "collisionModel.H"
  30 #include "dispersionModel.H"
  31 #include "injectorModel.H"
  32
  33 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  34
  35 namespace Foam
  36 {
  37
  38 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  39
  40 void spray::inject()
  41 {
  42     scalar time = runTime_.value();
  43     scalar time0 = time0_;
  44
  45     // Inject the parcels for each injector sequentially
  46     forAll(injectors_, i)
  47     {
  48         autoPtr<injectorType>& it = injectors()[i].properties();
  49         if (!it->pressureIndependentVelocity())
  50         {
  51             scalar referencePressure = p().average().value();
  52             it->correctProfiles(fuels(), referencePressure);
  53         }
  54
  55         const label nHoles = it->nHoles();
  56
  57         // parcels have the same mass during a timestep
  58         scalar mass = it->mass(time0, time, twoD_, angleOfWedge_);
  59
  60         label Np = it->nParcelsToInject(time0, time);
  61
  62         if (mass > 0)
  63         {
  64             Np = max(1, Np);
  65             scalar mp = mass/Np/nHoles;
  66
  67             // constT is only larger than zero for the first
  68             // part of the injection
  69             scalar constT = max(0.0, it->tsoi() - time0);
  70
  71             // deltaT is the duration of injection during this timestep
  72             scalar deltaT = min
  73             (
  74                 runTime_.deltaT().value(),
  75                 min
  76                 (
  77                     time - it->tsoi(),
  78                     it->teoi() - time0
  79                 )
  80             );
  81
  82             for(label j=0; j<Np; j++)
  83             {
  84                 // calculate the time of injection for parcel 'j'
  85                 scalar toi = time0 + constT + deltaT*j/scalar(Np);
  86
  87                 for(label n=0; n<nHoles; n++)
  88                 {
  89
  90                     // calculate the velocity of the injected parcel
  91                     vector injectionPosition = it->position
  92                     (
  93                         n,
  94                         toi,
  95                         twoD_,
  96                         angleOfWedge_,
  97                         axisOfSymmetry_,
  98                         axisOfWedge_,
  99                         axisOfWedgeNormal_,
 100                         rndGen_
 101                     );
 102
 103                     scalar diameter = injection().d0(i, toi);
 104                     vector direction = injection().direction(i, n, toi, diameter);
 105                     vector U = injection().velocity(i, toi)*direction;
 106
 107                     scalar symComponent = direction & axisOfSymmetry_;
 108                     vector normal = direction - symComponent*axisOfSymmetry_;
 109                     normal /= mag(normal);
 110
 111                     // should be set from dict or model
 112                     scalar deviation = breakup().y0();
 113                     scalar ddev = breakup().yDot0();
 114
 115                     label injectorCell = mesh_.findCell(injectionPosition);
 116
 117 #                   include "findInjectorCell.H"
 118
 119                     if (injectorCell >= 0)
 120                     {
 121                         scalar liquidCore = 1.0;
 122
 123                         // construct the parcel that is to be injected
 124
 125                         parcel* pPtr = new parcel
 126                         (
 127                             *this,
 128                             injectionPosition,
 129                             injectorCell,
 130                             normal,
 131                             diameter,
 132                             it->T(toi),
 133                             mp,
 134                             deviation,
 135                             ddev,
 136                             0.0,
 137                             0.0,
 138                             0.0,
 139                             liquidCore,
 140                             scalar(i),
 141                             U,
 142                             vector::zero,
 143                             it->X(),
 144                             fuels_->components()
 145                         );
 146
 147                         injectedLiquidKE_ += 0.5*pPtr->m()*magSqr(U);
 148
 149                         scalar dt = time - toi;
 150
 151                         pPtr->stepFraction() =
 152                             (runTime_.deltaT().value() - dt)
 153                            /runTime_.deltaT().value();
 154
 155                         bool keepParcel = pPtr->move(*this);
 156
 157                         if (keepParcel)
 158                         {
 159                             addParticle(pPtr);
 160                         }
 161                         else
 162                         {
 163                             delete pPtr;
 164                         }
 165                     } // if (injectorCell....
 166                 } // for(label n=0...
 167             } // for(label j=0....
 168         } // if (mass>0)...
 169     } // forAll(injectors)...
 170
 171     time0_ = time;
 172 }
 173
 174
 175 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 176
 177 } // End namespace Foam
 178
 179 // ************************************************************************* //