boost::optional<DataArray> getExtents(MultiTag& dt) {
DataArray da = dt.extents();
if (da)
return boost::optional<DataArray>(da);
else
return boost::none;
}
void BaseTestMultiTag::testCreateRemove() {
std::vector<std::string> ids;
ndsize_t count = block.multiTagCount();
const char *names[5] = { "tag_a", "tag_b", "tag_c", "tag_d", "tag_e" };
for (int i = 0; i < 5; i++) {
std::string type = "Event";
MultiTag dt1 = block.createMultiTag(names[i], type, positions);
MultiTag dt2 = block.getMultiTag(dt1.id());
ids.push_back(dt1.id());
std::stringstream errmsg;
errmsg << "Error while accessing multiTag: dt1.id() = " << dt1.id()
<< " / dt2.id() = " << dt2.id();
CPPUNIT_ASSERT_MESSAGE(errmsg.str(), dt1.id().compare(dt2.id()) == 0);
}
std::stringstream errmsg2;
errmsg2 << "Error creating MultiTags. Counts do not match!";
CPPUNIT_ASSERT_MESSAGE(errmsg2.str(), block.multiTagCount() == (count+5));
CPPUNIT_ASSERT_THROW(block.createMultiTag(names[4], "test", positions), DuplicateName);
for (size_t i = 0; i < ids.size(); i++) {
block.deleteMultiTag(ids[i]);
}
std::stringstream errmsg1;
errmsg1 << "Error while removing multiTags!";
CPPUNIT_ASSERT_MESSAGE(errmsg1.str(), block.multiTagCount() == count);
DataArray a;
MultiTag mtag;
CPPUNIT_ASSERT_THROW(mtag = block.createMultiTag("test", "test", a), nix::UninitializedEntity);
mtag = block.createMultiTag("test", "test", positions);
mtag.extents(positions);
CPPUNIT_ASSERT_THROW(mtag.positions(a), UninitializedEntity);
CPPUNIT_ASSERT(mtag.extents().id() == positions.id());
CPPUNIT_ASSERT_NO_THROW(mtag.extents(a));
CPPUNIT_ASSERT(!mtag.extents());
}
Result validate(const MultiTag &multi_tag) {
Result result_base = validate_entity_with_sources(multi_tag);
Result result = validator({
must(multi_tag, &MultiTag::positions, notFalse(), "positions are not set!"),
// check units for validity
could(multi_tag, &MultiTag::units, notEmpty(), {
must(multi_tag, &MultiTag::units, isValidUnit(), "Some of the units in tag are invalid: not an atomic SI. Note: So far composite SI units are not supported!"),
must(multi_tag, &MultiTag::references, tagUnitsMatchRefsUnits(multi_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!")}),
// check positions & extents
could(multi_tag, &MultiTag::extents, notFalse(), {
must(multi_tag, &MultiTag::positions, extentsMatchPositions(multi_tag.extents()), "Number of entries in positions and extents do not match!") }),
could(multi_tag, &MultiTag::references, notEmpty(), {
could(multi_tag, &MultiTag::extents, notFalse(), {
must(multi_tag, &MultiTag::extents, extentsMatchRefs(multi_tag.references()), "number of entries (in 2nd dim) in extents does not match number of dimensions in all referenced DataArrays!") }),
must(multi_tag, &MultiTag::positions, positionsMatchRefs(multi_tag.references()), "number of entries (in 2nd dim) in positions does not match number of dimensions in all referenced DataArrays!") })
});
return result.concat(result_base);
}
DataView retrieveData(const MultiTag &tag, size_t position_index, size_t reference_index) {
DataArray positions = tag.positions();
DataArray extents = tag.extents();
vector<DataArray> refs = tag.references();
if (refs.size() == 0) { // Do I need this?
throw nix::OutOfBounds("There are no references in this tag!", 0);
}
if (position_index >= positions.dataExtent()[0] ||
(extents && position_index >= extents.dataExtent()[0])) {
throw nix::OutOfBounds("Index out of bounds of positions or extents!", 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.dataExtent().size() == 1 && dimension_count != 1) {
throw nix::IncompatibleDimensions("Number of dimensions in position or extent do not match dimensionality of data",
"util::retrieveData");
} else if (positions.dataExtent().size() > 1) {
if (positions.dataExtent()[1] > dimension_count ||
(extents && extents.dataExtent()[1] > 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], position_index, offset, count);
if (!positionAndExtentInData(refs[reference_index], offset, count)) {
throw nix::OutOfBounds("References data slice out of the extent of the DataArray!", 0);
}
DataView io = DataView(refs[reference_index], count, offset);
return io;
}
void setExtents(MultiTag& dt, const boost::optional<DataArray>& data) {
if (data)
dt.extents(*data);
else
dt.extents(boost::none);
}
void getOffsetAndCount(const MultiTag &tag, const DataArray &array, size_t index, NDSize &offsets, NDSize &counts) {
DataArray positions = tag.positions();
DataArray extents = tag.extents();
NDSize position_size, extent_size;
size_t dimension_count = array.dimensionCount();
if (positions) {
position_size = positions.dataExtent();
}
if (extents) {
extent_size = extents.dataExtent();
}
if (!positions || index >= position_size[0]) {
throw nix::OutOfBounds("Index out of bounds of positions!", 0);
}
if (extents && index >= extent_size[0]) {
throw nix::OutOfBounds("Index out of bounds of positions or extents!", 0);
}
if (position_size.size() == 1 && dimension_count != 1) {
throw nix::IncompatibleDimensions("Number of dimensions in positions does not match dimensionality of data",
"util::getOffsetAndCount");
}
if (position_size.size() > 1 && position_size[1] > dimension_count) {
throw nix::IncompatibleDimensions("Number of dimensions in positions does not match dimensionality of data",
"util::getOffsetAndCount");
}
if (extents && extent_size.size() > 1 && extent_size[1] > dimension_count) {
throw nix::IncompatibleDimensions("Number of dimensions in extents does not match dimensionality of data",
"util::getOffsetAndCount");
}
NDSize temp_offset = NDSize{static_cast<NDSize::value_type>(index), static_cast<NDSize::value_type>(0)};
NDSize temp_count{static_cast<NDSize::value_type>(1), static_cast<NDSize::value_type>(dimension_count)};
vector<double> offset;
positions.getData(offset, temp_count, temp_offset);
NDSize data_offset(dimension_count, static_cast<size_t>(0));
NDSize data_count(dimension_count, static_cast<size_t>(1));
vector<string> units = tag.units();
for (size_t i = 0; i < offset.size(); ++i) {
Dimension dimension = array.getDimension(i+1);
string unit = "none";
if (i <= units.size() && units.size() > 0) {
unit = units[i];
}
data_offset[i] = positionToIndex(offset[i], unit, dimension);
}
if (extents) {
vector<double> extent;
extents.getData(extent, temp_count, temp_offset);
for (size_t i = 0; i < extent.size(); ++i) {
Dimension dimension = array.getDimension(i+1);
string unit = "none";
if (i <= units.size() && units.size() > 0) {
unit = units[i];
}
ndsize_t c = positionToIndex(offset[i] + extent[i], unit, dimension) - data_offset[i];
data_count[i] = (c > 1) ? c : 1;
}
}
offsets = data_offset;
counts = data_count;
}
