Can't write coordinates of channel indexes with NixIO

[rgutzen]

Neo version = 0.7.1
NixIO version = 1.5.0b3
Quantities version = 0.12.1

import neo
import numpy as np
import quantities as pq

bl = neo.Block()
bl.channel_indexes.append(neo.ChannelIndex(np.array([1]), name='testchx'))
bl.channel_indexes[0].coordinates = (10, 20)*pq.mm

with neo.io.NixIO('tmp.nix', 'ow') as nixio:
    nixio.write_block(bl)

causes the following error message:

------------------------------------------
IndexErrorTraceback (most recent call last)
<ipython-input-25-a1dd10c3586c> in <module>
      8 
      9 with neo.io.NixIO('tmp.nix', 'ow') as nixio:
---> 10     nixio.write_block(bl)

~/anaconda3/envs/py36/lib/python3.6/site-packages/neo/io/nixio.py in write_block(self, block, use_obj_names)
    561         # descend into ChannelIndexes
    562         for chx in block.channel_indexes:
--> 563             self._write_channelindex(chx, nixblock)
    564 
    565         self._create_source_links(block, nixblock)

~/anaconda3/envs/py36/lib/python3.6/site-packages/neo/io/nixio.py in _write_channelindex(self, chx, nixblock)
    611             if chx.coordinates is not None and len(chx.coordinates):
    612                 coords = chx.coordinates[idx]
--> 613                 coordunits = stringify(coords[0].dimensionality)
    614                 nixcoords = tuple(c.magnitude.item() for c in coords)
    615                 chanprop = chanmd.create_property("coordinates", nixcoords)

~/anaconda3/envs/py36/lib/python3.6/site-packages/quantities/quantity.py in __getitem__(self, key)
    362     @with_doc(np.ndarray.__getitem__)
    363     def __getitem__(self, key):
--> 364         ret = super(Quantity, self).__getitem__(key)
    365         if isinstance(ret, Quantity):
    366             return ret

IndexError: too many indices for array

[achilleas-k]

I see the problem. While getting the dimensionality/unit of the coordinates, the IO assumes the coordinates property is 2-dimensional.

    coords = chx.coordinates[idx]
    coordunits = stringify(coords[0].dimensionality)

Here it's writing each channel index separately, so it's grabbing the corresponding coordinates index idx, then it's getting coords[0] to check the dimensionality of the first element in the coordinates.

Would making an exception for a single element ChannelIndex be general enough, or are there other problems we can foresee here? Is a 1D coordinates property only valid when a ChannelIndex contains one channel? Also, the IO takes coords[0] to check the dimensionality because it's conceivable that the coordinates property might be a list or tuple of quantities. I guess in many cases, it's a quantity array so taking coords.dimensionality would also work, but I wonder how safe that assumption is as well.

[rgutzen]

To be noted the same error also arises when having multiple indices
bl.channel_indexes.append(neo.ChannelIndex(np.array([1,2,3]), name='testchx'))
I think the problem is caused by going down too many levels into the ChannelIndex object. It is already looped over its elements when calling the function in nixio.py, line 562:

for chx in block.channel_indexes:
    self._write_channelindex(chx, nixblock)

and then looped again over the indices in each ChannelIndex element within the function _write_channelindex(self, chx, nixblock) in nixio.py, line 594:

for idx, channel in enumerate(chx.index):
.
.
    coords = chx.coordinates[idx]

So I would expect that chx.coordinates to only contain one pair of coordinates, if I'm not missing anything.

[achilleas-k]

Multiple indices, yes, but are the coordinates one-dimensional or two? It should work if each channel index has an (x, y) coordinate, for instance.

bl.channel_indexes.append(neo.ChannelIndex(np.array([1, 2]), name='testchx'))
bl.channel_indexes[0].coordinates = [(10, 20), (30, 40)]*pq.mm

Generally, the writer expects that for a given ChannelIndex object chx, len(chx.index) == len(chx.coordinates) == len(chx.channel_names) == len(chx.channel_ids), but also that each element in chx.coordinates is a multivalue coordinate ((x, y) or even (x, y, z)).

Just to clarify, the following combinations will cause an error. Which of them do we want to make valid?

1 index, 1-dimensional coordinate(s)

bl.channel_indexes.append(neo.ChannelIndex(np.array([1]), name='testchx'))
bl.channel_indexes[0].coordinates = (10, 20)*pq.mm

IndexError: too many indices for array
Valid

bl.channel_indexes.append(neo.ChannelIndex(np.array([1]), name='testchx'))
bl.channel_indexes[0].coordinates = [(10, 20)]*pq.mm

3 indexes, 1 coordinate

bl.channel_indexes.append(neo.ChannelIndex(np.array([1, 2, 3]), name='testchx'))
bl.channel_indexes[0].coordinates = (10, 20)*pq.mm

IndexError: index 1 is out of bounds for axis 0 with size 1
Valid

bl.channel_indexes.append(neo.ChannelIndex(np.array([1, 2, 3]), name='testchx'))
bl.channel_indexes[0].coordinates = [(10, 20), (10, 30), (10, 40)]*pq.mm

---

What should the writer expect for coordinates with respect to indexes?

[rgutzen]

Ok, thanks for this clarification!
In my use case this error could thus be solved by adpting the custom code which adds the coordinate information from the metadata to the neo structure.
Note: I use the BlackrockIO to load the data, which builds a new ChannelIndex for each channel so that all index arrays for ChannelIndex are of length 1, which corresponds to the case '1 index, 1-dimensional coordinates'

[achilleas-k]

Sounds like that would be a common case that the NIXIO should cover then. Keep the issue open and I'll make the change soon.

[achilleas-k]

PR submitted.