[MMRC]

Dear community, maybe my math skills are not current enough to confirm these 02 implementations are the same. Please check with me the production term and the FIRST term in the right side of the dissipation rate equation that for both software, are not the same, or are they?:


In openfoam ESI either 2012 or 2306 we have for production term:

const volScalarField::Internal divU
(fvc::div(fvc::absolute(this->phi(), U))().v() );
tmp<volTensorField> tgradU = fvc::grad(U);     const volScalarField::Internal GbyNu
     (
this->type() + ":GbyNu",
         tgradU().v() && dev(twoSymm(tgradU().v()))
     );
     const volScalarField::Internal G(this->GName(), nut()*GbyNu);
     tgradU.clear();

And, for epsilon equation this:

// Dissipation equation
      tmp<fvScalarMatrix> epsEqn
     (
         fvm::ddt(alpha, rho, epsilon_)
       + fvm::div(alphaRhoPhi, epsilon_)
       - fvm::laplacian(alpha*rho*DepsilonEff(), epsilon_)
      ==
         C1_*alpha()*rho()*GbyNu*Cmu_*k_()
 - fvm::SuSp(((2.0/3.0)*C1_ - C3_)*alpha()*rho()*divU, epsilon_)
 - fvm::Sp(C2_*alpha()*rho()*epsilon_()/k_(), epsilon_)
       + epsilonSource()
       + fvOptions(alpha, rho, epsilon_)
     );

In openfoam Foundation 9, we have for production term:

                           volScalarField::Internal divU
     (
         fvc::div(fvc::absolute(this->phi(), U))()
     );
 
 
     tmp<volTensorField> tgradU = fvc::grad(U);
     volScalarField::Internal G
     (
         this->GName(),
         nut()*(dev(twoSymm(tgradU().v())) && tgradU().v())
     );
     tgradU.clear();

And, for epsilon equation this:

  // Dissipation equation
                 tmp<fvScalarMatrix>             epsEqn
                 (
                     fvm::ddt(alpha,             rho, epsilon_)
                   +             fvm::div(alphaRhoPhi, epsilon_)
                   -             fvm::laplacian(alpha*rho*DepsilonEff(), epsilon_)
                  ==
                                 C1_*alpha()*rho()*G*epsilon_()/k_()
             -             fvm::SuSp(((2.0/3.0)*C1_ - C3_)*alpha()*rho()*divU, epsilon_)
              -             fvm::Sp(C2_*alpha()*rho()*epsilon_()/k_(), epsilon_)
                   +             epsilonSource()
                   +             fvModels.source(alpha, rho, epsilon_)
                 );

Key differences are:
1) In the section of Production G definition in ESI version, these variables are set as constants, would this imply they won't be modifiable while running the simulation?

2) Curiousity, is this math operation conmmutative of dot products commutative in order to asume that both source codes 'implements the same' ?

ESI:
const volScalarField::Internal GbyNu
(
IOobject::scopedName(this->type(), "GbyNu"),
tgradU().v() && devTwoSymm(tgradU().v())
);
const volScalarField::Internal G(this->GName(), nut()*GbyNu);


Foundation:
volScalarField::Internal G
(
this->GName(),
nut()*(dev(twoSymm(tgradU().v())) && tgradU().v())
);
3) The first term in RHS of dissipation equation... both are the same, right?
ESI: C1_*alpha()*rho()*GbyNu*Cmu_*k_()
Foundation: C1_*alpha()*rho()*G*epsilon_()/k_()


I'd truly appreciate any clarification.

[MMRC]

Hello community,

I solved my inquiry. Even though ESI and Foundation looks different in code implementation, at the end is the same. I tested by changing the definition of G and the first term of the RHS of transport of epsilon, in different tests and it prompts the same.

My inquiry came from the trying to implement a new type of turbulence model based on k-e and changing the way of cumputing nut. My first experience was getting different results than expected, and the issue was in these lines of code where my modified nut was not considered because old definition was used.

[Tobermory]

1) In the section of Production G definition in ESI version, these variables are set as constants, would this imply they won't be modifiable while running the simulation?

Not quite - remember that the contents of GbyNu are discarded once the variable goes out of scope, i.e. once the kEpsilon::correct() function has executed. It then gets created afresh (as a const) when the correct function is next called, i.e. the next iteration. The const label simply means that within the correct() function it is constant. I am not sure why the change was made - it's probably more correct/safer .... pls comment anyone else if you have insight to share.

2) Curiousity, is this math operation conmmutative of dot products commutative in order to asume that both source codes 'implements the same' ?

The double dot product is indeed commutative - just think about how the above terms expand out, and you'll see you have terms like , which is the same as since multiplication is commutative.

3) The first term in RHS of dissipation equation... both are the same, right?

Yes. Just substitute the definition of nut in and you will see that GbyNu*Cmu_*k_() is the same as G*epsilon_()/k_()

[MMRC]

Hola Tobermory, I trully appreciate your reply, thanks for the clarifications.

Originally Posted by Tobermory

Not quite - remember that the contents of GbyNu are discarded once the variable goes out of scope, i.e. once the kEpsilon::correct() function has executed. It then gets created afresh (as a const) when the correct function is next called, i.e. the next iteration. The const label simply means that within the correct() function it is constant. I am not sure why the change was made - it's probably more correct/safer .... pls comment anyone else if you have insight to share.


The double dot product is indeed commutative - just think about how the above terms expand out, and you'll see you have terms like , which is the same as since multiplication is commutative.



Yes. Just substitute the definition of nut in and you will see that GbyNu*Cmu_*k_() is the same as G*epsilon_()/k_()