[openfoammaofnepo]

Dear all,

Similar to the filtering operation in dynamic Smagorinsky model for the incompressible flows:

homogeneousDynSmagorinsky.H

I am trying to use the same filtering operations in one of the applications, like rhoPimepleFoam. In order to see how the filtering is applied, I first read the code of homogeneousDynSmagorinsky, but I have two questions:

1, How the class LESfilter is initialized? In homogeneousDynSmagorinsky.H, it appears as the priviate data:

LESfilter& filter_

I think filter is initialized when homogeneousDynSmagorinsky is initilized but I did not find where the latter is initialzied.

2, In homogeneousDynSmagorinsky.C, the filter operation is applied as filter_(x), I do not why here filter_(*) is used like a function, it is an object!

Thank you so much if anyone can provide some guidance.

[wyldckat]

Hi OFFO (the acronym OF is a lot easier to write ),

If the questions were about hard-core LES mathematics, I wouldn't be able to answer, but since it's C++ related questions, here we go:

Originally Posted by openfoammaofnepo

1, How the class LESfilter is initialized? In homogeneousDynSmagorinsky.H, it appears as the priviate data:

LESfilter& filter_

I think filter is initialized when homogeneousDynSmagorinsky is initilized but I did not find where the latter is initialzied.

This is a two sided issue:

• A bit of class inheritance: http://www.cplusplus.com/doc/tutorial/inheritance/
• But mostly variables by reference: http://www.cplusplus.com/articles/ENywvCM9/

Let's look at the C file: https://github.com/OpenFOAM/OpenFOAM...nSmagorinsky.C

1. Looking at the constructor:
   

   homogeneousDynSmagorinsky::homogeneousDynSmagorinsky
   (
       const volVectorField& U,
       const surfaceScalarField& phi,
       transportModel& transport,
       const word& turbulenceModelName,
       const word& modelName
   )

2. You'll see this:
   

   filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
   filter_(filterPtr_())

   The first line initializes "filterPtr_" with a new "LESfilter". The second line will assign to the reference variable "filter_" the memory address pointed to by "filterPtr_", because "filterPtr_()" is using an operator. For more on this, have a look into this article: http://openfoamwiki.net/index.php/OpenFOAM_guide/tmp

Note: "autoPtr" is a much more simple class than "tmp", but they are conceptually similar.

Originally Posted by openfoammaofnepo

2, In homogeneousDynSmagorinsky.C, the filter operation is applied as filter_(x), I do not why here filter_(*) is used like a function, it is an object!

Already hinted in the previous answer, because in C++ we can override operators, as explained here: http://www.cplusplus.com/doc/tutorial/operators/
If you look into the header file respective to LESfilter: https://github.com/OpenFOAM/OpenFOAM...er/LESfilter.H - you'll see that there are four "operator()", each one receiving a different type of field. These are abstract virtual methods, as explained here: http://www.cplusplus.com/doc/tutorial/polymorphism/ - which means that you will have to look at the specific filter implementation to see what the respective operator does.

Best regards,
Bruno

[openfoammaofnepo]

Dear Bruno,

Thank you first for your so detailed help. I will dig into it later today. Now I am implementing a dynamic constants in my mixing model, where the test filtering is used. Thank you again.

OFFO.

[openfoammaofnepo]

Dear Bruno,

About the following lines:

filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())

You have already given me the explanations. Thank you. So actually filterPtr_ is the pointer toward the object of LESfilter and the latter is initilized by LESfilter::New(U.mesh(), coeffDict()). The correpsonding constructor is as follows:

        //- Return a reference to the selected LES filter
        static autoPtr<LESfilter> New
        (
            const fvMesh&,
            const dictionary&
        );

The operation filterPtr_() gives me the object that filterPtr_ points to.

Besides, filter_ is the reference of the object "filterPtr_()". Are the above what I saying correct?

In the dynamic LES models , the expressions filter_ extensively appears, like filter_(U()) and filter_(D). what is the relation between the filter_(U()) and filter_(filterPtr_())? A little confused.

Thank you so much.

OFFO

[wyldckat]

Hi OFFO,

I know, C++ can get seriously confusing I suggest that you give a good study at this tutorial: http://www.cplusplus.com/doc/tutorial/

So, the notion to keep in mind is that this:

filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())

was declared in the initialization section of the constructor. This means that it follows the paradigm that the constructor will also initialize any dependant constructors of its child variables or inherited classes. Which is why the parenthesis are used.
In practice, for example, doing this:

MyOwnClass::MyOwnClass() :
  filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
  filter_(filterPtr_())
{
}

Is almost the same thing as doing this:

MyOwnClass::MyOwnClass()
{
  filterPtr_ = LESfilter::New(U.mesh(), coeffDict());
  filter_ = filterPtr_();
}

The difference is usually a matter of performance, where the first one is more efficient and faster to do when the solver is running.

• Side note - This:
  

  filterPtr_ = LESfilter::New(U.mesh(), coeffDict());

  Is basically this:
  

  filterPtr_ = new LESfilter(U.mesh(), coeffDict());

  But the difference is that we have to use the "New" method, because of some special operations that are needed when creating an instance of "LESfilter".

As for:

filter_(U);

is the same as doing this:

filter_.operator()(U);

where the method "operator()" is a special method, which is automatically called if you simply do the first form:

filter_(U);

And it's only possible to do so, because it was defined that way.
For example, doing:

filter_(2.0+1);

won't work, because the method "operator()(scalar value)" was not defined.

Best regards,
Bruno

[openfoammaofnepo]

Dear Bruno,

Thank you for your help. Much clearer now!

have a nice day!

OFFO

[ehsankf]

Hi Bruno,

I there a way to use filter_ operator in a solver like channelFoam, as in can be used in models.

[wyldckat]

Originally Posted by ehsankf

I there a way to use filter_ operator in a solver like channelFoam, as in can be used in models.

Quick answer:
From what I can see, my guess is that you'll have to create a new local instance of LESfilter, indicated in point #2, at post #2, namely this one:

Originally Posted by wyldckat

2. You'll see this:

filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())

[openfoammaofnepo]

Yes, Bruno is right.

In order to use coeffDict(), you need to define the following in createFields.H

    autoPtr<compressible::LESModel> les
    (
        compressible::LESModel::New
        (
            rho,
            U,
            phi,
            thermo
        )
    );

Then the lines mentioned in Bruno's thread is:

    autoPtr<LESfilter> filterPtr(LESfilter::New(U.mesh(), les->coeffDict()));
    LESfilter& filter(filterPtr());

Originally Posted by wyldckat

Quick answer:
From what I can see, my guess is that you'll have to create a new local instance of LESfilter, indicated in point #2, at post #2, namely this one:

[ehsan]

Hello

Could any one help me to know where the function "filter_" is defined in OF?

https://github.com/OpenFOAM/OpenFOAM...dynOneEqEddy.C

this function, filter_, used many times here and in other dynamic based SGS models but I could not find its definition.

Regards

[wyldckat]

Originally Posted by ehsan

Could any one help me to know where the function "filter_" is defined in OF?

Quick answer:

• Moved your post from another thread: http://www.cfd-online.com/Forums/ope...filtering.html - to here, since this thread is more related to what you're looking for.
• Did you check the file "dynOneEqEddy.H"?
• More details are in the posts above, which is also why I moved your post to here.

[ehsan]

Thank you, the problem is solved in this thread:

autoPtr<LESfilter> filterPtr_;
LESfilter& filter_;

Since it is an autoPtr its special Type is defined during runtime.

Meanwhile, I would like now to apply a new filter, which is called "scale-dependent dynamics viscosity" from this paper:

A scale-dependent dynamic model for large-eddy simulation: application to a neutral atmospheric boundary layer, by Porte-Agel et al.

A scale-dependent Lagrangian dynamic model for large eddy simulation of complex turbulent flows

, which needs a third filter as well, could any one gives a help?

Thanks a lot

[wyldckat]

Quick answers:

• Multiple filter support for LES was introduced in OpenFOAM-dev: http://www.openfoam.org/mantisbt/view.php?id=1659
• Beyond this, I suggest you start a new thread dedicated to creating such a new model that you want to implement.

[ehsan]

On the meanwhile, may I ask you why in dynamicSmagorinsky, the used filter width is not two times larger than the cell size, it calls filter_, without doubling the filter width.
Regards

[wyldckat]

Hi Ehsan,

Sorry, I have no idea. I'm not familiar with LES modelling itself. Perhaps openfoammaofnepo (the forum member who started this thread ) can answer about that?

Nonetheless, I believe there are a lot of threads about dynamicSmagorinsky itself, including a modified model provided here: https://bitbucket.org/albertop/dynamicsmagorinsky

Good luck! Best regards,
Bruno

[aghsin]

Originally Posted by openfoammaofnepo

Yes, Bruno is right.

In order to use coeffDict(), you need to define the following in createFields.H

    autoPtr<compressible::LESModel> les
    (
        compressible::LESModel::New
        (
            rho,
            U,
            phi,
            thermo
        )
    );

Then the lines mentioned in Bruno's thread is:

    autoPtr<LESfilter> filterPtr(LESfilter::New(U.mesh(), les->coeffDict()));
    LESfilter& filter(filterPtr());

hello friend
I want to implement sompleFilter on one of the term in my solver. would you please let me know how I can add the filter inside a solver
regards

[Mahdi2010]

Did you manage to solve your problem with applying a filter within the solver?

[aghsin]

Originally Posted by Mahdi2010

Did you manage to solve your problem with applying a filter within the solver?

yep I applied simpleFilter from LESFilter Class

[Mahdi2010]

Originally Posted by aghsin

yep I applied simpleFilter from LESFilter Class

Good. I have done as well. But what about the width of simple filter? This is something unclear to me.
As in other threads we discuss if the simple filter of OpenFOAM uses neighboring cells?

[sinatahmooresi]

Originally Posted by openfoammaofnepo

Yes, Bruno is right.

In order to use coeffDict(), you need to define the following in createFields.H

    autoPtr<compressible::LESModel> les
    (
        compressible::LESModel::New
        (
            rho,
            U,
            phi,
            thermo
        )
    );

Then the lines mentioned in Bruno's thread is:

    autoPtr<LESfilter> filterPtr(LESfilter::New(U.mesh(), les->coeffDict()));
    LESfilter& filter(filterPtr());

Hello Dear Foamer, and thanks for this useful thread. I have the same intention to use filter operation in pimpleFoam. Thus, I tired to do the initialization using "autoPtr...". However I get the following error:



no suitable user-defined conversion from "Foam::volVectorField" to "const Foam::geometricOneField" exists
incompressible::LESModel::New(U, phi, laminarTransport)
The same error is repeated for "phi" and "laminarTransport" based on their types (the error is basically the same as "no suitable user-defined conversion..."



Here is what I wrote in creatFields.H:


autoPtr<incompressible::LESModel> sgsModel
(
incompressible::LESModel::New(U, phi, laminarTransport)
);

autoPtr<LESfilter> filterPtr(LESfilter::New(U.mesh(), sgsModel->coeffDict()));
LESfilter& filter(filterPtr());


Any idea on what goes wrong here?