Probes or monitor points
Line sampling
Cutting plane sampling
Surface sampling based on patches
Field averaging
Frequent writing of selected variables
Streamlines
Field min/max
Mass flow at patches and other operations on cell faces
Volume averaging/integration in whole domain or a cell zone

Flame center point calculation (*** swak4foam needed ***)
Panic dump (*** swak4foam needed ***)

Function objects are added by pasting the code into the functions() section of the controlDict file. For a large number of objects it is recommended to include them from separate files. This allows to keep track of the function objects in use and to comment or uncomment them easily. The function objects are executed during rum time. This on-the-fly post-processing doesn't require to keep the field data.

/*--------------------------------*- C++ -*----------------------------------*\ | ========= | | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | | \\ / O peration | Version: 2.4.0 | | \\ / A nd | Web: www.OpenFOAM.org | | \\/ M anipulation | | \*---------------------------------------------------------------------------*/ FoamFile { version 2.0; format ascii; class dictionary; location "system"; object controlDict; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // application icoFoam; startFrom startTime; startTime 0; stopAt endTime; endTime 0.5; deltaT 0.005; writeControl timeStep; writeInterval 20; purgeWrite 0; writeFormat ascii; writePrecision 6; writeCompression off; timeFormat general; timePrecision 6; runTimeModifiable true; functions { --- your function object here --- or #include "cuttingPlane" } // ************************************************************************* //

Probes or monitor points

Probes are the simplest way to monitor your simulation without loading the result fields. Everytime the simulation is (re)started a new time folder is generated and the probe file created.

probes { type probes; functionObjectLibs ( "libsampling.so" ); // Name of the directory for probe data name myProbes; // Write at same frequency as fields outputControl timeStep; outputInterval 2; // Fields to be probed fields ( p U ); probeLocations // points outside the domain will be omitted and produce warnings ( ( 0.01 0.12 0 ) // comment 1 ( 0.01 0 0.12 ) // comment 2 ( 0.039 0.12 0 ) // ( 0.2 0 0 ) // ); }

Line sampling

Line sampling can be used to monitor velocity profiles, etc. Each written time step is saved in a new time folder. Each line and variable is saved to a separate file. If the resulting lines have missing points, the interpolation setting should be set to a simpler scheme.

myLine // defines name of output folder { type sets; interpolationScheme cellPoint; setFormat raw; // raw, gnuplot, xmgr, jplot outputControl timeStep; outputInterval 2; enabled true; fields ( U T ); sets ( line1 // defines prefix of output file name, many lines can be added { type uniform; axis xyz; //x,y,z,xyz,distance (way of saving coordinates) start (0.0 0.0 0.0); end (0.0 1.0 0.0); nPoints 100; // resolution } ); }

Cutting plane sampling

This code writes a VTK surface file periodically into the postProcessing folder. If interpolate is set to true, the data is saved at the nodes of the surface mesh. It's stored in the cell centers otherwise. The first option looks smoother, but produces slightly larger files. The option triangulate allows to convert all surface mesh elements into triangles. A triangle surface is easier to post-process, because all elements have the same number of nodes.
It's not possible to make cuts other than planes with this function object.

cuttingPlane { type surfaces; functionObjectLibs ("libsampling.so"); outputControl timeStep; outputInterval 2; // every 2nd time step surfaceFormat vtk; // format to store the surface fields ( p U ); // fields to save interpolationScheme cellPoint; surfaces ( yNormal { type cuttingPlane; planeType pointAndNormal; pointAndNormalDict { basePoint (0 0 0); normalVector (0 1 0); } interpolate true; triangulate false; // convert faces into triangles? } ); }

Surface sampling based on patches

In many cases, the planar sampling method is unefficient due to the large number of planes needed. The sampling of a single or multiple patches (boundary conditions) might be a good alternative, especially when monitoring air foils, blades, etc. Specifying all patches will save just the outside surface of the domain.

myBCSurfaceSampling { type surfaces; functionObjectLibs ("libsampling.so"); outputControl timeStep; // ( // adjustableTime // clockTime // cpuTime // none // outputTime // runTime // timeStep // ) outputInterval 2; surfaceFormat vtk; fields ( p U ); interpolationScheme cellPoint; surfaces ( basket { type patch; patches ( ".*walls.*" ); // choose your BCs here, wild cards are allowed interpolate true; triangulate false; //true; } ); } // worked with OF version 2.4

Field averaging

Field averaging is a must in transient simulations. Here prime2Mean means the average of the squared perturbations and is related to the standard deviation. This field is usually not needed in basic simulations.
Averaging should be enabled once the simulations stabilised after the initialisation phase. New foam versions have several features to control the averaging window.

fieldAverage { type fieldAverage; functionObjectLibs ( "libfieldFunctionObjects.so" ); enabled true; outputControl outputTime; //timeStep; outputInterval 1; resetOnRestart false; fields ( p { mean on; prime2Mean off; base time; } U { mean on; prime2Mean off; base time; } ); }

Frequent writing of selected variables

When making movies or debugging a selected variable needs to be saved on the disk with a small time step. This function object allows to do it without saving all other variables.
Be careful with the settings. You can fill up your disk within minutes!

//frequent write frequentWrite { type writeRegisteredObject; // Where to load it from functionObjectLibs ("libIOFunctionObjects.so"); // Execute upon options: // timeStep // outputTime // adjustableTime // runTime // clockTime // cpuTime outputControl timeStep; // Write every writeInterval (only valid for timeStemp, outputTime) outputInterval 1; // be careful here!!! // Interval of time (sec) to write down( writeInterval 10; //(adjustableTime, runTime, clockTime, cpuTime) // Objects (fields or lagrangian fields in any of the clouds) // to write every outputTime objectNames (T); exclusiveWriting false; // Is the object written by this function Object alone }

Streamlines

This code generates stream lines during run time. Refer to the motorcycle tutorial for more information.

/*--------------------------------*- C++ -*----------------------------------*\ | ========= | | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | | \\ / O peration | Version: 2.4.0 | | \\ / A nd | Web: www.OpenFOAM.org | | \\/ M anipulation | | \*---------------------------------------------------------------------------*/ streamLines { type streamLine; // Output every outputControl outputTime; // outputInterval 10; setFormat vtk; //gnuplot; //xmgr; //raw; //jplot; //csv; //ensight; // Velocity field to use for tracking. UName U; // Tracked forwards (+U) or backwards (-U) trackForward true; // Names of fields to sample. Should contain above velocity field! fields (p U k); // Steps particles can travel before being removed lifeTime 10000; //- Specify either absolute length of steps (trackLength) or a number // of subcycling steps per cell (nSubCycle) // Size of single track segment [m] //trackLength 1e-3; // Number of steps per cell (estimate). Set to 1 to disable subcycling. nSubCycle 5; // Cloud name to use cloudName particleTracks; // Seeding method. See the sampleSets in sampleDict. seedSampleSet uniform; //cloud;//triSurfaceMeshPointSet; uniformCoeffs { type uniform; axis x; //distance; // Note: tracks slightly offset so as not to be on a face start (-1.001 -0.05 0.0011); end (-1.001 -0.05 1.0011); nPoints 20; } } // ************************************************************************* //

Field min/max

This function object allows to track the min and max values of selected variables during run time. The location where the min and max were found is returned. An abnormal behaviour of the simulation can be detected quickly.

fieldMinMax1 { type fieldMinMax; functionObjectLibs ("libfieldFunctionObjects.so"); write yes; // write to file? log yes; // write min/max to standard output? location yes; // write location of min/max, optional, yes default mode magnitude; // calculation mode: magnitude (default) or component fields ( U p ); }

Mass flow at patches and other operations on cell faces

OpenFoam provides a general function object to perform calculation on cell faces. These faces are commonly grouped to a patch (boundary condition) or a face zone created by the user. The operations can be various types of integration or averaging. The sumation of the flux phi on a patch will result in a mass flow rate, a value commonly monitored in transient simulations.

// face operators massFlow { type faceSource; functionObjectLibs ("libfieldFunctionObjects.so"); enabled true; outputControl timeStep; outputInterval 2; log true; valueOutput false; // surface output format needed when true!!! source patch; // faceZone patch sampledSurface sourceName outlet; // patch, faceZone or surface name operation sum; // CoV areaAverage areaIntegrate areaNormalAverage // areaNormalIntegrate average max min none sum // sumDirection sumDirectionBalance sumMag weightedAverage fields ( phi // phi = flux, sum(flux)@surface = mass flow ); }

Volume averaging/integration in whole domain or a cell zone

This is a general function object which allows to perform a mathematical operation like average, itegration, min, max, etc on cells: the whole mesh or just a cell zone. A cell zone is a group of cells defined by the user before the simulation using topoSet.
Example applications are: integration of (local) heat release in combustion simulations, averaging in regions of interest, etc.

// volume operation (averaging, integration, etc.) on cell set cellSource1 { type cellSource; functionObjectLibs ("libfieldFunctionObjects.so"); enabled true; outputControl timeStep; outputInterval 2; log true; // write to standard output? valueOutput true; // write to file? source cellZone; // all = whole mesh, cellZone = existing cell zone sourceName myZone; // zone name if cellZone selected operation volAverage; // CoV average max min none sum sumMag // volAverage volIntegrate weightedAverage weightField none; fields ( p U ); }

Flame center point calculation (*** swak4foam needed ***)

This swak4foam based object calculates the integrated heat release times coordinate product needed to track the center of a flame. To get the flame center the value needs to be divided by the total heat relese which is done as post-processing.
This function object is a generalisation of the standard foam function object for cells and faces, but with an extended set of operations. The specification of own expressions makes it very flexible, once the syntax is understood.

// calculate heat release weighted with the coordnate // needed for flame center calculation in fireFoam myCenter { type swakExpression; valueType cellSet; // cellSet cellZone faceSet faceZone // internalField patch set surface setName mySet; // created with topoSet //zoneName myZone; outputControlMode timeStep; outputInterval 1; variables ( "dQx=dQ*pos();" // center = heat release * coordinate / total heat release // the division by the total heat release needs to be done later //"dQtot=integrate(dQ);" //select the downwards direction ); expression "dQx"; // accumulations ( integrate // weightSum integrate bigger weightedRange sum smaller ); // weightedSmaller sumMag weightedQuantile weightedAverage // median average size min maxweightedMedian weightedBigger // quantile range weightedSum verbose true; }

Panic dump (*** swak4foam needed ***)

This is a simple function object for dumping fields when some extreme conditions are reached. It's usually used for debugging diverging cases.

// dump result immediately if extreme values found myPanicDump // needs swak4foam!!! { type panicDump; fieldName p; minimum 10; maximum 201430; }