For example the sinusoidal motion of the floating object in the
potentialFreeSurfaceFoam/oscillatingBox tutorial is now specified thus

    floatingObject
    {
        type            fixedNormalInletOutletVelocity;

        fixTangentialInflow false;

        normalVelocity
        {
            type            uniformFixedValue;
            uniformValue    sine;
            uniformValueCoeffs
            {
                frequency 1;
                amplitude table
                (
                    (   0     0)
                    (  10 0.025)
                    (1000 0.025)
                );
                scale     (0 1 0);
                level     (0 0 0);
            }
        }

        value           uniform (0 0 0);
    }

rather than using

    floatingObject
    {
        type            fixedNormalInletOutletVelocity;

        fixTangentialInflow false;

        normalVelocity
        {
            type            oscillatingFixedValue;
            refValue        uniform (0 1 0);
            offset          (0 -1 0);
            amplitude       table
            (
                (   0     0)
                (  10 0.025)
                (1000 0.025)
            );
            frequency       constant 1;
        }

        value           uniform (0 0 0);
    }

    Templated sine function with support for an offset level.

        \f[
            a sin(2 \pi f (t - t_0)) s + l
        \f]

    where

    \vartable
        symbol  | Description       | Data type
        a       | Amplitude         | Function1<scalar>
        f       | Frequency [1/s]   | Function1<scalar>
        s       | Type scale factor | Function1<Type>
        l       | Type offset level | Function1<Type>
        t_0     | Start time [s]    | scalar
        t       | Time [s]          | scalar
    \endvartable

tutorials/compressible/rhoPimpleFoam/ras/angledDuct: Updated for change in U boundary condition update order

Function1 is an abstract base-class of run-time selectable unary
functions which may be composed of other Function1's allowing the user
to specify complex functions of a single scalar variable, e.g. time.
The implementations need not be a simple or continuous functions;
interpolated tables and polynomials are also supported.  In fact form of
mapping between a single scalar input and a single primitive type output
is supportable.

The primary application of Function1 is in time-varying boundary
conditions, it also used for other functions of time, e.g. injected mass
is spray simulations but is not limited to functions of time.

Description
    Templated sine function with support for an offset level.

        \f[
            a sin(2 \pi f (t - t_0)) s + l
        \f]

    where

    \vartable
        a       | Amplitude
        f       | Frequency [1/s]
        s       | Type scale factor
        l       | Type offset level
        t_0     | Start time [s]
        t       | Time [s]
    \endvartable

    Example for a scalar:
    \verbatim
        <entryName> sine;
        <entryName>Coeffs
        {
            frequency 10;
            amplitude 0.1;
            scale     2e-6;
            level     2e-6;
        }
    \endverbatim

    Example for a vector:
    \verbatim
        <entryName> sine;
        <entryName>Coeffs
        {
            frequency 10;
            amplitude 1;
            scale     (1 0.1 0);
            level     (10 1 0);
        }
    \endverbatim

PV4FoamReaders: Updated to build with ParaView-5.0.0
paraFoam: Updated to load PV4FoamReaders for ParaView-5.0.0

Currently this is experimental but if it becomes clear that ParaView-4
and ParaView-5 are and will remain consistent with respect to readers
the plan is to rename

PV4 -> PV

or

PV4 -> PV45 if it is assumed that PV6 may need to be different.

e.g.

    inlet
    {
        type                flowRateInletVelocity;
        massFlowRate        0.2;
        extrapolateProfile  yes;
        rho                 rho;
        rhoInlet            1.0;
        value               uniform (0 0 0);
    }

to avoid name conflicts with these primitive names in the OpenFOAM namespace

Removed inconsistent binary output.
Removed unused and IO-inconsistent functions.
Simplified the handling of backward-compatible constant value:
    Removed the unnecessary CompatibilityConstant,
    Updated Constant and DataEntryNew to handle constant value construction.

This ensures the U boundary conditions are updated before the explicit
parts of the stress are evaluated.

Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=1988

    // Polynomial functions and interpolation do evaluate to label
    // Instead evaluate a scalar and convert to label as appropriate
    // makeDataEntryType(PolynomialEntry, label);
    // makeDataEntryType(CSV, label);
    // makeDataEntryType(Table, label);
    // makeDataEntryType(TableFile, label);

Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=1987

rather than the fixed name "fieldAveragingProperties" to allow for the
same field to be averaged more than once.

Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=1336

and pre-construct constant strings and names

Speeds-up parsing of DTAGS so that lookup of a name takes ~1s

Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=982

Patch provided by Armin Wehrfritz
Resolves feature request http://www.openfoam.org/mantisbt/view.php?id=843

This change ensures that these patches are named consistently so that
they can be looked-up as required in e.g. patchMeanVelocityForce

Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=992

    ln(mu) = sum_i=1^N(a[i]*ln(T)^(i-1))
    ln(kappa) = sum_i=1^N(b[i]* ln(T)^(i-1))

Based on patch provided by Armin Wehrfritz

Resolves feature-request http://www.openfoam.org/mantisbt/view.php?id=978

    If the mean velocity force is applied to a cyclic patch for parallel
    runs include contributions from processorCyclic patches generated
    from the decomposition of the cyclic patch

    When restarting form a previous calculation, the averaging is continuous or
    may be restarted using the \c restartOnRestart option.

    The averaging process may be restarted after each calculation output time
    using the \c restartOnOutput option or restarted periodically using the \c
    periodicRestart option and setting \c restartPeriod to the required
    averaging period.

    Example of function object specification:
    \verbatim
    fieldAverage1
    {
        type fieldAverage;
        functionObjectLibs ("libfieldFunctionObjects.so");
        ...
        restartOnRestart  false;
        restartOnOutput   false;
        periodicRestart false;
        restartPeriod   0.002;
        fields
        (
            U
            {
                mean            on;
                prime2Mean      on;
                base            time;
                window          10.0;
                windowName      w1;
            }
            p
            {
                mean            on;
                prime2Mean      on;
                base            time;
            }
        );
    }
    \endverbatim

    \heading Function object usage
    \table
        Property        | Description           | Required    | Default value
        type            | type name: fieldAverage | yes |
        restartOnRestart  | Restart the averaging on restart | no | no
        restartOnOutput   | Restart the averaging on output | no | no
        periodicRestart | Periodically restart the averaging | no | no
        restartPeriod   | Periodic restart period | conditional |
        fields          | list of fields and averaging options | yes |
    \endtable

Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=1982

in decomposeParDict.

This default number of processors may be overridden by the new "-np"
option to runParallel which must be specified before the application
name e.g.:

runParallel -np 4 pisoFoam

which may be optionally overridden by version-specific rules.

For example the default rules for gcc on GNU/Linux x86_64 are in the
wmake/rules/linux64Gcc directory.  If there is a need to change any of
the rules for a specific version of gcc, e.g. gcc-4.8.4 the directory
wmake/rules/linux64Gcc48 may be created into which any of the language
files may be provided containing the rules to override the defaults.

when building ThirdParty packages.
c++0x is used rather than c++11 to support gcc-4.5.?