void BaseTestMultiTag::testUnits() {
MultiTag dt = block.createMultiTag("TestMultiTag1", "Tag", positions);
std::vector<std::string> valid_units = {"mV", "cm", "m^2"};
std::vector<std::string> invalid_units = {"mV", "haha", "qm^2"};
std::vector<std::string> insane_units = {"muV ", " muS"};
CPPUNIT_ASSERT_NO_THROW(dt.units(valid_units));
CPPUNIT_ASSERT(dt.units().size() == valid_units.size());
std::vector<std::string> retrieved_units = dt.units();
for (size_t i = 0; i < retrieved_units.size(); i++) {
CPPUNIT_ASSERT(retrieved_units[i] == valid_units[i]);
}
dt.units(none);
CPPUNIT_ASSERT(dt.units().size() == 0);
CPPUNIT_ASSERT_THROW(dt.units(invalid_units), InvalidUnit);
CPPUNIT_ASSERT(dt.units().size() == 0);
dt.units(insane_units);
retrieved_units = dt.units();
CPPUNIT_ASSERT(retrieved_units.size() == 2);
CPPUNIT_ASSERT(retrieved_units[0] == "uV");
CPPUNIT_ASSERT(retrieved_units[1] == "uS");
block.deleteMultiTag(dt.id());
}
void BaseTestDataAccess::testMultiTagUnitSupport() {
std::vector<std::string> valid_units{"none","ms","s"};
std::vector<std::string> invalid_units{"mV", "Ohm", "muV"};
MultiTag testTag = block.createMultiTag("test", "testTag", multi_tag.positions());
testTag.units(valid_units);
testTag.addReference(data_array);
CPPUNIT_ASSERT_NO_THROW(util::retrieveData(testTag, 0, 0));
testTag.units(none);
CPPUNIT_ASSERT_NO_THROW(util::retrieveData(testTag, 0, 0));
testTag.units(invalid_units);
CPPUNIT_ASSERT_THROW(util::retrieveData(testTag, 0, 0), nix::IncompatibleDimensions);
}
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);
}
void setUnits(MultiTag& dt, const std::vector<std::string>& units) {
if (!units.empty())
dt.units(units);
else
dt.units(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;
}