- in expressions BCs in particular, there is various logic handling
  for if value/refValue/refGradient etc are found or not.

  Handle the lookups as findEntry and branch to use Field assign
  or other handling, depending on its existence.

STYLE: use wordList instead of wordRes for copy/filter dictionary

- noexcept on some Time methods

ENH: pass through is_oriented() method for clearer coding

- use logical and/or/xor instead of bitwise versions (clearer intent)

ENH: noiseModels - replaced graph usage by writeFile

See merge request !562

Andrew Heather authored 2 years ago and Mark OLESEN committed 2 years ago

Header information now includes, e.g.

    f [Hz] vs P(f) [Pa]
    Lower frequency: 2.500000e+01
    Upper frequency: 5.000000e+03
    Window model: Hanning
    Window number: 2
    Window samples: 512
    Window overlap %: 5.000000e+01
    dBRef       : 2.000000e-05
    Area average: false
    Area sum    : 6.475194e-04
    Number of faces: 473

Note: output files now have .dat extension

Andrew Heather authored 2 years ago and Mark OLESEN committed 2 years ago

ENH: writeFile - renamed createFile functions
     to newFileAtTime and newFileAtStartTime

This reverts the v2206 behaviour so does not include
the edge-integration (2LI) optimisation - it uses
the exact same code as v2206.

If a `value` field is present use it and don't look for time
directories since this messes up the construct-from-dictionary

- for example,

    defaultFieldValues
    (
        areaScalarFieldValue h 0.00014
    );

    regions
    (
        clipPlaneToFace
        {
            point  (0 0 0);
            normal (1 0 0);

            fieldValues
            (
                areaScalarFieldValue h 0.00015
            );
        }
    );

ENH: additional clipPlaneTo{Cell,Face,Point} topo sets

- less cumbersome than defining a semi-infinite bounding box

- remedy by performing the attach() action sequentially (as per
  stitchMesh changes). This ensures that the current point addressing
  is always used and avoids references to the already-merged points
  (which is what causes the failure).

ENH: improve handling of empty patch removal

- only remove empty *merged* patches, but leave any other empty
  patches untouched since they may intentional placeholders for other
  parts of a workflow.

- remove any empty point/face zones created for patch merging

- commonly used calculations

ENH: add faPatch::patchRawSlice method

- slices using the nEdges() instead of the virtual size(),
  which provides similar functionality as finite-volume has with
  its distinction between polyPatch vs fvPatch patchSlice

- use patchInternal for obtaining faPatch, fvPatch information

- similar to boundaryFieldRef(), primitiveFieldRef() for providing
  write access. Complimentary naming to internalField(). Identical to
  ref() but more explicitly named, and less likely to be confused with
  a tmp::ref(), for example.

- prefer .primitiveFieldRef() over .ref().field()

- mark some access methods noexcept

- replace SLList with direct handling (like a hand-rolled DynamicList)

ENH: support PtrList transfer for polyMesh::addZones

- combineReduce     (older: combineAllGather)
- listCombineReduce (older: listCombineAllGather)
- mapCombineReduce  (older: mapCombineAllGather)

- these were previously constructing from an fvPatch (for simpler
  integration with regionFaModel) but this unnecessarily restricts
  the finiteArea to a single volume patch.

- adjusted derived faOptions to support multiple patches

- list of faces() was using mesh-faces, not area-faces

ENH: provision for patch and faceSet selection in fa::faceSetOption

- adjust most of the faOptions to respect subset of faces

ENH: support Function1 for externalHeatFluxSource

BUG: incorrect handling of fixedPower (externalHeatFluxSource)

- used local areas instead of global total area

- old constructor interface allowed arbitrary strings to specify the
  method enumeration. If actually used at runtime, they could/would
  raise a FatalError (unknown enumeration).
  Define a simpler default constructor instead.

- whichPolyPatches() = the polyPatches related to the areaMesh.

  This helps when pre-calculating (and caching) any patch-specific
  content.

- whichPatchFaces() = the poly-patch/patch-face for each of the faceLabels.

  This allows more convenient lookups and, since the list is cached on
  the area mesh, reduces the number of calls to whichPatch() etc.

- whichFace() = the area-face corresponding to the given mesh-face

ENH: more flexible/consistent volume->area mapper functions

- whichPatchFace() returns the (patchi, patchFacei) tuple,
  whichPatch() simply wraps whichPatchFace()

- groupNames() : similar to zones

ENH: simplify calls to faPatch/fvPatch patchField, lookupPatchField

- make second (ununsed) template parameter optional.
  Was previously needed for old compilers (2008 and earlier).

- simplifies construction/inheritance

ENH: add {fa,fv}PatchField::zeroGradientType() static

- can be used to avoid literal "zeroGradient" in places

STYLE: adjust naming of pointPatch runtime selection table

- simply use 'patch' as per fa/fv fields

STYLE: add zero-size guard to patch constraintType(const word&)

For example, instead of

   if (dict.found("value"))
   {
       fvScalarField::operator=
       (
           Field<scalar>("value", dict, p.size())
       );
   }

can use more precise specifications, and also eliminate searching
the dictionary multiple times:

   const auto* eptr = dict.findEntry("value", keyType::LITERAL);

   //or:  dict.findCompat("value", {{"oldName" ... }}, keyType::LITERAL);

   if (eptr)
   {
       fvScalarField::assign(*eptr, p.size());
   }

STYLE: combine declaration of FieldBase into Field.H

- include -no-libs option by default, similar to '-lib',
  which makes it available to all solvers/utilities.
  Add argList allowLibs() method to query it.

- relocate with/no functionObjects logic from Time to argList
  itself as argList allowFunctionObjects()

- add libs/functionObjects override handling to decomposePar etc

ENH: report the stream relativeName for IOerrors (see c9333a5a)

- disallow inadvertant casting and hidden copy constructions etc

- can use a (patchi, elemi) pair to access an element of a FieldField

- clearer coding intent. Mark operator() as 'deprecated'

- add bounds checking to get(label) and set(label) methods.

  This gives failsafe behaviour for get() that is symmetric with
  HashPtrTable, autoPtr etc and aligns the set(label) methods
  for UPtrList, PtrList and PtrDynList.

- use top-level PtrList::clone() instead of cloning individual elements

ENH: support HashPtrTable set with refPtr/tmp (flexibility)

- avoids try/catch exception handling

STYLE: prefer refCast (shorter) to dynamicCast where possible

- define returnReduce *after* defining all specializations for reduce
  so that the compiler does not take the generic templated reduce.

ENH: add UPstream::reduceAnd, UPstream::reduceOr

- direct wrapper of MPI_LAND, MPI_LOR intrinsics

ENH: provide special purpose returnReduce for logical operations

- returnReduceAnd(bool), returnReduceOr(bool) as a inline wrappers
  for returnReduce with andOp<bool>(), orOp<bool>() operators,
  respectively.

  These forms are more succinct and force casting of the parameter
  into a bool. Using MPI bool operations allows vendor/hardware MPI
  optimisations.

  * Test for existence on any rank:

      1.  if (returnReduceOr(list.size()) { ... }
      1b. if (returnReduceOr(!list.empty()) { ... }

      2.  if (returnReduce(bool(list.size(), orOp<bool>())) { ... }
      3.  if (returnReduce(list.size(), sumOp<label>()) != 0) { ... }
      3b. if (returnReduce(list.size(), sumOp<label>()) > 0) { ... }

  * Test for non-existence on all ranks:

      1.  if (returnReduceAnd(list.empty()) { ... }
      1b. if (!returnReduceOr(list.size()) { ... }

      2.  if (returnReduce(list.empty(), andOp<bool>())) { ... }
      3.  if (returnReduce(list.size(), sumOp<label>()) == 0) { ... }

  Notes:
      Form 1. succinct
      Form 2. may require explicit bool() for correct dispatch
      Form 3. more expensive sumOp<label> just for testing size!
      There are also some places using maxOp<label> instead of sumOp<label>

- these also work for bitSet, HashSet with slightly lower overhead

ENH: locate FOAM_NODISCARD attribute macro in stdFoam.H

- simplifies coding
  * finishedRequest(), waitRequest(), waitRequests() with parRun guards
  * nRequests() is noexcept

- more consistent use of UPstream::defaultCommsType in branching