- Accumulate field data in a dictionary
- ASCII data
    - with keywords are stored in primitiveEntry objects
    - without keywords are stored in formattingEntry objects
- Binary data are stored in fieldDataEntry objects
- The IDs in the data.bp are names of the entries
- New feature: global uniform. Determine whether each field is uniform on all the ranks. Do it using a single reduce per GeometricField.
- For volFields the procPatch fields are removed from the IO
- For surfaceFields the procPatch fields are mapped into the global internal surfaceField and then removed

- STYLE: added comments and separation of concerns in sliceProcPatch
- ENH: separation of concerns in slicePermutation for reusibility of sorting permutations

- Provide correct field id (no processor in the name if needed)
- Introduce a check to identify globally uniform fields

- Introduce OFCstream derived from OFstream
- OFCstream is created in GeometricField and enables tracking which List will be written next
- Back-up for currently not supported Lists: write with full id containing processor directory name
- Derive sliceMesh from MeshObject in order to put the former into the objectRegistry, thus, keeping it at run and enabling access via the registry

- Reason: the former depends on the latter

- Lists for linear and tree communications were allocated at start-up, each of those is n^2 large where n is number of MPI ranks. This behavior leeded to job failure due to insufficient memory for large jobs.
- Only size the lists to n at the start-up. Do not allocate the memory for the list entries. Evaluate a communication list entry of type commsStruct on the fly when accessed via operator[] of the UList.

Writing parallel mesh (via renumbering the mesh by new cell numbering, using sliceMesh and writing paritionStarts) from decomposePar. (Use with flag -mesh)

(BROKEN PARALLEL IO AND RESTARTS) Writing points in vector format and removing redundant move semantics.

(BROKEN PARALLEL IO AND RESTARTS) Starting new format (TODO siceable fields) and refactoring of adios instantiation through abstract factory.

First implementation of sliceMesh conversion and initial encapsulation of ADIOS2 dependencies for writing.

- adds icoFoamTar
- installation of tar modules requires local manual third party installation (see applications/tarmodules/startTarCase/thirdParty/myreadme)
- usage of tar modules is described in applications/tarmodules/README
- example controlDict for tar modules in applications/tarmodules/tarSystemCall/controlDict
- to use ADIOS2 IO in decomposePar it has to be performed twice
    1) decomposePar -mesh
    2) decomposePar -fields
- uncollated ascii, binary, and parallel IO mode can all be started from polyMesh.bp and data.bp
(Processor folders are still created during decomposition to enable uncollated IO modes.)

- ADIOS restricts the string size (64kB?) and thus e.g. faces could not be written
- Switch from std::string to char arrays
- Reading with bpls is still possible with -S flag, e.g.:
  bpls -Sd constant/polyMesh.bp constant/polyMesh/faces

- ADIOS Mesh data is written and read to/from "constant/polyMesh.bp"
- When reading such functions such headerOkPar, findInstance or parStreamPar check first whether data.bp or polyMesh.bp are present

- Exclude some solvers and schemes not needed for basic runs

- Add a functionality to UListIO for writing non-contiguous data in order to handle faces (list of lists)
- UListIO uses a OStringStream to buffer list of lists and OFStream puts it as a string into the .bp file at destruction
- Make a typedef parIOType for the ADIOS data type which are not strings. Now it can be changed (e.g. from char to double) at one place in IOStream.H

 - added libraries blockMesh relies on:
   - src/ODE excluding sixDOF
   - src/dynamicMesh/dynamicMesh
   - src/mesh/blockMesh

- Hack BeginStep/EndStep into regIOobject using static member functions. Allows to Put variables in Deffered Mode.
- Somewhat ugly solution, but enables proper benchmarking.
- Since Mode::Append has a bug (no aggregation possible) on ADIOS side, the default mode for writing is set to Mode::Write.

- Check if data.bp is present. If yes, read from it. If not, fall back to standard IO.

    - The only working variant for write is BeginStep() and EndStep() in Mode::Append. Other variants of writing have issues, see commentary in adiosWrite.C
    - Save only double arrays => all adios templates are instantiated with double* instead of char*.
    - Refactor adios classes. Pull adios write and read functionality out of adiosCore into seprate classes. Clean up.

Example of a subdict in controlDict:

DebugSwitches
{
    dictionary 2;
    IOobject 1;
    time 1;
    DebugIOList 1;
    DebugIOField 1;
    volScalarField 1;
    volVectorField 1;
    OFstream 1;
    ISstream 2;
    IFstream 1;
}

Note that some of the switches have several level of verbosity, i.e. much more ouput if set to 2.