[cmigueis]

Hi everybody! First of all, let me say that I've started to learn how to use OpenFOAM about a month ago, so I've only studied the tutorial cases that are presented in the official guide.

I would like to receive some help on how to setup a case for the simulation of a fluidized bed reactor gasifier. In my study, I'd like to simulate the gasification process of biomass, using an Euler-Lagrange approach. The turbulence moddeling would use LES approach, but I'm still studying this subject to decide about it. The flow is compressible.

I'll try to give a brief explanation about the whole case that I want to simulate:

1. Inside the reactor are 4000 particles of inert material, and fixed diameter (sand or char, for example).
2. The reactor wall has a fixed temperature.
3. There is an inlet on the side of the gasifier, where will be injected the biomass particles, with a fixed initial diameter and fixed injection temperature.
4. At the botton of the reactor will be injected the gasifier agent (steam/air/O2/mixture) with fixed injection temperature.
5. The biomass particles will dry (releasing water vapour), and then will occur the pyrolysis of the dryed biomass, wich will have a decrease at it's size.
6. Some chemical reactions will occur (gasification and oxidation reactions).
7. At the top of the reactor the resulting gases will leave the reactor.
8. I would like to analise the temperature profile inside the reactor, and the gas concentrations at the outlet of the reactor.

I hope this picture can help a little bit the understanding of the situation:

I've made a research about the existing solvers, and sounds to me that the coalChemistryFoam solver can be used to do the simulation (please correct me if I'm wrong). I'm trying to understand how it works, but I can't figure out how to addapt it to my needs.

So, I woul appreciate any help or tip anyone can give me.

Thanks in advance, and regards from Brasil.

[cmigueis]

Hello everyone, I tried to setup the bed particles first, but I'm facing a problem.

I defined the initial location of the 4000 bed particles, using the limestonePositions file. This is how the initial configuration looks like:

Each particle has 3mm of diameter.

When I tried to see how it would be after each particle accomodate itself in the bed, just because of gravity and the collisions between particles/particles and particles/wall, I got this, after a few step:

And they seem to disappear after more steps. It seems to me that each particle is invisible to another, but I put the springSliderDashpot model collision for particles!

This is the limestoneCloudProperties:

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

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

    sourceTerms
    {
        schemes
        {
            U               explicit 1;
            h               explicit 1;
            radiation       explicit 1;
        }
    }

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

    integrationSchemes
    {
        U               Euler;
        T               analytical;
    }
}

constantProperties
{
    parcelTypeId    2;

    rho0            1500;
    T0              1050;
    Cp0             1300;

    epsilon0        1;
    f0              0.5;
}

subModels
{
    particleForces
    {
        sphereDrag;
        gravity;
    }

    injectionModels
    {
        model1
        {
            type            manualInjection;
            massTotal       0;
            parcelBasisType fixed;
            nParticle       1;
            SOI             0;
            positionsFile   "limestonePositions";
            U0              ( 0 0 0 );
            sizeDistribution
            {
                type        fixedValue;
                fixedValueDistribution
                {
                    value   0.003;
                }
            }
        }
    }

    dispersionModel none;

    patchInteractionModel standardWallInteraction;

    heatTransferModel RanzMarshall;

    stochasticCollisionModel none;

    collisionModel pairCollision;

    pairCollisionCoeffs
    {
        maxInteractionDistance  0.003;

        writeReferredParticleCloud no;

        pairModel pairSpringSliderDashpot;

        pairSpringSliderDashpotCoeffs
        {
            useEquivalentSize   no;
            alpha               0.5;
            b                   1.5;
            mu                  0.30;
            cohesionEnergyDensity 0;
            collisionResolutionSteps 12;
        };

        wallModel wallSpringSliderDashpot;

        wallSpringSliderDashpotCoeffs
        {
            useEquivalentSize no;
            collisionResolutionSteps 12;
            youngsModulus   2e9;
            poissonsRatio   0.3;
            alpha           0.1;
            b               1.5;
            mu              0.3;
            cohesionEnergyDensity 0;
        };

    }

    surfaceFilmModel none;

    radiation       on;

    standardWallInteractionCoeffs
    {
        type            rebound;
        e               0.5;
        mu              0.3;
    }

    RanzMarshallCoeffs
    {
        BirdCorrection  false;
    }
}


cloudFunctions
{}

This is my blockMeshDict file:

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

convertToMeters 0.001;

vertices
(
    (0 0 0)
    (95 0 0)
    (0 60 0)
    (95 60 0)
    (0 110 0)
    (95 110 0)
    (-19.5 600 0)
    (0 600 0)
    (95 600 0)
    (114.5 600 0)
    (-19.5 1000 0)
    (0 1000 0)
    (95 1000 0)
    (114.5 1000 0)
    (-19.5 1040 0)
    (0 1040 0)
    (95 1040 0)
    (114.5 1040 0)
    (-19.5 1100 0)
    (0 1100 0)
    (95 1100 0)
    (114.5 1100 0)
    (0 0 4)
    (95 0 4)
    (0 60 4)
    (95 60 4)
    (0 110 4)
    (95 110 4)
    (-19.5 600 4)
    (0 600 4)
    (95 600 4)
    (114.5 600 4)
    (-19.5 1000 4)
    (0 1000 4)
    (95 1000 4)
    (114.5 1000 4)
    (-19.5 1040 4)
    (0 1040 4)
    (95 1040 4)
    (114.5 1040 4)
    (-19.5 1100 4)
    (0 1100 4)
    (95 1100 4)
    (114.5 1100 4)
);

blocks
(
    hex (0 1 3 2 22 23 25 24) (10 6 1) simpleGrading (1 1 1)
    hex (2 3 5 4 24 25 27 26) (10 5 1) simpleGrading (1 1 1)
    hex (4 5 8 7 26 27 30 29) (10 49 1) simpleGrading (1 1 1)
    hex (6 7 11 10 28 29 33 32) (2 40 1) simpleGrading (1 1 1)
    hex (7 8 12 11 29 30 34 33) (10 40 1) simpleGrading (1 1 1)
    hex (8 9 13 12 30 31 35 34) (2 40 1) simpleGrading (1 1 1)
    hex (10 11 15 14 32 33 37 36) (2 4 1) simpleGrading (1 1 1)
    hex (11 12 16 15 33 34 38 37) (10 4 1) simpleGrading (1 1 1)
    hex (12 13 17 16 34 35 39 38) (2 4 1) simpleGrading (1 1 1)
    hex (14 15 19 18 36 37 41 40) (2 6 1) simpleGrading (1 1 1)
    hex (15 16 20 19 37 38 42 41) (10 6 1) simpleGrading (1 1 1)
    hex (16 17 21 20 38 39 43 42) (2 6 1) simpleGrading (1 1 1)    
);

edges
(
);

boundary
(
    top
    {
        type wall;
        faces
        (
        (19 18 40 41)
        (20 19 41 42)
        (21 20 42 43)
        );
    }
    bottom
    {
        type wall;
        faces
        (
                (0 1 23 22)
        );
    }
    walls
    {
        type wall;
        faces
        (
                (0 22 24 2)
                (4 26 29 7)
                (6 28 32 10)
         (10 32 36 14)
                (14 36 40 18)
                (1 3 25 23)
         (3 5 27 25)
                (5 8 30 27)
                (9 13 35 31)
         (17 21 43 39)
         (6 7 29 28)
         (8 9 31 30)
        );
    }
    entrada
    {
        type patch;
        faces
        (
                (2 24 26 4)
        );
    }
    saida
    {
        type patch;
        faces
        (
                (13 17 39 35)
        );
    }
 
);

mergePatchPairs
(
);

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

Can anyone help me in this?

[cmigueis]

Somebody can help me?