[siefer92]

Howdy Yall,

I was able to get the kinematic cloud merged with Sonic foam and achieved some visually agreeable results for the ma 3 forward facing step tutorial. Momentum is coupled and the results look, upon visual inspection, good.


The problem is that I am trying to incorporate heat transfer now and I switched from kinematicCloud -> thermoCloud. From my understanding thermoCloud should just add some functionality and act as a wrapper to kinematicCloud. I made some modifications to the creatFields.H file and coupled the cloud to the continuum energy equation through (+ dustCloud.Sh(e))

My code compiles and I go to run my test case, the simulation proceeds as normal except for the fact that once the particle injection time is reached, the simulation crashes without an error.

Specifically it crashes on the evolution step of a particular time step.

I am attaching my case files in this top post and will make a comment that has my code files

Pardon the language in my log text.

Evolving dustCloud

Did OpenFOAM Fucking Freeze Again?

Solving 2-D cloud dustCloud
Cloud: dustCloud
    Current number of parcels       = 0
    Current mass in system          = 0
    Linear momentum                 = (0 0 0)
   |Linear momentum|                = 0
    Linear kinetic energy           = 0
    Average particle per parcel     = 0
    Injector model1:
      - parcels added               = 0
      - mass introduced             = 0
    Parcel fate: system (number, mass)
      - escape                      = 0, 0
    Parcel fate: patch (number, mass) inlet
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) outlet
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) bottom
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) top
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) obstacle
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) defaultFaces
      - escape                      = 0, 0
      - stick                       = 0, 0
    Temperature min/max             = 0, 0


Not Yet.
ExecutionTime = 10.93 s  ClockTime = 11 s

Time = 0.1002

Courant Number mean: 0.0477675 max: 0.0615826
diagonal:  Solving for rho, Initial residual = 0, Final residual = 0, No Iterations 0
PIMPLE: iteration 1
smoothSolver:  Solving for Ux, Initial residual = 0.00116844, Final residual = 3.81639e-07, No Iterations 1
smoothSolver:  Solving for Uy, Initial residual = 0.00166205, Final residual = 1.54533e-06, No Iterations 1
smoothSolver:  Solving for e, Initial residual = 0.00103972, Final residual = 7.14875e-07, No Iterations 1
smoothSolver:  Solving for p, Initial residual = 0.000908961, Final residual = 6.32946e-07, No Iterations 1
diagonal:  Solving for rho, Initial residual = 0, Final residual = 0, No Iterations 0
time step continuity errors : sum local = 1.6622e-07, global = -4.03005e-08, cumulative = 1.31019e-05

Evolving dustCloud

Did OpenFOAM Fucking Freeze Again?

Solving 2-D cloud dustCloud
-------------------------------------------------------
Primary job  terminated normally, but 1 process returned
a non-zero exit code.. Per user-direction, the job has been aborted.
-------------------------------------------------------
--------------------------------------------------------------------------
mpirun detected that one or more processes exited with non-zero status, thus causing
the job to be terminated. The first process to do so was:

  Process name: [[18412,1],1]
  Exit code:    144
--------------------------------------------------------------------------

It should be noted that this error is just an MPI error and running in serial will have the code crash on "Solving 2-D cloud dustCloud"

I've seen it mentioned on the forums that the lagragian wall rebound treatment can couse hanging, though I am crashing, if the mesh is trash near the wall. Despite not using the rebound model I checked the mesh just to make sure it wasn't the cause using> checkMesh -allGeometry

The output of the check is:

/*---------------------------------------------------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  v1912                                 |
|   \\  /    A nd           | Website:  www.openfoam.com                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
Build  : _f3950763fe-20191219 OPENFOAM=1912
Arch   : "LSB;label=64;scalar=64"
Exec   : checkMesh -allGeometry
Date   : Feb 19 2020
Time   : 12:37:15
Host   : AEK997
PID    : 27748
I/O    : uncollated
Case   : /forwardStepLPTT
nProcs : 1
trapFpe: Floating point exception trapping enabled (FOAM_SIGFPE).
fileModificationChecking : Monitoring run-time modified files using timeStampMaster (fileModificationSkew 10)
allowSystemOperations : Allowing user-supplied system call operations

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Create time

Create mesh for time = 0

Enabling all geometry checks.

Time = 0

Mesh stats
    points:           32898
    internal points:  0
    faces:            64832
    internal faces:   31936
    cells:            16128
    faces per cell:   6
    boundary patches: 6
    point zones:      0
    face zones:       0
    cell zones:       0

Overall number of cells of each type:
    hexahedra:     16128
    prisms:        0
    wedges:        0
    pyramids:      0
    tet wedges:    0
    tetrahedra:    0
    polyhedra:     0

Checking topology...
    Boundary definition OK.
    Cell to face addressing OK.
    Point usage OK.
    Upper triangular ordering OK.
    Face vertices OK.
    Number of regions: 1 (OK).

Checking patch topology for multiply connected surfaces...
    Patch               Faces    Points   Surface topology                   Bounding box
    inlet               80       162      ok (non-closed singly connected)   (0 0 -0.05) (0 1 0.05)
    outlet              64       130      ok (non-closed singly connected)   (3 0.2 -0.05) (3 1 0.05)
    bottom              48       98       ok (non-closed singly connected)   (0 0 -0.05) (0.6 0 0.05)
    top                 240      482      ok (non-closed singly connected)   (0 1 -0.05) (3 1 0.05)
    obstacle            208      418      ok (non-closed singly connected)   (0.6 0 -0.05) (3 0.2 0.05)
    defaultFaces        32256    32898    ok (non-closed singly connected)   (0 0 -0.05) (3 1 0.05)

Checking faceZone topology for multiply connected surfaces...
    No faceZones found.

Checking basic cellZone addressing...
    No cellZones found.

Checking geometry...
    Overall domain bounding box (0 0 -0.05) (3 1 0.05)
    Mesh has 2 geometric (non-empty/wedge) directions (1 1 0)
    Mesh has 2 solution (non-empty) directions (1 1 0)
    All edges aligned with or perpendicular to non-empty directions.
    Boundary openness (1.18817e-18 6.76884e-17 -2.78861e-15) OK.
    Max cell openness = 1.73472e-16 OK.
    Max aspect ratio = 1 OK.
    Minimum face area = 0.00015625. Maximum face area = 0.00125.  Face area magnitudes OK.
    Min volume = 1.5625e-05. Max volume = 1.5625e-05.  Total volume = 0.252.  Cell volumes OK.
    Mesh non-orthogonality Max: 0 average: 0
    Non-orthogonality check OK.
    Face pyramids OK.
    Max skewness = 2.13163e-13 OK.
    Coupled point location match (average 0) OK.
    Face tets OK.
    Min/max edge length = 0.0125 0.1 OK.
    All angles in faces OK.
    Face flatness (1 = flat, 0 = butterfly) : min = 1  average = 1
    All face flatness OK.
    Cell determinant (wellposedness) : minimum: 0.125 average: 0.490118
    Cell determinant check OK.
    Concave cell check OK.
    Face interpolation weight : minimum: 0.5 average: 0.5
    Face interpolation weight check OK.
    Face volume ratio : minimum: 1 average: 1
    Face volume ratio check OK.

Mesh OK.

End

here is my constant/dustCloudProperties file

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  4.x                                   |
|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    location    "constant";
    object      kinematicCloudProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

solution
{
    active          true;
    coupled         true;
    transient       yes;
    cellValueSourceCorrection off;
    maxCo           0.3;

    interpolationSchemes
    {
        rho             cell;
        U               cellPoint;
        thermo:mu       cell;
        T               cell;
        Cp              cell;
        kappa           cell;
        p               cell;
        G               cell;
        DUcDt           cell;
    }

    integrationSchemes
    {
        U               Euler;
        T               analytical;
    }

    sourceTerms
    {
        schemes
        {
            rho             semiImplicit 1;
            U               semiImplicit 1;
            Yi              semiImplicit 1;
            h               semiImplicit 1;
        }
    }
}

constantProperties
{
    rho0            8800;
    youngsModulus   1.3e5;
    poissonsRatio   0.35;
    T0              1;
    Cp0             4187;
    epsilon0        1;
    f0              0.5;
}


subModels
{
    particleForces
    {
        sphereDrag;

        gravity;

        pressureGradient
        {
            U U;
        }

    }

    injectionModels
    {
        model1
        {
            type             patchInjection;
            patch            inlet;
            duration         1;
            parcelsPerSecond 1390885;
            massTotal        40;
            parcelBasisType  fixed;
            flowRateProfile  constant 1;
            nParticle        1;
            SOI              0.1;
            U0               (3 0 0);
            T0               3;
            sizeDistribution
            {
                type        fixedValue;
                fixedValueDistribution
                {
                    value   0.00007;
                }
            }
        }
    }

    dispersionModel none;

    patchInteractionModel standardWallInteraction;

    standardWallInteractionCoeffs
    {
        type rebound;
        e    0.97;
        mu   0.09;
    }

    surfaceFilmModel none;

    stochasticCollisionModel none;

    radiation       off;
    heatTransferModel none;


    RanzMarshallCoeffs
    {
        BirdCorrection  true;
    }

    collisionModel none;

    pairCollisionCoeffs
    {
        maxInteractionDistance  0.00007;

        writeReferredParticleCloud no;

        pairModel pairSpringSliderDashpot;

        pairSpringSliderDashpotCoeffs
        {
            useEquivalentSize   no;
            alpha               0.12;
            b                   1.5;
            mu                  0.52;
            cohesionEnergyDensity 0;
            collisionResolutionSteps 12;
        };

        wallModel wallSpringSliderDashpot;

        wallSpringSliderDashpotCoeffs
        {
            useEquivalentSize no;
            collisionResolutionSteps 12;
            youngsModulus   1e10;
            poissonsRatio   0.23;
            alpha           0.12;
            b               1.5;
            mu              0.43;
            cohesionEnergyDensity 0;
        };
    }
}

cloudFunctions
{
    voidFraction1
    {
        type            voidFraction;
    }
}

UEQN

// Solve the Momentum equation

MRF.correctBoundaryVelocity(U);

fvVectorMatrix UEqn
(
    fvm::ddt(rho, U) + fvm::div(phi, U)
  + MRF.DDt(rho, U)
  + turbulence->divDevRhoReff(U)
 ==
    fvOptions(rho, U) + dustParcels.SU(U)
);

UEqn.relax();

fvOptions.constrain(UEqn);

if (pimple.momentumPredictor())
{
    solve(UEqn == -fvc::grad(p));

    fvOptions.correct(U);
    K = 0.5*magSqr(U);
}

EEQN

{
    fvScalarMatrix EEqn
    (
        fvm::ddt(rho, e) + fvm::div(phi, e)
      + fvc::ddt(rho, K) + fvc::div(phi, K)
      + fvc::div(fvc::absolute(phi/fvc::interpolate(rho), U), p, "div(phiv,p)")
      - fvm::laplacian(turbulence->alphaEff(), e)
     ==
        fvOptions(rho, e) + dustParcels.Sh(e)
    );

    EEqn.relax();

    fvOptions.constrain(EEqn);

    EEqn.solve();

    fvOptions.correct(e);

    thermo.correct();
}

My Create Fields File

{

#include "readGravitationalAcceleration.H"

 Info<< "Reading thermophysical properties\n" << endl;
 autoPtr<psiThermo> pThermo(psiThermo::New(mesh));
 psiThermo& thermo = pThermo();
 thermo.validate(args.executable(), "h", "e");

 SLGThermo slgThermo(mesh, thermo);

volScalarField& p = thermo.p();
// const volScalarField& T = thermo.T();
// const volScalarField& psi = thermo.psi();

multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 fields.add(thermo.he());

volScalarField rho
(
    IOobject
    (
        "rho",
        runTime.timeName(),
        mesh
    ),
    thermo.rho()
);

Info<< "Reading field U\n" << endl;
volVectorField U
(
    IOobject
    (
        "U",
        runTime.timeName(),
        mesh,
        IOobject::MUST_READ,
        IOobject::AUTO_WRITE
    ),
    mesh
);

#include "compressibleCreatePhi.H"

mesh.setFluxRequired(p.name());

Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
    compressible::turbulenceModel::New
    (
        rho,
        U,
        phi,
        thermo
    )
);

#include "createK.H"

#include "createMRF.H"

 Info<< "Reading transportProperties\n" <<endl;
IOdictionary transportProperties
        (
                IOobject
                (
                        "transportProperties",
                        runTime.constant(),
                        mesh,
                        IOobject::MUST_READ_IF_MODIFIED,
                        IOobject::NO_WRITE
                )
        );
dimensionedScalar rhoInfValue
        (
                transportProperties.lookup("rhoInf")
        );
dimensionedScalar invrhoInf("invrhoInf",(1.0/rhoInfValue));

volScalarField rhoInf
        (
                IOobject
                (
                        "rho",
                        runTime.timeName(),
                        mesh,
                        IOobject::NO_READ,
                        IOobject::AUTO_WRITE
                ),
                mesh,
                rhoInfValue
        );




volScalarField mu
        (
                IOobject
                (
                        "mu",
                        runTime.timeName(),
                        mesh,
                        IOobject::NO_READ,
                        IOobject::AUTO_WRITE
                ),
                turbulence->nu()*rhoInfValue
        );

const word thermoCloudName
        (
                args.optionLookupOrDefault<word>("CloudName", "dustCloud")
        );

 Info<< "\nConstructing dust cloud" << endl;
 basicThermoCloud dustParcels
 (
                thermoCloudName,
                rhoInf,
                U,
                g,
                slgThermo

 );

#include "createFvOptions.H"
}

and the modified solver file

/*---------------------------------------------------------------------------

\*---------------------------------------------------------------------------*/

#include "fvCFD.H"
#include "SLGThermo.H"
#include "psiThermo.H"
#include "turbulentFluidThermoModel.H"
#include "pimpleControl.H"
#include "fvOptions.H"
#include "basicThermoCloud.H"
#include "radiationModel.H"
#include "pressureControl.H"
#include "localEulerDdtScheme.H"
#include "fvcSmooth.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

int main(int argc, char *argv[])
{
    argList::addNote
    (
        "Transient solver for trans-sonic/supersonic, turbulent flow"
        " of a compressible gas."
    );

    #include "postProcess.H"

    #include "addCheckCaseOptions.H"
    #include "setRootCaseLists.H"
    #include "createTime.H"
    #include "createMesh.H"
//    #include "readGravitationalAcceleration.H"
    #include "createControl.H"
    #include "createFields.H"
    #include "createFieldRefs.H"
    #include "initContinuityErrs.H"turbulence->validate();

    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

    Info<< "\nStarting time loop\n" << endl;

    while (runTime.loop())
    {
        Info<< "Time = " << runTime.timeName() << nl << endl;

        #include "compressibleCourantNo.H"

        #include "rhoEqn.H"

        // --- Pressure-velocity PIMPLE corrector loop
        while (pimple.loop())
        {
            #include "UEqn.H"
            #include "EEqn.H"

            // --- Pressure corrector loop
            while (pimple.correct())
            {
                #include "pEqn.H"
            }

            if (pimple.turbCorr())
            {
                turbulence->correct();
            }
        }

        rho = thermo.rho();

        Info << "\nEvolving " << dustParcels.name() << endl;
        Info << "\nDid OpenFOAM Fucking Freeze Again?" << endl;
        dustParcels.evolve();
        Info << "\nNot Yet." << endl;
        runTime.write();

        runTime.printExecutionTime(Info);
    }

    Info<< "End\n" << endl;

    return 0;
}


// ************************************************************************* //

Given the lack of an error code, the complicated nature of the Lagrangian source code and my, relative, inexperience with openFOAM solver programming I'm quite at a loss here.

I know that this has to caused by user error, but I haven't pinned down a specific reason for why within the lagrangian evolve() function

if you want additional files I'll upload them in the comments if it is requested.

Thanks yall!

[raumpolizei]

Hey there, the error is a bit unprecise. What is the error message when running in serial mode? Maybe you could try using gdb to output more information regarding the error and its backtrace?

$gdb yourApplicationName

then use the command

run

inside gdb and after it crashed

bt

to see at which point the program stoped to work.

[siefer92]

That's the thing, there is no error when running in serial mode it just crashes. Ill attach

Evolving dustCloud

Did OpenFOAM Fucking Freeze Again?

Solving 2-D cloud dustCloud
Cloud: dustCloud
    Current number of parcels       = 0
    Current mass in system          = 0
    Linear momentum                 = (0 0 0)
   |Linear momentum|                = 0
    Linear kinetic energy           = 0
    Average particle per parcel     = 0
    Injector model1:
      - parcels added               = 0
      - mass introduced             = 0
    Parcel fate: system (number, mass)
      - escape                      = 0, 0
    Parcel fate: patch (number, mass) inlet
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) outlet
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) bottom
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) top
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) obstacle
      - escape                      = 0, 0
      - stick                       = 0, 0
    Parcel fate: patch (number, mass) defaultFaces
      - escape                      = 0, 0
      - stick                       = 0, 0
    Temperature min/max             = 0, 0


Not Yet.
ExecutionTime = 10.99 s  ClockTime = 11 s

Time = 0.1002

Courant Number mean: 0.0477675 max: 0.0616668
diagonal:  Solving for rho, Initial residual = 0, Final residual = 0, No Iterations 0
PIMPLE: iteration 1
smoothSolver:  Solving for Ux, Initial residual = 0.00116857, Final residual = 2.52804e-09, No Iterations 1
smoothSolver:  Solving for Uy, Initial residual = 0.0016621, Final residual = 4.25478e-09, No Iterations 1
smoothSolver:  Solving for e, Initial residual = 0.00103959, Final residual = 2.14555e-07, No Iterations 1
smoothSolver:  Solving for p, Initial residual = 0.000908946, Final residual = 2.11092e-07, No Iterations 1
diagonal:  Solving for rho, Initial residual = 0, Final residual = 0, No Iterations 0
time step continuity errors : sum local = 5.54642e-08, global = -4.17947e-08, cumulative = 4.64595e-06

Evolving dustCloud

Did OpenFOAM Fucking Freeze Again?

Solving 2-D cloud dustCloud

[raumpolizei]

Ok, so if I understand you correctly: The application just stays in some kind of endless loop and you have to kill the job manually?
Just looked over your injection model setup. It looks like you are injecting with 40 kg/s. From your simulation I can also see that the timestep used seems to be 2e-4s, which would mean a total of 8e-3 kg injected per time step. With your additional size distribution and an estimated density of 1000 kg/m3, I estimated the total of number of injected parcels per timestep to 45 million. That would basically explain the "freezing", which would be in fact just a very, very long computation (until your computer runs out of memory ).
Maybe have a look at the way this type of injection should be used.

[siefer92]

If the process simply froze and was stuck calculating, your logic would be sound. However, the process simply dies.

there is no process to kill once it get's to this point.

openFOAM simply dies

[raumpolizei]

Ok. Can you then try to use a simpler injection model (like manualInjection)?

[siefer92]

Did that,

and it freezes at the same place.

New injection model:

injectionModels
    {
        model1
        {
            type             manualInjection;
            patch            inlet;
            duration         1;
            parcelsPerSecond 13905;
            massTotal        40;
            parcelBasisType  fixed;
            flowRateProfile  constant 1;
            nParticle        1;
            SOI              0;
            positionsFile   "dustPositions";
            U0               (3 0 0);
            T0               3;
            sizeDistribution
            {
                type        fixedValue;
                fixedValueDistribution
                {
                    value   0.00007;
                }
            }
        }

Here is my dust positions file:

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  v1912                                 |
|   \\  /    A nd           | Website:  www.openfoam.com                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    location    "";
    class       vectorField;
    object      limestonePositions;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
(
(1.5 .5 0.0)

)
// ************************************************************************* //

Right now I am adding comments to the KinematicCloud.C and ThermoCloud.C templates and trying to manually find where it dies.

here is how my code ends now :

No MRF models present

Reading transportProperties


Constructing dust cloud
Constructing particle forces
    Selecting particle force sphereDrag
    Selecting particle force gravity
Constructing cloud functions
    none
Constructing particle injection models
Creating injector: model1
Selecting injection model manualInjection
    Constructing 2-D injection
    Choosing nParticle to be a fixed value, massTotal variable now does not determine anything.
Selecting distribution model fixedValue
Selecting dispersion model none
Selecting patch interaction model standardWallInteraction
Selecting stochastic collision model none
Selecting surface film model none
Selecting U integration scheme Euler
Selecting heat transfer model none
Selecting T integration scheme analytical
No finite volume options present

Starting time loop

Time = 0.0002

Courant Number mean: 0.0479762 max: 0.048
diagonal:  Solving for rho, Initial residual = 0, Final residual = 0, No Iterations 0
PIMPLE: iteration 1
smoothSolver:  Solving for Ux, Initial residual = 0.646268, Final residual = 0.167319, No Iterations 1000
smoothSolver:  Solving for Uy, Initial residual = 0, Final residual = 0, No Iterations 0
smoothSolver:  Solving for e, Initial residual = 1, Final residual = 3.1659e-07, No Iterations 2
smoothSolver:  Solving for p, Initial residual = 1, Final residual = 3.54324e-07, No Iterations 2
diagonal:  Solving for rho, Initial residual = 0, Final residual = 0, No Iterations 0
time step continuity errors : sum local = 1.78486e-05, global = 1.78481e-05, cumulative = 1.78481e-05

Evolving dustCloud

Did OpenFOAM Fucking Freeze Again?

Can the Cloud Evolve?

Yes

Solving 2-D cloud dustCloud

Starting Pre-Evolve

It gets to the .preEvolve() function. I'll keep digging to find where it dies :/. couldn't get gdb to recognize the OpenFOAM command and this computer will take hours to recompile in dubug mode so I am going to debug, in what I assume is, the idiots way (Brute Force Comments).

I appreciate your suggestions / help thus far though

[siefer92]

So the code fails at the following:

line 211 of:

src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C

the function: injectors_.inject(cloud, td);

still trying to figure out where to go from here

[raumpolizei]

Try this config maybe. I know that it works well for me.

injectionModels
    {
        OneSingleDroplet
        {
            type            manualInjection;
            massTotal       6.038715e-07;
            parcelBasisType mass;
            SOI 0;
            positionsFile "cloudPositions";
            U0 (1 0 0);
            sizeDistribution
            {
                type        uniform;

                uniformDistribution
                {
                    minValue        4e-5;
                    maxValue        4e-05;
                }
            }
        }
    }

[siefer92]

That doesn't work either :/

I am inside the injection function:

lagrangian/intermediate/lnInclude/InjectionModelList.C

and have found my code doesn't get past this section:

forAll(*this, i)
    {
        this->operator[](i).inject(cloud, td);
    }

So it is definitely something to do with the particle injection.

[raumpolizei]

What do you mean by "your code"? Did you change your standard openfoam installation?

[siefer92]

I didn't change the standard installation. Though, I am trying to combine ThermoCloud functionality with sonicFoam like I was able to do with KinematicCollidingCloud and sonicFoam.

this is a custom solver.

[siefer92]

By adding the line:

Info << "\n" << this->operator[](i).massTotal() << endl;

before:

this->operator[](i).inject(cloud, td);

The solver reports that the total mass is 6.038715e-07 before it crashes.

so I know that it is taking in the cloudProperties input that you suggested

[raumpolizei]

Were you able to solve your issue?

[mbookin]

Though the post is old but rather relevant on a search for coupling thermo to kinematic clouds it still have no clear decision. One may suggest that a successfully compiled solver could crash on running if you did not add necessary libraries to the solver. Could you please share your Make/options file?