- use refCount instead of the tmp<...>::refCount alias

- tie the MPI rules to the base compiler type *without* its version.
  Eg, linux64Gcc (which exists) instead of linux64Gcc81

- use normal instead of volumeType to decide on the sign.
  This provides a continuous field and eliminates special handling of
  GREAT in iso-surface routines.

- fix regression in isoSurfaceCell cutting that was introduced by the
  previous adjustments for distanceSurface

- this enables x,y,z access of lagrangian positions, which is useful
  for postprocessing in paraview, but at the expense of slightly
  more disk space.

- input or output scaling of values to manage dissimilar unit systems
  in the structures model

- logging of communicated force, moments and updated positions.
  This allows tracking of the information exchange throughout the
  duration of the simulation and may assist in post-simulation diagnosis.

- relocated from
    etc/caseDicts/postProcessing/catalyst/ -> etc/caseDicts/insitu/catalyst/

- adjusted for unified catalyst function object

- default is now without polyhedral decomposition, since this produces
  compacter files and VTK mananges this in most instances.
  However, provide function object flag to reinstate the old behaviour.

    Calculates and outputs a field whose values are offset to a reference
    value obtained by sampling the field at a user-specified location.

    The field values are calculated using:

    \f[
        f_c = s(f_{c,t} - f_p + f_{off})
    \f]

    where
    \vartable
        f_c     | field values at cell
        s       | optional scale factor (default = 1)
        f_{c,t} | current field values at cell at this time
        f_p     | field value at position
        f_{off} | offset field value (default = 0)
    \endvartable

Usage
    Example of function object specification to calculate the reference
field:
    \verbatim
    pRef
    {
        type        reference;
        libs        ("libfieldFunctionObjects.so");
        ...
        field       p;
        result      pRef;
        position    (0 0 0);
        scale       1.2;
        offset      100000;
    }
    \endverbatim

- now treat all mesh geometries as moving, since we cannot know
  beforehand if this is the case.

- allows processing of the data during the calculation.

- prevents accidental overwrite of runtime conversions.

- use same data mask width as ensightCase (8 digits)

- consolidate geometry time steps with data time steps if possible,
  for a cleaner case file.

- catch (value)
- forward declarations for operator<<()
- non-const access to Reaction name()
- spurious return statement

- the problem arises since the various surface writers are stateless.
  The collated output format hacks around this limitation by adding in
  its own fieldDict caching (to disk).

  Now include an updateMesh() method to hook into geometry changes.
  This is considered a stop-gap measure until the surface output
  handling is improved.

- improvement documentation for surface sampling.

- can now specify alternative sampling scheme for obtaining the
  face values instead of just using the "cell" value. For example,

      sampleScheme    cellPoint;

  This can be useful for cases when the surface is close to a boundary
  cell and there are large gradients in the sampled field.

- distanceSurface now handles non-closed surfaces more robustly.
  Unknown regions (not inside or outside) are marked internally and
  excluded from consideration. This allows use of 'signed' surfaces
  where not previously possible.

- this avoids some valgrind messages

      "Uninitialised byte(s) found during client check request"

- a -valgrind option for logging with valgrind

- determine number of processors from system/decomposeParDict
  or -decomposeParDict if -np was not specified

- find the position of the first bit off - symmetrical with find_first()

-  this should normally not be triggered, provided that setRefCell was
   used. However, if getRefCellValue() was called without any previous
   checking on refCelli, it is possible to provoke errors.

- The iterator for a HashSet dereferences directly to its key.

- Eg,

      for (const label patchi : patchSet)
      {
          ...
      }
  vs.
      forAllConstIter(labelHashSet, patchSet, iter)
      {
          const label patchi = iter.key();
          ...
      }