[Woo37830]

I am working to use the icoUncoupledKinematicParcelFoam application to simulate the particles emitted by a human breathing. The fluid portion of the setup converged and provides the background airflow and heat sources. I am presently using the normalDistribution with the following parameters for 20,000 particles per 5 second breath:

    injectionModels
    {
        model1
        {

                        type            coneInjection;
                        SOI             0.000;
                        duration         5.000;
                        positionAxis
                        (
                              (( 0.050  0.000  1.630) ( 1.000  0.000 0.000 ))
                        );

            massTotal        1;
            parcelsPerInjector 10000.0;
            nParticle          20000.0;
            parcelBasisType        fixed;
            flowRateProfile   constant 1.0;
            Umag            constant 1.4;
            thetaInner        constant 0;
            thetaOuter       constant 45;

            sizeDistribution
            {
                type        normal;
                normalDistribution
                {
                     minValue    1e-06;
                     maxValue    1e-04;
                    expectation 5.0e-05; 
                     variance    2e-5;
                }
            }
        }

I am trying to create a cloud of particles looking roughly like a 'cone' with a gaussian cross section at the beginning, aerosol particles drifting up, large droplets falling to the ground, and mid-range particles drifting horizontally with the air currents ( as can be seen in schleiren(?) photographs ). What the above gives me is a very thin steam. BTW, the background air velocity is very low. I have not been able to determine how to adjust the parameters to get a realistic plume. Any pointers would be appreciated.

[Nomis]

Hi John,

you could use patchInjection instead of coneInjection to widen the particle cone...

Greetings Simon

[Woo37830]

That may provide what I need, but I can't locate a tutorial
or example of using patch injection. Can you direct me to one that shows the parameters and what they mean and the format for the injector?

[Nomis]

You can find the definition of the bc here.
Basically you need an boundary patch e.g. the mouth.

The parcels are then injected randomly over the patch with the user defined properties (size distribution, velocity vector, etc...)


When using reactingParcelFoam you can set the bc patchInjection in the file constant/reactingCloud1Properties as follows:

subModels
{
    particleForces
    {
        sphereDrag;
        gravity;
    }

    injectionModels
    {


mouth
{
type   patchInjection;
patchName   mouth;
SOI    0.0;
duration   1; 
parcelBasisType number; 
nParticle       1;  
parcelsPerSecond 60;  
massFlowRate    1.066e-12;  
massTotal       2.068e-12; 
U0     (-0.232442140931368 0.26512025555733915 -0.9357787672374562);  
flowRateProfile table ( 
(0.0     1.066e-12)  
(2.0     1.066e-12) 
   );  
            sizeDistribution
            {
                type         RosinRammler;
                RosinRammlerDistribution
                {
                    minValue        1e-8; // 10 nm
                    maxValue        1e-4; // 100 µm
                    d               3e-7; // 300 nm
                    n               2.0;
                }
            } 
}
}

Good luck!Simon

[Woo37830]

I create the avatars programmatically, so lots of effort to go from simple cylinder to patched cylinder.

I did notice you used parcelType number.

What do the parameters for that mean?

I've been using parcelType mass and also fixed. No matter what I do, the injectors stop injecting after a certain number of steps. I inject every 5 seconds for a duration of 5 seconds. After the 25th second, no more particles get injected. What is stopping them?

[Woo37830]

When trying to create an approximation to a human exhalation, I come across these parameters:

massTotal 1;
parcelsPerInjector 10000.0;
nParticle 20000.0;
parcelBasisType fixed;
flowRateProfile constant 1.0;

How are these related. I looked at the code and found that for fixed basis type, the massTotal is not involved, but if I omit it, I get an error that massTotal was omitted. As I stated above, my injectors each 5 seconds emit a stream of particles for about 5 seconds controlled by the distribution. But, after about 25 seconds, the emissions stop. What is the relationship between parcelsPerInjector, nParticle, parcelBasisType, massTotal, and flowRateProfile? Any ideas on how to set these and the distribution, e.g. normalDistribution, or rosinRammler, parameters to get a simulated 'puff' of human breath?

[Nomis]

Hi John,



well that's the hidden and sometimes strange part of Euler-Lagrangian Simulations with OpenFOAM :-)

I try to answer your questions using reactingParcelFoam and PatchInjection.

Let's start with parcelBasisType. According to the file OpenFOAM-8/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectionModel/InjectionModel.C lines 196

        case pbMass:
        {
            scalar volumep = pi/6.0*pow3(diameter); // voluem of a single particle or droplet to be injected
            scalar volumeTot = massTotal_/rho;  // massTotal_ = mass to be injected (massTotal specified in reactingCloud1Properties) 

            nP = volumeFraction*volumeTot/(parcels*volumep);
            // nP = 

            break;
        }
        case pbNumber:
        {
            nP = massTotal_/(rho*volumeTotal_);
            // for Patch injection
            // OpenFOAM-8/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/PatchInjection/PatchInjection.C line 71:
            //  this->volumeTotal_ = flowRateProfile_.integrate(0.0, duration_);
            // nP = massFlowRate / integral_SOI^duration{flowRateProfile} / rho0
            break;
        }
        case pbFixed:
        {
            nP = nParticleFixed_; // from nParcels
            break;
         }

As you see, depending on the case for parcelBasisType some values specified in the reactingCloud1Properties are used and some not. However, for the sake of completeness you have to specify all of them...


Hope this helps you. The question of size distribution for human breath is difficult to answer as it is an actual topic of research. However an excellent review paper on this subject can be found here: https://arxiv.org/abs/2103.01188
As you see we are working on the same problem ;-)


Good luck! Simon

[Woo37830]

Thank you for the reference to a very complete paper. I am still at a loss, however on how to specify the parameters for a RosinRammler cone injector that would match the expected 'cloud' behavior. I am using parameters d=0.8e-5 and n=1.5 along with a Umax of 1.40, but I get no cloud behavior, but rather a stream of particles. What can be done to cause the particle distribution a short distance from the injector to more closely resemble a 'cloud'?

[Woo37830]

I used this set of parameters, but I got an error about d having extra values

        {

                        type            coneInjection;
                        SOI             0.000;//JN: start of injection
                        duration         5.000;//JN: end of injection
                        positionAxis//JN: position and axes
                        (
                              ((-9.529  8.602  1.580) (-0.971  0.238  0.000 ))
                              ((-1.408 -2.753  1.580) (-0.755 -0.656  0.000 ))
                              ((-3.170  8.380  1.580) (-1.000  0.000  0.000 ))
                              (( 3.957 -2.598  1.580) (-0.656 -0.755  0.000 ))
                              ((-6.649  8.930  1.530) (-0.980 -0.200  0.000 ))
                        );

            parcelsPerInjector 5000.0;
            nParticle          5000.0;
            parcelBasisType        number;
            nParticle                 1;
            parcelsPerSecond         60;
            massFlowRate           1.066e-12;
            massTotal              2.068e-12;
            U0 (-0.232442140931368 0.26512025555733915 -0.9357787672374562);  
            flowRateProfile table ( 
                              (0.0     1.066e-12)  
                              (2.0     1.066e-12) 
                              );
            Umag            constant 1.4;
            thetaInner        constant 0;
            thetaOuter       constant 35;

            sizeDistribution
            {
                type        RosinRammler;
                RosinRammlerDistribution
                {
                     minValue     1e-08; // 10nm
                     maxValue     1e-04; // 100mm, ref covid paper, more larger parcels
                     d             3e-7: // 300 nm
                     n              2.0;
                }
            }
        }

        model1
        {

[nhowlett]

Originally Posted by Woo37830

I am trying to create a cloud of particles looking roughly like a 'cone' with a gaussian cross section at the beginning, aerosol particles drifting up, large droplets falling to the ground, and mid-range particles drifting horizontally with the air currents ( as can be seen in schleiren(?) photographs ). What the above gives me is a very thin steam.

Heya John, did you end up resolving your issue? Was it similar to mine -- namely I get flow almost constained to 2 dimensions (see picture below). Notice the particles expand adequately in the horizontal direction, but basically no vertical motion. I used a custom-coded boundary condition (see code below).

    mouth
    {
        /**
         * Thanks to Joel Guerrero for guidance on custom boundary condition: 
         *  - https://wiki.openfoam.com/Programming1
         * Part of the 'OpenFOAM in 15 days': 
         *  - https://wiki.openfoam.com/index.php?title=%223_weeks%22_series
         */
        type            codedFixedValue;            // custom-coded BC
        value           uniform (0 0 0);            // initialization (for ParaView only)
        name            myCustomBC;

        codeOptions                                 // compilation options
        #{
            -I$(LIB_SRC)/finiteVolume/lnInclude \
            -I$(LIB_SRC)/meshTools/lnInclude
        #};

        codeInclude                                 // required files
        #{
            #include <cmath>
            #include <iostream>
        #};

        code                                        // executes every time-step (deltaT)
        #{
            const vectorField& Cf = patch().Cf();   // get all coordinates of the face's center in a patch
            vectorField& field = *this;             // initialize where we are going to assign the profile

            forAll(Cf, faceI)                       // loop over faces in patch
            {
                /**
                 * Following article reviews the experimental studies on the 
                 * characterization of mouth exhaled airflow, comparing the measured 
                 * parameters, in addition to discussing techniques: 
                 *  - https://www.semanticscholar.org/paper/A-review-on-the-applied-techniques-of-exhaled-and-Merghani-Sagot/b231f36f142985051d07b105d86fcd75d44640bc
                 */

                const scalar Ux = 0;
                const scalar Uy = -4;


                // create expansion by varying velocity direction across mouth patch
                const scalar x_i = Cf[faceI].x();
                const scalar Ux = 200 * x_i;
                const scalar z_i = Cf[faceI].z();
                const scalar Uz = 200 * z_i;
 
                field[faceI] = vector(Ux, Uy, Uz);
            }
        #};
    }