void BaseTestTag::testExtent() {
Tag st = block.createTag("TestTag1", "Tag", {0.0, 2.0, 3.4});
st.references(refs);
std::vector<double> extent = {1.0, 2.0, 3.0};
st.extent(extent);
std::vector<double> retrieved = st.extent();
CPPUNIT_ASSERT(retrieved.size() == extent.size());
for(size_t i = 0; i < retrieved.size(); i++) {
CPPUNIT_ASSERT(retrieved[i] == extent[i]);
}
st.extent(none);
CPPUNIT_ASSERT(st.extent().size() == 0);
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
block.deleteTag(st.id());
}
void getOffsetAndCount(const Tag &tag, const DataArray &array, NDSize &offset, NDSize &count) {
vector<double> position = tag.position();
vector<double> extent = tag.extent();
vector<string> units = tag.units();
NDSize temp_offset(position.size());
NDSize temp_count(position.size(), 1);
if (array.dimensionCount() != position.size() || (extent.size() > 0 && extent.size() != array.dimensionCount())) {
throw std::runtime_error("Dimensionality of position or extent vector does not match dimensionality of data!");
}
for (size_t i = 0; i < position.size(); ++i) {
Dimension dim = array.getDimension(i+1);
temp_offset[i] = positionToIndex(position[i], i >= units.size() ? "none" : units[i], dim);
if (i < extent.size()) {
ndsize_t c = positionToIndex(position[i] + extent[i], i >= units.size() ? "none" : units[i], dim) - temp_offset[i];
temp_count[i] = (c > 1) ? c : 1;
}
}
offset = temp_offset;
count = temp_count;
}
Result validate(const Tag &tag) {
Result result_base = validate_entity_with_sources(tag);
Result result = validator({
must(tag, &Tag::position, notEmpty(), "position is not set!"),
could(tag, &Tag::references, notEmpty(), {
must(tag, &Tag::position, positionsMatchRefs(tag.references()),
"number of entries in position does not match number of dimensions in all referenced DataArrays!"),
could(tag, &Tag::extent, notEmpty(), {
must(tag, &Tag::position, extentsMatchPositions(tag.extent()), "Number of entries in position and extent do not match!"),
must(tag, &Tag::extent, extentsMatchRefs(tag.references()),
"number of entries in extent does not match number of dimensions in all referenced DataArrays!") })
}),
// check units for validity
could(tag, &Tag::units, notEmpty(), {
must(tag, &Tag::units, isValidUnit(), "Unit is invalid: not an atomic SI. Note: So far composite units are not supported!"),
must(tag, &Tag::references, tagRefsHaveUnits(tag.units()), "Some of the referenced DataArrays' dimensions don't have units where the tag has. Make sure that all references have the same number of dimensions as the tag has units and that each dimension has a unit set."),
must(tag, &Tag::references, tagUnitsMatchRefsUnits(tag.units()), "Some of the referenced DataArrays' dimensions have units that are not convertible to the units set in tag. Note: So far composite SI units are not supported!")}),
});
return result.concat(result_base);
}
DataView retrieveData(const Tag &tag, size_t reference_index) {
vector<double> positions = tag.position();
vector<double> extents = tag.extent();
vector<DataArray> refs = tag.references();
if (refs.size() == 0) {
throw nix::OutOfBounds("There are no references in this tag!", 0);
}
if (!(reference_index < tag.referenceCount())) {
throw nix::OutOfBounds("Reference index out of bounds.", 0);
}
size_t dimension_count = refs[reference_index].dimensionCount();
if (positions.size() != dimension_count || (extents.size() > 0 && extents.size() != dimension_count)) {
throw nix::IncompatibleDimensions("Number of dimensions in position or extent do not match dimensionality of data","util::retrieveData");
}
NDSize offset, count;
getOffsetAndCount(tag, refs[reference_index], offset, count);
if (!positionAndExtentInData(refs[reference_index], offset, count)) {
throw nix::OutOfBounds("Referenced data slice out of the extent of the DataArray!", 0);
}
DataView io = DataView(refs[reference_index], count, offset);
return io;
}
