[dlahaye]

Why is the constructor for the thermo class called without brackets and the constructor for the turbulence class called with brackets.

Apologies for my low literacy in C++. Thx!

[Tobermory]

Not sure I follow you Domenico - do you want to add an example?

[dlahaye]

Thanks for the reply.

An example is line 67 of createFields of reactingFoam at https://develop.openfoam.com/Develop...createFields.H

Motivating my question is the desire of understanding for the combustion model is implemented.

It appears that the implementation of EDM combustion model is not the standard implementation. We thus might want to change that to be able to compare with standard implementations in various other codes.

Cheers, Domenico.

[Lorenzo210]

Hi,
First of all, let me say that I consider myself as a beginner, so I cannot be totally sure of my suggestion.

Could it be that thermo is defined as an object, whereas turbulence is a pointer?
Looking at createFields.H, thermo is defined in line 5 (see that also pThermo, which is a pointer, is called with parentheses):

psiReactionThermo& thermo = pThermo();

turbulence is defined in line 53:

autoPtr<compressible::turbulenceModel> turbulence
(
    compressible::turbulenceModel::New
    (
        rho,
        U,
        phi,
        thermo
    )
);

Regards,

Lorenzo

[dlahaye]

Dear Lorenzo,

Thank you so much for pointing me in the (what I perceive to be) the correct direction!

Here is my current understanding of what is happening.

For thermo: First, pThermo() is created as an autoPtr. Next, thermo is cast to a pointer.

autoPtr<psiReactionThermo> pThermo(psiReactionThermo::New(mesh));
psiReactionThermo& thermo = pThermo();


For turbulence: turbulence is created as an autoPtr. This is the only step. A possible reason is that turbulence is not used as argument to create an autoPtr (unlike thermo).

autoPtr<compressible::turbulenceModel> turbulence
(
    compressible::turbulenceModel::New
    (
        rho,
        U,
        phi,
        thermo
    )
);

Grazie ancora.

[Tobermory]

Domenico

just a few refinements to your earlier post:

Originally Posted by dlahaye

For thermo: First, pThermo() is created as an autoPtr. Next, thermo is cast to a pointer.
For turbulence: turbulence is created as an autoPtr. This is the only step. A possible reason is that turbulence is not used as argument to create an autoPtr (unlike thermo).

I think that a more precise version is as follows:
1. On line 4 of createFields.H, a new psiReactionThermo object is created; this returns a pointer that is assigned to smart pointer pThermo

autoPtr<psiReactionThermo> pThermo(psiReactionThermo::New(mesh));

2. A reference (think of it as an alias) is set to this psiReactionThermo object called thermo, not a pointer; to set the reference you need to address the object (eg int& x = y), and for the autoPtr class you do that with operator() - see line 135 in autoPtrI.H. So that is why we have pThermo() on line 5 of createFields.

psiReactionThermo& thermo = pThermo();

3. Thereafter, the code uses thermo as a shorthand for pThermo()
4. The turbulence model is constructed in a similar way - first, create a new momentumTransportModel object and assign its pointer to smart pointer called turbulence

 autoPtr<compressible::momentumTransportModel> turbulence
 (
     compressible::momentumTransportModel::New
     (
         rho,
         U,
         phi,
         thermo
     )
 );

5. to reference the turbulence model object, you need to call the autoPtr operator() method, i.e. you use turbulence(). An example of this is a few lines later in createFields:

psiReactionThermophysicalTransportModel::New(turbulence(), thermo)

but I guess that this could have been written as:

psiReactionThermophysicalTransportModel::New(turbulence(), pThermo())

Is that a little clearer? For many years I had shied away from looking "under the hood" at what exactly are autoPtr and tmp ... the coding is actually pretty simple, so if you have an afternoon then have a look ... just make some notes, since I find that the "knowledge" is pretty transient!

[dlahaye]

Perfectly clear, thank you so much!

Domenico.