rigidBodyDynamics/rigidBodySolvers: Added run-time selectable solvers to integrate the rigid-body motion

Currently supported solvers: symplectic, Newmark, CrankNicolson

The symplectic solver should only be used if iteration over the forces
and body-motion is not required.  Newmark and CrankNicolson both require
iteration to provide 2nd-order behavior.

See applications/test/rigidBodyDynamics/spring for an example of the
application of the Newmark solver.

This development is sponsored by Carnegie Wave Energy Ltd.

“Error when reading ascii data. Possible mismatch of datasize with
declaration.”

Patch contributed by Karl Meredith, FMGlobal

This is a more convenient way of maintaining the state or multiple
states (for higher-order integration), storing, retrieving and passing
between processors.

Included for backward-compatibility with the 6-DoF solver but in the
future will be re-implemented as a joint rather than body restraint and
accumulated in tau (internal forces) rather than fx (external forces).

applications/test/rigidBodyDynamics/spring: Test of the linear spring with damper restraint
Damped simple harmonic motion of a weight on a spring is simulated and
the results compared with analytical solution

    Test-spring
    gnuplot spring.gnuplot
    evince spring.eps

This development is sponsored by Carnegie Wave Energy Ltd.

rigidBodyDynamics/bodies/subBody: Changed "parent" to "master" to avoid confusion with the parent to which this composite body is joined

Added support for composite joints including a specialized 6-DoF form for floating bodies.

rigidBodyDynamics/bodies: Complete set of clone functions to support copy construction and assignment

e.g. (fvc::interpolate(HbyA) & mesh.Sf()) -> fvc::flux(HbyA)

This removes the need to create an intermediate face-vector field when
computing fluxes which is more efficient, reduces the peak storage and
improved cache coherency in addition to providing a simpler and cleaner
API.

dotInterpolate interpolates the field and "dots" the resulting
face-values with the vector field provided which removes the need to
create a temporary field for the interpolate.  This reduces the peak
storage of OpenFOAM caused by the divergence of the gradient of vector
fields, improves memory management and under some conditions decreases
run-time.

This development is based on a patch contributed by Paul Edwards, Intel.

to allow the construction of vtables for virtual member functions
involving the inner-products of fields for which a "NotImplemented"
specialization for scalar is provided.

src/Pstream/mpi/UPstream.C: Cast-away const-ness for backard-compatibility with OpenMPI versions  < 1.7.4
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=2044

rigidBodyDynamics: Added sphere body to simply construction of articulated bodies containing spheres

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

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

Based on the principles, algorithms, data structures and notation
presented in the book:

    Featherstone, R. (2008).
    Rigid body dynamics algorithms.
    Springer.

This development is sponsored by Carnegie Wave Energy Ltd.

    //- Disallow default shallow-copy assignment
    //
    //  Assignment of UList<T> may need to be either shallow (copy pointer)
    //  or deep (copy elements) depending on context or the particular type
    //  of list derived from UList and it is confusing and prone to error
    //  for the default assignment to be either.  The solution is to
    //  disallow default assignment and provide separate 'shallowCopy' and
    //  'deepCopy' member functions.
    void operator=(const UList<T>&) = delete;

    //- Copy the pointer held by the given UList.
    inline void shallowCopy(const UList<T>&);

    //- Copy elements of the given UList.
    void deepCopy(const UList<T>&);

Contributed by Mattijs Janssens.

1. Any non-blocking data exchange needs to know in advance the sizes to
   receive so it can size the buffer.  For "halo" exchanges this is not
   a problem since the sizes are known in advance but or all other data
   exchanges these sizes need to be exchanged in advance.

   This was previously done by having all processors send the sizes of data to
   send to the master and send it back such that all processors
   - had the same information
   - all could work out who was sending what to where and hence what needed to
     be received.

   This is now changed such that we only send the size to the
   destination processor (instead of to all as previously). This means
   that
   - the list of sizes to send is now of size nProcs v.s. nProcs*nProcs before
   - we cut out the route to the master and back by using a native MPI
     call

   It causes a small change to the API of exchange and PstreamBuffers -
   they now return the sizes of the local buffers only (a labelList) and
   not the sizes of the buffers on all processors (labelListList)

2. Reversing the order of the way in which the sending is done when
   scattering information from the master processor to the other
   processors. This is done in a tree like fashion. Each processor has a
   set of processors to receive from/ send to. When receiving it will
   first receive from the processors with the least amount of
   sub-processors (i.e. the ones which return first). When sending it
   needs to do the opposite: start sending to the processor with the
   most amount of sub-tree since this is the critical path.

Patch contributed by Mattijs Janssens
Resolved bug-report http://www.openfoam.org/mantisbt/view.php?id=2038