These models have been particularly designed for use in the VoF solvers, both
incompressible and compressible.  Currently constant and temperature dependent
surface tension models are provided but it easy to write models in which the
surface tension is evaluated from any fields held by the mesh database.

Resolves bug-report https://bugs.openfoam.org/view.php?id=2514

This update does not change the operation or controls of the regionModels, it is
to aid understanding of the code.

Created a base-class from contactAngleForce from which the
distributionContactAngleForce (for backward compatibility) and the new
temperatureDependentContactAngleForce are derived:

Description
    Temperature dependent contact angle force

    The contact angle in degrees is specified as a \c Function1 type, to
    enable the use of, e.g.  contant, polynomial, table values.

See also
    Foam::regionModels::surfaceFilmModels::contactAngleForce
    Foam::Function1Types

SourceFiles
    temperatureDependentContactAngleForce.C

according to

        Bai et al, `Modelling of gasoline spray impingement', Atom. Sprays,
        vol 12, pp 1-27, 2002

Resolves bug-report https://bugs.openfoam.org/view.php?id=2478

Demonstrates meshing a cylinder with hemispehrical ends using snappyHexMesh with
a polar background mesh that uses the point and edge projection feature of blockMesh.
The case prescribes a multiMotion on the cylinder, combining an oscillatingLinearMotion
and transverse rotatingMotion.

    Off-centering is specified via the mandatory coefficient \c ocCoeff in the
    range [0,1] following the scheme name e.g.
    \verbatim
    ddtSchemes
    {
        default         CrankNicolson 0.9;
    }
    \endverbatim
    or with an optional "ramp" function to transition from the Euler scheme to
    Crank-Nicolson over a initial period to avoid start-up problems, e.g.
    \verbatim
    ddtSchemes
    {
        default         CrankNicolson
        ocCoeff
        {
            type scale;
            scale linearRamp;
            duration 0.01;
            value 0.9;
        };
    }
    \endverbatim

Note this functionality is experimental and the specification and implementation
may change if issues arise.

Patch contributed by Timo Niemi, VTT.
Resolves bug-report https://bugs.openfoam.org/view.php?id=2510

Resolves bug-report https://bugs.openfoam.org/view.php?id=2512

Applied to eigen-value calculations. Fixed repeated-eigen-value issues
in eigen-vector generation.

Resolves bug-report https://bugs.openfoam.org/view.php?id=2511

Resolves bug-report https://bugs.openfoam.org/view.php?id=2507

For example in the potentialFreeSurfaceFoam/oscillatingBox tutorial it is
cleaner to apply the "linearRamp" function to the "sine" function rather than
using an amplitude table:

    floatingObject
    {
        type            fixedNormalInletOutletVelocity;

        fixTangentialInflow false;

        normalVelocity
        {
            type            uniformFixedValue;

            uniformValue
            {
                type        scale;

                value
                {
                    type sine;

                    frequency   1;
                    amplitude   0.025;
                    scale       (0 1 0);
                    level       (0 0 0);
                }

                scale
                {
                    type linearRamp;

                    duration 10;
                }
            }
        }

        value           uniform (0 0 0);
    }

with more general forms of those functions.

coupled patches, to prevent rebound/stick/etc... on these patches. Also
added "none" interaction type to LocalInteraction, which reverts the
patch interaction to the fundamental behaviour. This is primarily useful
for non-coupled constraint types.

Resolves https://bugs.openfoam.org/view.php?id=2458

The pitzDaily case uses a lot of mesh grading close to walls and the shear layer.
Prior to v2.4, blockMesh only permitted grading in one direction within a single block,
so the pitzDaily mesh comprised of 13 blocks to accommodate the complex grading pattern.

blockMesh has multi-grading that allows users to divide a block in a given direction and
apply different grading within each division.  The mesh generated with blockMesh using
13 blocks has been replaced with a mesh of 5 blocks that use multi-grading.  The new
blockMeshDict configuration produces a mesh very similar to the original 13-block mesh.

generated whenever a BlendedInterfacialModel is created.

Resolves bug-report https://bugs.openfoam.org/view.php?id=2472

including support for TDAC and ISAT for efficient chemistry calculation.

Description
    Eddy Dissipation Concept (EDC) turbulent combustion model.

    This model considers that the reaction occurs in the regions of the flow
    where the dissipation of turbulence kinetic energy takes place (fine
    structures). The mass fraction of the fine structures and the mean residence
    time are provided by an energy cascade model.

    There are many versions and developments of the EDC model, 4 of which are
    currently supported in this implementation: v1981, v1996, v2005 and
    v2016.  The model variant is selected using the optional \c version entry in
    the \c EDCCoeffs dictionary, \eg

    \verbatim
        EDCCoeffs
        {
            version v2016;
        }
    \endverbatim

    The default version is \c v2015 if the \c version entry is not specified.

    Model versions and references:
    \verbatim
        V...

to provide smoother behavior on start-up when an acceleration impulse is
applied, e.g. if the body is suddenly released.  e.g.

dynamicFvMesh       dynamicMotionSolverFvMesh;

motionSolverLibs   ("librigidBodyMeshMotion.so");

solver             rigidBodyMotion;

rigidBodyMotionCoeffs
{
    report          on;

    solver
    {
        type    Newmark;
    }

    ramp
    {
        type     quadratic;
        start    0;
        duration 10;
    }
.
.
.

will quadratically ramp the forces from 0 to their full values over the first
10s of the run starting from 0.  If the 'ramp' entry is omitted no force ramping
is applied.

Description
    Ramp function base class for the set of scalar functions starting from 0 and
    increasing monotonically to 1 from \c start over the \c duration and
    remaining at 1 thereafter.

    Usage:
    \verbatim
        <entryName> <rampFunction>;
        <entryName>Coeffs
        {
            start     10;
            duration  20;
        }
    \endverbatim
    or
    \verbatim
        <entryName>
        {
            type      <rampFunction>;
            start     10;
            duration  20;
        }
    \endverbatim

    Where:
    \table
        Property | Description  | Required | Default value
        start    | Start time   | no       | 0
        duration | Duration     | yes      |
    \endtable

The following common ramp functions are provided: linear, quadratic, halfCosine,
quarterCosine and quaterSine, others can easily be added and registered to the run-time
selection system.

e.g.
    ramp
    {
        type     quadratic;
        start    200;
        duration 1.6;
    }

but the old format is supported for backward compatibility:

    ramp linear;
    rampCoeffs
    {
        start    200;
        duration 1.6;
    }