#include <lptspray.h>

Collaboration diagram for SprayModel< nDim >:

Public Member Functions
	SprayModel ()

void	init (LPT< nDim > *_particle)
	Spray model initialisation. More...

void	injection (const MFloat dt)
	Perform a spray injection. More...

void	secondaryBreakUp (const MFloat dt)
	Atomization of particles. More...

MFloat	timeSinceSOI () const

MFloat &	timeSinceSOI ()

MFloat	injectionDuration () const

MFloat	injectionSpeed () const

MBool	soonInjection (const MFloat time)

std::mt19937_64 &	randomPrimBreakUp (const MInt calls)

Public Attributes
MFloat *	m_injData = nullptr

MBool	m_broadcastInjected = true

MInt	m_injStep = 0

MInt	m_injStopTimeStep = -1

MInt	m_injStartTimeStep = -1

MFloat	m_injectionCrankAngle = -1

MFloat	m_Strouhal = -99

MFloat	m_initialCad = 0

std::mt19937_64	m_PRNGPrimBreakUp

MInt	m_PRNGPrimBreakUpCount = 0

MLong	m_spraySeed {}

MInt	m_noRTsecBreakUp = 0

MInt	m_noKHsecBreakUp = 0

Static Public Attributes
static constexpr MInt	m_injDataSize = 11

Private Member Functions
MInt	domainId () const

MInt	solverId () const

MaterialState< nDim > &	material () const

MFloat	sphericalMass (const MFloat diameter, const MFloat temperature)

void	readSprayProperties ()

void	logDistributionFunction ()
	create log of distribution functions for plots and debugging More...

void	updateInjectionRate ()
	Update injection rate. More...

void	primaryBreakUp (const MFloat dt)
	Inject new particles from the injector exit. More...

void	injectParticles (const MInt spawnParticlesCount, const MFloat *spawnCoord, const MFloat particleDiameter, const MFloat particleDensityRatio, const MFloat particleVelocity, const MFloat sprayConeAngle, const MFloat coneDiameter, std::function< MFloat(MInt)> holePositionAngle, std::function< MFloat(MInt)> injectorDiameter, std::function< MFloat(MInt)> holeNozzleAngle, const MBool hull, const MInt parcelSize, const MInt noInjectionHoles)
	Create new random particles using the provided options. More...

void	injectParticles (const MInt spawnParticlesCount, const MFloat *spawnCoord, const MFloat particleDiameter, const MFloat particleDensityRatio, const MFloat particleVelocity, const MFloat sprayConeAngle, const MFloat coneDiameter, const MBool hull, const MFloat nozzleAngle, const MInt parcelSize, const MInt noInjectionHoles)

void	initPRNG (const MInt seed, const MInt discard)

std::mt19937_64 &	randomSecBreakUp ()

Private Attributes
MFloat	m_currentInjectionRate = 0.0

MFloatTensor	m_injectionRateList

MFloatTensor	m_injectionTimings

MFloat	m_primMinDropletSize = 5e-7

MFloat	m_injDuration = 0.00055

MFloat	m_injectorNozzleDiameter = 0.0

MFloat	m_injectionSpeed = -1.0

MFloat *	m_injectorDiameter = nullptr

MFloat *	m_injectorOrificeAngle = nullptr

MFloat *	m_orificePositionAngle = nullptr

MFloat	m_injectorOrficeSize {}

MFloat	m_RosinRammlerMin = -1

MFloat	m_RosinRammlerMean = -1

MFloat	m_RosinRammlerMax = -1

MFloat	m_RosinRammlerSpread = -1

MFloat *	m_needleLiftTime = nullptr

MFloat	m_injectorDir [nDim] {}

MFloat	m_injectionDistSigmaCoeff = 1.0

MInt	m_partEmittDist = 0

MFloat *	m_sprayAngle = nullptr

MFloat	m_sprayConeAngle = 0.0

MBool	m_primRosinRammler = true

MFloat	m_timeSinceSOI = 0.0

MFloat	m_B0 = 0.61

MFloat	m_B1 = 40

MFloat	m_CRT = 0.1

MFloat	m_CT = 1.0

MFloat	m_weberLimitKH = 6

MFloat	m_massLimit = 0.03

MFloat	m_weberLimitRT = 300

MBool	m_secBUDisplayMessage = false

MInt	m_maxRTChildParcels = 3

MFloat	m_Cbu = 20

MInt	m_RTDiameterMode = 0

MFloat	m_sprayAngleKH = 2

MBool	m_activePrimaryBUp = true

MBool	m_activeSecondaryBUp = false

MInt	m_primBrkUpParcelSize = 1

MBool	m_useNeedleLiftTime = false

MFloat	m_angularGap = -1

MInt	m_injectorType = 0

MBool	m_multiHoleInjector = false

MBool	m_singleHoleInjector = false

MBool	m_hollowConeInjector = false

MBool	m_predictivePRNG = true

MBool	m_RTsecBreakUp = true

MBool	m_KHsecBreakUp = true

MBool	m_RTsecBreakUpLength = true

MPI_Comm	m_primBUp

MInt	m_maxNoPrimParcels = 1

MInt	m_primParcelsPerInj = 1000000

std::mt19937_64	m_PRNGSecBU

Static Private Attributes
static LPT< nDim > *	s_backPtr = nullptr

static MFloat	s_lengthFactor {}

Detailed Description

template<MInt nDim>
class SprayModel< nDim >

Definition at line 21 of file lptspray.h.

Constructor & Destructor Documentation

◆ SprayModel()

template<MInt nDim>

SprayModel< nDim >::SprayModel ( )

inline

Definition at line 24 of file lptspray.h.

24{};

Member Function Documentation

◆ domainId()

template<MInt nDim>

MInt SprayModel< nDim >::domainId ( ) const

inlineprivate

Definition at line 69 of file lptspray.h.

69{ return s_backPtr->domainId(); }

SprayModel::s_backPtr

static LPT< nDim > * s_backPtr

Definition: lptspray.h:66

◆ init()

template<MInt nDim>

void SprayModel< nDim >::init ( LPT< nDim > * _particle )

Author: Sven Berger

Date: October 2015

Parameters

[in] spawnCellId Location at which particles are created.

Definition at line 29 of file lptspray.cpp.

                                                {
  m_log << "       Initialising spray model" << endl;
 
  s_backPtr = _particle;
  s_lengthFactor = s_backPtr->m_partList[0].s_lengthFactor;
 
  m_activePrimaryBUp = s_backPtr->m_activePrimaryBUp;
  m_activeSecondaryBUp = s_backPtr->m_activeSecondaryBUp;
 
  if(!s_backPtr->m_restart) {
    s_backPtr->m_particleResiduum = 0.0;
  }
 
  // allocate spray data
  mAlloc(m_needleLiftTime, 2, "needleLiftTime", AT_);
  mAlloc(m_sprayAngle, 2, "m_sprayAngle", F0, AT_);
  mAlloc(m_injData, m_injDataSize, "m_injData", AT_);
 
  readSprayProperties();
 
  logDistributionFunction();
}

◆ initPRNG()

template<MInt nDim>

void SprayModel< nDim >::initPRNG	(	const MInt	seed,
		const MInt	discard
	)

inlineprivate

Definition at line 220 of file lptspray.h.

                                                     {
    if(m_predictivePRNG) {
      m_PRNGSecBU.seed(seed);
      m_PRNGSecBU.discard(discard);
    }
  }

◆ injection()

template<MInt nDim>

void SprayModel< nDim >::injection ( const MFloat dt )

Author: Sven Berger

Date: November 2015

Definition at line 672 of file lptspray.cpp.

                                                {
  // injection has not started yet, this also means that zero particles should be present!
  if(m_injectionCrankAngle > maia::math::crankAngle(s_backPtr->m_time, m_Strouhal, m_initialCad, 0)) {
    ASSERT(s_backPtr->a_noParticles() == 0, "");
    if(domainId() == 0) {
      cerr << "Before injection" << m_injectionCrankAngle << " "
           << maia::math::crankAngle(s_backPtr->m_time, m_Strouhal, m_initialCad, 0) << endl;
    }
    for(MInt i = 0; i < m_injDataSize; i++) {
      m_injData[i] = 0;
    }
    return;
  }
 
  m_timeSinceSOI += dt;
 
 
  MBool endOfInjection = false;
  if(m_injStopTimeStep > -1 && globalTimeStep > m_injStopTimeStep) endOfInjection = true;
  if(m_timeSinceSOI > m_injDuration) endOfInjection = true;
  if(m_injStartTimeStep > -1 && globalTimeStep < m_injStartTimeStep) endOfInjection = true;
 
  // injection has already ended
  if(endOfInjection) {
    cerr0 << "After injection " << m_timeSinceSOI << " " << m_injDuration << endl;
 
    for(MInt i = 0; i < m_injDataSize; i++) {
      m_injData[i] = 0;
    }
    if(s_backPtr->m_spawnCellId > -1) {
      m_injData[0] = m_timeSinceSOI;
    }
    return;
  }
 
 
  // injection location is on another domain
  if(s_backPtr->m_spawnCellId < 0) {
    ASSERT(s_backPtr->noDomains() > 1, "");
 
    // receive injected particles instead
    if(m_broadcastInjected) {
      s_backPtr->recvInjected();
    }
    for(MInt i = 0; i < m_injDataSize; i++) {
      m_injData[i] = 0;
    }
 
  } else {
    // injection on this domain
    ASSERT(domainId() == s_backPtr->m_spawnDomainId, "");
 
    // update injection rate
    updateInjectionRate();
 
    // current number of particles
    const MInt prevNo = s_backPtr->a_noParticles();
 
    // inject new particles
    primaryBreakUp(dt);
 
    if(m_broadcastInjected) {
      s_backPtr->broadcastInjected(prevNo);
    }
  }
}

◆ injectionDuration()

template<MInt nDim>

MFloat SprayModel< nDim >::injectionDuration ( ) const

inline

Definition at line 35 of file lptspray.h.

35{ return m_injDuration; }

◆ injectionSpeed()

template<MInt nDim>

MFloat SprayModel< nDim >::injectionSpeed ( ) const

inline

Definition at line 36 of file lptspray.h.

36{ return m_injectionSpeed; }

SprayModel::m_injectionSpeed

MFloat m_injectionSpeed

Definition: lptspray.h:103

◆ injectParticles() [1/2]

template<MInt nDim>

void SprayModel< nDim >::injectParticles	(	const MInt	spawnParticlesCount,
		const MFloat *	spawnCoord,
		const MFloat	particleDiameter,
		const MFloat	particleDensityRatio,
		const MFloat	particleVelocity,
		const MFloat	sprayConeAngle,
		const MFloat	coneDiameter,
		const MBool	hull,
		const MFloat	nozzleAngle,
		const MInt	parcelSize,
		const MInt	noInjectionHoles
	)

inlineprivate

Definition at line 203 of file lptspray.h.

                                                    {
    std::function<MFloat(MInt)> dummyDefault = [&](MInt) { return -1.0; };
    std::function<MFloat(MInt)> holeNozzleAngle = [&](MInt) { return nozzleAngle; };
    ASSERT(noInjectionHoles == 1, "Incorrect function call!");
 
    injectParticles(spawnParticlesCount, spawnCoord, particleDiameter, particleDensityRatio, particleVelocity,
                    sprayConeAngle, coneDiameter, dummyDefault, dummyDefault, holeNozzleAngle, hull, parcelSize,
                    noInjectionHoles);
  }

◆ injectParticles() [2/2]

template<MInt nDim>

void SprayModel< nDim >::injectParticles	(	const MInt	spawnParticlesCount,
		const MFloat *	spawnCoord,
		const MFloat	particleDiameter,
		const MFloat	particleDensityRatio,
		const MFloat	particleVelocity,
		const MFloat	sprayConeAngle,
		const MFloat	coneDiameter,
		std::function< MFloat(MInt)>	holePositionAngle,
		std::function< MFloat(MInt)>	injectorDiameter,
		std::function< MFloat(MInt)>	holeNozzleAngle,
		const MBool	hull,
		const MInt	parcelSize,
		const MInt	noInjectionHoles
	)

private

Author: Sven Berger, Tim Wegmann

Date: November 2015

Parameters

[in]	spawnParticlesCount	Number of particles created in the given location.
[in]	spawnCoord	Coordinates of the location to spawn the particles in. (Note: Check if this is on the calling procs domain!!!)
[in]	particleDiameter	Size of the particles that get created.
[in]	particleDensityRatio	Density ratio of the newly created particles.
[in]	particleVelocity	initial velocity of the created particles.
[in]	sprayConeAngle	Angle of the cone in which particles are created
[in]	coneDiameter	intial diameter of the spray cone (0.0 for blob-injection)
[in]	hull	Only create particles on the hull of the cone
[in]	holeNozzleAngle	Opening angle of the nozzle
[in]	parcelSize	Parcel size that is used for the newly created particles
[in]	noInjectionHoles	Number of holes of the injector
[in]	injectorDiameter	Diameter of the injector.

Definition at line 1696 of file lptspray.cpp.

                                                                                           {
  std::array<MFloat, nDim> spawnParticlesInitVelo;
  array<MFloat, 3> injectionLocation{};
  array<MFloat, 3> holeLocation{};
 
  if(spawnParticlesCount > 0) {
    m_injStep++;
  }
 
  if(particleDiameter < s_backPtr->m_sizeLimit) {
    cerr << "Inj. small particle " << particleDiameter << " " << s_backPtr->m_sizeLimit << endl;
  }
 
  for(MInt i = 0; i < spawnParticlesCount; i++) {
    MInt randomShift = 1;
    if(m_partEmittDist != PART_EMITT_DIST_NONE) {
      randomShift = 0;
      m_PRNGPrimBreakUpCount +=
          randomVectorInCone(&spawnParticlesInitVelo[0], &m_injectorDir[0], particleVelocity, sprayConeAngle,
                             m_partEmittDist, randomPrimBreakUp(0), m_injectionDistSigmaCoeff, 0);
 
      if(coneDiameter > numeric_limits<MFloat>::epsilon() && !hull) {
        // determine a random point within the injector orfice
        randomPointInCircle(&holeLocation[0], &m_injectorDir[0], coneDiameter, randomPrimBreakUp(2));
 
        if(noInjectionHoles > 1) {
          // determine position of the hole
          pointOnCircle(&injectionLocation[0], &m_injectorDir[0], injectorDiameter(i), holePositionAngle(i));
        }
      } else if(hull) {
        m_PRNGPrimBreakUpCount +=
            randomVectorInCone(&spawnParticlesInitVelo[0], &m_injectorDir[0], particleVelocity, sprayConeAngle,
                               m_partEmittDist, randomPrimBreakUp(0), m_injectionDistSigmaCoeff, holeNozzleAngle(i));
 
        // determine a point just on the hull of the cone (like for a hollow-cone injector)
        // TODO labels:LPT make settable
        static constexpr MBool randomDist = false;
        if(randomDist) {
          randomPointOnCircle(&injectionLocation[0], &m_injectorDir[0], coneDiameter, randomPrimBreakUp(1),
                              spawnParticlesCount, i);
        } else {
          // generate one particle per 1 deg
          const static MFloat angleBetween = 360.0 / spawnParticlesCount;
          const MFloat phi = (i * angleBetween + ((m_injStep - 1) % static_cast<MInt>(angleBetween))) / 180.0 * M_PI;
          pointOnCircle(&injectionLocation[0], &m_injectorDir[0], coneDiameter, phi);
        }
      }
    }
 
    // rotate injection by the angle of the nozzle
    if(fabs(holeNozzleAngle(i)) > numeric_limits<MFloat>::epsilon()) {
      const MFloat holeAngleRad = -holeNozzleAngle(i) / 180 * M_PI;
      const MFloat absDist = maia::math::norm(injectionLocation);
 
      array<MFloat, nDim> crossP{};
      array<MFloat, nDim> revInjLoc{};
      for(MInt j = 0; j < nDim; j++) {
        revInjLoc[j] = -injectionLocation[j] / absDist;
      }
 
      maia::math::cross(&m_injectorDir[0], &revInjLoc[0], &crossP[0]);
 
      // boundary basis at the injection location
      MFloatScratchSpace injLocBasis(nDim, nDim, FUN_, "R");
      for(MInt j = 0; j < nDim; j++) {
        injLocBasis(j, 0) = m_injectorDir[j];
        injLocBasis(j, 1) = revInjLoc[j];
        injLocBasis(j, 2) = crossP[j];
      }
 
      // find inverse for reverse-tranformation
      MFloatScratchSpace inverse(nDim, nDim, AT_, "inverse");
      for(MInt j = 0; j < nDim; j++) {
        for(MInt k = 0; k < nDim; k++) {
          inverse(j, k) = injLocBasis(j, k);
        }
      }
 
      maia::math::invert(&inverse(0, 0), 3, 3);
      // NOTE: inverse might not be normalized correctly, meaning that the magnitude is not conserved!
 
      // rotation matrix around the z-axis in the injection location basis
      MFloatScratchSpace R(nDim, nDim, FUN_, "R");
      R.fill(0.0);
      R(2, 2) = 1.0;
      R(0, 0) = cos(holeAngleRad);
      R(1, 0) = sin(holeAngleRad);
      R(0, 1) = -sin(holeAngleRad);
      R(1, 1) = cos(holeAngleRad);
 
      // global coordinate transformation is then found be B*R*B^-1
      MFloatScratchSpace result1(nDim, nDim, FUN_, "result1");
      MFloatScratchSpace result(nDim, nDim, FUN_, "result");
      MFloatScratchSpace tempV(nDim, FUN_, "tempV");
      for(MInt j = 0; j < nDim; j++) {
        tempV[j] = spawnParticlesInitVelo[j];
      }
 
      maia::math::multiplyMatricesSq(injLocBasis, R, result1, nDim);
      maia::math::multiplyMatricesSq(result1, inverse, result, nDim);
      for(MInt j = 0; j < nDim; j++) {
        spawnParticlesInitVelo[j] = 0;
        for(MInt k = 0; k < nDim; k++) {
          spawnParticlesInitVelo[j] += result(j, k) * tempV[k];
        }
      }
 
      // reset vector length and direction
      maia::math::normalize(&spawnParticlesInitVelo[0], nDim);
      // reverse sign if velocity has opposite direction to the injector direction
      if(scalarProduct(&spawnParticlesInitVelo[0], &m_injectorDir[0], nDim) < 0.0) {
        for(MInt j = 0; j < nDim; j++) {
          spawnParticlesInitVelo[j] *= -1;
        }
      }
      for(MInt j = 0; j < nDim; j++) {
        spawnParticlesInitVelo[j] *= particleVelocity;
      }
    }
    // final injection position = hole position + orifice position + injector center
    for(MInt j = 0; j < nDim; j++) {
      injectionLocation[j] += spawnCoord[j] + holeLocation[j];
    }
 
    s_backPtr->addParticle(s_backPtr->m_spawnCellId, particleDiameter, particleDensityRatio, randomShift, 2,
                           &spawnParticlesInitVelo[0], &injectionLocation[0], parcelSize);
  }
}

◆ logDistributionFunction()

template<MInt nDim>

void SprayModel< nDim >::logDistributionFunction

private

Author: Tim Wegmann

Date: January 2023

Definition at line 1837 of file lptspray.cpp.

                                               {
  if(domainId() != 0) return;
 
  const MInt noDraws = 1000000;
  MFloat minValue = m_injectorNozzleDiameter / m_RosinRammlerMin;
  MFloat maxValue = m_injectorNozzleDiameter / m_RosinRammlerMax;
  MFloat meanValue = m_injectorNozzleDiameter / m_RosinRammlerMean;
 
  std::mt19937_64 randomNumberGenerator;
  randomNumberGenerator.seed(m_spraySeed);
 
  const MInt noBinns = 1000;
  MFloat binWidth = (maxValue - minValue) / noBinns;
  MIntScratchSpace binValue(noBinns, AT_, "binValue");
  binValue.fill(0);
 
  for(MInt i = 0; i < noDraws; i++) {
    const MFloat drawValue = rosinRammler(minValue, meanValue, maxValue, m_RosinRammlerSpread, randomNumberGenerator);
    const MInt binId = std::floor((drawValue - minValue) / binWidth);
    binValue[binId]++;
  }
 
  m_log << "IDSD Binning: " << endl;
  m_log << "Rosin-Rammler distribution: " << endl;
  m_log << "Min-value : " << minValue << endl;
  m_log << "Max-value : " << maxValue << endl;
  m_log << "Mean-value: " << meanValue << endl;
  m_log << "Spread    : " << m_RosinRammlerSpread << endl;
  m_log << "Number-draws: " << noDraws << endl;
 
  for(MInt i = 0; i < noBinns; i++) {
    m_log << minValue + i * binWidth << " " << binValue[i] << endl;
  }
 
  minValue = 0.0;
  maxValue = 5 * meanValue;
  binWidth = (maxValue - minValue) / noBinns;
 
  binValue.fill(0);
 
  for(MInt i = 0; i < noDraws; i++) {
    const MFloat drawValue = NTDistribution(meanValue, randomNumberGenerator);
    const MInt binId = std::floor((drawValue - minValue) / binWidth);
    binValue[binId]++;
  }
 
  m_log << "Nukiyama-Tanasawa distribution: " << endl;
  m_log << "Mean-value: " << meanValue << endl;
  for(MInt i = 0; i < noBinns; i++) {
    m_log << minValue + i * binWidth << " " << binValue[i] << endl;
  }
}

◆ material()

template<MInt nDim>

MaterialState< nDim > & SprayModel< nDim >::material ( ) const

inlineprivate

Definition at line 72 of file lptspray.h.

72{ return *s_backPtr->m_material; }

◆ primaryBreakUp()

template<MInt nDim>

void SprayModel< nDim >::primaryBreakUp ( const MFloat dt )

private

Author: Sven Berger

Date: November 2015

Definition at line 744 of file lptspray.cpp.

                                                     {
  TRACE();
 
  ASSERT(domainId() == s_backPtr->m_spawnDomainId, "");
  ASSERT(s_backPtr->m_spawnCellId > -1, "");
 
  // invalidate injection data:
  MInt noInjParticles = -1;
  MInt noInjDroplets = -1;
  MFloat injMass = NAN;
  MFloat injParticleDiameter = NAN;
  static MFloat lastD = -1;
 
  // 1) ramp-up and other general injection parameters:
 
  MFloat injectionProgress = m_timeSinceSOI / m_injDuration;
 
 
  // the rampFactor is used to control/ramp the massflowrate and velocity
  // during the injector opening and closing
  // which linearly increases/decreases to the full injection velocity massflowrate
  MFloat rampFactor = 1.0;
  if(injectionProgress < m_needleLiftTime[0]) {
    rampFactor = injectionProgress / m_needleLiftTime[0];
  } else if(injectionProgress > (1 - m_needleLiftTime[1])) {
    rampFactor = 1 - (injectionProgress - (1 - m_needleLiftTime[1])) / m_needleLiftTime[1];
  }
 
  // theoretically injected mass during this timestep
  // current injection rate + left over mass from previous timestep
  injMass = m_currentInjectionRate * rampFactor * dt + s_backPtr->m_particleResiduum;
 
  // considering ramp-factor for parcel count
  MInt noDroplets = mMax(1, (MInt)(m_primBrkUpParcelSize * rampFactor));
 
  // 2) injector dependant injection parameters
  //   and injection of new particles
  if(m_singleHoleInjector) { //(Spray A)
 
    if(m_primRosinRammler) {
      // droplet diameter distribution function
 
      const MFloat diameterMin = m_injectorNozzleDiameter / m_RosinRammlerMin;
      const MFloat diameterMean = m_injectorNozzleDiameter / m_RosinRammlerMean;
      const MFloat diameterMax = m_injectorNozzleDiameter / m_RosinRammlerMax;
 
      // mass of the smallest possible droplet
      const MFloat minMass = sphericalMass(diameterMin, material().T());
 
      noInjParticles = 0;
      noInjDroplets = 0;
 
      MFloat remainingMass = injMass;
      injMass = 0;
 
      while(remainingMass > minMass) {
        if(lastD > 0) {
          injParticleDiameter = lastD;
        } else {
          injParticleDiameter =
              rosinRammler(diameterMin, diameterMean, diameterMax, m_RosinRammlerSpread, randomPrimBreakUp(1));
        }
 
        const MFloat particleMass = noDroplets * sphericalMass(injParticleDiameter, material().T());
        const MFloat tempMass = remainingMass - particleMass;
 
        // limit mass to be positive
        if(tempMass < 0) {
          lastD = injParticleDiameter;
          s_backPtr->m_particleResiduum = remainingMass;
          break;
        }
 
        // the initial cone diameter needs to be reduced by half of the droplet diameter
        // since the droplet is supposed to be fully within the cone
        const MFloat coneDiameter = m_injectorOrficeSize - 0.5 * injParticleDiameter;
        lastD = -1;
        injectParticles(1, s_backPtr->m_spawnCoord, injParticleDiameter, material().densityRatio(),
                        m_injectionSpeed * rampFactor, m_sprayConeAngle, coneDiameter, false, 0.0, noDroplets, 1);
 
        noInjParticles++;
        noInjDroplets += noDroplets;
        injMass += particleMass;
        remainingMass -= particleMass;
      }
 
    } else {
      // blob-injection with all particles at the injector center
 
      injParticleDiameter = m_injectorNozzleDiameter;
      noInjDroplets = 1;
 
      const MFloat initParticleMass = sphericalMass(injParticleDiameter, material().T());
 
 
      MFloat noNewParticles = (m_currentInjectionRate * dt) / initParticleMass + s_backPtr->m_particleResiduum;
      noInjParticles = floor(noNewParticles);
 
      s_backPtr->m_particleResiduum = noNewParticles - noInjParticles;
 
      injectParticles(noInjParticles, s_backPtr->m_spawnCoord, injParticleDiameter, material().densityRatio(),
                      m_injectionSpeed, m_sprayConeAngle, 0.0, false, 0.0, 1, 1);
    }
  } else if(m_hollowConeInjector) {
    // hollow cone injector, such as the TMFB Injector
    // This implementation of the hollow cone injector model of:
    // Spray Modeling for Outwardly-Opening Hollow-Cone Injectors, Sim, Badra et al., SAE, 2016
 
    // maximum number of parcels to be generated during this time step
    const MInt parcelTargetNo = m_primParcelsPerInj / m_injDuration * dt;
 
    // limit the number of parcels to be injected to maxNoPrimParcels
    noInjParticles = std::min(parcelTargetNo, m_maxNoPrimParcels);
 
    // injection velocity is scaled by this factor
    const MFloat scaledInjectionV = rampFactor * m_injectionSpeed;
 
    // thickness of the fluid flow within the angular gap
    MFloat initialLiquidSheetThickness = NAN;
 
    if(m_angularGap > -1) {
      initialLiquidSheetThickness = max(m_angularGap * rampFactor, m_primMinDropletSize);
    } else {
      initialLiquidSheetThickness =
          max(0.5 * m_injectorNozzleDiameter
                  - sqrt(M_PI * POW2(m_injectorNozzleDiameter) * material().density() * scaledInjectionV
                         - 4.0 * m_currentInjectionRate * rampFactor)
                        / (2.0 * sqrt(M_PI) * sqrt(material().density() * scaledInjectionV)),
              m_primMinDropletSize);
    }
 
    // initial particle size when considered as string like coneshaped
    // starting from the injector angular gap
    injParticleDiameter = 4.0 / M_PI * initialLiquidSheetThickness;
    if(m_primRosinRammler) {
      const MFloat diameterMin = injParticleDiameter / m_RosinRammlerMin;
      const MFloat diameterMean = injParticleDiameter / m_RosinRammlerMean;
      const MFloat diameterMax = injParticleDiameter / m_RosinRammlerMax;
      injParticleDiameter =
          rosinRammler(diameterMin, diameterMean, diameterMax, m_RosinRammlerSpread, randomPrimBreakUp(1));
    }
 
    // mass of a particle to be added
    const MFloat initialDropletMass = sphericalMass(injParticleDiameter, material().T());
 
    const MFloat newDroplets = injMass / initialDropletMass;
 
    noInjDroplets = floor(newDroplets / noInjParticles);
 
    if(noInjDroplets > 0) {
      const MFloat injectorGapDiameter = m_injectorNozzleDiameter - 0.5 * injParticleDiameter;
      s_backPtr->m_particleResiduum = (newDroplets - noInjParticles * noInjDroplets) * initialDropletMass;
 
      injectParticles(noInjParticles, s_backPtr->m_spawnCoord, injParticleDiameter, material().densityRatio(),
                      scaledInjectionV, m_sprayConeAngle, injectorGapDiameter * s_lengthFactor, true, m_angularGap,
                      noInjDroplets, 1.0);
 
      injMass = noInjParticles * noInjDroplets * initialDropletMass;
 
    } else {
      injMass = 0;
      noInjParticles = 0;
    }
 
  } else if(m_multiHoleInjector) {
    // injectors with multiple injection holes
    // MULTIHOLE     : ECN Spray-G
    // MULTIHOLE_Opt : optimized 7-hole Spray-G
    // MULTIHOLE_TME : 5-hole Injection of the TME
 
    MInt noHoles = -1;
    switch(m_injectorType) {
      case MULTIHOLE: {
        noHoles = 8;
        break;
      }
      case MULTIHOLE_OPT: {
        noHoles = 7;
        break;
      }
      case MULTIHOLE_TME: {
        noHoles = 5;
        break;
      }
      default:
        mTerm(1, AT_, "Unknown multi-hole injector-type!");
    }
 
    static constexpr MFloat C_a = 0.65;
    // NOTE: Wehrfritz et. al. propose to use the nominal injector nozzle diameter!
    //      otherwise the area-coefficient of ~0.65 can be used
 
    const MFloat initialConeAngle = m_sprayConeAngle;
    // as in:
    //"Validation of a comprehensive computational fluid dynamics methodology to predict the direct
    // injection process of gasoline sprays using Spray G experimental data"
    // Davide Paredi , Tommaso Lucchini , Gianluca D’Errico, Angelo Onorati,
    // Lyle Pickett and Joshua Lacey
    // International J of Engine Research 2020, Vol. 21(1) 199–216
 
    ASSERT(m_primRosinRammler, "");
 
    const MFloat effectiveDiam = sqrt(C_a) * m_injectorNozzleDiameter;
    const MFloat diameterMin = effectiveDiam / m_RosinRammlerMin;
    const MFloat diameterMean = effectiveDiam / m_RosinRammlerMean;
    const MFloat diameterMax = effectiveDiam / m_RosinRammlerMax;
 
    MFloat remainingMass = injMass;
    const MFloat minMass = sphericalMass(diameterMin, material().T());
 
    injMass = 0;
    noInjParticles = 0;
    noInjDroplets = 0;
 
    std::function<MFloat(MInt)> holePosition = [&](MInt id) {
      const MFloat angleDelta = 2 * M_PI / 8;
      switch(m_injectorType) {
        case MULTIHOLE: {
          return (id * angleDelta);
        }
        case MULTIHOLE_OPT: {
          // 0: x=0,  z=-1
          // 2: x=-1, z=0
          // 4: x=0,  z=1
          // 6: x=1,  z=0
          if(id > 1) {
            id = id + 1;
          }
          return id * angleDelta;
        }
        case MULTIHOLE_TME: {
          return m_orificePositionAngle[id] / 180 * M_PI;
        }
        default:
          mTerm(1, AT_, "Unknown multi-hole injector-type!");
      }
    };
 
    std::function<MFloat(MInt)> injectorDiameter = [&](MInt id) {
      switch(m_injectorType) {
        case MULTIHOLE:
        case MULTIHOLE_OPT: {
          return m_injectorDiameter[0];
        }
        case MULTIHOLE_TME: {
          return m_injectorDiameter[id + 1];
        }
        default:
          mTerm(1, AT_, "Unknown multi-hole injector-type!");
      }
    };
 
    // return angle [degree] of the hole orientation
    std::function<MFloat(MInt)> holeAngle = [&](MInt id) {
      switch(m_injectorType) {
        case MULTIHOLE:
        case MULTIHOLE_OPT: {
          return 37.0;
        }
        case MULTIHOLE_TME: {
          return m_injectorOrificeAngle[id];
        }
        default:
          mTerm(1, AT_, "Unknown multi-hole injector-type!");
      }
    };
 
    while(remainingMass > minMass) {
      if(lastD > 0) {
        injParticleDiameter = lastD;
      } else {
        injParticleDiameter =
            rosinRammler(diameterMin, diameterMean, diameterMax, m_RosinRammlerSpread, randomPrimBreakUp(1));
      }
 
      const MFloat particleMass = noHoles * noDroplets * sphericalMass(injParticleDiameter, material().T());
 
      const MFloat tempMass = remainingMass - particleMass;
 
      if(tempMass < 0) {
        lastD = injParticleDiameter;
        s_backPtr->m_particleResiduum = remainingMass;
        break;
      }
 
      lastD = -1;
      injectParticles(noHoles, s_backPtr->m_spawnCoord, injParticleDiameter, material().densityRatio(),
                      m_injectionSpeed, initialConeAngle, m_injectorOrficeSize, holePosition, injectorDiameter,
                      holeAngle, false, noDroplets, noHoles);
 
      injMass += particleMass;
      noInjParticles += noHoles;
      noInjDroplets += noHoles * noDroplets;
      remainingMass -= particleMass;
    }
  }
 
  // 3) store injection data for possible post-processing:
  m_injData[0] = m_timeSinceSOI;
  m_injData[1] = injectionProgress;
  m_injData[2] = rampFactor;
  m_injData[3] = noInjParticles;
  m_injData[4] = noInjDroplets;
  m_injData[5] = injParticleDiameter;
  m_injData[6] = injMass;
 
  array<MFloat, 3> injMomentum = {};
  for(MInt i = 0; i < 3; i++) {
    injMomentum[i] = 0;
  }
  MFloat injEnergy = 0;
  for(MInt i = 0; i < noInjParticles; i++) {
    const MInt id = s_backPtr->a_noParticles() - 1 - i;
    const MFloat mass = sphericalMass(s_backPtr->m_partList[id].m_diameter, s_backPtr->m_partList[id].m_temperature)
                        * s_backPtr->m_partList[id].m_noParticles;
    MFloat velMagSquared = 0;
    for(MInt j = 0; j < nDim; j++) {
      injMomentum[j] += mass * s_backPtr->m_partList[id].m_velocity[j];
      velMagSquared += POW2(s_backPtr->m_partList[id].m_velocity[j]);
    }
    injEnergy += mass * s_backPtr->m_material->cp(s_backPtr->m_partList[id].m_temperature)
                 * s_backPtr->m_partList[id].m_temperature * 1 / s_backPtr->m_material->gammaMinusOne();
    injEnergy += 0.5 * mass * velMagSquared;
  }
  m_injData[7] = injMomentum[0];
  m_injData[8] = injMomentum[1];
  m_injData[9] = injMomentum[2];
  m_injData[10] = injEnergy;
 
  cerr << globalTimeStep << " " << m_timeSinceSOI << " injMass " << injMass << " injParticles " << noInjParticles
       << endl;
}

◆ randomPrimBreakUp()

template<MInt nDim>

std::mt19937_64 & SprayModel< nDim >::randomPrimBreakUp ( const MInt calls )

inline

Definition at line 234 of file lptspray.h.

                                                            {
    ASSERT(domainId() == s_backPtr->m_spawnDomainId, "");
    m_PRNGPrimBreakUpCount += calls;
    return m_PRNGPrimBreakUp;
  }

◆ randomSecBreakUp()

template<MInt nDim>

std::mt19937_64 & SprayModel< nDim >::randomSecBreakUp ( )

inlineprivate

Definition at line 227 of file lptspray.h.

227{ return m_PRNGSecBU; }

◆ readSprayProperties()

template<MInt nDim>

void SprayModel< nDim >::readSprayProperties ( )

private

◆ secondaryBreakUp()

template<MInt nDim>

void SprayModel< nDim >::secondaryBreakUp ( const MFloat dt )

Author: Sven Berger

Date: November 2015

Definition at line 1081 of file lptspray.cpp.

                                                       {
  TRACE();
 
  m_noRTsecBreakUp = 0;
  m_noKHsecBreakUp = 0;
 
  if(!m_RTsecBreakUp && !m_KHsecBreakUp) return;
 
  // use const to avoid breakup of particles which have just been created
  const MInt noPart = s_backPtr->a_noParticles();
 
  // increase size of particle vector if necessary before joining next loop
  if(0.5 * s_backPtr->m_partList.capacity() < s_backPtr->a_noParticles()) {
    s_backPtr->m_partList.reserve(10 * s_backPtr->m_partList.capacity());
  }
 
  // 0) Compute break-up length:
  // (usually used when no initial droplet size distribution (IDS) is available and
  // the blob method is used
  // Break-up length can be calculated by Levich theory according to Levich, 1962
 
  const MFloat breakupLength =
      m_RTsecBreakUpLength ? m_Cbu * m_injectorNozzleDiameter * sqrt(material().ambientDensityRatio()) : 0;
 
  // if(droplet.m_breakUpTime > 0.43839) {
  // reset for particles which have been affected significantly by tumble motion!
  //  breakupLength = 0.0;
  //}
 
 
  ASSERT(m_injectorNozzleDiameter > 0, "ERROR: No valid nozzle diameter set.");
  ASSERT(breakupLength > -MFloatEps, "ERROR: Invalid breakup length.");
 
  // 1) Loop over all particles and check for break-up
  for(MInt i = 0; i < noPart; i++) {
    auto& droplet = s_backPtr->m_partList.at(i);
 
    if(droplet.firstStep()) continue;
    if(droplet.isInvalid()) continue;
    if(droplet.fullyEvaporated()) continue;
    ASSERT(!isnan(droplet.m_diameter), "Invalid diameter! ");
    if(droplet.m_diameter < s_backPtr->m_sizeLimit) continue;
    if(droplet.hadWallColl()) continue;
 
    ASSERT(droplet.m_cellId > 0, "ERROR: Invalid cellId");
 
    // increase breakup time
    droplet.m_breakUpTime += dt;
 
    ASSERT(!isnan(droplet.m_shedDiam) && droplet.m_shedDiam > -MFloatEps, "");
 
    // 2) Computations for Kelvin-Helmholtz Break up Model mainly based on:
    //   "Modeling Spray Atomization with the Kelvin-Helmholtz/Rayleigh-Taylor Hibrid Model"
    //    by Beale and Reitz, Atomization and Sprays (1999)
    // NOTE: in this case the radius and not the diameter is used as reference length!
 
    MFloat liquidLength = MFloatMax;
    if(m_RTsecBreakUpLength) {
      liquidLength = maia::math::distance(s_backPtr->m_spawnCoord, droplet.m_position);
      /*
      if(m_injectorType == MULTIHOLE) {
        const MFloat dist1 = maia::math::distance(s_backPtr->m_spawnCoord, droplet.m_position);
        const MFloat diff = POW2(dist1) - POW2(m_injectorDiameter);
        if(diff > 0) {
          liquidLength = sqrt(diff);
        } else {
          liquidLength = 0;
        }
      }
      */
    }
 
    const MFloat dropRadius = 0.5 * droplet.m_diameter;
    const MFloat relV = droplet.magRelVel(&droplet.m_fluidVel[0], &droplet.m_velocity[0]);
 
    //#ifdef LPT_DEBUG
    if(isnan(relV)) {
      cerr << droplet.m_fluidVel[0] << " " << droplet.m_fluidVel[1] << " " << droplet.m_fluidVel[nDim - 1] << endl;
      mTerm(1, AT_, "");
    }
    //#endif
 
    // radius based particle Weber-number
    const MFloat We_l =
        droplet.WeberNumber(s_backPtr->m_material->density(droplet.m_temperature), pow(relV, 2), droplet.m_temperature)
        * droplet.s_We;
 
    // if the weber number is to small the further calculated values are nan or inf
    if(We_l < m_weberLimitKH) continue;
 
    // particle Reynolds number
    // factor 0.5 to convert from diameter to radius based
    const MFloat Re_l = 0.5
                        * droplet.particleRe(material().density(droplet.m_temperature), relV,
                                             material().dynamicViscosity(droplet.m_temperature))
                        * droplet.s_Re;
 
    // gas Weber number
    const MFloat We_g = droplet.WeberNumber(droplet.m_fluidDensity, pow(relV, 2), droplet.m_temperature) * droplet.s_We;
    // Ohnesorge number
    const MFloat Z = sqrt(We_l) / Re_l;
    // Taylor number
    const MFloat T = Z * sqrt(We_g);
 
    // Lamda_KH
    const MFloat KH_waveL = 9.02 * dropRadius * (1.0 + 0.45 * sqrt(Z)) * (1.0 + 0.4 * pow(T, 0.7))
                            / pow(1.0 + 0.865 * pow(We_g, 1.67), 0.6);
 
 
    // Kelvin-Helmholtz reference diameter (thus factor 2.0)
    const MFloat KH_diameter = 2.0 * m_B0 * KH_waveL;
 
    // ASSERT(KH_diameter > MFloatEps,
    //       to_string(KH_diameter) + " surfWL " + to_string(KH_waveL));
    if(KH_diameter < 2 * MFloatEps) {
      cerr << KH_diameter << " d_KH " << dropRadius << " " << Z << " " << T << " " << We_g << " " << We_l << endl;
    }
 
    // Omega_KH
    const MFloat KH_growthR = ((0.34 + 0.38 * pow(We_g, 1.5)) / ((1.0 + Z) * (1.0 + 1.4 * pow(T, 0.6))))
                              * sqrt(material().spraySurfaceTension(droplet.m_temperature)
                                     / (material().density(droplet.m_temperature) * pow(dropRadius, 3)))
                              * sqrt(1 / droplet.s_We);
 
 
    // tau_kH
    const MFloat KH_time = 3.726 * m_B1 * dropRadius / (KH_waveL * KH_growthR);
 
    // const MFloat KH_speed = (droplet.m_diameter - KH_diameter) / KH_time;
 
    // 3) prepare initialisation of new droplets
    // parent velocity magnitude
    const MFloat magVel = droplet.magVel();
    array<MFloat, nDim> parentTrajectory{};
    // get parent droplet direction
    for(MInt v = 0; v < nDim; v++) {
      parentTrajectory.at(v) = droplet.m_velocity.at(v) / magVel;
    }
 
    // in case parent parcel is not moving
    if(magVel < MFloatEps) {
      // TODO labels:LPT,totest check if this exception is necessary!
      continue;
      /*
      // get direction from flow direction
      MFloat fluidVel = 0;
      for(MInt j = 0; j < nDim; j++) {
        fluidVel += POW2(s_backPtr->a_fluidVelocity(droplet.m_cellId, j));
      }
      fluidVel = sqrt(fluidVel);
 
      for(MInt v = 0; v < nDim; v++) {
        parentTrajectory[v] = s_backPtr->a_fluidVelocity(droplet.m_cellId, v) / fluidVel;
      }
      */
    }
 
    // magnitude of droplet acceleration
    MFloat drop_accel = 0.0;
    for(MInt dir = 0; dir < nDim; dir++) {
      drop_accel += POW2(droplet.m_accel.at(dir));
    }
    drop_accel = sqrt(drop_accel);
 
    // storing some old droplet properties
    const MFloat oldMass = droplet.sphericalMass() * droplet.m_noParticles;
    vector<MFloat> oldMom(nDim);
    for(MInt n = 0; n < nDim; n++) {
      oldMom[n] = oldMass * droplet.m_velocity[n];
    }
    const MFloat oldDiameter = droplet.m_diameter;
 
    // 4) Computations for Rayleigh-Taylor Break up Model mainly based on:
    //   "Modeling Spray Atomization with the Kelvin-Helmholtz/Rayleigh-Taylor Hibrid Model"
    //    by Beale and Reitz, Atomization and Sprays (1999)
    //    or Baumgarten
 
    // NOTE wavelength = 2 * PI * 1/ waveNumber(=K_RT)
    const MFloat RT_waveL =
        2.0 * PI
        * sqrt(3.0 * material().spraySurfaceTension(droplet.m_temperature)
               / (drop_accel * (material().density(droplet.m_temperature) - droplet.m_fluidDensity)))
        / sqrt(droplet.s_We);
 
    // Omega_RT
    const MFloat RT_frequency =
        sqrt(2.0 / (3.0 * sqrt(3.0 * material().spraySurfaceTension(droplet.m_temperature)))
             * pow(drop_accel * (material().density(droplet.m_temperature) - droplet.m_fluidDensity), 3.0 / 2.0)
             / (material().density(droplet.m_temperature) + droplet.m_fluidDensity))
        * pow(droplet.s_We, 1 / 4);
 
    const MFloat RT_time = m_CT / RT_frequency;
 
    // NOTE: in this case its the diameter!
    const MFloat RT_diameter = m_CRT * RT_waveL;
 
    ASSERT(RT_diameter > 0, "");
 
    // const MFloat RT_speed = (droplet.m_diameter - RT_diameter) / RT_time;
 
 
    // 6) Rayleigh-Taylor break-up
    if(m_RTsecBreakUp && liquidLength >= breakupLength && droplet.m_breakUpTime >= RT_time
       && droplet.m_diameter > RT_diameter && We_l < m_weberLimitRT) {
      // choose RT child diameter version
      MFloat childDiameter = RT_diameter;
      if(m_RTDiameterMode == 2) {
        initPRNG(globalTimeStep, s_backPtr->c_globalId(droplet.m_cellId));
        const MFloat diameterMin = RT_diameter / m_RosinRammlerMin;
        const MFloat diameterMean = RT_diameter / m_RosinRammlerMean;
        const MFloat diameterMax = RT_diameter / m_RosinRammlerMax;
        childDiameter = rosinRammler(diameterMin, diameterMean, diameterMax, m_RosinRammlerSpread, randomSecBreakUp());
        if(droplet.m_diameter < childDiameter) {
          // no breakup
          continue;
        }
      } else if(m_RTDiameterMode == 1) {
        childDiameter = pow(oldDiameter, 2 / 3) * pow(RT_diameter, 1 / 3);
      }
 
      if(m_maxRTChildParcels == 0) {
        // no child parcles are added, only the diameter and no-particles is changed
        auto noDroplets = static_cast<MInt>(droplet.m_noParticles * POW3(oldDiameter / childDiameter));
        // NOTE: casting obove means a runding down for all positive values
        //      version below applies additiona round up for values above 0.75
 
        // NOTE: applying rounding to avoid mass-losses!
        if(noDroplets > 0) {
          childDiameter = pow(6.0 / PI, 1.0 / 3.0)
                          * pow(oldMass / (noDroplets * material().density(droplet.m_temperature)), 1.0 / 3.0);
          droplet.m_diameter = childDiameter;
          droplet.m_shedDiam = childDiameter;
          droplet.m_noParticles = noDroplets;
          droplet.m_breakUpTime = 0.0;
          m_noRTsecBreakUp++;
 
          const MFloat newMass = sphericalMass(droplet.m_diameter, droplet.m_temperature) * droplet.m_noParticles;
          if(fabs(newMass - oldMass) > MFloatEps) {
            cerr << "Missing mass is RT-breakup " << oldMass << " " << newMass << endl;
          }
        }
 
      } else {
        if(m_RTDiameterMode != 2) {
          initPRNG(globalTimeStep, s_backPtr->c_globalId(droplet.m_cellId));
        }
 
        // calculate new number of droplets
        const MFloat dropletVolume = pow(droplet.m_diameter, 3.0);
        const MFloat dropletRTVolume = pow(childDiameter, 3.0);
 
        MInt noBrokenUpDroplets = dropletVolume / dropletRTVolume;
 
        // don't allow inconsequential breakup
        if(noBrokenUpDroplets == 1) {
          continue;
        }
        noBrokenUpDroplets *= droplet.m_noParticles;
 
        // number of drops per new parcel
        auto dropsPerParcel = static_cast<MInt>(
            noBrokenUpDroplets > m_maxRTChildParcels ? floor(noBrokenUpDroplets / m_maxRTChildParcels) : 1);
 
        // limit the number of new parcels
        MInt noNewParcels = noBrokenUpDroplets;
        if(dropsPerParcel > 1) {
          noNewParcels = m_maxRTChildParcels - 1;
        } else {
          --noNewParcels;
        }
 
        const MFloat RT_dropletMass = sphericalMass(childDiameter, droplet.m_temperature);
        const MFloat parentMass = oldMass - dropsPerParcel * RT_dropletMass * noNewParcels;
        const MFloat parentDiam =
            pow(6.0 / PI, 1.0 / 3.0)
            * pow(parentMass / (dropsPerParcel * material().density(droplet.m_temperature)), 1.0 / 3.0);
 
        ASSERT(parentMass > 0, "Invalid mass!");
        ASSERT(parentDiam > 0 && !isnan(parentDiam), "");
        ASSERT(dropsPerParcel > 0, "");
 
        // Reset values
        droplet.m_diameter = parentDiam;
        droplet.m_shedDiam = parentDiam;
        droplet.m_noParticles = dropsPerParcel;
        droplet.m_breakUpTime = 0.0;
        m_noRTsecBreakUp++;
 
#ifdef _OPENMP
#pragma omp critical
#endif
        if(m_secBUDisplayMessage) {
          cerr << "#################################################" << endl;
          cerr << "Break-Up type: RT" << endl;
          cerr << "parent diameter: " << droplet.m_diameter << endl;
          cerr << "Time: " << m_timeSinceSOI << endl;
          cerr << "old number of particles: " << droplet.m_noParticles << endl;
          cerr << "new particles/parcels: " << noNewParcels << endl;
          cerr << "parcel size: " << dropsPerParcel << endl;
          cerr << "Weber number: " << We_l << endl;
          cerr << "#################################################" << endl;
        }
 
        MFloat sprayAngle = m_sprayAngle[0];
        if(m_hollowConeInjector) {
          // hollow cone injectors have a large spray angle because of the hollow cone
          // geometry the actual relevant spray angle is much smaller
          static constexpr MFloat angularGapAngle = 45.0;
          sprayAngle = m_sprayAngle[0] - 2 * angularGapAngle;
        }
 
#ifdef LPT_DEBUG
        vector<MFloat> mom(nDim);
#endif
 
        // create new droplets
        array<MFloat, nDim> childVelocity{};
        for(MInt s = 0; s < noNewParcels; s++) {
          randomVectorInCone(&childVelocity[0], &parentTrajectory[0], magVel, sprayAngle, m_partEmittDist,
                             randomSecBreakUp(), m_injectionDistSigmaCoeff);
 
          const MInt childId = s_backPtr->addParticle(droplet.m_cellId, childDiameter, droplet.m_densityRatio, 0, 3,
                                                      &childVelocity[0], &droplet.m_position[0], dropsPerParcel);
 
          // set child temperature based on parent value
          s_backPtr->m_partList[childId].m_temperature = droplet.m_temperature;
          s_backPtr->m_partList[childId].m_heatFlux = 0.0;
          s_backPtr->m_partList[childId].m_dM = 0.0;
 
 
#ifdef LPT_DEBUG
          // check kin. energy conservation
          MFloat magVelChild = 0;
          for(MInt n = 0; n < nDim; n++) {
            magVelChild += POW2(childVelocity[n]);
          }
          magVelChild = sqrt(magVelChild);
          if(fabs(magVel - magVelChild) > MFloatEps) {
            cerr << "RT kin. energy loss: " << magVel << " " << magVelChild << endl;
          }
          for(MInt n = 0; n < nDim; n++) {
            mom[n] += sphericalMass(childDiameter, droplet.m_temperature) * dropsPerParcel * childVelocity[n];
          }
#endif
        }
 
#ifdef LPT_DEBUG
        // check momentum conservation:
        for(MInt n = 0; n < nDim; n++) {
          mom[n] +=
              droplet.m_velocity[n] * sphericalMass(droplet.m_diameter, droplet.m_temperature) * droplet.m_noParticles;
 
          if(fabs(oldMom[n] - mom[n]) > MFloatEps) {
            cerr << "RT momentum change: " << oldMom[n] << " " << mom[n] << endl;
          }
        }
 
        // check conservation:
        const MFloat newMass = sphericalMass(droplet.m_diameter, droplet.m_temperature) * droplet.m_noParticles;
        MFloat childMass = 0;
        for(MInt n = 0; n < noNewParcels; n++) {
          const MInt id = s_backPtr->a_noParticles() - 1 - n;
          childMass += (sphericalMass(s_backPtr->m_partList[id].m_diameter, s_backPtr->m_partList[id].m_temperature)
                        * s_backPtr->m_partList[id].m_noParticles);
        }
        const MFloat massLoss_RT = oldMass - newMass - childMass;
        if(fabs(massLoss_RT) > MFloatEps) {
          cerr << "RT Mass loss! Old " << oldMass << " parent " << newMass << " childs " << childMass << " diff "
               << massLoss_RT << endl;
        }
#endif
      }
      continue;
    }
 
    // Kelvin-Helmholtz induced break-up
    // if((KH_speed >= RT_speed || liquidLength < breakupLength) && droplet.m_diameter >= KH_diameter && m_KHsecBreakUp)
    // {
    if(m_KHsecBreakUp && droplet.m_diameter > KH_diameter) {
      const MFloat KH_mass = sphericalMass(KH_diameter, droplet.m_temperature);
      if(KH_mass < MFloatEps) continue;
      // ASSERT(KH_mass > MFloatEps, to_string(KH_mass) + " KH_diameter:" + to_string(KH_diameter));
 
      // Kelvin-Helmholtz induced mass stripping
      // NOTE: shedDiam is the diameter of the parent particle after undergoing KH-breakup!
      // i.e. the remaining mass in the parent!
      droplet.m_shedDiam -= (droplet.m_shedDiam - KH_diameter) / KH_time * dt;
 
      // if the shed diameter is smaller than the KH diameter
      // no child parcel is added, the parent diameter is set to the KH-diameter
      // and the noParticles is set by mass conservation
      if(droplet.m_shedDiam < KH_diameter) {
        MInt noDroplets = floor(oldMass / KH_mass);
        if(noDroplets > 0) {
          const MFloat diameter = pow(6.0 / PI, 1.0 / 3.0)
                                  * pow(oldMass / (noDroplets * material().density(droplet.m_temperature)), 1.0 / 3.0);
          // fully transversion to KH-diameter
          // after applying rounding to avoid mass-losses!
          // droplet.m_breakUpTime = -dt;
          droplet.m_diameter = diameter;
          droplet.m_shedDiam = diameter;
          droplet.m_noParticles = noDroplets;
          m_noKHsecBreakUp++;
 
          const MFloat newMass = sphericalMass(droplet.m_diameter, droplet.m_temperature) * droplet.m_noParticles;
          if(fabs(newMass - oldMass) > MFloatEps) {
            cerr << "Missing mass at KH-breakup 1 is " << oldMass << " " << newMass << endl;
          }
          continue;
        }
      }
 
      // mass going into the particle = oldMass - mass remaining in the parant parcel
      const MFloat sheddedMass =
          oldMass - sphericalMass(droplet.m_shedDiam, droplet.m_temperature) * droplet.m_noParticles;
 
      if(m_massLimit > sheddedMass / oldMass) {
        continue;
      }
 
      MInt noSheddedOffDrops = floor(sheddedMass / KH_mass);
      if(noSheddedOffDrops <= 0) continue;
      const MFloat parentMass = oldMass - KH_mass * noSheddedOffDrops;
      ASSERT(parentMass > 0, "");
      // when reformulating the equations above, parentDiam is equal to the shedDiam!
      const MFloat parentDiam =
          pow(6.0 / PI * parentMass / (droplet.m_noParticles * material().density(droplet.m_temperature)), 1.0 / 3.0);
 
      // adding additional child parcel
      // child parcel properties set as prescribed in
      //"Modeling Atomization Processes in High-Pressure Vaporizing Sprays"
      // R. Reitz , Atom.& Sprayz 3 (1987) 309-337
      initPRNG(globalTimeStep, s_backPtr->c_globalId(droplet.m_cellId));
 
      // droplet.m_breakUpTime = -dt;
      droplet.m_diameter = parentDiam;
      droplet.m_shedDiam = parentDiam;
 
      // different spray-angle versions
      MFloat angle = m_sprayAngle[0];
      if(m_sprayAngleKH > 1 && m_sprayAngleKH < 2.9) {
        angle = m_sprayAngle[0];
        if(liquidLength < breakupLength) {
          angle = m_sprayConeAngle;
        }
      } else if(m_sprayAngleKH > 0 && m_sprayAngleKH < 1) {
        angle = 2 * atan(m_sprayAngleKH * KH_growthR * KH_waveL / m_injectionSpeed);
        angle = min(m_sprayAngle[0], angle);
      } else if(m_sprayAngleKH > 2.9) {
        if(liquidLength < breakupLength) {
          angle = m_sprayAngle[0];
        } else {
          angle = m_sprayAngle[1];
        }
      }
 
      if(angle < 0 || angle > 90) {
        cerr << "Large KH-spray angle : " << angle << endl;
      }
 
      array<MFloat, nDim> childVelocity{};
      randomVectorInCone(&childVelocity[0], &parentTrajectory[0], magVel, angle, string2enum("PART_EMITT_DIST_NONE"),
                         randomSecBreakUp(), m_injectionDistSigmaCoeff);
 
      // adding a single additional parcel with KH_diameter
      const MInt childId = s_backPtr->addParticle(droplet.m_cellId, KH_diameter, droplet.m_densityRatio, 0, 3,
                                                  &childVelocity[0], &droplet.m_position[0], noSheddedOffDrops);
 
      // set child temperature based on parent value
      s_backPtr->m_partList[childId].m_temperature = droplet.m_temperature;
      s_backPtr->m_partList[childId].m_heatFlux = 0.0;
      s_backPtr->m_partList[childId].m_dM = 0.0;
 
 
      m_noKHsecBreakUp++;
 
#ifdef _OPENMP
#pragma omp critical
#endif
      if(m_secBUDisplayMessage) {
        cerr << "#################################################" << endl;
        cerr << "Break-Up type: KH" << endl;
        cerr << "parent diameter: " << droplet.m_diameter << " " << parentDiam << endl;
        cerr << "KH size: " << KH_diameter << endl;
        cerr << "KH time: " << KH_time << endl;
        cerr << "Time: " << m_timeSinceSOI << endl;
        cerr << "old #droplets: " << droplet.m_noParticles << endl;
        cerr << "# new droplets: " << noSheddedOffDrops << endl;
        cerr << "Weber number: " << We_l << endl;
        cerr << "#################################################" << endl;
      }
 
      // apply velocity change to parent particle
      // under momentum and kin. energy conservation!
      /*
      vector<MFloat> childMom(nDim);
      for(MInt n = 0; n < nDim; n++){
        childMom[n] = sphericalMass(KH_diameter) * noSheddedOffDrops * childVelocity[n];
        droplet.m_velocity[n] = (oldMom[n] - childMom[n])
                              / (sphericalMass(droplet.m_diameter) * droplet.m_noParticles);
      }
 
      maia::math::normalize(&droplet.m_velocity[0], 3);
      for(MInt n = 0; i < nDim; n++){
        droplet.m_velocity[i] *= magVel;
      }
      */
 
#ifdef LPT_DEBUG
      // check momentum conservation
      vector<MFloat> mom(nDim);
      for(MInt n = 0; n < nDim; n++) {
        mom[n] =
            droplet.m_velocity[n] * sphericalMass(droplet.m_diameter, droplet.m_temperature) * droplet.m_noParticles
            + sphericalMass(KH_diameter, droplet.m_temperature) * noSheddedOffDrops * childVelocity[n];
        if(fabs(oldMom[n] - mom[n]) > MFloatEps) {
          cerr << "KH momentum change: " << oldMom[n] << " " << mom[n] << " "
               << droplet.m_velocity[n] * sphericalMass(droplet.m_diameter, droplet.m_temperature)
                      * droplet.m_noParticles
               << endl;
        }
      }
 
      // check kin. energy conservation
      MFloat magVelChild = 0;
      for(MInt n = 0; n < nDim; n++) {
        magVelChild += POW2(childVelocity[n]);
      }
      magVelChild = sqrt(magVelChild);
      if(fabs(magVel - magVelChild) > MFloatEps) {
        cerr << "KH kin. energy loss: " << magVel << " " << magVelChild << endl;
      }
      MFloat magVelNew = droplet.magVel();
      if(fabs(magVel - magVelNew) > MFloatEps) {
        cerr << "KH kin. energy loss: " << magVel << " " << magVelNew << endl;
      }
      // check mass conservation
      const MFloat newMass = sphericalMass(droplet.m_diameter, droplet.m_temperature) * droplet.m_noParticles;
      const MInt childId = s_backPtr->a_noParticles() - 1;
      const MFloat childMass =
          sphericalMass(s_backPtr->m_partList[childId].m_diameter, s_backPtr->m_partList[childId].m_temperature)
          * s_backPtr->m_partList[childId].m_noParticles;
      const MFloat massLoss_KH = oldMass - newMass - childMass;
      if(fabs(massLoss_KH) > MFloatEps) {
        cerr << "KH Mass loss! Old " << oldMass << " parent " << newMass << " childs " << childMass << " diff "
             << massLoss_KH << endl;
      }
#endif
    } /*else if( m_KHsecBreakUp && KH_diameter > droplet.m_diameter &&
               droplet.m_breakUpTime > KH_time ) {
      //version by Reitz (1987)
      MFloat d_KH = 2 * mMin(
         pow(3 * PI * POW2(droplet.m_diameter) * relV / ( 2 * 4 * KH_growthR), 0.33),
         pow(3 * POW2(droplet.m_diameter) * KH_waveL / 16, 0.33));
 
      auto noDroplets =  static_cast<MInt>(droplet.m_noParticles *
                                           POW3(droplet.m_diameter) / POW3(d_KH));
      if(noDroplets > 0 ) {
        const MFloat diameter = pow(6.0 / PI, 1.0 / 3.0) *
                                pow(oldMass / (noDroplets * material().density(droplet.m_temperature)), 1.0/ 3.0);
        //change droplet diameter
        droplet.m_breakUpTime = 0.0;
        droplet.m_diameter = diameter;
        droplet.m_shedDiam = diameter;
        droplet.m_noParticles = noDroplets;
        m_noKHsecBreakUp++;
      }
    }
    */
  }
}

◆ solverId()

template<MInt nDim>

MInt SprayModel< nDim >::solverId ( ) const

inlineprivate

Definition at line 70 of file lptspray.h.

70{ return s_backPtr->solverId(); }

◆ soonInjection()

template<MInt nDim>

MBool SprayModel< nDim >::soonInjection ( const MFloat time )

inline

Definition at line 47 of file lptspray.h.

                                         {
    if(m_injStartTimeStep > -1 && globalTimeStep + 100 < m_injStartTimeStep) {
      return true;
    }
    if(m_injectionCrankAngle < 0) {
      return true;
    } else if(m_injectionCrankAngle > -1
              && maia::math::crankAngle(time, m_Strouhal, m_initialCad, 0) > m_injectionCrankAngle) {
      return true;
    }
    return false;
  }

◆ sphericalMass()

template<MInt nDim>

MFloat SprayModel< nDim >::sphericalMass	(	const MFloat	diameter,
		const MFloat	temperature
	)

inlineprivate

Definition at line 74 of file lptspray.h.

                                                                        {
    return 1.0 / 6.0 * PI * material().density(temperature) * POW3(diameter);
  }

◆ timeSinceSOI() [1/2]

template<MInt nDim>

MFloat & SprayModel< nDim >::timeSinceSOI ( )

inline

Definition at line 33 of file lptspray.h.

33{ return m_timeSinceSOI; }

◆ timeSinceSOI() [2/2]

template<MInt nDim>

MFloat SprayModel< nDim >::timeSinceSOI ( ) const

inline

Definition at line 32 of file lptspray.h.

32{ return m_timeSinceSOI; }

◆ updateInjectionRate()

template<MInt nDim>

void SprayModel< nDim >::updateInjectionRate

private

Author: Piotr Duda, Sven Berger

Date: June 2016

Definition at line 1658 of file lptspray.cpp.

                                           {
  const MInt numInjections = m_injectionRateList.dim0();
  if(numInjections == 0) return;
 
  if(m_injectionTimings[0] > m_timeSinceSOI) {
    m_currentInjectionRate = (m_timeSinceSOI + 1) / (m_injectionTimings[0] + 1) * m_injectionRateList[0];
  } else {
    for(MInt i = 0; i <= numInjections; i++) {
      if(m_injectionTimings[i] > m_timeSinceSOI) {
        const MFloat t =
            (m_timeSinceSOI - m_injectionTimings[i - 1]) / (m_injectionTimings[i] - m_injectionTimings[i - 1]);
        m_currentInjectionRate = m_injectionRateList[i - 1] + t * (m_injectionRateList[i] - m_injectionRateList[i - 1]);
        break;
      }
    }
  }
}

Member Data Documentation

◆ m_activePrimaryBUp

template<MInt nDim>

MBool SprayModel< nDim >::m_activePrimaryBUp = true

private

Definition at line 165 of file lptspray.h.

◆ m_activeSecondaryBUp

template<MInt nDim>

MBool SprayModel< nDim >::m_activeSecondaryBUp = false

private

Definition at line 166 of file lptspray.h.

◆ m_angularGap

template<MInt nDim>

MFloat SprayModel< nDim >::m_angularGap = -1

private

Definition at line 172 of file lptspray.h.

◆ m_B0

template<MInt nDim>

MFloat SprayModel< nDim >::m_B0 = 0.61

private

Definition at line 152 of file lptspray.h.

◆ m_B1

template<MInt nDim>

MFloat SprayModel< nDim >::m_B1 = 40

private

Definition at line 153 of file lptspray.h.

◆ m_broadcastInjected

template<MInt nDim>

MBool SprayModel< nDim >::m_broadcastInjected = true

Definition at line 41 of file lptspray.h.

◆ m_Cbu

template<MInt nDim>

MFloat SprayModel< nDim >::m_Cbu = 20

private

Definition at line 161 of file lptspray.h.

◆ m_CRT

template<MInt nDim>

MFloat SprayModel< nDim >::m_CRT = 0.1

private

Definition at line 154 of file lptspray.h.

◆ m_CT

template<MInt nDim>

MFloat SprayModel< nDim >::m_CT = 1.0

private

Definition at line 155 of file lptspray.h.

◆ m_currentInjectionRate

template<MInt nDim>

MFloat SprayModel< nDim >::m_currentInjectionRate = 0.0

private

Definition at line 84 of file lptspray.h.

◆ m_hollowConeInjector

template<MInt nDim>

MBool SprayModel< nDim >::m_hollowConeInjector = false

private

Definition at line 178 of file lptspray.h.

◆ m_initialCad

template<MInt nDim>

MFloat SprayModel< nDim >::m_initialCad = 0

Definition at line 62 of file lptspray.h.

◆ m_injData

template<MInt nDim>

MFloat* SprayModel< nDim >::m_injData = nullptr

Definition at line 39 of file lptspray.h.

◆ m_injDataSize

template<MInt nDim>

constexpr MInt SprayModel< nDim >::m_injDataSize = 11

staticconstexpr

Definition at line 38 of file lptspray.h.

◆ m_injDuration

template<MInt nDim>

MFloat SprayModel< nDim >::m_injDuration = 0.00055

private

Definition at line 96 of file lptspray.h.

◆ m_injectionCrankAngle

template<MInt nDim>

MFloat SprayModel< nDim >::m_injectionCrankAngle = -1

Definition at line 60 of file lptspray.h.

◆ m_injectionDistSigmaCoeff

template<MInt nDim>

MFloat SprayModel< nDim >::m_injectionDistSigmaCoeff = 1.0

private

Definition at line 137 of file lptspray.h.

◆ m_injectionRateList

template<MInt nDim>

MFloatTensor SprayModel< nDim >::m_injectionRateList

private

Definition at line 87 of file lptspray.h.

◆ m_injectionSpeed

template<MInt nDim>

MFloat SprayModel< nDim >::m_injectionSpeed = -1.0

private

Definition at line 103 of file lptspray.h.

◆ m_injectionTimings

template<MInt nDim>

MFloatTensor SprayModel< nDim >::m_injectionTimings

private

Definition at line 90 of file lptspray.h.

◆ m_injectorDiameter

template<MInt nDim>

MFloat* SprayModel< nDim >::m_injectorDiameter = nullptr

private

Definition at line 106 of file lptspray.h.

◆ m_injectorDir

template<MInt nDim>

MFloat SprayModel< nDim >::m_injectorDir[nDim] {}

private

Definition at line 135 of file lptspray.h.

◆ m_injectorNozzleDiameter

template<MInt nDim>

MFloat SprayModel< nDim >::m_injectorNozzleDiameter = 0.0

private

Definition at line 100 of file lptspray.h.

◆ m_injectorOrficeSize

template<MInt nDim>

MFloat SprayModel< nDim >::m_injectorOrficeSize {}

private

Definition at line 115 of file lptspray.h.

◆ m_injectorOrificeAngle

template<MInt nDim>

MFloat* SprayModel< nDim >::m_injectorOrificeAngle = nullptr

private

Definition at line 109 of file lptspray.h.

◆ m_injectorType

template<MInt nDim>

MInt SprayModel< nDim >::m_injectorType = 0

private

Definition at line 175 of file lptspray.h.

◆ m_injStartTimeStep

template<MInt nDim>

MInt SprayModel< nDim >::m_injStartTimeStep = -1

Definition at line 45 of file lptspray.h.

◆ m_injStep

template<MInt nDim>

MInt SprayModel< nDim >::m_injStep = 0

Definition at line 43 of file lptspray.h.

◆ m_injStopTimeStep

template<MInt nDim>

MInt SprayModel< nDim >::m_injStopTimeStep = -1

Definition at line 44 of file lptspray.h.

◆ m_KHsecBreakUp

template<MInt nDim>

MBool SprayModel< nDim >::m_KHsecBreakUp = true

private

Definition at line 182 of file lptspray.h.

◆ m_massLimit

template<MInt nDim>

MFloat SprayModel< nDim >::m_massLimit = 0.03

private

Definition at line 157 of file lptspray.h.

◆ m_maxNoPrimParcels

template<MInt nDim>

MInt SprayModel< nDim >::m_maxNoPrimParcels = 1

private

Definition at line 187 of file lptspray.h.

◆ m_maxRTChildParcels

template<MInt nDim>

MInt SprayModel< nDim >::m_maxRTChildParcels = 3

private

Definition at line 160 of file lptspray.h.

◆ m_multiHoleInjector

template<MInt nDim>

MBool SprayModel< nDim >::m_multiHoleInjector = false

private

Definition at line 176 of file lptspray.h.

◆ m_needleLiftTime

template<MInt nDim>

MFloat* SprayModel< nDim >::m_needleLiftTime = nullptr

private

Definition at line 132 of file lptspray.h.

◆ m_noKHsecBreakUp

template<MInt nDim>

MInt SprayModel< nDim >::m_noKHsecBreakUp = 0

Definition at line 243 of file lptspray.h.

◆ m_noRTsecBreakUp

template<MInt nDim>

MInt SprayModel< nDim >::m_noRTsecBreakUp = 0

Definition at line 242 of file lptspray.h.

◆ m_orificePositionAngle

template<MInt nDim>

MFloat* SprayModel< nDim >::m_orificePositionAngle = nullptr

private

Definition at line 112 of file lptspray.h.

◆ m_partEmittDist

template<MInt nDim>

MInt SprayModel< nDim >::m_partEmittDist = 0

private

Definition at line 140 of file lptspray.h.

◆ m_predictivePRNG

template<MInt nDim>

MBool SprayModel< nDim >::m_predictivePRNG = true

private

Definition at line 180 of file lptspray.h.

◆ m_primBrkUpParcelSize

template<MInt nDim>

MInt SprayModel< nDim >::m_primBrkUpParcelSize = 1

private

Definition at line 168 of file lptspray.h.

◆ m_primBUp

template<MInt nDim>

MPI_Comm SprayModel< nDim >::m_primBUp

private

Definition at line 185 of file lptspray.h.

◆ m_primMinDropletSize

template<MInt nDim>

MFloat SprayModel< nDim >::m_primMinDropletSize = 5e-7

private

Definition at line 93 of file lptspray.h.

◆ m_primParcelsPerInj

template<MInt nDim>

MInt SprayModel< nDim >::m_primParcelsPerInj = 1000000

private

Definition at line 188 of file lptspray.h.

◆ m_primRosinRammler

template<MInt nDim>

MBool SprayModel< nDim >::m_primRosinRammler = true

private

Definition at line 147 of file lptspray.h.

◆ m_PRNGPrimBreakUp

template<MInt nDim>

std::mt19937_64 SprayModel< nDim >::m_PRNGPrimBreakUp

Definition at line 231 of file lptspray.h.

◆ m_PRNGPrimBreakUpCount

template<MInt nDim>

MInt SprayModel< nDim >::m_PRNGPrimBreakUpCount = 0

Definition at line 232 of file lptspray.h.

◆ m_PRNGSecBU

template<MInt nDim>

std::mt19937_64 SprayModel< nDim >::m_PRNGSecBU

private

Definition at line 191 of file lptspray.h.

◆ m_RosinRammlerMax

template<MInt nDim>

MFloat SprayModel< nDim >::m_RosinRammlerMax = -1

private

Definition at line 124 of file lptspray.h.

◆ m_RosinRammlerMean

template<MInt nDim>

MFloat SprayModel< nDim >::m_RosinRammlerMean = -1

private

Definition at line 121 of file lptspray.h.

◆ m_RosinRammlerMin

template<MInt nDim>

MFloat SprayModel< nDim >::m_RosinRammlerMin = -1

private

Definition at line 118 of file lptspray.h.

◆ m_RosinRammlerSpread

template<MInt nDim>

MFloat SprayModel< nDim >::m_RosinRammlerSpread = -1

private

Definition at line 129 of file lptspray.h.

◆ m_RTDiameterMode

template<MInt nDim>

MInt SprayModel< nDim >::m_RTDiameterMode = 0

private

Definition at line 162 of file lptspray.h.

◆ m_RTsecBreakUp

template<MInt nDim>

MBool SprayModel< nDim >::m_RTsecBreakUp = true

private

Definition at line 181 of file lptspray.h.

◆ m_RTsecBreakUpLength

template<MInt nDim>

MBool SprayModel< nDim >::m_RTsecBreakUpLength = true

private

Definition at line 183 of file lptspray.h.

◆ m_secBUDisplayMessage

template<MInt nDim>

MBool SprayModel< nDim >::m_secBUDisplayMessage = false

private

Definition at line 159 of file lptspray.h.

◆ m_singleHoleInjector

template<MInt nDim>

MBool SprayModel< nDim >::m_singleHoleInjector = false

private

Definition at line 177 of file lptspray.h.

◆ m_sprayAngle

template<MInt nDim>

MFloat* SprayModel< nDim >::m_sprayAngle = nullptr

private

Definition at line 143 of file lptspray.h.

◆ m_sprayAngleKH

template<MInt nDim>

MFloat SprayModel< nDim >::m_sprayAngleKH = 2

private

Definition at line 163 of file lptspray.h.

◆ m_sprayConeAngle

template<MInt nDim>

MFloat SprayModel< nDim >::m_sprayConeAngle = 0.0

private

Definition at line 144 of file lptspray.h.

◆ m_spraySeed

template<MInt nDim>

MLong SprayModel< nDim >::m_spraySeed {}

Definition at line 240 of file lptspray.h.

◆ m_Strouhal

template<MInt nDim>

MFloat SprayModel< nDim >::m_Strouhal = -99

Definition at line 61 of file lptspray.h.

◆ m_timeSinceSOI

template<MInt nDim>

MFloat SprayModel< nDim >::m_timeSinceSOI = 0.0

private

Definition at line 149 of file lptspray.h.

◆ m_useNeedleLiftTime

template<MInt nDim>

MBool SprayModel< nDim >::m_useNeedleLiftTime = false

private

Definition at line 170 of file lptspray.h.

◆ m_weberLimitKH

template<MInt nDim>

MFloat SprayModel< nDim >::m_weberLimitKH = 6

private

Definition at line 156 of file lptspray.h.

◆ m_weberLimitRT

template<MInt nDim>

MFloat SprayModel< nDim >::m_weberLimitRT = 300

private

Definition at line 158 of file lptspray.h.

◆ s_backPtr

template<MInt nDim>

LPT< nDim > * SprayModel< nDim >::s_backPtr = nullptr

staticprivate

Definition at line 66 of file lptspray.h.

◆ s_lengthFactor

template<MInt nDim>

MFloat SprayModel< nDim >::s_lengthFactor {}

staticprivate

Definition at line 67 of file lptspray.h.

The documentation for this class was generated from the following files:

/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/LPT/lpt.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/LPT/lptspray.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/LPT/lptspray.cpp

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SprayModel()

Member Function Documentation

◆ domainId()

◆ init()

◆ initPRNG()

◆ injection()

◆ injectionDuration()

◆ injectionSpeed()

◆ injectParticles() [1/2]

◆ injectParticles() [2/2]

◆ logDistributionFunction()

◆ material()

◆ primaryBreakUp()

◆ randomPrimBreakUp()

◆ randomSecBreakUp()

◆ readSprayProperties()

◆ secondaryBreakUp()

◆ solverId()

◆ soonInjection()

◆ sphericalMass()

◆ timeSinceSOI() [1/2]

◆ timeSinceSOI() [2/2]

◆ updateInjectionRate()

Member Data Documentation

◆ m_activePrimaryBUp

◆ m_activeSecondaryBUp

◆ m_angularGap

◆ m_B0

◆ m_B1

◆ m_broadcastInjected

◆ m_Cbu

◆ m_CRT

◆ m_CT

◆ m_currentInjectionRate

◆ m_hollowConeInjector

◆ m_initialCad

◆ m_injData

◆ m_injDataSize

◆ m_injDuration

◆ m_injectionCrankAngle

◆ m_injectionDistSigmaCoeff

◆ m_injectionRateList

◆ m_injectionSpeed

◆ m_injectionTimings

◆ m_injectorDiameter

◆ m_injectorDir

◆ m_injectorNozzleDiameter

◆ m_injectorOrficeSize

◆ m_injectorOrificeAngle

◆ m_injectorType

◆ m_injStartTimeStep

◆ m_injStep

◆ m_injStopTimeStep

◆ m_KHsecBreakUp

◆ m_massLimit

◆ m_maxNoPrimParcels

◆ m_maxRTChildParcels

◆ m_multiHoleInjector

◆ m_needleLiftTime

◆ m_noKHsecBreakUp

◆ m_noRTsecBreakUp

◆ m_orificePositionAngle

◆ m_partEmittDist

◆ m_predictivePRNG

◆ m_primBrkUpParcelSize

◆ m_primBUp

◆ m_primMinDropletSize

◆ m_primParcelsPerInj

◆ m_primRosinRammler

◆ m_PRNGPrimBreakUp

◆ m_PRNGPrimBreakUpCount

◆ m_PRNGSecBU