- Add timer in objectRegistry::writeObject
- Disable writing of surfaceScalarFields that are
  not yet supported

Replace '(' with '_' by now for writing tests.

FIXME fixed. Check data with local size since a variable may not exist
locally but still have a global size (e.g. a patch field exists on
another rank)

IFCstream::readNonProcessorBoundaryFields(bool) is now somewhat
responsible for the processor boundary fields and requires a "true" as
argument to create dummy entries for them.

- Due to latest refactor in renumberMesh a readFields function is used
that setsIOobjectOption::NO_WRITE. Dirty bug fix by now: change it to
AUTO_WRITE. Certainly, it breaks many things, reconsider.

- In serial, reading a GeometricField in a legacy format (e.g. ASCII)
  and with "writeFormat coherent", IOobject::typeHeaderOk function
  gives an ok=true since the check is performed for legacy formats if
  coherent check fails.
  Refactor the checking to avoid this.
  IOobject::readAndCheckCoherentHeader is now a protected member
  function and is called from GeoField directly returning false if the
  format in the file header is not coherent.

- Allow to write coherent format without decomposing, e.g. for
  renumbering of serial mesh. Previously,
  "-coherent" always triggered a decomposition.
  The behaviour of

    renumberMesh -coherent

  is now achieved by

    renumberMesh -decompose -write-coherent

- Utility renumberMesh can also be used as mesh converter now keeping
  the mesh topology identical to the original mesh in legacy format:

    renumberMesh -write-coherent -renumber-method none -no-fields

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

- in renumberMesh replace calculation of a subMesh connectivity
  with calculation of the full mesh connectivity followed by subsetting
  of the full adjacency matrix. This should reduce the overall number of
  operations. (MR !669)

- 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