- The most visible change is the meta-data syntax.
  The attributes are now written in a "dictionary-like" style,
  although actually still streamed as a list of tokens.

    old:
        nonuniform List<scalar> 400 "p/internalField";

    new:
        nonuniform List<scalar> { name "p/internalField"; total 400; };

  Self-documenting and more extensible, at the cost of slightly
  more verbosity.

- reading of the "polyMesh/coherent" dictionary now respects the time
  instance of the polyBoundaryMesh, or can be specified to use an
  alternative timeName

- IFCstream base simplified by reusing existing components for stream
  allocators, reading and broadcast etc.

  The IFCstream reading has been revised to use globalIndex whenever
  possible.  To avoid needless communication, the dictionary/token
  streams are checked for pending tokens. If any are found, the
  globalIndex (eg, the patch size) is calculated once and reused for
  subsequent reading at the similar scope.

  This helps for boundary conditions based on mixed BC, which has four
  fields per patch. For internalField, similarly use the globalIndex
  directly instead of re-creating it again.

    old: label coherentFieldSize();
    new: const globalIndex& coherentInternalOffsets() const;

- use globalIndex semantics when fetching data from ADIOS.

- can now differential between scalar and sphericalTensor on reading.
  This was known to have broken, but was awaiting addition of rank
  information to compoundToken.

- improve robustness of the compoundToken expansion.
  When the tokens are read, they are placed in a "pending" state.
  Later when using ADIOS to populate them, only the pending ones are
  populated. This provisions for situations where some smaller fields
  have been written with a compoundToken but without the ADIOS backend.
  (Currently not possible since these would likely be written in ascii).

ENH: remove old polyMesh/data.bp directory before writing

- avoids an endless appending when the OpenFOAM utility is ostensibly
  in "-overwrite" mode, or when repeatedly calling something like
  blockMesh.

Sergey Lesnik authored 1 year ago and Mark OLESEN committed 1 year ago

- Enable parallel runs with XiFoam and icoFoam in coherent format.
  Reading and, thus, startup is supported only from uniform fields.

- Refactor IOobject. Trait is_coherentIOobject is now used directly in
  typeHeaderOk() with SFINAE. Often the header and object type is
  checked via a base IOobject and the type is provided via the function
  template parameter:

    IOobject header
        (
        ...
        );
    header.typeHeaderOk<volScalarField>(true);

  The change allows to move the corresponding logic from GeometricField
  back to IOobject.

- In the two solvers, disable processor directories check by argList
  that otherwise leads to a fatal error.

Sergey Lesnik authored 1 year ago and Mark OLESEN committed 1 year ago

Introduce the code only. Not compiling yet.

Sergey Lesnik authored 1 year ago and Mark OLESEN committed 1 year ago

- IFCstream: extract the type of the field from the compound token and
not via the template parameter since boundary fields may be of different
type. The corresponding functions are not templates anymore.

- Field file reading for coherent is done directly in GeometricField.
If file is not found or the format in the file header is not coherent,
the standard reading is triggered.

- BUG in OFCstream: write flat fields (label, scalar component type)
with a flat shape consisting of a single element. Also close
sliceStreamRepo instead of flush that performs close+open.

- BUG: CoherentMesh tried to read boundary file although boundary
information must be extracted from file "coherent". It's tied to
constant and thus needs a fix in the future.

- BUG: coherentMesh writes every time step. Check write option of the
points to control the write behavior.

- this implicitly invokes -decompose and sets the output stream
  to COHERENT when writing the mesh

- normally the mesh partitioning corresponds to the mesh ranks.
  However, when preparing a serial mesh with proper cell ordering
  for a parallel coherent case, the writing will occur in serial.

  For this case, use the polyMesh.data() member [a dictionary]
  to pass the desired partitioning into the writing backend.

- new wrapping methods (using various pTraits helpers) remove the need
  for the read/write primitives code [will remove in the future]

- use std::string instead of Foam::string for ADIOS identifiers
  since this can be considered low-level infrastructure

- plumb handling of labelPair into lower classes, which mostly
  eliminates the overhead of labelList to convey single or pairs of
  values. There is obviously still a std::vector allocation for
  the final ADIOS dimensions, but at the top-level can reduce overhead
  and conveniently specify shape as first/second.

- change base-level output interface

    OLD:  write(std::unique_ptr<uListProxyBase>)
    NEW:  write(const word&, std::unique_ptr<UListProxyBase>)

  Following the relocation of coherent output into Field instead of
  UList, this provides an interface which more symmetric with the
  usual writeEntry(key, val) semantics and eliminates the need to
  scan the incoming words for "List<scalar>" etc.

  This call is done directly from the Field::writeEntry() method
  with the possible compound token type now being originated from
  the UList information.

  The states are now managed by writeKeyword/endEntry
  and beginBlock/endBlock pairs.

- use internal field synchronization points for the field output.

  The GeometricField output is now unwrapped and the boundary patches
  are walked manually. At the begin of each patch (as well as the
  internalField), a sync index is set on the output stream. This sync
  index provides context when creating the individual fieldDataEntry
  items (ie, a correspondence of fieldDataEntry and CoherentMesh
  entities).

- Tracked fieldDataEntry outside of the collecting dictionary to allow
  directly pruning etc (also avoids recursive gathering).

- Replace the list-based reduction of the uniformity tags/values in
  favour of a direct individual reduction (can be revisited).

COMP: forward declare UListProxyBase, add OFCstream debug flag

- cannot rely on DimensionedField::debug since this is not defined
  for triSurface fields (for example)

ENH: support reading with specified instance

- some functions (eg, Foam::zip) clash with existing OpenFOAM
  functions, even if they were unused

STYLE: remove local Foam::subset template algorithm

- even if not a compilation clash, the Foam::subset has a semantic
  clash with existing OpenFOAM 'subset' functions.
  Unroll outer loop and and use std::copy_if instead.

GIT: remove old (duplicate) formattingEntry

Sergey Lesnik authored 1 year ago and Mark OLESEN committed 1 year ago

- Tested by writing volFields with the icoFoam's cavity test case
(boundary file is still needed in polyMesh)

- ASCII field files have some formatting issues (writing is done with
dictionary::write)

- OFCstream now inherits from OCharStream; rename foam-extend flavored
member functions to OF equivalents

- New regIOobject virtual member function "writeToStream" allows to
construct OFCstream within GeometricField

- The heavy data is now given to an OFCstream in the Field class, not UList.
Doing this makes it simple to ensure that every rank will call
OFCstream::write for every field.

- reduced overhead and bookkeeping
- non-blocking communication of slices and shared points
- use globalIndex for all internal accounting

- extracts more relevant information during construct or reset
  to allow inexpensive queries such as the number of
  internal/boundary faces and (non-processor) patch sizes etc.

  By consolidating more bookkeeping and functionality can
  greatly reduce the number of scans of input data performed.

- avoid fragile instance counter in favour of construct with index

- support two-stage construction, hide some functions, remove unused
  variables

- align naming more with OpenFOAM conventions.

- include sanity checks on boundary reading, PtrList management

- ensure that "boundary" information does not have more patches
  than known from the coherent format

- polyPatchList instead of List of raw pointers for additional safety.
  Avoids memory leaks, even if the caller doesn't use the data.

Gregor Weiss authored 1 year ago and Mark OLESEN committed 1 year ago

- integration notes (Mark Olesen):

  * left the MUST_READ/READ_IF_PRESENT flags untouched in the
    initializer to reduce noise of the commit (to be addressed)

- also generates a "polyMesh/coherent" dictionary with some boundary
  information etc. Can be useful for later detection of coherent vs
  non-coherent formats etc.

General
-------

- avoid parameter copying, more stringent test on bad input

- support writing primitives with globalIndex reference and labelPair

- obtain underlying component type and number from VectorSpace members
  instead of assuming that these are only 'scalar' and that the data
  buffer is non-null!

- add Reader(), Writer() factory methods for creating streams.
  * Simpler code and few header dependencies.

- style: method name sync_buffer() instead of bufferSync()

- support SYNC mode when reading/writing slice contents.
  Avoids using deferred and then sync on the entire buffer.
  Use get(), get_sync() methods instead of readToContainer helper

Repo
----

- make SliceStreamRepo singleton a std::unique_ptr.
  (avoids leakage on closure).

- add closeInstance() and endInstance() for extra management
  of the singleton

ENH: robuster handling of ADIOS config file

- use "system/adios-config.xml" or "system/adios-config.yaml"
  (was "system/config.xml") to make its intended purpose more transparent.

- although ADIOS does not require a config file, it will fail if the
  config file is specified and missing. Now check the availability of
  the config file(s) and unset if missing.

  NB: checks use the absolute global case-path for additional safety.

ENH: split off read buffer creation and size querying

- add missing totalSize() method

- replace the size() method, which was actually the local size
  with a range() method for querying the local dimensions

  range()     : queries the first component of Start() and Count()
  totalSize() : queries the first component of the Shape()

- add clear(), reset(), clone() methods to InitFromADIOS to simplify
  reuse and multiple queries etc.

ENH: add version (api) and sizes (label,scalar) as attributes

ENH: handle writing of multi-component types directly from SliceStream

- the sliceWritePrimitives helper routines should now be redundant

- cleaner integration of globalIndex:
  * support extract to globalIndex
  * use globalIndex at the components level (for gradual phase-out)

- global end-offsets are directly calculated (using MPI Allgather)

- global start-offsets are calculated with globalIndex::calcOffsets,
  without an intermediate list

- provide constant() DataComponent functor

  * simply returns the constant value with which it was constructed.
    Replace special-purpose start_from_myProcNo, count_two functions
    with equivalent constant() functors

- pass and return strings by reference

ENH: use factory forwarding for InitStrategies to simplify code

- std::unique_ptr ownership passed by move reference

STYLE: place DataComponent functions into OffsetStrategies namespace

- reduces clutter of the Foam namespace
- document their functionality

- replace internal labelPair typedef (std::pair<label,label>, not
  Foam::labelPair) with range_type to avoid possible confusion

- use internal typedefs for OffsetStrategy and DataComponent::base_ptr
  to avoid additional clutter in Foam namespace.

- use class instead of struct with private/protected content

- use OpenFOAM containers and naming conventions.

INT: add transitional methods to Offsets

- Offsets is slated for future removal since it is largely identically
  to what globalIndex provides, but provide compilation path for now

STYLE: simplify/extend sliceMeshHelper

- a namespace with some static functions and/or algorithms for
  handling some of the coherent mesh format details.

 * basic extraction for slice faces / points

 * categorization of upper-connected face neighbours

 * serialize/deserialize owners/faces :
   somewhat similar to CompactListList pack/unpack but
   templated on parameters to support std::vector etc.

  - partition-offsets  (was partitionStarts)
  - owner-offsets      (was ownerStarts)
  - neighbour          (was neighbours)
  - face-offsets       (was faceStarts)
  - face-points        (was faces)

STYLE: adjust class naming to reflect (current/future) purpose

- coherentMeshPolyMapper (old: FragmentPermutation)
- coherentProcessorPatch (old: ProcessorPatch)
- polyMeshCoherentMapper (old: SlicePermutation)

STYLE: use contains() for slice maps

- combine DataComponentFree into DataComponent

- make sliceMap header-only (will be removed)

GIT: remove remnant OffsetDecorator header

- this will presumably change again in the future

- provide is_coherentIOobject type trait

Improve streaming matrix and internal memory management

See merge request Development/openfoam!671

- reduce local overhead prior to sending for master assembly
- non-blocking mode when assembling solution vector
- automatic resizing of pivots

- align member order between template and non-template versions
- move construct, move assignment

ENH: adjust renumbering methods, extend renumberMesh options

See merge request Development/openfoam!669

- renumberMesh now has -dry-run, -write-maps, -no-fields,
  -renumber-method, -renumber-coeffs options.

  * Use -dry-run with -write-maps to visualize the before/after
    effects of renumbering (creates a VTK file).

  * -no-fields to renumber the mesh only.
    This is useful and faster when the input fields are uniform
    and the -overwrite option is specified.

  * -renumber-method allows a quick means of specifying a different
    default renumber method (instead of Cuthill-McKee).

    The -renumber-coeffs option allows passing of dictionary content
    for the method.

    Examples,

       // Different ways to specify reverse Cuthill-McKee

       *  -renumber-method RCM
       *  -renumber-coeffs 'reverse true;'
       *  -renumber-method CuthillMcKee
       *  -renumber-coeffs 'reverse true;'
       *  -renumber-coeffs 'method CuthillMcKee; reverse true;'

       // Other (without dictionary coefficients)
       *  renumberMesh -renumber-method random

       // Other (with dictionary coefficients)
       renumberMesh \
           -renumber-method spring \
           -renumber-coeffs 'maxCo 0.1; maxIter 1000; freezeFraction 0.99;'

       // Other (with additional libraries)
       renumberMesh -renumber-method zoltan -lib zoltanRenumber

COMP: build zoltan renumbering to MPI-specific location

- zoltan and Sloan renumbering are now longer automatically linked to
  the renumberMesh utility but must be separately loaded by a
  command-line option or through a dictionary "libs" entry.

ENH: add output cellID for decomposePar -dry-run -cellDist

- reads file contents into a DynamicList<char>, which can then be
  broadcast, moved to a ICharStream etc.

ENH: eliminate unnecessary duplicate communicator

- in globalMeshData previously had a comm_dup hack to avoid clashes
  with deltaCoeffs calculations. However, this was largely due to a
  manual implementation of reduce() that used point-to-point
  communication. This has since been updated to use an MPI_Allreduce
  and now an MPI_Allgather, neither of which need this hack.

ENH: add rank() method for compound tokens

ENH: add IOstream::minPrecision(unsigned)

- reduced typing, more expressive, no namespace ambiguity with max()

    new: IOstream::minPrecision(10);
    old: IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));

STYLE: namespace qualify min/max for some buffer sizing [clang/hipp]

- this was previously a UList instead of SubList,
  but SubList supports better assignment of values

ENH: add invertOneToManyCompact

- returns a CompactListList<label> instead of labelListList, which
  allows for reuse as partitioning table etc and/or slightly reduced
  memory overhead