[hz283]

Dear ALl,

Can I ask you a question about forAll()? Thank you in advance!

In openfoam, there are lots of forAll used, for example (it is from hPsiMixture.C):

const scalarField& hCells = h_.internalField();
const scalarField& pCells = p_.internalField();

scalarField& TCells = T_.internalField();
scalarField& psiCells = psi_.internalField();
scalarField& muCells = mu_.internalField();
scalarField& alphaCells = alpha_.internalField();

forAll(TCells, celli)
{
const typename MixtureType::thermoType& mixture =
this->cellMixture(celli);

TCells[celli] = mixture.TH(hCells[celli], TCells[celli]);
psiCells[celli] = mixture.psi(pCells[celli], TCells[celli]);

muCells[celli] = mixture.mu(TCells[celli]);
alphaCells[celli] = mixture.alpha(TCells[celli]);
}

Here, why is the Tcells in forAll() used? I mean why not use other quantities like muCells or alphaCells? I read the source code src/OpenFOAM/containers/Lists/UList/UList.H, but still not got a clear understanding about it.

best regards, h

[wyldckat]

Hi hz283,

From what I can see, you can choose either one of the arrays as a reference for the cell ID, as long as you know that all of them have the same IDs. The choice for "TCells" is probably because:

1. It's the shortest name.
2. It's the first array of all 4 being used.
3. It's the one more likely to remain unchanged.

"forAll" is a very quick and simple way of iterating over all items of a list. You can read it as: "for all items in TCells, look at each one as celli".


For example, to give another point of view on a similar way of going through an array: in C#, it's possible to go over a complete array with a source code like this:

int[] fibarray = new int[] { 0, 1, 2, 3, 5, 8, 13 };
foreach (int i in fibarray)
{
     System.Console.WriteLine(i);
}

In this case, it reads like: "for each item 'i' (of type int) of the array 'fibarray', do..."

C# foreach is basically the same thing as OpenFOAM's forAll. But OpenFOAM's is simpler and easier to use!


Besides all of this, the other advantage is that forAll is generic enough to work in parallel, therefore it won't go through all of the cells of the global mesh in all of the processors, it only goes through the list of cells present in the current processor (at least as far as I can understand).

Best regards,
Bruno

[hz283]

Dear Bruno,

Thank you so much for the continuous help! About the last point you mentioned, I indeed have some difficulty to understand. For example. I write a loop forAll() in fireFoam. C, which is the top level code we can see. In this case, forAll will be run in a parallel way for a parallel computations?

Thank you !

Originally Posted by wyldckat

Hi hz283,

From what I can see, you can choose either one of the arrays as a reference for the cell ID, as long as you know that all of them have the same IDs. The choice for "TCells" is probably because:

1. It's the shortest name.
2. It's the first array of all 4 being used.
3. It's the one more likely to remain unchanged.

"forAll" is a very quick and simple way of iterating over all items of a list. You can read it as: "for all items in TCells, look at each one as celli".


For example, to give another point of view on a similar way of going through an array: in C#, it's possible to go over a complete array with a source code like this:

int[] fibarray = new int[] { 0, 1, 2, 3, 5, 8, 13 };
foreach (int i in fibarray)
{
     System.Console.WriteLine(i);
}

In this case, it reads like: "for each item 'i' (of type int) of the array 'fibarray', do..."

C# foreach is basically the same thing as OpenFOAM's forAll. But OpenFOAM's is simpler and easier to use!


Besides all of this, the other advantage is that forAll is generic enough to work in parallel, therefore it won't go through all of the cells of the global mesh in all of the processors, it only goes through the list of cells present in the current processor (at least as far as I can understand).

Best regards,
Bruno

[wyldckat]

If I remember this correctly:

1. When running in parallel, the mesh is already decomposed.
2. Therefore, each processor only has access to its own sub-domain of items in the array.
3. This way, forAll will only go through the list of items on the sub-domain, which enables the ability to run in parallel.

You'll need to study a few more source code files from OpenFOAM's own applications (solvers and utilities) to confirm this. The folder "applications/test" also has some nice hints on what can be done with arrays and so on!

[l_r_mcglashan]

forAll is simply:

#define forAll(list, i) \
    for (Foam::label i=0; i<(list).size(); i++)

It does not do anything special. You can find other convenience macros at the bottom of src/OpenFOAM/containers/Lists/UList/UList.H

Here's your example using the new c++11 standard (no need to switch language!):

int fibarray[7] = { 0, 1, 2, 3, 5, 8, 13 };
for (const auto& i : fibarray)
{
    cout<< i << endl;
}