1. 14 Jun, 2018 2 commits
  2. 13 Jun, 2018 2 commits
  3. 11 Jun, 2018 1 commit
  4. 06 Jun, 2018 1 commit
  5. 30 May, 2018 1 commit
  6. 29 May, 2018 1 commit
  7. 24 May, 2018 1 commit
  8. 27 Feb, 2018 1 commit
  9. 09 May, 2018 2 commits
  10. 08 May, 2018 1 commit
    • Andrew Heather's avatar
      ENH: Added a new function object to create a field relative to a field value · 091d8470
      Andrew Heather authored
          Calculates and outputs a field whose values are offset to a reference
          value obtained by sampling the field at a user-specified location.
      
          The field values are calculated using:
      
          \f[
              f_c = s(f_{c,t} - f_p + f_{off})
          \f]
      
          where
          \vartable
              f_c     | field values at cell
              s       | optional scale factor (default = 1)
              f_{c,t} | current field values at cell at this time
              f_p     | field value at position
              f_{off} | offset field value (default = 0)
          \endvartable
      
      Usage
          Example of function object specification to calculate the reference
      field:
          \verbatim
          pRef
          {
              type        reference;
              libs        ("libfieldFunctionObjects.so");
              ...
              field       p;
              result      pRef;
              position    (0 0 0);
              scale       1.2;
              offset      100000;
          }
          \endverbatim
      091d8470
  11. 07 May, 2018 1 commit
    • Mark OLESEN's avatar
      ENH: improvements in the surface sampling infrastructure · b0648f2b
      Mark OLESEN authored
      - improvement documentation for surface sampling.
      
      - can now specify alternative sampling scheme for obtaining the
        face values instead of just using the "cell" value. For example,
      
            sampleScheme    cellPoint;
      
        This can be useful for cases when the surface is close to a boundary
        cell and there are large gradients in the sampled field.
      
      - distanceSurface now handles non-closed surfaces more robustly.
        Unknown regions (not inside or outside) are marked internally and
        excluded from consideration. This allows use of 'signed' surfaces
        where not previously possible.
      b0648f2b
  12. 05 Mar, 2018 1 commit
    • Mark OLESEN's avatar
      STYLE: use direct iteration for HashSet · 4fe8ed82
      Mark OLESEN authored
      - The iterator for a HashSet dereferences directly to its key.
      
      - Eg,
      
            for (const label patchi : patchSet)
            {
                ...
            }
        vs.
            forAllConstIter(labelHashSet, patchSet, iter)
            {
                const label patchi = iter.key();
                ...
            }
      4fe8ed82
  13. 30 Apr, 2018 1 commit
  14. 27 Apr, 2018 1 commit
  15. 28 Mar, 2018 1 commit
  16. 27 Mar, 2018 2 commits
  17. 11 Apr, 2018 1 commit
    • Mark OLESEN's avatar
      ENH: allow "<case>", "<system>" ... in the string expansions (issue #792) · 5f88e427
      Mark OLESEN authored
      - the expansions were previously required as slash to follow, but
        now either are possible.
      
          "<case>", "<case>/" both yield the same as "$FOAM_CASE" and
          will not have a trailing slash in the result. The expansion of
          "$FOAM_CASE/" will however have a trailing slash.
      
      - adjust additional files using these expansions
      5f88e427
  18. 26 Mar, 2018 1 commit
    • Mark OLESEN's avatar
      STYLE: consistent lookupOrDefault template parameters · 36719bf5
      Mark OLESEN authored
      - in many cases can just use lookupOrDefault("key", bool) instead of
        lookupOrDefault<bool> or lookupOrDefault<Switch> since reading a
        bool from an Istream uses the Switch(Istream&) anyhow
      
      STYLE: relocated Switch string names into file-local scope
      36719bf5
  19. 21 Mar, 2018 1 commit
  20. 22 Mar, 2018 1 commit
  21. 16 Mar, 2018 1 commit
    • Mark OLESEN's avatar
      STYLE: more consistent use of dimensioned Zero · 2f86cdc7
      Mark OLESEN authored
      - when constructing dimensioned fields that are to be zero-initialized,
        it is preferrable to use a form such as
      
            dimensionedScalar(dims, Zero)
            dimensionedVector(dims, Zero)
      
        rather than
      
            dimensionedScalar("0", dims, 0)
            dimensionedVector("zero", dims, vector::zero)
      
        This reduces clutter and also avoids any suggestion that the name of
        the dimensioned quantity has any influence on the field's name.
      
        An even shorter version is possible. Eg,
      
            dimensionedScalar(dims)
      
        but reduces the clarity of meaning.
      
      - NB: UniformDimensionedField is an exception to these style changes
        since it does use the name of the dimensioned type (instead of the
        regIOobject).
      2f86cdc7
  22. 14 Mar, 2018 1 commit
  23. 13 Mar, 2018 1 commit
    • Mark OLESEN's avatar
      ENH: code reduction in PackedList, PackedBoolList (issue #751) · 5d1fb235
      Mark OLESEN authored
      - eliminate iterators from PackedList since they were unused, had
        lower performance than direct access and added unneeded complexity.
      
      - eliminate auto-vivify for the PackedList '[] operator.
        The set() method provides any required auto-vivification and
        removing this ability from the '[]' operator allows for a lower
        when accessing the values. Replaced the previous cascade of iterators
        with simpler reference class.
      
      PackedBoolList:
      
      - (temporarily) eliminate logic and addition operators since
        these contained partially unclear semantics.
      
      - the new test() method tests the value of a single bit position and
        returns a bool without any ambiguity caused by the return type
        (like the get() method), nor the const/non-const access (like
        operator[] has). The name corresponds to what std::bitset uses.
      
      - more consistent use of PackedBoolList test(), set(), unset() methods
        for fewer operation and clearer code. Eg,
      
            if (list.test(index)) ...    |  if (list[index]) ...
            if (!list.test(index)) ...   |  if (list[index] == 0u) ...
            list.set(index);             |  list[index] = 1u;
            list.unset(index);           |  list[index] = 0u;
      
      - deleted the operator=(const labelUList&) and replaced with a setMany()
        method for more clarity about the intended operation and to avoid any
        potential inadvertent behaviour.
      5d1fb235
  24. 07 Mar, 2018 1 commit
    • Mark OLESEN's avatar
      ENH: new bitSet class and improved PackedList class (closes #751) · bac943e6
      Mark OLESEN authored
      - The bitSet class replaces the old PackedBoolList class.
        The redesign provides better block-wise access and reduced method
        calls. This helps both in cases where the bitSet may be relatively
        sparse, and in cases where advantage of contiguous operations can be
        made. This makes it easier to work with a bitSet as top-level object.
      
        In addition to the previously available count() method to determine
        if a bitSet is being used, now have simpler queries:
      
          - all()  - true if all bits in the addressable range are empty
          - any()  - true if any bits are set at all.
          - none() - true if no bits are set.
      
        These are faster than count() and allow early termination.
      
        The new test() method tests the value of a single bit position and
        returns a bool without any ambiguity caused by the return type
        (like the get() method), nor the const/non-const access (like
        operator[] has). The name corresponds to what std::bitset uses.
      
        The new find_first(), find_last(), find_next() methods provide a faster
        means of searching for bits that are set.
      
        This can be especially useful when using a bitSet to control an
        conditional:
      
        OLD (with macro):
      
            forAll(selected, celli)
            {
                if (selected[celli])
                {
                    sumVol += mesh_.cellVolumes()[celli];
                }
            }
      
        NEW (with const_iterator):
      
            for (const label celli : selected)
            {
                sumVol += mesh_.cellVolumes()[celli];
            }
      
            or manually
      
            for
            (
                label celli = selected.find_first();
                celli != -1;
                celli = selected.find_next()
            )
            {
                sumVol += mesh_.cellVolumes()[celli];
            }
      
      - When marking up contiguous parts of a bitset, an interval can be
        represented more efficiently as a labelRange of start/size.
        For example,
      
        OLD:
      
            if (isA<processorPolyPatch>(pp))
            {
                forAll(pp, i)
                {
                    ignoreFaces.set(i);
                }
            }
      
        NEW:
      
            if (isA<processorPolyPatch>(pp))
            {
                ignoreFaces.set(pp.range());
            }
      bac943e6
  25. 23 Feb, 2018 1 commit
  26. 05 Mar, 2018 1 commit
  27. 26 Feb, 2018 3 commits
    • Mark OLESEN's avatar
    • Mark OLESEN's avatar
      ENH: cleanup tmp class (issue #639) · 52b36f84
      Mark OLESEN authored
      Improve alignment of its behaviour with std::shared_ptr
      
        - element_type typedef
        - swap, reset methods
      
      * additional reference access methods:
      
      cref()
          returns a const reference, synonymous with operator().
          This provides a more verbose alternative to using the '()' operator
          when that is desired.
      
              Mnemonic: a const form of 'ref()'
      
      constCast()
          returns a non-const reference, regardless if the underlying object
          itself is a managed pointer or a const object.
          This is similar to ref(), but more permissive.
      
              Mnemonic: const_cast<>
      
          Using the constCast() method greatly reduces the amount of typing
          and reading. And since the data type is already defined via the tmp
          template parameter, the type deduction is automatically known.
      
          Previously,
      
              const tmp<volScalarField>& tfld;
      
              const_cast<volScalarField&>(tfld()).rename("name");
              volScalarField& fld = const_cast<volScalarField&>(tfld());
      
          Now,
      
              tfld.constCast().rename("name");
              auto& fld = tfld.constCast();
      
      --
      
      BUG: attempts to move tmp value that may still be shared.
      
      - old code simply checked isTmp() to decide if the contents could be
        transfered. However, this means that the content of a shared tmp
        would be removed, leaving other instances without content.
      
      * movable() method checks that for a non-null temporary that is
        unique (not shared).
      52b36f84
    • Mark OLESEN's avatar
      ENH: cleanup autoPtr class (issue #639) · 660f3e54
      Mark OLESEN authored
      Improve alignment of its behaviour with std::unique_ptr
      
        - element_type typedef
        - release() method - identical to ptr() method
        - get() method to get the pointer without checking and without releasing it.
        - operator*() for dereferencing
      
      Method name changes
      
        - renamed rawPtr() to get()
        - renamed rawRef() to ref(), removed unused const version.
      
      Removed methods/operators
      
        - assignment from a raw pointer was deleted (was rarely used).
          Can be convenient, but uncontrolled and potentially unsafe.
          Do allow assignment from a literal nullptr though, since this
          can never leak (and also corresponds to the unique_ptr API).
      
      Additional methods
      
        - clone() method: forwards to the clone() method of the underlying
          data object with argument forwarding.
      
        - reset(autoPtr&&) as an alternative to operator=(autoPtr&&)
      
      STYLE: avoid implicit conversion from autoPtr to object type in many places
      
      - existing implementation has the following:
      
           operator const T&() const { return operator*(); }
      
        which means that the following code works:
      
             autoPtr<mapPolyMesh> map = ...;
             updateMesh(*map);    // OK: explicit dereferencing
             updateMesh(map());   // OK: explicit dereferencing
             updateMesh(map);     // OK: implicit dereferencing
      
        for clarity it may preferable to avoid the implicit dereferencing
      
      - prefer operator* to operator() when deferenced a return value
        so it is clearer that a pointer is involve and not a function call
        etc    Eg,   return *meshPtr_;  vs.  return meshPtr_();
      660f3e54
  28. 21 Feb, 2018 1 commit
  29. 09 Feb, 2018 1 commit
    • Mark OLESEN's avatar
      BUG: incorrect HashTable / HashSet instances · 09a6e940
      Mark OLESEN authored
      - Eg instead of using labelHashSet, used HashSet<label> which uses
        the string::hash for hashing. Other places inadvertently using the
        string::hash instead of Hash<label> for hashing.
      
      STYLE: use Map<..> instead of HashTable<.., label, Hash<label>>
      
      - reduces clutter
      09a6e940
  30. 11 Jan, 2018 1 commit
  31. 28 Dec, 2017 1 commit
  32. 26 Dec, 2017 1 commit
  33. 22 Dec, 2017 2 commits