[boffin5]

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:

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!

[boffin5]

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

[boffin5]

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

It fails with this message:

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!

[boffin5]

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.

[boffin5]

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

[boffin5]

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?

[boffin5]

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

streamLine streamLines write:
    seeded 0 particles
    Tracks:0
    Total samples:0

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

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.

[boffin5]

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!

[Yann]

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.:

region    fluid;

Originally Posted by boffin5

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:

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

[boffin5]

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:

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:

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:

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:

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:

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

[Yann]

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:

#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:

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:

/*--------------------------------*- 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:

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:

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:

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:

	
	
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

[boffin5]

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:

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:

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):

#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:

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?

[Yann]

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

[boffin5]

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:

 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:

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:

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:

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:

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:

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:

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:

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!

[boffin5]

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