CFD Online Discussion Forums - chtmultiRegion case is not generating sets folder in postprocessing

CFD Online Discussion Forums (https://www.cfd-online.com/Forums/)

- OpenFOAM Running, Solving & CFD (https://www.cfd-online.com/Forums/openfoam-solving/)

- - chtmultiRegion case is not generating sets folder in postprocessing (https://www.cfd-online.com/Forums/openfoam-solving/255001-chtmultiregion-case-not-generating-sets-folder-postprocessing.html)

chtmultiRegion case is not generating sets folder in postprocessing

Using the data in the sets folder, OpenFOAM creates streamlines. But while my case shows the postprocessing folder, it does not contain sets, so I can't generate streamlines. This is my preferred way to do it, as the ParaView streamlines don't work very well.

I have another case where everything works properly, but in this one, it does not, and I can't find the difference.

Attached is the run log, and here is the controlDict file:

Code:

FoamFile

{

    version     2.0;

    format      ascii;

    class       dictionary;

    location    "system";

    object      controlDict;

}

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



application     chtMultiRegionFoam;



startFrom       latestTime;



startTime       0;



stopAt          endTime;



//endTime         2000;

endTime         50;



deltaT          1;



writeControl    timeStep;



writeInterval   5;



purgeWrite      0;



writeFormat     ascii;



writePrecision  6;



writeCompression off;



timeFormat      general;



timePrecision   6;



runTimeModifiable true;



functions

{

    #include "streamLines"

    #include "cuttingPlane"

    #include "forceCoeffs"



   FieldsMinMax                // monitor 

    {

        type  fieldMinMax;

        functionObjectLibs      ("libfieldFunctionObjects.so");

        region                  fluid;

        enabled                 true;

        mode                    component;

        writeControl            timeStep;

        writeInterval           5;  // output every 5 time steps, change

 as needed

        log                     true;

        fields                  (p U k);  // list of any fields you want

 to monitor

    }



    FreeMemorySystemCall        // memory

    {

        type                    systemCall;

        region                  fluid;

        libs                    ("libutilityFunctionObjects.so");

        executeCalls            ();

        writeCalls              ("free");

        endCalls                ();

        writeControl            timeStep;

        writeInterval           50;  // Set the interval as required

    }

            

        all

        {

            log no;

            enabled yes;



            type forceCoeffs;

            

            region fluid;

            

            functionObjectLibs ( "libforces.so");



            patches (fuselage spinner lips fairing flap);



            rho rhoInf;

            rhoInf 1.205;



            //porosity no;

            CofR ( 0 0 0);

            liftDir ( 0 0 1);

            dragDir ( 1 0 0);

            pitchAxis ( 0 1 0);

            magUInf 30;

            lRef 1;

            Aref 1;

            writeControl timeStep;

            writeInterval 1;

        }

        

        yplus

        {

            type    yPlus;

            functionObjectLibs ("libfieldFunctionObjects.so");

            

            region  fluid;



            enabled true;



            writeControl outputTime;                      

            

         }



#includeEtc "caseDicts/postProcessing/visualization/streamlines.cfg"



}

In the run log, OpenFOAM is complaining about several of the controlDict intial entries: "entry is not a dictionary".
I don't know what to make of this. My other case with essentially the same controlDict has none of these errors.

I hope that someone can spot my error and get me going again!

Actually, the problem is related either to the loft, or the BCs, so the battle goes on.

Here is the new run log; if anyone can make sense of it please let me know!

It fails with this message:

Code:

Energy -> temperature conversion failed to converge:

          iter          Test           e/h          Cv/p          Tnew

             0       221.394        156299       1002.05         251.2

             1         251.2        215170       1006.19       222.374

.

.

.

Complete run log is attached.
Thanks, everyone!

Interestingly, it ran to the end with a different set of BCs. Does this imply that the loft is okay? If so, I am again left at my wits end.

If anyone is inclined to help me out of my misery, I would be delighted to post my case on dropbox.

continuing problem with sets folder wrt streamlines

In the process of running a simpleFoam case to debug my chtmultiRegion case, I need to create streamlines to visualize flow. The native OpenFOAM streamline function works far better than the paraview version, so I always try to use it.

This requires a sets folder to be created under postProcessing. But in my current simulation, the sets folder is not being created, and for the life of me, I cannot understand why. I am using a previous successful case as a template, but when I run the new one, the sets folder is absent.

Can someone tell me what it is that triggers the creation of the sets folder?

more info on streamline problem

Just to follow up, in the problematic case, this appears in the run log:

Code:

streamLine streamLines write:

    seeded 0 particles

    Tracks:0

    Total samples:0

Whereas, in the case that works, it looks like this:

Code:

treamLine streamLines write:

    seeded 60 particles

    Tracks:60

    Total samples:28805

It seems that the problem may have something to do with sampling, even though I didn't address it in the successful case. If sampling is the problem, how do I fix it? As usual, humbly hoping for help.

problem solved! But now I have a new one: no postProcessing folder is created

My problem was that there was no 'sets' folder under the 'postProcessing' folder, when I was trying to implement streamlines. Finally, I found this procedure:
Enter 'foamGet streamlines' at the command prompt in the run folder.
Then it asks it you want option (1) or (2). I selected (1). This created a file 'streamlines' in the system directory. Note that the streamline function also uses a file 'streamLines' in the same directory. Previously, I had always used the latter file, but found that I could edit the 'streamlines' file, and the upshot was that the desired 'sets' folder was now created!

It is an oddity that both 'streamlines' and 'streamLines' can be used, but this is indicative of the committee nature of the OpenFoam programming culture.

New problem: this was all in relation to a simpleFoam case that I was using to debug my multiregionFoam case. So, after getting it to work, I transported the appropriate files to my multiregion case. Now, I find that when running it, no postProcessing folder is created at all!

I'm still searching for the cause, but if anyone has guidance, I would be grateful!

Hello Alan,

When using function objects on a multiregion case, you should define in which region the function should be applied, using the "region" parameter in the function definition. E.g.:

Code:

region fluid;

Quote:

Originally Posted by boffin5 (Post 867524)

It is an oddity that both 'streamlines' and 'streamLines' can be used, but this is indicative of the committee nature of the OpenFoam programming culture

Regarding this, what matters is to use the proper function name:

Code:

type streamLine;

This is defined in the streamlines.cfg file which is included in your streamLines file with this line: #includeEtc "caseDicts/postProcessing/visualization/streamlines.cfg"

The name of the files itself does not matter, it could be streamLines, streamline.cfg, streamlines.whatever, foobar, it would still work as long as the files contains the proper code snippets and are properly included where it is required.
These predefined files are just a trick to avoid having to define the function by yourself but you can also totally avoid using these files, and define the function yourself in the controlDict file (or in whatever file you will then include in the controlDict)

Regards,
Yann

Can't find the magic key to get the case to work!

Hi Yann,

Thanks for the reply! Still it doesn't work. There is inconsistency between some of the cases you have helped me with.

First, I have a simple template case, which is chtMultiRegionFoam simulation run in parallel, which you may still have. It works great, and here is the applicable part of the run parallel script:

Code:

mpirun -np 8 chtMultiRegionFoam -parallel | tee run.log

Even though there is no reference to postProcessing, this folder containing the 'sets' folder is created at the end of the run, allowing me to view streamlines. :)

Now regarding my current chtMultiRegion case, I first ran it as a simpleFoam case without the heat exchanger. I was struggling with streamlines, and finally got it to work. Here is the controlDict:

Code:

functions

{

    #include "streamLines"

    #include "cuttingPlane"

    #include "forceCoeffs"

    

    FieldsMinMax                // monitor 

    {

        type  fieldMinMax;

        functionObjectLibs      ("libfieldFunctionObjects.so");

        enabled                 true;

        mode                    component;

        writeControl            timeStep;

        writeInterval           5;  // output every 5 time steps, change as needed

        log                     true;

        fields                  (p U k epsilon);  // list of any fields you want to monitor

    }



    FreeMemorySystemCall        // memory

    {

        type                    systemCall;

        libs                    ("libutilityFunctionObjects.so");

        executeCalls            ();

        writeCalls              ("free");

        endCalls                ();

        writeControl            timeStep;

        writeInterval           50;  // Set the interval as required

    }

#includeFunc streamlines

}

Even though at first it says '#include "streamLines", I only got it to work by adding '#includeFunc streamlines' at the end, and then editing 'streamlines' in the system folder. Prior to this, it ignored the 'streamLines' file in system, and did not create a postProcessing folder.

btw, the streamlines.cfg file reads as:

Code:

type            streamLine;

libs            ("libfieldFunctionObjects.so");



executeControl  writeTime;

writeControl    writeTime;



setFormat       vtk;



lifeTime        10000;

nSubCycle       5;



cloudName       particleTracks;

Even though it says 'type streamLine', when the case works properly, it only reads the 'streamline' file . Go figure!

Then, I took the simpleFoam case and adapted it to be a chtMultiRegion case. It is set up as a serial run, and only works if the run script contains:

Code:

chtMultiRegionFoam | tee run.log

However, there is no postProcessing folder, even though the first mentioned template case with a similar run script, did produce one. Now I can't do streamlines :(

If I edit the run script as follows:

Code:

chtMultiRegionFoam -postProcess -region fluid | tee run.log

It fails. That is where I am at. So close, after slaving away for a very long time, but not quite there. If you can help, I would be over the moon!

If you have a slot in your busy schedule to have a look, the case can be found here:
https://www.dropbox.com/scl/fi/09w9b...950pnwdv6&dl=0

Hello Alan,

I feel like you are getting confused by the function objects and the different ways to use it. Let's untangle your setup.

Here is the first line of the functions section in your controlDict:

Code:

#include "streamLines"

This line refers to a streamLines file placed in your system directory.
In your system directory, there is a streamlines rather than a streamLines file.
This should not work, my best guess is that you are using WSL and since Windows is not case sensitive it does not make a difference between streamLines and streamlines.

Alright so if you remove all the functions from your controlDict except the #include "streamLines" bit, you will notice the solver is not happy with it as it throws a bunch of errors:

Code:

PIMPLE: Region fluid

PIMPLE: No convergence criteria found





PIMPLE: Region solid

PIMPLE: No convergence criteria found





PIMPLE: Operating solver in steady-state mode with 1 outer corrector

PIMPLE: Operating solver in SIMPLE mode





Region: fluid Courant Number mean: 90.0808 max: 1.33005e+06

Region: solid Courant Number mean: 0.437445 max: 0.524934

--> FOAM Warning : 

    From function bool Foam::functionObjectList::read()

    in file db/functionObjects/functionObjectList/functionObjectList.C at line 807

    Reading "/mnt/c/Users/Yann/OpenFOAM-8-run/meredith-half-en-almostworks/system/controlDict" from line 17 to line 120

    Entry type is not a dictionary

--> FOAM Warning : 

    From function bool Foam::functionObjectList::read()

    in file db/functionObjects/functionObjectList/functionObjectList.C at line 807

    Reading "/mnt/c/Users/Yann/OpenFOAM-8-run/meredith-half-en-almostworks/system/controlDict" from line 17 to line 120

    Entry executeControl is not a dictionary

--> FOAM Warning : 

    From function bool Foam::functionObjectList::read()

    in file db/functionObjects/functionObjectList/functionObjectList.C at line 807

    Reading "/mnt/c/Users/Yann/OpenFOAM-8-run/meredith-half-en-almostworks/system/controlDict" from line 17 to line 120

    Entry writeControl is not a dictionary

--> FOAM Warning : 

    From function bool Foam::functionObjectList::read()

    in file db/functionObjects/functionObjectList/functionObjectList.C at line 807

    Reading "/mnt/c/Users/Yann/OpenFOAM-8-run/meredith-half-en-almostworks/system/controlDict" from line 17 to line 120

    Entry setFormat is not a dictionary

[...]

This is because your streamlines file does not have the proper syntax. The function definition is supposed to be encapsulated in a dictionary, like this:

Code:

/*--------------------------------*- C++ -*----------------------------------*\

  =========                 |

  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox

   \\    /   O peration     | Website:  https://openfoam.org

    \\  /    A nd           | Version:  8

     \\/     M anipulation  |

-------------------------------------------------------------------------------

Description

    Writes out files of streamlines with interpolated field data in VTK format.



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



Alan_function

{

        #includeEtc "caseDicts/postProcessing/visualization/streamlines.cfg"



        fields  (U p);



        // Streamline direction: forward, backward, both

        direction       forward;



        // Select from methods with sub-dictionary settings below

        seedMethod      lineUniform;



        // Seeding along a line

        lineCell

        {

                type            lineCell;   // lineCellFace, lineFace

                start           (0 -1 1);

                end             (0  1 1);

        }



        // I removed the rest so it's easier to read...



}

As you can see, the first line of the function is including a file located in $FOAM_ETC/caseDicts/postProcessing/visualization/streamlines.cfg
You can have a look at this file using this command for instance:

Code:

nano FOAM_ETC/caseDicts/postProcessing/visualization/streamlines.cfg

As you will see, it contains a bunch of parameters, and it's equivalent to just have everything defined right in your streamlines file like this:

Code:

Alan_function

{

        type            streamLine;

        libs            ("libfieldFunctionObjects.so");



        executeControl  writeTime;

        writeControl    writeTime;



        setFormat       vtk;



        lifeTime        10000;

        nSubCycle       5;



        cloudName       particleTracks;



        fields  (U p);



        // Streamline direction: forward, backward, both

        direction       forward;



        // Select from methods with sub-dictionary settings below

        seedMethod      lineUniform;



        // Seeding along a line

        lineCell

        {

                type            lineCell;   // lineCellFace, lineFace

                start           (0 -1 1);

                end             (0  1 1);

        }



        // I removed the rest so it's easier to read...



}

Now if you try to run it, you will get this error:

Code:

Region: fluid Courant Number mean: 90.0808 max: 1.33005e+06

Region: solid Courant Number mean: 0.437445 max: 0.524934

--> FOAM Warning : 

    From function bool Foam::functionObjectList::read()

    in file db/functionObjects/functionObjectList/functionObjectList.C at line 871

    Caught FatalError 

--> FOAM FATAL ERROR: 



    request for objectRegistry region0 from objectRegistry meredith-half-en-almostworks failed

    available objects of type objectRegistry are



2

(

fluid

solid

)





    From function const Type& Foam::objectRegistry::lookupObject(const Foam::word&) const [with Type = Foam::objectRegistry]

    in file /home/ubuntu/OpenFOAM/OpenFOAM-8/src/OpenFOAM/lnInclude/objectRegistryTemplates.C at line 211.

When using function objects on multiregion cases, you need to define in which region the function has to be applied:

Code:



        Code:


        
Alan_function

{

        type            streamLine;

        libs            ("libfieldFunctionObjects.so");



        region        fluid;



        // I removed the rest so it's easier to read...



}

Here you go, you get your sets in your postProcessing directory.
This is why you had some functions working with simpleFoam but not chtMultiRegionFoam: the region parameter was not defined, and it is obviously only required on multi region cases.

The #includeEtc, or #includeFunc directives are meant to be a handy way to get default functions settings, which you are supposed to adjust to your case if needed.
You can have a look in the section 6.2.2 of the user guide for more details: https://doc.cfd.direct/openfoam/user...processing-cli

I hope this made things a bit clearer.
Yann

Made some progress, but there is still a streamlines problem

Hi Yann,

Finally I managed to get the streamlines working, although this was with the system folder
containing a stream*l*ine file, rather than stream*L*ine. If I used the latter, no sets folder was created. I followed your advice, editing
the files to add the fluid region to my multiregion case, including cuttingPlane, forceCoeffs and streamline.

Here is the text for controlDict:

Code:

application     chtMultiRegionFoam;



startFrom       latestTime;



startTime       0;



stopAt          endTime;



endTime         12;



deltaT          1;



writeControl    timeStep;



writeInterval   10;



purgeWrite      0;



writeFormat     binary;



writePrecision  6;



writeCompression off;



timeFormat      general;



timePrecision   6;



runTimeModifiable true;



functions

{

    #includeFunc streamlines

    //#include "streamLines"

    #include "cuttingPlane"

    #include "forceCoeffs"

    

    FieldsMinMax                // monitor 

    {

        type  fieldMinMax;

        functionObjectLibs      ("libfieldFunctionObjects.so");

        region                  fluid;

        enabled                 true;

        mode                    component;

        writeControl            timeStep;

        writeInterval           5;  // output every 5 time steps, change as needed

        log                     true;

        fields                  (p U k epsilon);  // list of any fields you want to monitor

    }



    FreeMemorySystemCall        // memory

    {

        type                    systemCall;

        region                  fluid;

        libs                    ("libutilityFunctionObjects.so");

        executeCalls            ();

        writeCalls              ("free");

        endCalls                ();

        writeControl            timeStep;

        writeInterval           12;  // Set the interval as required

    }

          

        yplus

        {

            type    yPlus;

            functionObjectLibs ("libfieldFunctionObjects.so");

            

            region  fluid;



            enabled true;



            writeControl outputTime;                      

            

         }



}

And for forceCoeffs:

Code:

forceCoeffs1

{

    type            forceCoeffs;



    libs            ("libforces.so");

    

    region           fluid;



    writeControl    writeTime;

    writeFields     true;





    patches         (fuselage spinner lips fairing radiator-interface edges trailingedge);



    p               p;

    U               U;



    rho             rhoInf;      // Indicates incompressible

    rhoInf          1;           // Redundant for incompressible

    liftDir         (0 0 1);

    dragDir         (1 0 0);

    CofR            (2.0 0 0);  // Axle midpoint on ground

    pitchAxis       (0 1 0);

    magUInf         40.0;

    lRef            6.071;        // Wheelbase length

    Aref            2.2803;        // Estimated

    

    binData

    {

        nBin        20;          // output data into 20 bins

        direction   (1 0 0);     // bin direction

        cumulative  yes;

    }

    

}

And for streamlines (small l):

Code:

#includeEtc "caseDicts/postProcessing/visualization/streamlines.cfg"



fields  (U);  //(U p)



region       fluid;





// Streamline direction: forward, backward, both

direction       forward;



// Select from methods with sub-dictionary settings below

seedMethod      lineUniform;



// Seeding along a line



lineUniform

{

    type            lineUniform;

    start           (1.37 -.095 -.57);

    end             (1.37  -.095 -.68);

    nPoints         50;

}



// Seeding within a volume region

boxUniform

{

    type            boxUniform;

    box             (-1 -1 -1) (1 1 1);

    nPoints         (3 3 3);

}



sphereRandom

{

    type            sphereRandom;

    centre          (0 0 0);

    radius          1;

    nPoints         50;

}



// Seeding at points on a surface

triSurfaceMesh

{

    type            triSurfaceMesh;

    surface         "surfaceMeshFile.obj"; // in constant/triSurface directory

}



// Seeding at a boundary

boundaryRandom

{

    type            boundaryRandom;

    patches         (patch1 patch2);

    nPoints         50;

}



// Seeding a set of points

points

{

    type            points;

    points          (

                        (0 -1 1)

                        (0  0 1)

                        (0  1 1)

                    );

    ordered         on;

}



boundaryPoints

{

    type            boundaryPoints;

    points          (

                        (0 -1 1)

                        (0  0 1)

                        (0  1 1)

                    );

    maxDistance     1;

}



// DO NOT REMOVE from END of file; sets the seedSampleSet

seedSampleSet

{

    ${$seedMethod};

    axis x;

}

Here is some of the run log. It has a lot of warnings, not fatal, that relate to the meshing software that I used:

Code:

Create time



Create fluid mesh for region fluid for time = 0



Create fluid mesh for region solid for time = 0



*** Reading fluid mesh thermophysical properties for region fluid



    Adding to thermoFluid



Selecting thermodynamics package 

{

    type            heRhoThermo;

    mixture         pureMixture;

    transport       polynomial;

    thermo          hPolynomial;

    equationOfState icoPolynomial;

    specie          specie;

    energy          sensibleEnthalpy;

}



    Adding to rhoFluid



    Adding to UFluid



    Adding to phiFluid



    Adding to gFluid



    Adding to hRefFluid



    Adding to pRefFluid



    Adding to ghFluid



    Adding to ghfFluid



    Adding to turbulenceFluid



Selecting turbulence model type RAS

Selecting RAS turbulence model kEpsilon

RAS

{

    model           kEpsilon;

    turbulence      on;

    printCoeffs     on;

    Cmu             0.09;

    C1              1.44;

    C2              1.92;

    C3              0;

    sigmak          1;

    sigmaEps        1.3;

}



    Adding to thermophysicalTransport



Selecting thermophysical transport type RAS

Selecting default RAS thermophysical transport model eddyDiffusivity

    Adding to reactionFluid



Combustion model not active: combustionProperties not found

Selecting combustion model none

    Adding to radiationFluid



Radiation model not active: radiationProperties not found

Selecting radiationModel none

    Adding to KFluid



    Adding to dpdtFluid



    Adding to fieldsFluid



    Adding MRF



No MRF models present



    Adding fvOptions



Creating finite volume options from "constant/fvOptions"



Selecting finite volume options model type constantHeatTransfer

    Source: fluidTosolid

Selecting finite volume options model type interRegionExplicitPorositySource

    Source: porosityBlockage

- selecting inter region mapping

Creating mesh-to-mesh addressing for fluid and solid regions using cellVolumeWeight

    Overlap volume: 0.00219013

Selecting finite volume options model type limitTemperature

    Source: limitT

    - selecting all cells

    - selected 154985 cell(s) with volume 6368.32

*** Reading fluid mesh thermophysical properties for region solid



    Adding to thermoFluid



Selecting thermodynamics package 

{

    type            heRhoThermo;

    mixture         pureMixture;

    transport       polynomial;

    thermo          hPolynomial;

    equationOfState icoPolynomial;

    specie          specie;

    energy          sensibleEnthalpy;

}



    Adding to rhoFluid



    Adding to UFluid



    Adding to phiFluid



    Adding to gFluid



    Adding to hRefFluid



    Adding to pRefFluid



    Adding to ghFluid



    Adding to ghfFluid



    Adding to turbulenceFluid



Selecting turbulence model type laminar

Selecting laminar stress model Stokes

    Adding to thermophysicalTransport



Selecting thermophysical transport type laminar

Selecting default laminar thermophysical transport model Fourier

    Adding to reactionFluid



Combustion model not active: combustionProperties not found

Selecting combustion model none

    Adding to radiationFluid



Radiation model not active: radiationProperties not found

Selecting radiationModel none

    Adding to KFluid



    Adding to dpdtFluid



    Adding to fieldsFluid



    Adding MRF



No MRF models present



    Adding fvOptions



Creating finite volume options from "constant/fvOptions"



Selecting finite volume options model type constantHeatTransfer

    Source: solidTofluid

- selecting inter region mapping

Creating mesh-to-mesh addressing for solid and fluid regions using cellVolumeWeight

--> FOAM Warning : 

    From function Foam::triFace Foam::tetIndices::faceTriIs(const Foam::polyMesh&) const

    in file meshes/polyMesh/polyMeshTetDecomposition/tetIndicesI.H at line 76

    No base point for face 1419, 6(2623 2627 2628 2629 2630 2624), produces a valid tet decomposition.

--> FOAM Warning : 

    From function Foam::triFace Foam::tetIndices::faceTriIs(const Foam::polyMesh&) const

    in file meshes/polyMesh/polyMeshTetDecomposition/tetIndicesI.H at line 76



--> FOAM Warning : 

    From function Foam::triFace Foam::tetIndices::faceTriIs(const Foam::polyMesh&) const

    in file meshes/polyMesh/polyMeshTetDecomposition/tetIndicesI.H at line 76

    No base point for face 336351, 9(352955 352951 352950 352945 128918 128916 128925 128933 352954), produces a valid tet decomposition.

Reading surface description:

    yNormal



streamLine streamlines write:

    seeded 50 particles

    Tracks:50

    Total samples:16840

    Writing data to "/home/boffin5/cfdaero/meredith-en-dell2/postProcessing/sets/streamlines/fluid/0"

Region: fluid Courant Number mean: 90.0808 max: 1.33005e+06

Region: solid Courant Number mean: 0.437445 max: 0.524934

Time = 1

.

.

.

Time = 12





Solving for fluid region fluid

DILUPBiCGStab:  Solving for Ux, Initial residual = 0.00028733, Final residual = 6.20676e-06, No Iterations 1

DILUPBiCGStab:  Solving for Uy, Initial residual = 0.000169537, Final residual = 4.37575e-06, No Iterations 1

DILUPBiCGStab:  Solving for Uz, Initial residual = 0.00143944, Final residual = 3.61902e-05, No Iterations 1

DILUPBiCGStab:  Solving for h, Initial residual = 0.0635227, Final residual = 0.00510205, No Iterations 21

Min/max T:279.829 305.813

GAMG:  Solving for p_rgh, Initial residual = 0.000684261, Final residual = 2.09175e-06, No Iterations 5

time step continuity errors : sum local = 1.70058e-06, global = 3.27887e-07, cumulative = 3.27887e-07

DILUPBiCGStab:  Solving for epsilon, Initial residual = 0.00744825, Final residual = 2.42548e-06, No Iterations 1

DILUPBiCGStab:  Solving for k, Initial residual = 0.00671512, Final residual = 9.4212e-06, No Iterations 1



Solving for fluid region solid

DILUPBiCGStab:  Solving for Ux, Initial residual = 0.377755, Final residual = 0.000121298, No Iterations 1

DILUPBiCGStab:  Solving for Uy, Initial residual = 0.141345, Final residual = 7.23171e-05, No Iterations 1

DILUPBiCGStab:  Solving for Uz, Initial residual = 0.155198, Final residual = 9.26559e-05, No Iterations 1

DILUPBiCGStab:  Solving for h, Initial residual = 0.0246786, Final residual = 4.36518e-05, No Iterations 1

Min/max T:377.352 377.59

GAMG:  Solving for p_rgh, Initial residual = 0.616704, Final residual = 0.00443168, No Iterations 1

time step continuity errors : sum local = 5.50618e-07, global = 4.5934e-07, cumulative = 4.5934e-07

ExecutionTime = 239.52 s  ClockTime = 249 s



End

So I now get streamlines, but my big problem is that for the chtmultiregion case they
do not flow properly around the body. However for the simpleFoam case they look great.
See the attached image.

For the multiregion case, on the outside of the duct, they just flow to the surface and stop,
rather than flowing around. On the inside, they do not diverge to follow the expanding duct,
but just stay towards the bottom. This is inconsistent with the paraview image of the U field.
In this, the maximum velocity is in the middle of the radiator, but the streamlines don't flow
there at all. Also included is the image for the p field, which seems reasonable. This is
with the darcy-forchheimer coeffcients set at d(20 20 20) and f(20 20 20) which is a very low
flow restriction.

Using the same CAD geometry, I have used two different meshing packages to create the mesh,
but the results have been the same, which indicates that the problem is inherent to my case setup.
What in the world am I doing wrong?

Hello Alan,

Are you using the same boundary conditions on both simpleFoam and chtMultiRegionFoam?

As far as I remember, you set a velocity value on the wall on your CHT case, which does not really make sense (it should be either slip, noSlip, or fixedValue uniform (0 0 0)).
This could explain why the streamlines stop at the wall.

Regards,
Yann

OMG! It worked! But failed at time step 5 - almost there!

Hi Yann,

You were right about the U boundary condition; what I had was stupid and I am a bit embarrassed. But when I fixed the U bc's, the case failed at time step 6, so I changed it to stop at 5, and the streamlines look awesome!

There is still an issue with the bc's, so I am showing them to see if you can save me again, as if you haven't done it enough already (this in lieu of my normal practice of wildly changing values):

fluid p:

Code:

 dimensions      [1 -1 -2 0 0 0 0];



internalField   uniform 90812;  //84559



boundaryField

{

    #includeEtc "caseDicts/setConstraintTypes"

    

    frontier

    {

        type            slip;

    }

       

    inlet

    {

        type            calculated;

        value           uniform 90812;

    }

    

    outlet

    {

        type            calculated;

        value           uniform 90812;

    }

    

    fuselage

    {

        type            calculated;

        value           uniform 90812;

    }

    

    spinner

    {

        type            calculated;

        value           uniform 90812;

    }

    

    lips

    {

        type            calculated;

        value           uniform 90812;

    }

    

    fairing

    {

        type            calculated;

        value           uniform 90812;

    }

    

    flap

    {

        type            calculated;

        value           uniform 90812;

    }

    

    radiator-interface {

        type            calculated;

        value           uniform 90812;

        }

    edges {

        type            calculated;

        value           uniform 90812;

        }

    trailingedge {

        type            calculated;

        value           uniform 90812;

        } 

  }

--------------------------------------

fluid p_rgh:

Code:

dimensions      [1 -1 -2 0 0 0 0];



internalField   uniform 90812;  //84559



boundaryField

{

    #includeEtc "caseDicts/setConstraintTypes"

    

    frontier

    {

        type            slip;

    }

    

    inlet

    {

        type            fixedFluxPressure;

    }

    

    outlet

    {

        type            fixedValue;

        value           $internalField;

    }

    

    fuselage

    {

        type            fixedFluxPressure;

    }

    

    spinner

    {

        type            fixedFluxPressure;

    }

    

    lips

    {

        type            fixedFluxPressure;

    }

    

    fairing

    {

        type            fixedFluxPressure;

    }

    

    flap

    {

        type            fixedFluxPressure;

    }

    

    radiator-interface {

        type fixedFluxPressure;

        }

    edges {

        type fixedFluxPressure;

        }

    trailingedge {

        type fixedFluxPressure;

        } 

  }

----------------------------------------------------

fluid T:

Code:

dimensions      [0 0 0 1 0 0 0];



internalField   uniform 282.214;



boundaryField

{

    #includeEtc "caseDicts/setConstraintTypes"

    

    frontier

    {

              type            slip;

    }

        

    inlet

    {

        type            fixedValue;

        value           uniform 282.214;

    }

    

    outlet

    {

        type            inletOutlet;

        inletValue      uniform 282.214;

        value           uniform 282.214;

    }

    

    fuselage

    {

        type            zeroGradient;

    }

    

    spinner

    {

        type            zeroGradient;

    }

    

     lips

    {

        type            zeroGradient;

    }

    

     fairing

    {

        type            zeroGradient;

    }

    

     flap

    {

        type            zeroGradient;

    }



     radiator-interface {

        type zeroGradient;

        }

    edges {

        type zeroGradient;

        }

    trailingedge {

        type zeroGradient;

        } 

  }

-----------------------------------------------------

fluid U:

Code:

dimensions      [0 1 -1 0 0 0 0];



internalField   uniform (59.161 0 0);



boundaryField

{

    #includeEtc "caseDicts/setConstraintTypes"

    

    frontier

    {

        type            slip;

    }

    

    inlet

    {

        type            fixedValue;

        value           uniform (59.161 0 0);

    }

    

    outlet

    {

        type            inletOutlet;

        inletValue      uniform (0 0 0);

        value           uniform (0 0 0);

    }

    

    fuselage

    {

        type            noSlip;

    }

    

    spinner

    {

        type            noSlip;

    }

    

    lips

    {

        type            noSlip;

    }

    

    fairing

    {

        type            noSlip;

    }

    

    flap

    {

        type            noSlip;

    }

    

    radiator-interface {

        type noSlip;

        }

    edges {

        type noSlip;

        }

    trailingedge {

        type noSlip;

        }

  }

------------------------------------------------

solid p:

Code:

dimensions      [1 -1 -2 0 0 0 0];

  

internalField   uniform 90812;



boundaryField

{

    #includeEtc "caseDicts/setConstraintTypes"

    

    frontier

    {

        type            slip;

    }

        

    inlet

    {

        type            calculated;

        value           uniform 90812;

    }

    

    outlet

    {

        type            calculated;

        value           uniform 90812;

    }

      

    

     rad_radinlet

    {

        type            calculated;

        value           uniform 90812;

    }

    

    rad_radoutlet

    {

        type            calculated;

        value           uniform 90812;

    }



    rad_radfrontier

    {

        type            calculated;

        value           uniform 90812;

    }

       

    "proc.*"

    {

        type processor;

    }



    

  }

----------------------------------------------------

solid p_rgh:

Code:

dimensions      [1 -1 -2 0 0 0 0];

  

internalField   uniform 90812;



boundaryField

{

    #includeEtc "caseDicts/setConstraintTypes"

    

    frontier

    {

        type            slip;

    }

        

    inlet

    {

        type            fixedFluxPressure;

    }

    

    outlet

    {

        type            fixedValue;

        value           uniform 90812;

    }

    

    

    rad_radinlet

    {

        type            fixedFluxPressure;

    }

    

    rad_radoutlet

    {

        type            fixedValue;

        value           uniform 90812;

    }



    rad_radfrontier

    {

        type            fixedFluxPressure;        

    }

    



    "proc.*"

    {

        type processor;

    }



  }

--------------------------------------------------

solid T:

Code:

dimensions      [0 0 0 1 0 0 0];

  

internalField   uniform 377.59;



boundaryField

{

    #includeEtc "caseDicts/setConstraintTypes"

    

    frontier

    {

        type            slip;

    }

        

    inlet

    {

        type            fixedValue;

        value           uniform 377.59;

    }

    

    outlet

    {

        type            inletOutlet;

        inletValue      uniform 377.59;

        value           uniform 377.59;

    }

    

   

    rad_radinlet

    {

        type            fixedValue;

        value           $internalField;

    }

    

    rad_radoutlet

    {

        type            inletOutlet;

        inletValue      $internalField;

        value           $internalField;

    }



    rad_radfrontier

    {

        type            zeroGradient;

    }

    

   

    

    "proc.*"

    {

        type processor;

    }

  }

--------------------------------------------

solid U:

Code:

dimensions      [0 1 -1 0 0 0 0];



//internalField   uniform (10 0 0);

internalField   uniform (0.01 0 0);



boundaryField

{

    #includeEtc "caseDicts/setConstraintTypes"

    

    frontier

    {

        type            slip;

    }

        

    inlet

    {

        type            fixedValue;

        value           uniform (0.01 0 0);

    }

    

    outlet

    {

        type            inletOutlet;

        inletValue      uniform (0 0 0);

        value           uniform (0 0 0);

    }

   

    

    rad_radinlet

    {

        type            fixedValue;

        value           uniform (0.01 0 0);

    }

    

    rad_radoutlet

    {

        type            inletOutlet;

        inletValue      uniform (0 0 0);

        value           uniform (0 0 0);

    }



    rad_radfrontier

    {

        type            noSlip;

    }

   

    

    "proc.*"

    {

        type processor;

    }



}

With your help, I can see the light at the end of the tunnel, after having literally been working on this case for years. But hey, sometimes it takes a little while!

I should have mentioned, it fails with the "Energy -> temperature conversion failed to converge:" message.