- Previously had just 'Warning' instead of '::Foam::Warning', which
meant that an identically named class method would inadvertently be
used - resulting in a compile failure.
- resize with factor 2 as per DynamicList
Old insertion speed:
1000000 in 0.61 s
2000000 in 2.24 s
3000000 in 3.97 s
4000000 in 5.76 s
5000000 in 7.54 s
6000000 in 9.41 s
7000000 in 11.5 s
New insertion speed:
1000000 in 0.01 s
2000000 in 0.02 s
3000000 in 0.01 s
4000000 in 0.02 s
5000000 in 0.01 s
6000000 in 0.01 s
7000000 in 0.01 s
- compatibility:
* 'polySpline' and 'simpleSpline' accepted
* detect and discard end tangent specifications
- a BSpline is also included (eg, for future support of NURBS), but is
not selectable from blockMesh since it really isn't as nice as the
Catmull-Rom (ie, doesn't *exactly* go through each point).
triangle, from:
http://en.wikipedia.org/wiki/Inertia_tensor_of_triangle
Adding the ability to calculate the inertia tensor of a polygon face
by summing the triangle inertias.
Added a test application to draw a test face with its principal
axes and moments of inertia.
triangle, from:
http://en.wikipedia.org/wiki/Inertia_tensor_of_triangle
Adding the ability to calculate the inertia tensor of a polygon face
by summing the triangle inertias.
Added a test application to draw a test face with its principal
axes and moments of inertia.
- now that I re-examined the code, the note in commit 51fd6327a6
can be mostly ignored
PackedList isMaster(nPoints, 1u);
is not really inefficient at all, since the '1u' is packed into
32/64-bits before the subsequent assignment and doesn't involve
shifts/masking for each index
The same misinformation applies to the PackedList(size, 0u) form.
It isn't much slower at all.
Nonetheless, add bool specialization so that it is a simple assign.
- forgot to use readList in removeEntry, which caused the test failure.
- remaining problem:
it doesn't work as might be expected
This is the problem:
dict
{
foo xxx;
bar yyy;
}
dict
{
baz zzz;
#remove foo
}
This only removes 'foo' from the current scope (the second dict), since
it occurs before the dictionary merge does.
To remove from the final, merged dictionary, we'd need a new
deleteEntry type that would do the right thing on the merge before
self-destructing (ie, removing itself too).
Changed the underlying map to be a Map<scalar> to allow the addition
of a value to the Distribution to be weighted (by timestep or by cell
size for example) component by-component - default weight is one.
Adding normalisation, write, mean snd median functions.
Test application DistributionTest draws numbers from the Random class
and creates distributions of them, writing to disk, for the main
types: scalar, vector, symmTensior, sphericalTensor and tensor.
Creating a labelVector distibution, but need to check what is
happening to the mean and median values and what happens when an odd
number is used as a binWidth, as truncation to label will be
occurring.
- iterators store pointers instead of references to the HashTbl.
This lets us use the default bitwise copy/assignment
- add empty constructor for iterators. It returns the equivalent to end().
This lets us do this:
HashTbl<label>::iterator iter;
// some time later
iter = find(Value);
- erase(const HashTbl<AnyType, Key, AnyHash>&) is now more generous.
Only the Key type matters, not the hashing function.
Conflicts:
src/OpenFOAM/matrices/simpleMatrix/simpleMatrix.C
src/OpenFOAM/matrices/simpleMatrix/simpleMatrix.H
src/mesh/blockMesh/curvedEdges/BSpline.C
src/mesh/blockMesh/curvedEdges/spline.C
src/mesh/blockMesh/curvedEdges/spline.H
- Also adjusted chemistrySolver/EulerImplicit/EulerImplicit.C
to use simpleMatrix with initialized values
- following Andy's idea to return values as label whenever possible
eg, 1.2e6 -> 1200000
but left it commented out
- avoid buffer overflow in ISstream::read(word&).
Is the 'if (fail())' check itself actually in the correct place??
- other minor cosmetic changes
- allow construct with Xfer container for the addressing
- Replaced non-const addressing() method in BiIndirectList with
resetAddressing() method as per IndirectList
- could also move to utilities/miscellaneous
- the dictionary compare contents might be useful enough to move
into dictionary code.
- usage example (w/o -rewrite):
for i in $(find -name fvSolution)
do
fvSolutionCombine -case "${i%/system/fvSolution}"
done
- use shift-right instead of shift-left formulation to avoid wrong behaviour
with non-optimized compilation when the packed items fit exactly in the
available number of bits.
- use shift-right instead of shift-left formulation to avoid wrong behaviour
with non-optimized compilation when the packed items fit exactly in the
available number of bits.
- similar to the #include directive, but does not generate an error if the
file does not exist.
Note: opted for an explicit naming #includeIfPresent rather than #cinclude
Oriented somewhat on dictionary methods.
Return the argument string associated with the named option:
Info<< "-foo: " << args.option("foo") << nl;
Return true if the named option is found
if (args.optionFound("foo")) ...
Return an IStringStream to the named option
old: value = readScalar(IStringStream(args.options()["foo"])());
newer: value = readScalar(args.optionLookup("foo")());
also: List<scalar> lst(args.optionLookup("foo")());
Read a value from the named option
newest: value = args.optionRead<scalar>("foo");
Read a value from the named option if present.
old: if (args.options().found("foo"))
{
value = readScalar(IStringStream(args.options()["foo"])());
}
new: args.optionReadIfPresent("foo", value);
Read a List of values from the named option
patches = args.optionReadList<word>("patches");
Didn't bother adding optionReadListIfPresent<T>(const word&), since it
probably wouldn't be common anyhow.
- Read a bracket-delimited list, or handle a single value as list of size 1.
Mostly useful for handling command-line arguments.
eg,
if (args.options().found("patches"))
{
patches = readList<word>(IStringStream(args.options()["patches"])());
}
can handle both of these:
-patches patch0
-patches \( patch1 patch2 patch3 \)
- added constructor dictionary(const dictionary*) that also handles NULL
pointers and makes it convenient to construct from a possibly nonexistent
sub-dictionary:
eg,
dictionary dict2(dict1.subDictPtr("someDict"));
- make some of the turbulence Coeffs sub-dictionary optional.
Their contents are all 'lookupOrAddDefault' anyhow.
- in turbulentMixingLength BCs, skip namespace qualifier in template
(eg, <RASModel> vs. <compressible::RASModel>)
- change comments from 'turbulenceProperties' to RASProperties/LESProperties
- consistency between compressible/incompressible - no separate file for
'New' selector etc
- consistency in accessing the model coefficients.
Use method coeffDict() for const access.
Use protected data member coeffDict_ for read/write access.
- document model coefficients in etc/constant/RASProperties.
Need the same for LESProperties before we can prune these from the
tutorials.
- #inputMode error
now issues a FatalError on duplicate entries
- #inputMode warn
issues a warning on duplicate entries, corresponds to the
old behaviour of 'error'
- #inputMode protect
prevents overwriting existing entries
The 'protect' mode provides a simple mechanism for supplying default values.
eg,
in file1:
#inputMode protect
intensity 0.1;
mixingLength 0.005;
#inputMode merge
inlet
{
type turbulentIntensityKineticEnergyInlet;
intensity $intensity;
}
which is included from file2:
intensity 0.05;
#include "file1"
- objectRegistry gets a rename() that also adjusts the dbDir
- cloud reworked to use static variables subInstance and defaultName.
This avoids writing "lagrangian" everywhere
string fixes
- avoid masking of std::string::replace in string.H
- avoid old strstream in PV3FoamReader
- regIOobject: don't re-register an unregister object on rename/assignment
- Hasher: split-off HasherInt with uint32_t specializations
- IOobject: writeBanner/writeDivider return Stream for easier chaining.
... also dropped some namespace bracketing while I was at it.
- If the underlying type is contiguous, FixedList hashes its storage directly.
- Drop labelPairHash (non-commutative) from fvMeshDistribute since
FixedList::Hash does the right thing anyhow.
- Hash<edge> specialization is commutative, without multiplication.
- Hash<triFace> specialization kept multiplication (but now uLabel).
There's not much point optimizing it, since it's not used much anyhow.
Misc. changes
- added StaticAssert to NamedEnum.H
- label.H / uLabel.H : define FOAM_LABEL_MAX, FOAM_ULABEL_MAX with the
values finally used for the storage. These can be useful for pre-processor
checks elsewhere (although I stopped needing them in the meantime).
- not much speed difference between SuperFastHash and Jenkin's lookup3 but
both are 5-10% faster than what is currently implemented in Foam::string,
albeit inlining probably helps there.
- TODO: integration with existing infrastructure
- compare iteratorBase == iteratorBase by value, not position
thus this works
list[a] == list[b] ...
- compare iterator == iteratorBase and const_iterator == iteratorBase
by position, not value. The inheritance rules means that this works:
iter == list.end() ...
this will compare positions:
iter == list[5];
Of course, this will still compare values:
*iter == list[5];
- it was possible to create a PackedList::iterator from a
PackedList::const_iterator and violate const-ness
- added HashTable::printInfo for emitting some information
- changed default table sizes from 100 -> 128 in preparation for future
2^n table sizes
- much better performance on empty tables (4-6x speedup), neutral
performance change on filled tables. Since tableSize_ is non-zero when
nElmts_ is, there is no modulus zero problem.
- change system/controlDict to use functions {..} instead of functions (..);
* This is internally more efficient
- fixed formatting of system/controlDict functions entry
- pedantic change: use 'return 0' instead of 'return(0)' in the applications,
since return is a C/C++ keyword, not a function.
- this (now deprecated) idiom:
for (runTime++; !runTime.end(); runTime++) { ... }
has a few problems:
* stop-on-next-write will be off-by-one (ie, doesn't work)
* function objects are not executed on exit with runTime.end()
Fixing these problems is not really possible.
- this idiom
while (runTime.run())
{
runTime++;
...
}
works without the above problems.
- added class OSHA1stream for a stream-based calculation method
- dictionary gets digest() method
- dictionaryEntry tweak: avoid trailing space after dictionary keyword
- OSspecific: chmod() -> chMod(), even although it's not used anywhere
- ListOps get subset() and inplaceSubset() templated on BoolListType
- added UList<bool>::operator[](..) const specialization.
Returns false (actually pTraits<bool>::zero) for out-of-range elements.
This lets us use List<bool> with lazy evaluation and no noticeable
change in performance.
- use rcIndex() and fcIndex() wherever possible.
Could check if branching or modulus is faster for fcIndex().
- UList and FixedList get 'const T* cdata() const' and 'T* data()' members.
Similar to the STL front() and std::string::data() methods, they return a
pointer to the first element without needing to write '&myList[0]', recast
begin() or violate const-ness.
- moving back to original flat addressing in iterators means there is no
performance issue with using lazy evaluation
- set() method now has ~0 for a default value.
We can thus simply write 'set(i) to trun on all of the bits.
This means we can use it just like labelHashSet::set(i)
- added flip() method for inverting bits. I don't know where we might need
it, but the STL has it so we might as well too.
- dropped auto-vivification for now (performance issue), but reworked to
allow easy reinstatement
- derived both iterator and const_iterator from iteratorBase and use
iteratorBase as our proxy for non-const access to the list elements.
This allows properly chaining assignments:
list[1] = list[2];
list[1] = list[2] = 10;
- assigning iterators from iteratorBase or other iterators works:
iterator iter = list[20];
- made template parameter nBits=1 the default
- the bit counting is relatively fast:
under 0.2 seconds for 1M bits counted 1000 times
- trim()'ing the final zero elements tested for a few cases,
but might need more attention
- exists() = forward to OSspecific exists(...)
- isDir() = forward to OSspecific dir(...)
- isFile() = forward to OSspecific file(...)
- IOobjectComponents() - split into instance, local, name following rules
set out for IOobject.
- added IOobject(path, registry, ...) constructor that uses
fileName::IOobjectComponents(). This hides the complexity we otherwise need.
- added Mattijs' speed tests
- optimized resize() and assignment operators to avoid set() method
- add const_iterator and re-did the proxy handling.
Reading/writing by looping across iterators is still somewhat slow, but
might be acceptable.
- eliminated previous PackedBitRef class, the iterator does all of that and
can also be used to (forward) traverse the list
- no const_iterator yet
- Note that PackedList is also a bit like DynamicList in terms of storage
management and the append() method. Since the underlying storage in
integer, any auto-vivified elements will also flood-fill the gaps with
zero.
regExp:
- added optional ignoreCase for constructor.
- the compile() methods is now exposed as set(...) method with an optional
ignoreCase argument. Not currently much use for the other regex compile
flags though. The set() method can be used directly instead of the
operator=() assignment.
keyType + wordRe:
- it's not clear that any particular characters are valid/invalid (compared
to string or word), so just drop the valid(char) method for now
wordRe:
- a bool doesn't suffice, added enum compOption (compile-option)
- most constructors now have a compOption. In *all* cases it defaults to
LITERAL - ie, the same behaviour for std::string and Foam::string
- added set(...) methods that do much the same as operator=(...), but the
compOption can be specified. In all cases, it defaults to DETECT.
In Summary
By default the constructors will generally preserve the argument as
string literal and the assignment operators will use the wordRe::DETECT
compOption to scan the string for regular expression meta characters
and/or invalid word characters and react accordingly.
The exceptions are when constructing/assigning from another
Foam::wordRe (preserve the same type) or from a Foam::word (always
literal).
- The capitalization is consistent with most other template classes, but
more importantly frees up xfer() for use as method name without needing
special treatment to avoid ambiguities.
It seems reasonable to have different names for transfer(...) and xfer()
methods, since the transfer is occuring in different directions.
The xfer() method can thus replace the recently introduced zero-parameter
transfer() methods.
Other name candidates (eg, yield, release, etc.) were deemed too abstract.
- a possible future replacement for keyType, but the immediate use is the
wordReList for grepping through other lists.
- note that the argList treatment of '(' ... ')' yields quoted strings,
which we can use for building a wordReList
minor cleanup of regExp class
- constructor from std::string, match std::string and
operator=(std::string&)
rely on automatic conversion to Foam::string
- ditch partialMatch with sub-groups, it doesn't make much sense
- Istream and Ostream now retain backslashes when reading/writing strings.
The previous implementation simply discarded them, except when used to
escape a double-quote or a newline. It is now vitally important to retain
them, eg for quoting regular expression meta-characters.
The backslash continues to be used as an escape character for double-quote
and newline, but otherwise get passed through "as-is" without any other
special meaning (ie, they are *NOT* C-style strings). This helps avoid
'backslash hell'!
For example,
string: "match real dots \.+, question mark \? or any char .*"
C-style: "match real dots \\.+, question mark \\? or any char .*"
- combined subfiles in db/IOstreams, some had more copyright info than code
- OPstreamI.H contained only private methods, moved into OPstream.C
Are these really correct?
IOstreams/Istream.H:# include "HashTable.C"
token/token.H:#define NoHashTableC
- this should provide a slightly more naturally means to using transfer
constructors, for example
labelList list2(list1.transfer());
vs. labelList list2(xferMove(list1));
- returns a plain list where appropriate (eg, DynamicList, SortableList)
for example
labelList list2(dynList1.transfer());
vs. labelList list2(xferMoveTo<labelList>(dynList1));
StaticHashTable:
- erase(iterator&) now actually alters the iterator and iterator++() handles
it properly
- clear() also sets count to zero
- operator=(const StaticHashTable&) doesn't crash after a previous transfer
- operator(), operator==() and operator!=() added
HashTable:
- operator=(const HashTable&) gets tableSize if required, eg, after a
previous transfer)
HashSet / Map
- add xfer<...> constructor for underlying HashTable
- This was originally plan 'B', but it is actually probably more efficient
than using PtrDictionary anyhow.
- straightened out the return value logic, but it wasn't being used anywhere
anyhow.
- new 'updated_' data member avoids inadvertent execution in the read()
method when execution is turned off.
- if mandatory is true, findEtcFile() will abort with a message (via cerr).
This allows a non-existent file to be caught at the lowest level and avoid
error handling in IFstream, which might not be initialized at that stage.
- the improved side-effect of enabling -zeroTimea alters default selection
behaviour and -latestTime selection behaviour for utilities in which
accidentally using the 0/ directory can cause damage (eg, reconstructPar)
- can combine -time ranges and -latestTime
- dropped setSize() in favour of List::setSize().
The size of the indices is set in sort() anyhow and undefined before that.
- added reverseSort() method
- added ListOps uniqueOrder() and duplicateOrder()
- setSize() adjusts the addressable length only.
Changed setSize(label) usage to setCapacity(label) or reserve(label)
throughout. The final name (capacity vs. storageSize() vs. whatever) can
easily be decided at a later date.
- added setSize(label, const T&), which may still not be really useful, but
is at least now meaningful
- made shrink() a bit more legible.
- added append(UList<T>&)
- copying from a UList avoids reallocations where possible
The following bits of code continue to use the DynamicList::setSize(), but
appear to be legitimate (or the corresponding code itself needs rethinking).
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointCells.C:167: error: within this context
src/OpenFOAM/lnInclude/faceTemplates.C:44: error: within this context
src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatCore.C:178: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:737: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:741: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:745: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:749: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:754: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:935: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:940: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:1041: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:1046: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2161: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2162: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2201: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2205: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2261: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2262: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2263: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2264: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:2265: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:3011: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:3076: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:3244: error: within this context
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C:3371: error: within this context
src/dynamicMesh/meshCut/cellLooper/topoCellLooper.C:73: error: within this context
src/dynamicMesh/meshCut/cellLooper/topoCellLooper.C:91: error: within this context
src/dynamicMesh/meshCut/cellLooper/topoCellLooper.C:73: error: within this context
src/dynamicMesh/meshCut/cellLooper/topoCellLooper.C:91: error: within this context
* DynamicList::allocSize(label)
- Adjust the allocated size. The addressed list can be truncated but not
extended, use setSize() for that.
* DynamicList::reserve(label)
- Reserve allocation for *at least* this number of elements.
Never shrinks the allocated size, nor touches the addressed list size.
* DynamicList::setSize(label)
- proposed behaviour:
Adjust the addressed list size, allocating extra space if required.
- The current behaviour is ambiguous about what addressable size will
actually get set and using it to extend the addressable size (as
per List) automatically shrinks the allocated space to this size!
- operator+= : add in the listed keys
- operator-= : remove the listed keys
- operator&= : intersection of keys
- added xfer constructor (just in case)
- moved labelHashSet typedef to HashSet.H, for consistency with the
wordHashSet typedef being there and since it is used so often
- removed operator* in favour of operator() for consistency with tmp
class. The previous use of operator() for const casting didn't work
anyhow due to template confusion.
- added xferCopy(), xferMove() and xferTmp() template functions instead
- preliminary changes to IOobjects and Fields for xfer
* added '#remove' function
* changed insert() method name to more general execute()
* using #inputMode or #remove within a primitiveEntry now provokes an error
* adjusted the dictionaryTest accordingly
