- 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.

- pass ownership of std::unique_ptr by move

STYLE: use class instead of struct with private/protected content

ENH: fix naive partitioning calculations (had some rounding issues)

- the updated SlicePermutation (now named polyMeshSlicer)
  should largely be parallel-aware.

  processorCyclic:
  - handled by deferring back to a plain cyclic (via the referPatchID)

  processor:
  - the faces on the owner side are retained, those on the neighbour
    side are ignored (removed from the faces to be mapped/sliced).

    In the first pass, the neighbour side sends its associated
    faceCells, but renumbered according to the global cell ID.

    In the second pass, owner side collects the face cells and uses
    them as its neighbour connectivity.

  As before, the slice neighbours are saved with the global cell ID
  and boundary patches are negative `-(patchi + 1)` encoded.

  When the polyMeshSlicer is used to write to disk (eg, via
  the ADIOS backend), the following elements are written:

  - faces:
    a face points in compact and ordered form,
    using naive global point numbering
    (ie contains duplicates for globally shared points).

      Local values written  : (numFaces * numPointsPerFace)
      Global values written : (numFaces * numPointsPerFace * numProcs)

    However, the numFaces is _after_ applying the processor boundary
    filtering (to remove the duplicate neighbour-side faces) so the
    numFaces here is generally not equal to mesh.nFaces()

  - facesStarts (FUTURE? faceOffsets):
    an offset list for begin/end offsets within the `faces` entry.
    Locally these each have (numFaces + 1) entries.
    Globally combined would have (numFaces * numProcs) + 1 entries.

  - owner:
    The face owners are not written, since they implicitly correspond
    to the sorted cellID order.

  - ownerStarts (FUTURE? faceOffsets):
    an offset list for begin/end offsets within the implicit `owner` entry.
    Each offset band corresponds to faces associated with that cellID.
    Locally these each have (numCells + 1) entries.
    Globally combined would have (numCells * numProcs) + 1 entries.

  - neighbours:
    The face neighbours using global cellID and encoded boundary patch
    identifiers.

      Local values written  : (numFaces)
      Global values written : (numFaces * numProcs)

  - points:
    The x/y/z coordinates for the face points (in face walk order)

      Local values written  : (numPoints)
      Global values written : (numPoints * numProcs)

- meta-data:

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

- remove 'reduce' option from Offsets as this will re-align with
  globalIndex

- pass and return strings by reference

- replace binary search within patches with indirect list addressing

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

Co-authored-by: Mark Olesen <>

- avoids unnecessary allocation overhead

- 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.

- construct initial slice faces in the target order instead of making
  a full copy and permuting them (invokes a second copy)

- return slice faces as const reference, not copy

- use standard faceMap(), pointMap() terminology for managing the
  slice permutation.

- the slice Offsets are largely identically in functionality with what
  globalIndex does except that it uses begin/end pairs instead of a
  compact list of offsets.

  However, it has used globalIndex to gather the sizes, with a
  hacked-version of globalIndex to retain the sizes (not offsets).

  For now, simply gather the sizes manually but with a future view to
  replacing this class entirely.

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

- fix amiguity of function resolution to regIOobject::readStream
- use public constructor for processorPolyPatch that creates the patch name
  automatically
- remove unused FragementPermutation::resetNextPatch method

- pass strings and labelList by const-ref
- default empty labelList as labelList::null() reference

- 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!

- new methods added to IOobject to ease mixed (serial vs parallel)
  file locations. Some redirect to Time, others are defined for
  IOobject only.

    | "normal" (serial/parallel) | "global" (serial locations) |
    | ---------------------------|-----------------------------|
    | caseName()                 | globalCaseName()            |
    | path()                     | globalPath()          *new* |
    | path(...)                  | globalPath(...)       *new* |
    | objectPath()               | objectGlobalPath()    *new* |

- avoids clutter of argList::envGlobalPath() ...

ENH: allow temporary overwriting of output writeFormat

- allows switching for particular output routines

COMP: explicitly use TimePaths methods with Time

- this simplifies any overloading done at a later stage

- this makes it easier to split creation into a two-stage process
  as required

- extend handling for polyBoundaryMeshEntries, faBoundaryMeshEntries
  with more functionality. Ensure that these are never registered.

ENH: addition writeEntry methods for polyBoundaryMesh

- simplifies streaming and collating into other files

ENH: polyMesh rereading - update owner/neighbour header information

- this avoids accidentally reading the "cells" file if the mesh has
  been created with NO_READ and then updated

STYLE: less vertical space when outputting empty PtrList

- returns the edge index within the face, -1 if not found

STYLE: use contains() and reduce reliance on edgeDirection -1/+1 values

- single() method : simply tests if the globalIndex has nProcs == 1,
  which is typically from a gatherNone invocation.
  For example,

     globalIndex gi;
     if (...) gi.reset(localSize);
     else     gi.reset(globalIndex::gatherNone{}, localSize);

     // later...
     const label begin = (gi.single() ? 0 : gi.localStart());
     const label count = (gi.single() ? gi.totalSize() : gi.localSize());

- add front() and back() methods to return the begin/end ranges,
  and begin_value(), end_value() - as per labelRange.

- make more methods noexcept

- calcOffset(), calcRange() helper functions to determine
  the processor-local of a numbering range without the overhead of
  creating a list of offsets.

  For example,

     label myOffset = globalIndex::calcOffset(mesh.nCells());
     labelRange mySlice = globalIndex::calcRange(mesh.nCells());

- add globalIndex localEnd() as per CompactListList method

STYLE: align looping constructs in CompactListList with List

- make more methods noexcept

- becoming more frequently used and there is no ambiguity in calling
  parameters either - identity(label) vs identity(labelUList&).

  Provide both int32 and int64 versions.

- consistent with probes. Allows reporting/querying

- support for SpanStreams etc

- extraction of Description from the respective tests.
  Relatively incomplete

  Uses the `application/tests/get-descriptions` extractor

- acts somewhat like an identity op that 'swallows' its parameter
  and maps back to zero.

- it seems that both sides of the ternary are evaluated despite
  the divide-by-zero protection. Use volatile to force the compiler
  to use in-order evaluation.

- prevent automatic comparison rewriting (c++20)
- no bitwise operations between different enumerations
- template instantiation

ENH: add DimensionedField Internal typedef (simplifies handling)