OpenFOAM

I would disagree in this case, afaik the paper from 2006/09 from Menter and Langtry both states they want to extent it to a crossflow term but werent able to quite yet. They judge it as a really important parameter, and results show that when you have dominant crossflow it can transition way earlier when comparing to the older model. Fluent, CFX and StarCCM+ have it all implemented afaik.

https://tenor.com/view/friends-joey-tribbiani-matt-le-blanc-wink-gif-15694137

https://arc.aiaa.org/doi/abs/10.2514/6.2015-2474

SU2 also has an implementation of this btw

So I was a bit suprised when OpenFOAM did not include any

Probably lack of user enquiry early on /support priorities later on

eh, I guess so. No idea how OpenFOAM development works

The turbulence models are a bit of a mess of OOP, so they're a bit odd to figure out how to compile first couple of times

But if you've created a custom boundary condition before, turbulence models aren't dramatically more complex

I have exactly 0 C knowledge, or programming overall

Aerospace Engineer, not a software engineer

Ah yeah, you might find it a bit tricky then

TBH, I dont see what the base model itself is.. gamma-Rtheta model? I was assuming that it would be in the k-omega family, since this was from Menter

Anyway, for now I am just going to be using the base model, without crossflow extension. Although that being said, my intermittency is 1 across my entire airfoil and goes laminar in my airfoil wake region.

Exactly as expected... awesome (not)

It is, OpenFOAM implements it as kOmegaSSTLM

mm.. as a starting point, can you differentiate the base and corrected models on pen and paper? outside of the programming part...

The only difference is a source term in the transport equation for Rethetat I believe

Okay,. and have you gone through the source code of kOmegaSSTLM? The good thing about openfoam is that the variables are named in english

```
        // Transition onset momentum-thickness Reynolds number equation
        tmp<fvScalarMatrix> ReThetatEqn
        (
            fvm::ddt(alpha, rho, ReThetat_)
          + fvm::div(alphaRhoPhi, ReThetat_)
          - fvm::laplacian(alpha*rho*DReThetatEff(), ReThetat_)
         ==
            Pthetat*ReThetat0(Us, dUsds, nu) - fvm::Sp(Pthetat, ReThetat_)
          + fvOptions(alpha, rho, ReThetat_)
        );  
        

```

That is this guy?
https://cdn.discordapp.com/attachments/1499412948110676008/1499414074125975733/image.png?ex=69f4b5ad&is=69f3642d&hm=d3676fedd4372d3273629cfda67c8041feaa90265263c0b555519e1052379723&

This above is the Rtheta eqn but there are also a bunch of other places in the same file where the variable is corrected in the file.. so, in order to make a correction, those need to be correlated to the math, so we know where to add your term


https://cdn.discordapp.com/attachments/1499412948110676008/1499414663098798090/image.png?ex=69f4b639&is=69f364b9&hm=2e473ec91bef00fd31e0df53d3328a8708c16e9ed4e74830e9e12b4a2079ed51&


https://cdn.discordapp.com/attachments/1499412948110676008/1499414696023822476/image.png?ex=69f4b641&is=69f364c1&hm=cb2c25af8beaa75d9e1b7c2624c4a3f0866af1a50566f64257d4c4eef3d705b5&

yes terms on LHS of the code I sent, those are the ddt, convection and diffusion terms in your equation, and the other one is Ptheta but it seems to be written in a different form (the equation seems to include ReTheta inside it) while in the code there is an expanded form calculating ReTheta_0 from other flow quantities


https://cdn.discordapp.com/attachments/1499412948110676008/1499414853738041414/image.png?ex=69f4b666&is=69f364e6&hm=055339d6ac8bb145acf5c648047b3b03132a6fd3f24816308f84ed6a9400e066&


https://cdn.discordapp.com/attachments/1499412948110676008/1499414879692521583/image.png?ex=69f4b66d&is=69f364ed&hm=949598de135bcb425afc163c64a35921e70c20cf065a2ffaefb82ff6b61a18a7&

This is the new stuff afaik, with the 2015 implementation

lol dont send me symbols I am not going to write it XD

yeah yeah, I am just putting it here so we can look at it

But you can see the new term, which is given with the stuff below

mm I think a starting point would be to compare Ptheta thingy in the original math, to the DSCF thingy in the new one... 
and side by side, look at the Ptheta *ReTheta_0 calculation in the code so you know what is to be changed

I am guessing OF just writes the long equation without splitting the operators into easier terms?

`` Pthetat*ReThetat0(Us, dUsds, nu)``

does a long calculation based on lambda and exponentials...

also OF I just realized is not a great abbreviation for OpenFOAM these days

Here is the original model equation for Rethetat
https://cdn.discordapp.com/attachments/1499412948110676008/1499415682696347658/image.png?ex=69f4b72c&is=69f365ac&hm=9c3c319b73a262943714b4d5ff667a7f66ae3b1fb778458103e29b7a07fb5885&

```
Pthetat*ReThetat0(Us, dUsds, nu) - fvm::Sp(Pthetat, ReThetat_)
          + fvOptions(alpha, rho, ReThetat_)
```

``fvm::Sp(Pthetat, ReThetat_)
          + fvOptions(alpha, rho, ReThetat_)`` that is for additional terms...

your equation stops here" ``Pthetat*ReThetat0(Us, dUsds, nu)``

```
 tmp<fvScalarMatrix> ReThetatEqn
        (
            fvm::ddt(alpha, rho, ReThetat_)
          + fvm::div(alphaRhoPhi, ReThetat_)
          - fvm::laplacian(alpha*rho*DReThetatEff(), ReThetat_)
         ==
            Pthetat*ReThetat0(Us, dUsds, nu) - fvm::Sp(Pthetat, ReThetat_)
          + fvOptions(alpha, rho, ReThetat_)
        ); 
```

So this is the full equation, then I have a temporal term also in the equation and a spatial term as divergence as well. The laplacian is now only for additional source terms?

Because the == shows P_thetat and the diffusion part of the viscosity as well (i think)

```
   fvm::ddt(alpha, rho, ReThetat_)
          + fvm::div(alphaRhoPhi, ReThetat_)
          - fvm::laplacian(alpha*rho*DReThetatEff(), ReThetat_)
         ==
            Pthetat*ReThetat0(Us, dUsds, nu)
```
this corresponds to the four terms you mentioned.
the fvOptions and fvm::Sp terms are extra for now

In the code, the laplacian has negative sign and goes to LHS, so it is simply a rerrangement of the terms so that the usual things are on the LHS (ddt, div and laplacian are common terms in all transport equations)

Essentially the ``Pthetat*Rthetat0()`` is what does the special tricks more or less... so we need to look at what it does.

Here's ``Pthetat`` in this term:

```
Pthetat(         alpha()*rho()*(cThetat_/t)*(1 - Fthetat));

```

and it is multiplied with a Rethetat0 which is a bunch of long-ass calculation

but the actual value of ReTheta0 comes down to something like this:
`` ReThetat0[celli] = max(thetat*Us[celli]/nu[celli], scalar(20));`` where ``thetat`` comes from an iterative loop and ``Us`` etc are coming from local flow, I think

My question for you is how does this correspond to the math side of Ptheta


https://cdn.discordapp.com/attachments/1499412948110676008/1499418845918789724/image.png?ex=69f4ba1e&is=69f3689e&hm=2b4ac18c570547f9d818d7f0af5dc6f3c8fdacf6111662993813b8e72446a7d8&

mmm whats the notation... what is the tilde term?

tilde is the actual transport variable, Rethetat is an empirical correlation

this would be better
https://cdn.discordapp.com/attachments/1499412948110676008/1499420091526283324/image.png?ex=69f4bb47&is=69f369c7&hm=848b5ccd66724fed1e849bd169d2524d4691548db73dbe956ed19033223a22c5&

I also gave the OpenFOAM implementation to a LLM and it spat out this mathematical equation


https://cdn.discordapp.com/attachments/1499412948110676008/1499420264562163924/image.png?ex=69f4bb70&is=69f369f0&hm=41c2816ef73d34fdee2849ad256ac3dbd85968e81bf1ae5a87ce5137a16a7a93&

aa okay yes.... I  made a mistake when I sent you the equation code.
``            Pthetat*ReThetat0(Us, dUsds, nu) - fvm::Sp(Pthetat, ReThetat_)
``
These two terms together do that subtraction

Together they form the PthetaT shown here

THe new term looks similar to the Ptheta term earlier, so actual addition may look similar. But the main challenge is the components of this Dscf...

why would it combine this effect? I thought its not included yet as the D term comes from the 2015 expansion

Okay look again at the equation in code:

```
            fvm::ddt(alpha, rho, ReThetat_)
          + fvm::div(alphaRhoPhi, ReThetat_)
          - fvm::laplacian(alpha*rho*DReThetatEff(), ReThetat_)
         ==
            Pthetat*ReThetat0(Us, dUsds, nu) - fvm::Sp(Pthetat, ReThetat_)
          + fvOptions(alpha, rho, ReThetat_)
```
The first three terms are time convection and diffusion.... (which are the terms 1,2 and 4 in the base equation)... The P term can be expanded into a difference of two terms... those are these two terms:
`` Pthetat*ReThetat0(Us, dUsds, nu) - fvm::Sp(Pthetat, ReThetat_)`` ... the fvm::Sp is a way to write a source-term which implicitly has the transported variables

so your DSCF term has a similar form with ``Rscf - Rtheta``
so, in the code, it would probably take a form like so:

``
 Dscf*ReSCF(..) - fvm::Sp(Dscf, ReThetat_)
``
does that make sense?

note that ``Dscf`` here is something like this:
``Pthetat(         alpha()*rho()*(cThetat_/t)*(1 - Fthetat));``
meaning that it is the other terms apart from ReTheta terms...

so in the Dscf implementation we will have
``Dscf
        ( alpha()*rho()*(cscf_/t)*(1 - Fthetat2));``
where cscf is some constant value...
and our final challenge is to calculate ``Ftheta2`` and ``Rscf``

this the ``Rscf`` term, so the main issue it to identify streamwise direction here....

and simialrly for ``Ftheta2`` there are some wake related parameters which I think are equations 15-20 in the correction paper

so you will basically need to write those down 😛

something which I think you'll be able to do in a week or so

there goes my hopes of being any good at explaning things 😄

sorry to break your heart but at some points you need to do it if you want to work beyond the normal computing situations...

Having said that, I would suggest to read the above thread at ease. there are hints on how you can look at the existing code in the file, and then add similar terms for newer physics...

yeah I know, I think I can do it but it will take some time to understand it

the aerospace challenge for you would be to find a way to determine streamwise direction to calculate your psi in your calculation

Feel free to ask away here or in <#814043123810304041>... people do help with the day to day struggles of coding up openfoam...

for a starting point, look up a tutorial on how to build custom BC, or custom turbulence Model... make a copy of the kOmegaSSTLM as kOmegaSSTLennyGo... and try to make sure it gets detected in the list of available models... then you can go about messing inside it, without breaking anything

(Hint: do a search for every occurence of kOmegaSSTLM, and create an identical of every single thing called kOmegaSSTLennyGo

I think the biggest issue associated is that i will have to proove that it works. And... I think only wings exist for checking this crossflow term and I really dont wanna use Snappy

I would rather use a given mesh for validating it, but idk if I can get any

You could seek help from otaola if you know reference mesh diagrams

Also, anyone who proposes something is likely to say it's super important, and the next big solution. A more honest estimate is to see others in the field who tested it and whether they agreed that it was actually good.

Rtheta model correction

Coding in openfoam is quite trivial at least to me, you have plenty of example source code things becomes difficult (for me) when you really have to implement a separate algorithm like additional Newton Raphson loop, but adding terms to equation should not be that hard right? Or atleast I would think so, at last it will take some time. More general pattern recognition than coding.

Well, turbulence models can be dense sometimes, because the underlying model is often quite complex with secondary functions... And then the implementations adjust things further from a coding perspective. All often is within a lot of templating. So I think it can be one of the more complex modules for a beginner. But also quite rewarding in order to understand OpenFoam as a library

Turbulence modeling -> regression analysis -> happy

Has anyone used the DeardorffDiffStress LES turbulence model?  What variables do I need to set boundary conditions for that one?