[obscureed]

In openFOAM v10, I have a function that calculates the volume-averaged flowspeed everywhere in my models. Inside ./system/controlDict, I have

functions
{
#includeFunc volAvU
}

and in ./system/volAvU I have

volAvU
{
  functionObjectLibs ( "libutilityFunctionObjects.so" );
  type            coded;

  codeOptions
#{
  -I$(LIB_SRC)/meshTools/lnInclude
#};

  codeExecute
#{
  const volVectorField& U
    (
     mesh().lookupObject<volVectorField>("U")
    );

  volScalarField magU(mag(U));
  volScalarField scalar(mag(U));
  dimensionedScalar totVol("totVol",dimensionSet(0,3,0,0,0,0,0),gSum(mesh().V()));
  dimensionedScalar avU("avU",dimensionSet(0,1,-1,0,0,0,0),0.0);

  scalar = mag(U);
  avU = fvc::domainIntegrate(scalar)/totVol;
  Info << "Time=," << mesh().time().value() << ", ";
  Info << "volAvMagU=" << avU.value() << endl;
#};
}

This has worked well for me in many models -- it prints this out for each timestep, so I can monitor convergence.

This now fails in openFOAM v11 -- I'll describe the errors in a follow-up post, because it's a bit messy. My questions are:
-- what has changed?
-- where can I find documentation of how this should work?


Actually, I also look at some more complicated measures as well -- for example, what volume fraction of the fluid has a speed above 5m/s, etc -- so I think I want the "coded" type, rather than a one-liner of type "volFieldValue". (However I would be interested to see if a one-liner can apply mag() to vector U.)

[obscureed]

If I try the coded function mentioned in the OP in openFOAM v11, I initially get an error:

[6] 
[6] 
[6] --> FOAM FATAL ERROR: 
[6] Unknown function type coded

Valid functions are : 

7
(
fvModel
massFractions
moleFractions
patchProbes
probes
sets
surfaces
)

which is obviously a bit discouraging, since it suggests that "coded" function type is no longer allowed at all. Or maybe not in an #includeFunc file? But there are examples of controlDicts in the tutorials with coded functions, so I've edited ./system/controlDict to contain an explicit coded function:

	
	
functions
{
  not_via_include
  {
    libs ( "libutilityFunctionObjects.so" );
    type coded;
    codeExecute
    #{
      Info<<"hello from not_via_include" <<endl;
      const Time& runTime = mesh().time();
      Info<<"time = "<<runTime.userTimeValue() <<endl;
    #};
  }
#includeFunc volAvU
}

The not_via_include coded function works on its own -- so coded functions are still possible, which makes that previous error message hard to understand. Even stranger, when the not_via_include function is present, then an attempt is made to wmake the includeFunc volAvU function. The error message changes to something like:

/home/username/example/system/controlDict/functions/volAvU/volAvU: In member function ‘virtual bool Foam::volAvUFunctionObject::execute()’:
/home/username/example/system/controlDict/functions/volAvU/volAvU:35:15: error: ‘fvc’ has not been declared

If I remove the not_via_include function, then the error message goes back to denying that coded functions even exist. What is going on there?

[obscureed]

None of the files in the tutorials mention "fvc", so I presume that this set of commands has been moved somewhere. Do I need to go and wrestle with the source code to find where?

Only one file in the tutorials mentions "integrate" (case-insensitive): it is
/opt/openfoam11/tutorials/compressibleVoF/ballValve/system/controlDict
in a function of type "volFieldValue", which seems limited. (Where should I look for documentation of volFieldValue? -- I tried the User Guide.)

Only one file in the tutorials mentions "gSum": it is
/opt/openfoam11/tutorials/multiphaseEuler/bubbleColumnEvaporating/system/continuityFunctions
in a function of type "coded". I am not sure whether different functions are allowed in continuityFunctions compared to controlDict, and I am not sure how to find out. (As you can tell, my knowledge of openFOAM is very patchy indeed. I presume that the code in continuityFunctions takes effect somehow, but it is not mentioned elsewhere in the tutorial files. Maybe continuityFunctions is a reserved filename with an automatic effect?)

I think my best chance of guessing how to proceed would be to investigate the coded function in
/opt/openfoam11/tutorials/potentialFoam/cylinder/system/controlDict
but I would prefer to learn properly, rather than cutting and pasting code at random. Can anyone advise me how to learn, please?

[Yann]

Hello,

I don't know why your coded function object does not work anymore with OpenFOAM 11.
However, about documentation for volFieldValue, you can use the (very handy) foamInto utility:

foamInfo volFieldValue

Which should return plenty of valuable informations:

File
    /opt/openfoam11/src/functionObjects/field/fieldValues/volFieldValue/volFieldValue.H

Description
    Provides a 'fvCellSet' specialisation of the fieldValue function object.

    Given a list of user-specified fields and a 'fvCellSet', a number of
    operations can be performed, such as sums, averages and integrations.

    Example of function object specification:
    \verbatim
    volFieldValue1
    {
        type            volFieldValue;
        libs            ("libfieldFunctionObjects.so");

        log             true;
        writeControl    writeTime;
        writeFields     true;

        select          cellZone;
        cellZone        c0;
        operation       volAverage;

        weightField     alpha1;

        fields
        (
            p
            U
        );
    }
    \endverbatim

Usage
    \table
        Property     | Description              | Required    | Default value
        type         | Type name: volFieldValue            | yes   |
        log          | Write data to standard output       | no    | no
        writeFields  | Write the region field values       | yes   |
        writeLocation| Write the location (if available)   | no    | no
        select       | fvCellSet type: see below           | yes   |
        name         | Name of fvCellSet if required       | no    |
        operation    | Operation to perform                | yes   |
        weightField  | Name of field to apply weighting    | no    |
        weightFields | Names of fields to apply weighting  | no    |
        fields       | List of fields to operate on        | yes   |
    \endtable

    Where \c select options are:
    \plaintable
        cellZone     | requires a 'name' entry to specify the cellZone
        all          | all cells
    \endplaintable

    The \c operation is one of:
    \plaintable
       none                 | No operation
       sum                  | Sum
       sumMag               | Sum of component magnitudes
       average              | Ensemble average
       volAverage           | Volume weighted average
       volIntegrate         | Volume integral
       min                  | Minimum
       max                  | Maximum
       minMag               | Minimum magnitude
       maxMag               | Maximum magnitude
       CoV                  | Coefficient of variation: standard deviation/mean
    \endplaintable

Model
    This appears to be the 'volFieldValue' model of the 'fieldValues' family.
    The models in the 'fieldValues' family are:
    + fieldValueDelta
    + surfaceFieldValue
    + volFieldValue

Examples using "volFieldValue"
    /opt/openfoam11/tutorials/compressibleVoF/ballValve

As you can see you can use a bunch of operation on your fields. There is no magnitude mode for volAverage, but you can use the mag function object to compute mag(U) and then volFieldValue to compute the volume average of mag(U).

On a side note, few others productivity-oriented tips here: https://cfd.direct/openfoam/v11-productive-cfd/

I hope this helps,
Yann

[obscureed]

Hi Yann,

Thanks, foamInfo is helpful -- but only for the commands that it covers.
-- gSum and domainIntegrate are not covered, for example. I think gSum is still valid, because it is in one of the tutorials. I am unsure about fvc::domainIntegrate. (Of course, it could be difficult to find it if it no longer exists in OF11 -- but it is not recognised by OF10's foamInfo.)

If I wanted to know (for example) the list of acceptable values for writeControl in volFieldValue, how would I find it?
-- foamInfo gives one example, writeTime -- and I know (from trying it) that this is not what I want.
-- foamInfo links to the source code volFieldValue.H, but that does not lead me to a list. Nor does https://cpp.openfoam.org/v11/volFieldValue_8H.html.

It could be useful to know that the info from foamInfo (for example the list of options) is not complete.
-- For example, tutorials/compressibleVoF/ballValve/system/controlDict shows that a function of "type volFieldValue;" can have "writeControl timeStep; writeInterval 1;". I think this is probably what I want, and I can guess what writeInterval does.

[Yann]

Hello obscureed,

foamInfo gives information about applications, models, function objects, boundary conditions... implemented in OpenFOAM.

gSum is none of that, only a C++ function. This is why you won't get anything about it with foamInfo. (foamInfo can only give you generic documentation of the coded function object)
The only way I can think of to get C++ related information/documentation would be to use the C++ source guide (https://cpp.openfoam.org/v11/) but it does not seem very handy to me and I fail to find what I'm looking for most of the time (maybe because I'm not a developer)

About writeControl: this is a general entry available for all function objects. foamInfo volFieldValue will only return documentation specific to this function object (basically it just retrieves the header of the source file for this function) and that's why you don't get anything about writeControl, which is not specific to volFieldValue but inherited from the functionObject base-class.

However, you can get information about writeControl with foamInfo functionObject.
(Or you can also use the good old banana trick to know what are your options for a specific entry, but it won't help you to learn about all existing entries)

Hope this helps,
Yann

[obscureed]

Yes, that is helpful, thank you.

I agree that it is difficult to make progress by looking at the source code documentation, even if it is theoretically very thorough.

My experience of all openFOAM documentation is that it is OK when you already have a good idea of what you are looking for, but frankly unhelpful when you do not. (The examples we have already discussed show this. What would lead me to type "foamInfo functionObject" for information about volFieldValue? If gSum is a standard C++ function, where is it defined? -- I went looking at https://cpp.hotexamples.com/examples...-examples.html, and all the examples were CFD- and openFOAM-related.)

The banana trick is good for taking a single step, but it feels like exploring in the dark sometimes.

So, thanks for your pointers to the help and foamInfo, Yann. If anyone has any specific information for the original coded function that I posted, it could save me some considerable time.

[franorn]

Not sure if it's still relevant, but as far as understand in OF11 you should replace:

functionObjectLibs ( "libutilityFunctionObjects.so" );

with:

libs ( "libutilityFunctionObjects.so" );

in your original "volAvU" extrnal dict.

Hope this helps.