GitLab

Slight performance improvement for large file writes.

Only query hdf5 for number of datasets in a file when unavoidable.
On some machines, this can cause performance problems when writing
to large hdf5 files.

Clang compiler would fail boost shared_dynamic_cast test because
of incorrect main arguments in CMake.

XPointers were generated incorrectly when the same XdmfWriter was
used to write files multiple times. This was caused by not resetting
xPathCount when after the file was written.

Add setter to writer to set heavy data writer.

Reuse HDF5Writers rather than creating new ones each time.
Release heavy data by default when writing.

XdmfArray stride was used incorrectly to calculate new size of array when
stride was larger than 1.
Add test to ensure that this will continue to work.

For some reason metis gets this wrong - when "partitioning" graph onto one
processor metis returns all ones instead of zeros despite having the correct
METIS_OPTION_NUMBERING. We now check explicitly for the case of partitioning
on one processor and handle it ourselves instead of relying on metis.

Modify writeHDF5 to reuse previous hdf5Writer if possible.
Also modify writeHDF5 to open and close hdf5 writer before writing.

Remove some warnings related to hidden functions.

shared_dynamic_cast was deprecated and removed from newer versions of boost
as dynamic_pointer_cast provides the same functionality. Check at
configure time whether shared_dynamic_cast exists and if not, then
provide our own implementation that uses dynamic_pointer_cast.

based on connectivity.

Previously, nodes added to a mesh in XdmfTopologyConverter were
compared using position to ensure nodes added to element boundaries
were not duplicated (added more than once). This failed in some
cases, especially for highly refined meshes, because of incorrect
floating point comparisons. Now, shared nodes are identified using
connectivity, ensuring that nodal addition should work in all cases,
even for highly refined meshes.

Get rid of some compiler warnings by removing unused argument names
from methods.

Graphs are stored in compressed sparse row format (XdmfSparseMatrix).
Added ability to partition graphs in XdmfPartitioner.
Added tests for new sparse matrix and graph classes.

Fix a bug in the reader that caused xincludes to not work properly when
nested. The xinclude needs to be evaluated in the local context rather
than the global context.

Replace with visitor pattern that avoids the need for catching the exception.
Update the HDF5Writer to use stringstreams for error message output for
concatenating strings and error codes.

Current chunking mechanism produces chunks too large for hdf5 to handle.
Reduce sizes of chunks for multi-dimensional hdf5 datasets.
Chunks for multi-dimensional hdf5 datasets have shape resembling overarching
dataset.
Add test for this to TestXdmfArrayWriteRead.

Since the reference element for spectral elements is by definition different
than a standard element, make these have different types in Xdmf.

Precision of values now tied to value type in getValuesString()
This precision is maintained when output to XML.

Add tests for I/O of strings (to hdf5 and xml).
Fix bug in XdmfExodusReader when reading grid centered data.
Add string I/O in python and add tests.

Modified writer to utilize hyperslabs to write in parallel to file.
Updated DSM to newest version (0.9.9).
Modified DSM test to write in parallel to DSM buffer.
Add test for new hyperslab writing mode.

Commit patch from Pat Collins allowing light data limit to be set from
Fortran interface.

If xml is parsed from a string its document url could be NULL which causes
an error when building a map of document urls to documents.

Add method to output heavy data.
Add method to read file from disk.

Output of Xdmf data in Fortran can now take advantage of xpointer functionality.
Calling any AddPrevious or SetPrevious methods will reuse previously
added Xdmf structure so that when it is written to disk xincludes can be
utilized rather than rewriting identical structure multiple times.  These
methods take an id which is returned in Add or Set calls.

Modified TestXdmfFortran.f90 to utilize new functionality.

Eliminate getRealPath calls which are expensive and not necessary in many cases
Parse XML node content only when necessary (parsing arrays)
Fix cases where copies were made of strings instead of using references
Use "map.insert()" rather than "map[] =" when adding properties to map

Just input file into partitioner with new number of processes. The file
is unpartitioned in memory and repartitioned.

Use -u flag to unpartition a previously partitioned mesh.

Slightly improves compile time on gcc.
Get rid of mHaveArray and mHaveArrayPointer - rely on blank in variant.
This reduces code and makes logic easier to understand.

Choose dataset name more carefully to avoid querying the file many times.
Use a more efficient function to check if a dataset already exists in a file.
Get DSM working with new changes.
Fix gcc compiler warning in test.

Previously, each time a dataset was written to hdf5, the file was opened
and closed. This was implemented because inside the heavy data writer
we have no idea whether another dataset will be written, so we don't know
whether to keep the file open. After profiling large xdmf writes it was
determined that closing the file appeared to be a bottleneck so hooks were
added to the heavy data writer to open the file and keep it open while writing.
This is optional, but was incorporated into several higher level classes
like XdmfWriter where we know we can leave a file open until we finish writing
the XML. For our test problem we saw a 7 time performance gain.