def test__construct_subsegment_by_unit(self): nb_seg = 3 nb_unit = 7 unit_with_sig = [0, 2, 5] signal_types = ['Vm', 'Conductances'] sig_len = 100 #recordingchannelgroups rcgs = [ RecordingChannelGroup(name = 'Vm', channel_indexes = unit_with_sig), RecordingChannelGroup(name = 'Conductance', channel_indexes = unit_with_sig), ] # Unit all_unit = [ ] for u in range(nb_unit): un = Unit(name = 'Unit #%d' % u, channel_indexes = [u]) all_unit.append(un) bl = Block() for s in range(nb_seg): seg = Segment(name = 'Simulation %s' % s) for j in range(nb_unit): st = SpikeTrain([1, 2, 3], units = 'ms', t_start = 0., t_stop = 10) st.unit = all_unit[j] for t in signal_types: anasigarr = AnalogSignalArray( np.zeros((sig_len, len(unit_with_sig)) ), units = 'nA', sampling_rate = 1000.*pq.Hz, channel_indexes = unit_with_sig ) seg.analogsignalarrays.append(anasigarr) # what you want subseg = seg.construct_subsegment_by_unit(all_unit[:4])
def test_time_slice_None(self): time_slices = [(None, 5.0 * pq.s), (5.0 * pq.s, None), (None, None)] anasig = AnalogSignal(np.arange(50.0) * pq.mV, sampling_rate=1.0 * pq.Hz) seg = Segment() seg.analogsignals = [anasig] block = Block() block.segments = [seg] block.create_many_to_one_relationship() # test without resetting the time for t_start, t_stop in time_slices: sliced = seg.time_slice(t_start, t_stop) assert_neo_object_is_compliant(sliced) self.assertEqual(len(sliced.analogsignals), 1) exp_t_start, exp_t_stop = t_start, t_stop if exp_t_start is None: exp_t_start = seg.t_start if exp_t_stop is None: exp_t_stop = seg.t_stop self.assertEqual(exp_t_start, sliced.t_start) self.assertEqual(exp_t_stop, sliced.t_stop)
def __init__(self, segment, identifier): """ """ self.init = True Segment.__init__(self, name=segment.name, description=segment.description, file_origin=segment.file_origin, file_datetime=segment.file_datetime, rec_datetime=segment.rec_datetime, index=segment.index) self.annotations = segment.annotations self.identifier = identifier # indicates whether the segment has been fully loaded self.full = False
def test__construct_subsegment_by_unit(self): nb_seg = 3 nb_unit = 7 unit_with_sig = np.array([0, 2, 5]) signal_types = ['Vm', 'Conductances'] sig_len = 100 # channelindexes chxs = [ChannelIndex(name='Vm', index=unit_with_sig), ChannelIndex(name='Conductance', index=unit_with_sig)] # Unit all_unit = [] for u in range(nb_unit): un = Unit(name='Unit #%d' % u, channel_indexes=np.array([u])) assert_neo_object_is_compliant(un) all_unit.append(un) blk = Block() blk.channel_indexes = chxs for s in range(nb_seg): seg = Segment(name='Simulation %s' % s) for j in range(nb_unit): st = SpikeTrain([1, 2], units='ms', t_start=0., t_stop=10) st.unit = all_unit[j] for t in signal_types: anasigarr = AnalogSignal(np.zeros((sig_len, len(unit_with_sig))), units='nA', sampling_rate=1000.*pq.Hz, channel_indexes=unit_with_sig) seg.analogsignals.append(anasigarr) blk.create_many_to_one_relationship() for unit in all_unit: assert_neo_object_is_compliant(unit) for chx in chxs: assert_neo_object_is_compliant(chx) assert_neo_object_is_compliant(blk) # what you want newseg = seg.construct_subsegment_by_unit(all_unit[:4]) assert_neo_object_is_compliant(newseg)
def test__construct_subsegment_by_unit(self): nb_seg = 3 nb_unit = 7 unit_with_sig = np.array([0, 2, 5]) signal_types = ['Vm', 'Conductances'] sig_len = 100 # channelindexes chxs = [ChannelIndex(name='Vm', index=unit_with_sig), ChannelIndex(name='Conductance', index=unit_with_sig)] # Unit all_unit = [] for u in range(nb_unit): un = Unit(name='Unit #%d' % u, channel_indexes=np.array([u])) assert_neo_object_is_compliant(un) all_unit.append(un) blk = Block() blk.channel_indexes = chxs for s in range(nb_seg): seg = Segment(name='Simulation %s' % s) for j in range(nb_unit): st = SpikeTrain([1, 2], units='ms', t_start=0., t_stop=10) st.unit = all_unit[j] for t in signal_types: anasigarr = AnalogSignal(np.zeros((sig_len, len(unit_with_sig))), units='nA', sampling_rate=1000. * pq.Hz, channel_indexes=unit_with_sig) seg.analogsignals.append(anasigarr) blk.create_many_to_one_relationship() for unit in all_unit: assert_neo_object_is_compliant(unit) for chx in chxs: assert_neo_object_is_compliant(chx) assert_neo_object_is_compliant(blk) # what you want newseg = seg.construct_subsegment_by_unit(all_unit[:4]) assert_neo_object_is_compliant(newseg)
def setup_segments(self): params = {'testarg2': 'yes', 'testarg3': True} self.segment1 = Segment(name='test', description='tester 1', file_origin='test.file', testarg1=1, **params) self.segment2 = Segment(name='test', description='tester 2', file_origin='test.file', testarg1=1, **params) self.segment1.annotate(testarg1=1.1, testarg0=[1, 2, 3]) self.segment2.annotate(testarg11=1.1, testarg10=[1, 2, 3]) self.segment1.analogsignals = self.sig1 self.segment2.analogsignals = self.sig2 self.segment1.analogsignalarrays = self.sigarr1 self.segment2.analogsignalarrays = self.sigarr2 self.segment1.epochs = self.epoch1 self.segment2.epochs = self.epoch2 self.segment1.epocharrays = self.epocharr1 self.segment2.epocharrays = self.epocharr2 self.segment1.events = self.event1 self.segment2.events = self.event2 self.segment1.eventarrays = self.eventarr1 self.segment2.eventarrays = self.eventarr2 self.segment1.irregularlysampledsignals = self.irsig1 self.segment2.irregularlysampledsignals = self.irsig2 self.segment1.spikes = self.spike1 self.segment2.spikes = self.spike2 self.segment1.spiketrains = self.train1 self.segment2.spiketrains = self.train2 create_many_to_one_relationship(self.segment1) create_many_to_one_relationship(self.segment2)
def setup_segments(self): params = {'testarg2': 'yes', 'testarg3': True} self.segment1 = Segment(name='test', description='tester 1', file_origin='test.file', testarg1=1, **params) self.segment2 = Segment(name='test', description='tester 2', file_origin='test.file', testarg1=1, **params) self.segment1.annotate(testarg1=1.1, testarg0=[1, 2, 3]) self.segment2.annotate(testarg11=1.1, testarg10=[1, 2, 3]) self.segment1.analogsignals = self.sig1 self.segment2.analogsignals = self.sig2 self.segment1.analogsignalarrays = self.sigarr1 self.segment2.analogsignalarrays = self.sigarr2 self.segment1.epochs = self.epoch1 self.segment2.epochs = self.epoch2 self.segment1.epocharrays = self.epocharr1 self.segment2.epocharrays = self.epocharr2 self.segment1.events = self.event1 self.segment2.events = self.event2 self.segment1.eventarrays = self.eventarr1 self.segment2.eventarrays = self.eventarr2 self.segment1.irregularlysampledsignals = self.irsig1 self.segment2.irregularlysampledsignals = self.irsig2 self.segment1.spikes = self.spike1 self.segment2.spikes = self.spike2 self.segment1.spiketrains = self.train1 self.segment2.spiketrains = self.train2 self.segment1.create_many_to_one_relationship() self.segment2.create_many_to_one_relationship()
def setUp(self): test_data = np.random.rand(100, 8) * pq.mV channel_names = np.array(["a", "b", "c", "d", "e", "f", "g", "h"]) self.test_signal = AnalogSignal(test_data, sampling_period=0.1 * pq.ms, name="test signal", description="this is a test signal", array_annotations={"channel_names": channel_names}, attUQoLtUaE=42) self.test_view = ChannelView(self.test_signal, [1, 2, 5, 7], name="view of test signal", description="this is a view of a test signal", array_annotations={"something": np.array(["A", "B", "C", "D"])}, sLaTfat="fish") self.test_spiketrains = [SpikeTrain(np.arange(100.0), units="ms", t_stop=200), SpikeTrain(np.arange(0.5, 100.5), units="ms", t_stop=200)] self.test_segment = Segment() self.test_segment.analogsignals.append(self.test_signal) self.test_segment.spiketrains.extend(self.test_spiketrains)
def test_init(self): seg = Segment(name='a segment', index=3) assert_neo_object_is_compliant(seg) self.assertEqual(seg.name, 'a segment') self.assertEqual(seg.file_origin, None) self.assertEqual(seg.index, 3)
def setUp(self): unitname11 = 'unit 1 1' unitname12 = 'unit 1 2' unitname21 = 'unit 2 1' unitname22 = 'unit 2 2' channame11 = 'chan 1 1' channame12 = 'chan 1 2' channame21 = 'chan 2 1' channame22 = 'chan 2 2' segname11 = 'seg 1 1' segname12 = 'seg 1 2' segname21 = 'seg 2 1' segname22 = 'seg 2 2' self.rcgname1 = 'rcg 1' self.rcgname2 = 'rcg 2' self.rcgnames = [self.rcgname1, self.rcgname2] self.unitnames1 = [unitname11, unitname12] self.unitnames2 = [unitname21, unitname22, unitname11] self.unitnames = [unitname11, unitname12, unitname21, unitname22] self.channames1 = [channame11, channame12] self.channames2 = [channame21, channame22, channame11] self.channames = [channame11, channame12, channame21, channame22] self.segnames1 = [segname11, segname12] self.segnames2 = [segname21, segname22, segname11] self.segnames = [segname11, segname12, segname21, segname22] unit11 = Unit(name=unitname11) unit12 = Unit(name=unitname12) unit21 = Unit(name=unitname21) unit22 = Unit(name=unitname22) unit23 = unit11 chan11 = RecordingChannel(name=channame11) chan12 = RecordingChannel(name=channame12) chan21 = RecordingChannel(name=channame21) chan22 = RecordingChannel(name=channame22) chan23 = chan11 seg11 = Segment(name=segname11) seg12 = Segment(name=segname12) seg21 = Segment(name=segname21) seg22 = Segment(name=segname22) seg23 = seg11 self.units1 = [unit11, unit12] self.units2 = [unit21, unit22, unit23] self.units = [unit11, unit12, unit21, unit22] self.chan1 = [chan11, chan12] self.chan2 = [chan21, chan22, chan23] self.chan = [chan11, chan12, chan21, chan22] self.seg1 = [seg11, seg12] self.seg2 = [seg21, seg22, seg23] self.seg = [seg11, seg12, seg21, seg22] self.rcg1 = RecordingChannelGroup(name=self.rcgname1) self.rcg2 = RecordingChannelGroup(name=self.rcgname2) self.rcg = [self.rcg1, self.rcg2] self.rcg1.units = self.units1 self.rcg2.units = self.units2 self.rcg1.recordingchannels = self.chan1 self.rcg2.recordingchannels = self.chan2
def test__time_slice(self): time_slice = [.5, 5.6] * pq.s epoch2 = Epoch([0.6, 9.5, 16.8, 34.1] * pq.s, durations=[4.5, 4.8, 5.0, 5.0] * pq.s, t_start=.1 * pq.s) epoch2.annotate(epoch_type='b') epoch2.array_annotate(trial_id=[1, 2, 3, 4]) event = Event(times=[0.5, 10.0, 25.2] * pq.s, t_start=.1 * pq.s) event.annotate(event_type='trial start') event.array_annotate(trial_id=[1, 2, 3]) anasig = AnalogSignal(np.arange(50.0) * pq.mV, t_start=.1 * pq.s, sampling_rate=1.0 * pq.Hz) irrsig = IrregularlySampledSignal(signal=np.arange(50.0) * pq.mV, times=anasig.times, t_start=.1 * pq.s) st = SpikeTrain( np.arange(0.5, 50, 7) * pq.s, t_start=.1 * pq.s, t_stop=50.0 * pq.s, waveforms=np.array( [[[0., 1.], [0.1, 1.1]], [[2., 3.], [2.1, 3.1]], [[4., 5.], [4.1, 5.1]], [[6., 7.], [6.1, 7.1]], [[8., 9.], [8.1, 9.1]], [[12., 13.], [12.1, 13.1]], [[14., 15.], [14.1, 15.1]], [[16., 17.], [16.1, 17.1]]]) * pq.mV, array_annotations={'spikenum': np.arange(1, 9)}) seg = Segment() seg.epochs = [epoch2] seg.events = [event] seg.analogsignals = [anasig] seg.irregularlysampledsignals = [irrsig] seg.spiketrains = [st] block = Block() block.segments = [seg] block.create_many_to_one_relationship() # test without resetting the time sliced = seg.time_slice(time_slice[0], time_slice[1]) assert_neo_object_is_compliant(sliced) self.assertEqual(len(sliced.events), 1) self.assertEqual(len(sliced.spiketrains), 1) self.assertEqual(len(sliced.analogsignals), 1) self.assertEqual(len(sliced.irregularlysampledsignals), 1) self.assertEqual(len(sliced.epochs), 1) assert_same_attributes( sliced.spiketrains[0], st.time_slice(t_start=time_slice[0], t_stop=time_slice[1])) assert_same_attributes( sliced.analogsignals[0], anasig.time_slice(t_start=time_slice[0], t_stop=time_slice[1])) assert_same_attributes( sliced.irregularlysampledsignals[0], irrsig.time_slice(t_start=time_slice[0], t_stop=time_slice[1])) assert_same_attributes( sliced.events[0], event.time_slice(t_start=time_slice[0], t_stop=time_slice[1])) assert_same_attributes( sliced.epochs[0], epoch2.time_slice(t_start=time_slice[0], t_stop=time_slice[1])) seg = Segment() seg.epochs = [epoch2] seg.events = [event] seg.analogsignals = [anasig] seg.irregularlysampledsignals = [irrsig] seg.spiketrains = [st] block = Block() block.segments = [seg] block.create_many_to_one_relationship() # test with resetting the time sliced = seg.time_slice(time_slice[0], time_slice[1], reset_time=True) assert_neo_object_is_compliant(sliced) self.assertEqual(len(sliced.events), 1) self.assertEqual(len(sliced.spiketrains), 1) self.assertEqual(len(sliced.analogsignals), 1) self.assertEqual(len(sliced.irregularlysampledsignals), 1) self.assertEqual(len(sliced.epochs), 1) assert_same_attributes( sliced.spiketrains[0], st.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0])) anasig_target = anasig.copy() anasig_target = anasig_target.time_shift(-time_slice[0]).time_slice( t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0]) assert_same_attributes(sliced.analogsignals[0], anasig_target) irrsig_target = irrsig.copy() irrsig_target = irrsig_target.time_shift(-time_slice[0]).time_slice( t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0]) assert_same_attributes(sliced.irregularlysampledsignals[0], irrsig_target) assert_same_attributes( sliced.events[0], event.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0])) assert_same_attributes( sliced.epochs[0], epoch2.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0])) seg = Segment() reader = ExampleRawIO(filename='my_filename.fake') reader.parse_header() proxy_anasig = AnalogSignalProxy(rawio=reader, stream_index=0, inner_stream_channels=None, block_index=0, seg_index=0) seg.analogsignals.append(proxy_anasig) proxy_st = SpikeTrainProxy(rawio=reader, spike_channel_index=0, block_index=0, seg_index=0) seg.spiketrains.append(proxy_st) proxy_event = EventProxy(rawio=reader, event_channel_index=0, block_index=0, seg_index=0) seg.events.append(proxy_event) proxy_epoch = EpochProxy(rawio=reader, event_channel_index=1, block_index=0, seg_index=0) proxy_epoch.annotate(pick='me') seg.epochs.append(proxy_epoch) loaded_epoch = proxy_epoch.load() loaded_event = proxy_event.load() loaded_st = proxy_st.load() loaded_anasig = proxy_anasig.load() block = Block() block.segments = [seg] block.create_many_to_one_relationship() # test with proxy objects sliced = seg.time_slice(time_slice[0], time_slice[1]) assert_neo_object_is_compliant(sliced) sliced_event = loaded_event.time_slice(t_start=time_slice[0], t_stop=time_slice[1]) has_event = len(sliced_event) > 0 sliced_anasig = loaded_anasig.time_slice(t_start=time_slice[0], t_stop=time_slice[1]) sliced_st = loaded_st.time_slice(t_start=time_slice[0], t_stop=time_slice[1]) self.assertEqual(len(sliced.events), int(has_event)) self.assertEqual(len(sliced.spiketrains), 1) self.assertEqual(len(sliced.analogsignals), 1) self.assertTrue(isinstance(sliced.spiketrains[0], SpikeTrain)) assert_same_attributes(sliced.spiketrains[0], sliced_st) self.assertTrue(isinstance(sliced.analogsignals[0], AnalogSignal)) assert_same_attributes(sliced.analogsignals[0], sliced_anasig) if has_event: self.assertTrue(isinstance(sliced.events[0], Event)) assert_same_attributes(sliced.events[0], sliced_event)
def test_times(self): for seg in [self.seg1, self.seg2]: # calculate target values for t_start and t_stop t_starts, t_stops = [], [] for children in [ seg.analogsignals, seg.epochs, seg.events, seg.irregularlysampledsignals, seg.spiketrains ]: for child in children: if hasattr(child, 't_start'): t_starts.append(child.t_start) if hasattr(child, 't_stop'): t_stops.append(child.t_stop) if hasattr(child, 'time'): t_starts.append(child.time) t_stops.append(child.time) if hasattr(child, 'times'): t_starts.append(child.times[0]) t_stops.append(child.times[-1]) targ_t_start = min(t_starts) targ_t_stop = max(t_stops) self.assertEqual(seg.t_start, targ_t_start) self.assertEqual(seg.t_stop, targ_t_stop) # Testing times with ProxyObjects seg = Segment() reader = ExampleRawIO(filename='my_filename.fake') reader.parse_header() proxy_anasig = AnalogSignalProxy(rawio=reader, stream_index=0, inner_stream_channels=None, block_index=0, seg_index=0) seg.analogsignals.append(proxy_anasig) proxy_st = SpikeTrainProxy(rawio=reader, spike_channel_index=0, block_index=0, seg_index=0) seg.spiketrains.append(proxy_st) proxy_event = EventProxy(rawio=reader, event_channel_index=0, block_index=0, seg_index=0) seg.events.append(proxy_event) proxy_epoch = EpochProxy(rawio=reader, event_channel_index=1, block_index=0, seg_index=0) seg.epochs.append(proxy_epoch) t_starts, t_stops = [], [] for children in [ seg.analogsignals, seg.epochs, seg.events, seg.irregularlysampledsignals, seg.spiketrains ]: for child in children: if hasattr(child, 't_start'): t_starts.append(child.t_start) if hasattr(child, 't_stop'): t_stops.append(child.t_stop) if hasattr(child, 'time'): t_starts.append(child.time) t_stops.append(child.time) if hasattr(child, 'times'): t_starts.append(child.times[0]) t_stops.append(child.times[-1]) targ_t_start = min(t_starts) targ_t_stop = max(t_stops) self.assertEqual(seg.t_start, targ_t_start) self.assertEqual(seg.t_stop, targ_t_stop)
def test_init(self): seg = Segment(name='a segment', index=3) self.assertEqual(seg.name, 'a segment') self.assertEqual(seg.file_origin, None) self.assertEqual(seg.index, 3)
def merge_datastores( datastores, root_directory, merge_recordings=True, merge_analysis=True, merge_stimuli=True, replace=False, ): """ This function takes a tuple of datastore in input and merge them into one single datastore which will be saved in root_directory. The type of data that should be merged can be controlled through the merge_recordings, merge_analysis and merge_stimuli booleans It returns this datastore as a Datastore object. """ merged_datastore = PickledDataStore( load=False, parameters=ParameterSet({ "root_directory": root_directory, "store_stimuli": merge_stimuli }), replace=replace, ) j = 0 # Here we check if sheets and neurons are the same in all datastores assert compare_sheets_datastores( datastores), "All datastores should contain the same sheets" assert compare_neurons_ids_datastores( datastores), "Neurons in the datastores should have the same ids" assert compare_neurons_position_datastores( datastores), "Neurons in the datastores should have the same position" assert compare_neurons_annotations_datastores( datastores ), "Neurons in the datastores should have the same annotations" if not os.path.isdir(root_directory): os.makedirs(root_directory) # Change the block annotations so that it gets the merged version of the experiment parameters merged_datastore.block.annotations = datastores[0].block.annotations merged_datastore.block.annotations[ "experiment_parameters"] = merge_experiment_parameters_datastores( datastores) j = 0 for datastore in datastores: # Merge the recording of all the datastores if this flag is set to true if merge_recordings: segments = datastore.get_segments() segments += datastore.get_segments(null=True) for seg in segments: for s in merged_datastore.get_segments(): if seg.annotations == s.annotations and seg.null == s.null: print( "Warning: A segment with the same parametrization was already added in the datastore.: %s" % (seg.annotations)) raise ValueError( "A segment with the same parametrization was already added in the datastore already added in the datastore. Currently uniqueness is required. User should check what caused this and modify his simulations to avoid this!: %s \n %s" % (str(seg.annotations), str(s.annotations))) # Load the full segment and adds it to the merged datastore if not seg.full: seg.load_full() merged_datastore.block.segments.append( PickledDataStoreNeoWrapper(seg, "Segment" + str(j), root_directory, null=seg.null)) merged_datastore.stimulus_dict[ seg.annotations["stimulus"]] = True # Create a new pickle file for this mozaik segment and store a corresponding neo segment there f = open(root_directory + "/" + "Segment" + str(j) + ".pickle", "wb") s = Segment(description=seg.description, file_origin=seg.file_origin, file_datetime=seg.file_datetime, rec_datetime=seg.rec_datetime, index=seg.index, **seg.annotations) s.spiketrains = seg.spiketrains s.analogsignals = seg.analogsignals pickle.dump(s, f) # Release each segment once it has been added to the merged datastore to save memory seg.release() j = j + 1 # Merge the analysis of all the datastores if this flag is set to true if merge_analysis: adss = datastore.get_analysis_result() for ads in adss: merged_datastore.add_analysis_result(ads) # Merge the stimuli all the datastores if this flag is set to true if merge_stimuli: for key, value in datastore.sensory_stimulus.items(): merged_datastore.sensory_stimulus[key] = value return merged_datastore
class TestSegment(unittest.TestCase): def setUp(self): self.setup_analogsignals() self.setup_analogsignalarrays() self.setup_epochs() self.setup_epocharrays() self.setup_events() self.setup_eventarrays() self.setup_irregularlysampledsignals() self.setup_spikes() self.setup_spiketrains() self.setup_units() self.setup_segments() def setup_segments(self): params = {'testarg2': 'yes', 'testarg3': True} self.segment1 = Segment(name='test', description='tester 1', file_origin='test.file', testarg1=1, **params) self.segment2 = Segment(name='test', description='tester 2', file_origin='test.file', testarg1=1, **params) self.segment1.annotate(testarg1=1.1, testarg0=[1, 2, 3]) self.segment2.annotate(testarg11=1.1, testarg10=[1, 2, 3]) self.segment1.analogsignals = self.sig1 self.segment2.analogsignals = self.sig2 self.segment1.analogsignalarrays = self.sigarr1 self.segment2.analogsignalarrays = self.sigarr2 self.segment1.epochs = self.epoch1 self.segment2.epochs = self.epoch2 self.segment1.epocharrays = self.epocharr1 self.segment2.epocharrays = self.epocharr2 self.segment1.events = self.event1 self.segment2.events = self.event2 self.segment1.eventarrays = self.eventarr1 self.segment2.eventarrays = self.eventarr2 self.segment1.irregularlysampledsignals = self.irsig1 self.segment2.irregularlysampledsignals = self.irsig2 self.segment1.spikes = self.spike1 self.segment2.spikes = self.spike2 self.segment1.spiketrains = self.train1 self.segment2.spiketrains = self.train2 create_many_to_one_relationship(self.segment1) create_many_to_one_relationship(self.segment2) def setup_units(self): params = {'testarg2': 'yes', 'testarg3': True} self.unit1 = Unit(name='test', description='tester 1', file_origin='test.file', channel_indexes=np.array([1]), testarg1=1, **params) self.unit2 = Unit(name='test', description='tester 2', file_origin='test.file', channel_indexes=np.array([2]), testarg1=1, **params) self.unit1.annotate(testarg1=1.1, testarg0=[1, 2, 3]) self.unit2.annotate(testarg11=1.1, testarg10=[1, 2, 3]) self.unit1train = [self.train1[0], self.train2[1]] self.unit2train = [self.train1[1], self.train2[0]] self.unit1.spiketrains = self.unit1train self.unit2.spiketrains = self.unit2train self.unit1spike = [self.spike1[0], self.spike2[1]] self.unit2spike = [self.spike1[1], self.spike2[0]] self.unit1.spikes = self.unit1spike self.unit2.spikes = self.unit2spike create_many_to_one_relationship(self.unit1) create_many_to_one_relationship(self.unit2) def setup_analogsignals(self): signame11 = 'analogsignal 1 1' signame12 = 'analogsignal 1 2' signame21 = 'analogsignal 2 1' signame22 = 'analogsignal 2 2' sigdata11 = np.arange(0, 10) * pq.mV sigdata12 = np.arange(10, 20) * pq.mV sigdata21 = np.arange(20, 30) * pq.V sigdata22 = np.arange(30, 40) * pq.V self.signames1 = [signame11, signame12] self.signames2 = [signame21, signame22] self.signames = [signame11, signame12, signame21, signame22] sig11 = AnalogSignal(sigdata11, name=signame11, channel_index=1, sampling_rate=1*pq.Hz) sig12 = AnalogSignal(sigdata12, name=signame12, channel_index=2, sampling_rate=1*pq.Hz) sig21 = AnalogSignal(sigdata21, name=signame21, channel_index=1, sampling_rate=1*pq.Hz) sig22 = AnalogSignal(sigdata22, name=signame22, channel_index=2, sampling_rate=1*pq.Hz) self.sig1 = [sig11, sig12] self.sig2 = [sig21, sig22] self.sig = [sig11, sig12, sig21, sig22] self.chan1sig = [self.sig1[0], self.sig2[0]] self.chan2sig = [self.sig1[1], self.sig2[1]] def setup_analogsignalarrays(self): sigarrname11 = 'analogsignalarray 1 1' sigarrname12 = 'analogsignalarray 1 2' sigarrname21 = 'analogsignalarray 2 1' sigarrname22 = 'analogsignalarray 2 2' sigarrdata11 = np.arange(0, 10).reshape(5, 2) * pq.mV sigarrdata12 = np.arange(10, 20).reshape(5, 2) * pq.mV sigarrdata21 = np.arange(20, 30).reshape(5, 2) * pq.V sigarrdata22 = np.arange(30, 40).reshape(5, 2) * pq.V sigarrdata112 = np.hstack([sigarrdata11, sigarrdata11]) * pq.mV self.sigarrnames1 = [sigarrname11, sigarrname12] self.sigarrnames2 = [sigarrname21, sigarrname22, sigarrname11] self.sigarrnames = [sigarrname11, sigarrname12, sigarrname21, sigarrname22] sigarr11 = AnalogSignalArray(sigarrdata11, name=sigarrname11, sampling_rate=1*pq.Hz, channel_index=np.array([1, 2])) sigarr12 = AnalogSignalArray(sigarrdata12, name=sigarrname12, sampling_rate=1*pq.Hz, channel_index=np.array([2, 1])) sigarr21 = AnalogSignalArray(sigarrdata21, name=sigarrname21, sampling_rate=1*pq.Hz, channel_index=np.array([1, 2])) sigarr22 = AnalogSignalArray(sigarrdata22, name=sigarrname22, sampling_rate=1*pq.Hz, channel_index=np.array([2, 1])) sigarr23 = AnalogSignalArray(sigarrdata11, name=sigarrname11, sampling_rate=1*pq.Hz, channel_index=np.array([1, 2])) sigarr112 = AnalogSignalArray(sigarrdata112, name=sigarrname11, sampling_rate=1*pq.Hz, channel_index=np.array([1, 2])) self.sigarr1 = [sigarr11, sigarr12] self.sigarr2 = [sigarr21, sigarr22, sigarr23] self.sigarr = [sigarr112, sigarr12, sigarr21, sigarr22] self.chan1sigarr1 = [sigarr11[:, 0:1], sigarr12[:, 1:2]] self.chan2sigarr1 = [sigarr11[:, 1:2], sigarr12[:, 0:1]] self.chan1sigarr2 = [sigarr21[:, 0:1], sigarr22[:, 1:2], sigarr23[:, 0:1]] self.chan2sigarr2 = [sigarr21[:, 1:2], sigarr22[:, 0:1], sigarr23[:, 0:1]] def setup_epochs(self): epochname11 = 'epoch 1 1' epochname12 = 'epoch 1 2' epochname21 = 'epoch 2 1' epochname22 = 'epoch 2 2' epochtime11 = 10 * pq.ms epochtime12 = 20 * pq.ms epochtime21 = 30 * pq.s epochtime22 = 40 * pq.s epochdur11 = 11 * pq.s epochdur12 = 21 * pq.s epochdur21 = 31 * pq.ms epochdur22 = 41 * pq.ms self.epochnames1 = [epochname11, epochname12] self.epochnames2 = [epochname21, epochname22] self.epochnames = [epochname11, epochname12, epochname21, epochname22] epoch11 = Epoch(epochtime11, epochdur11, label=epochname11, name=epochname11, channel_index=1, testattr=True) epoch12 = Epoch(epochtime12, epochdur12, label=epochname12, name=epochname12, channel_index=2, testattr=False) epoch21 = Epoch(epochtime21, epochdur21, label=epochname21, name=epochname21, channel_index=1) epoch22 = Epoch(epochtime22, epochdur22, label=epochname22, name=epochname22, channel_index=2) self.epoch1 = [epoch11, epoch12] self.epoch2 = [epoch21, epoch22] self.epoch = [epoch11, epoch12, epoch21, epoch22] def setup_epocharrays(self): epocharrname11 = 'epocharr 1 1' epocharrname12 = 'epocharr 1 2' epocharrname21 = 'epocharr 2 1' epocharrname22 = 'epocharr 2 2' epocharrtime11 = np.arange(0, 10) * pq.ms epocharrtime12 = np.arange(10, 20) * pq.ms epocharrtime21 = np.arange(20, 30) * pq.s epocharrtime22 = np.arange(30, 40) * pq.s epocharrdur11 = np.arange(1, 11) * pq.s epocharrdur12 = np.arange(11, 21) * pq.s epocharrdur21 = np.arange(21, 31) * pq.ms epocharrdur22 = np.arange(31, 41) * pq.ms self.epocharrnames1 = [epocharrname11, epocharrname12] self.epocharrnames2 = [epocharrname21, epocharrname22] self.epocharrnames = [epocharrname11, epocharrname12, epocharrname21, epocharrname22] epocharr11 = EpochArray(epocharrtime11, epocharrdur11, label=epocharrname11, name=epocharrname11) epocharr12 = EpochArray(epocharrtime12, epocharrdur12, label=epocharrname12, name=epocharrname12) epocharr21 = EpochArray(epocharrtime21, epocharrdur21, label=epocharrname21, name=epocharrname21) epocharr22 = EpochArray(epocharrtime22, epocharrdur22, label=epocharrname22, name=epocharrname22) self.epocharr1 = [epocharr11, epocharr12] self.epocharr2 = [epocharr21, epocharr22] self.epocharr = [epocharr11, epocharr12, epocharr21, epocharr22] def setup_events(self): eventname11 = 'event 1 1' eventname12 = 'event 1 2' eventname21 = 'event 2 1' eventname22 = 'event 2 2' eventtime11 = 10 * pq.ms eventtime12 = 20 * pq.ms eventtime21 = 30 * pq.s eventtime22 = 40 * pq.s self.eventnames1 = [eventname11, eventname12] self.eventnames2 = [eventname21, eventname22] self.eventnames = [eventname11, eventname12, eventname21, eventname22] params1 = {'testattr': True} params2 = {'testattr': 5} event11 = Event(eventtime11, label=eventname11, name=eventname11, **params1) event12 = Event(eventtime12, label=eventname12, name=eventname12, **params2) event21 = Event(eventtime21, label=eventname21, name=eventname21) event22 = Event(eventtime22, label=eventname22, name=eventname22) self.event1 = [event11, event12] self.event2 = [event21, event22] self.event = [event11, event12, event21, event22] def setup_eventarrays(self): eventarrname11 = 'eventarr 1 1' eventarrname12 = 'eventarr 1 2' eventarrname21 = 'eventarr 2 1' eventarrname22 = 'eventarr 2 2' eventarrtime11 = np.arange(0, 10) * pq.ms eventarrtime12 = np.arange(10, 20) * pq.ms eventarrtime21 = np.arange(20, 30) * pq.s eventarrtime22 = np.arange(30, 40) * pq.s self.eventarrnames1 = [eventarrname11, eventarrname12] self.eventarrnames2 = [eventarrname21, eventarrname22] self.eventarrnames = [eventarrname11, eventarrname12, eventarrname21, eventarrname22] eventarr11 = EventArray(eventarrtime11, label=eventarrname11, name=eventarrname11) eventarr12 = EventArray(eventarrtime12, label=eventarrname12, name=eventarrname12) eventarr21 = EventArray(eventarrtime21, label=eventarrname21, name=eventarrname21) eventarr22 = EventArray(eventarrtime22, label=eventarrname22, name=eventarrname22) self.eventarr1 = [eventarr11, eventarr12] self.eventarr2 = [eventarr21, eventarr22] self.eventarr = [eventarr11, eventarr12, eventarr21, eventarr22] def setup_irregularlysampledsignals(self): irsigname11 = 'irregularsignal 1 1' irsigname12 = 'irregularsignal 1 2' irsigname21 = 'irregularsignal 2 1' irsigname22 = 'irregularsignal 2 2' irsigdata11 = np.arange(0, 10) * pq.mA irsigdata12 = np.arange(10, 20) * pq.mA irsigdata21 = np.arange(20, 30) * pq.A irsigdata22 = np.arange(30, 40) * pq.A irsigtimes11 = np.arange(0, 10) * pq.ms irsigtimes12 = np.arange(10, 20) * pq.ms irsigtimes21 = np.arange(20, 30) * pq.s irsigtimes22 = np.arange(30, 40) * pq.s self.irsignames1 = [irsigname11, irsigname12] self.irsignames2 = [irsigname21, irsigname22] self.irsignames = [irsigname11, irsigname12, irsigname21, irsigname22] irsig11 = IrregularlySampledSignal(irsigtimes11, irsigdata11, name=irsigname11) irsig12 = IrregularlySampledSignal(irsigtimes12, irsigdata12, name=irsigname12) irsig21 = IrregularlySampledSignal(irsigtimes21, irsigdata21, name=irsigname21) irsig22 = IrregularlySampledSignal(irsigtimes22, irsigdata22, name=irsigname22) self.irsig1 = [irsig11, irsig12] self.irsig2 = [irsig21, irsig22] self.irsig = [irsig11, irsig12, irsig21, irsig22] def setup_spikes(self): spikename11 = 'spike 1 1' spikename12 = 'spike 1 2' spikename21 = 'spike 2 1' spikename22 = 'spike 2 2' spikedata11 = 10 * pq.ms spikedata12 = 20 * pq.ms spikedata21 = 30 * pq.s spikedata22 = 40 * pq.s self.spikenames1 = [spikename11, spikename12] self.spikenames2 = [spikename21, spikename22] self.spikenames = [spikename11, spikename12, spikename21, spikename22] spike11 = Spike(spikedata11, t_stop=100*pq.s, name=spikename11) spike12 = Spike(spikedata12, t_stop=100*pq.s, name=spikename12) spike21 = Spike(spikedata21, t_stop=100*pq.s, name=spikename21) spike22 = Spike(spikedata22, t_stop=100*pq.s, name=spikename22) self.spike1 = [spike11, spike12] self.spike2 = [spike21, spike22] self.spike = [spike11, spike12, spike21, spike22] def setup_spiketrains(self): trainname11 = 'spiketrain 1 1' trainname12 = 'spiketrain 1 2' trainname21 = 'spiketrain 2 1' trainname22 = 'spiketrain 2 2' traindata11 = np.arange(0, 10) * pq.ms traindata12 = np.arange(10, 20) * pq.ms traindata21 = np.arange(20, 30) * pq.s traindata22 = np.arange(30, 40) * pq.s self.trainnames1 = [trainname11, trainname12] self.trainnames2 = [trainname21, trainname22] self.trainnames = [trainname11, trainname12, trainname21, trainname22] train11 = SpikeTrain(traindata11, t_stop=100*pq.s, name=trainname11) train12 = SpikeTrain(traindata12, t_stop=100*pq.s, name=trainname12) train21 = SpikeTrain(traindata21, t_stop=100*pq.s, name=trainname21) train22 = SpikeTrain(traindata22, t_stop=100*pq.s, name=trainname22) self.train1 = [train11, train12] self.train2 = [train21, train22] self.train = [train11, train12, train21, train22] def test_init(self): seg = Segment(name='a segment', index=3) assert_neo_object_is_compliant(seg) self.assertEqual(seg.name, 'a segment') self.assertEqual(seg.file_origin, None) self.assertEqual(seg.index, 3) def test__construct_subsegment_by_unit(self): nb_seg = 3 nb_unit = 7 unit_with_sig = np.array([0, 2, 5]) signal_types = ['Vm', 'Conductances'] sig_len = 100 #recordingchannelgroups rcgs = [RecordingChannelGroup(name='Vm', channel_indexes=unit_with_sig), RecordingChannelGroup(name='Conductance', channel_indexes=unit_with_sig)] # Unit all_unit = [] for u in range(nb_unit): un = Unit(name='Unit #%d' % u, channel_indexes=np.array([u])) assert_neo_object_is_compliant(un) all_unit.append(un) blk = Block() blk.recordingchannelgroups = rcgs for s in range(nb_seg): seg = Segment(name='Simulation %s' % s) for j in range(nb_unit): st = SpikeTrain([1, 2, 3], units='ms', t_start=0., t_stop=10) st.unit = all_unit[j] for t in signal_types: anasigarr = AnalogSignalArray(np.zeros((sig_len, len(unit_with_sig))), units='nA', sampling_rate=1000.*pq.Hz, channel_indexes=unit_with_sig) seg.analogsignalarrays.append(anasigarr) create_many_to_one_relationship(blk) for unit in all_unit: assert_neo_object_is_compliant(unit) for rcg in rcgs: assert_neo_object_is_compliant(rcg) assert_neo_object_is_compliant(blk) # what you want newseg = seg.construct_subsegment_by_unit(all_unit[:4]) assert_neo_object_is_compliant(newseg) def test_segment_creation(self): assert_neo_object_is_compliant(self.segment1) assert_neo_object_is_compliant(self.segment2) assert_neo_object_is_compliant(self.unit1) assert_neo_object_is_compliant(self.unit2) self.assertEqual(self.segment1.name, 'test') self.assertEqual(self.segment2.name, 'test') self.assertEqual(self.segment1.description, 'tester 1') self.assertEqual(self.segment2.description, 'tester 2') self.assertEqual(self.segment1.file_origin, 'test.file') self.assertEqual(self.segment2.file_origin, 'test.file') self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3]) self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3]) self.assertEqual(self.segment1.annotations['testarg1'], 1.1) self.assertEqual(self.segment2.annotations['testarg1'], 1) self.assertEqual(self.segment2.annotations['testarg11'], 1.1) self.assertEqual(self.segment1.annotations['testarg2'], 'yes') self.assertEqual(self.segment2.annotations['testarg2'], 'yes') self.assertTrue(self.segment1.annotations['testarg3']) self.assertTrue(self.segment2.annotations['testarg3']) self.assertTrue(hasattr(self.segment1, 'analogsignals')) self.assertTrue(hasattr(self.segment2, 'analogsignals')) self.assertEqual(len(self.segment1.analogsignals), 2) self.assertEqual(len(self.segment2.analogsignals), 2) for res, targ in zip(self.segment1.analogsignals, self.sig1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignals, self.sig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'analogsignalarrays')) self.assertTrue(hasattr(self.segment2, 'analogsignalarrays')) self.assertEqual(len(self.segment1.analogsignalarrays), 2) self.assertEqual(len(self.segment2.analogsignalarrays), 3) for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epochs')) self.assertTrue(hasattr(self.segment2, 'epochs')) self.assertEqual(len(self.segment1.epochs), 2) self.assertEqual(len(self.segment2.epochs), 2) for res, targ in zip(self.segment1.epochs, self.epoch1): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epochs, self.epoch2): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epocharrays')) self.assertTrue(hasattr(self.segment2, 'epocharrays')) self.assertEqual(len(self.segment1.epocharrays), 2) self.assertEqual(len(self.segment2.epocharrays), 2) for res, targ in zip(self.segment1.epocharrays, self.epocharr1): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epocharrays, self.epocharr2): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'events')) self.assertTrue(hasattr(self.segment2, 'events')) self.assertEqual(len(self.segment1.events), 2) self.assertEqual(len(self.segment2.events), 2) for res, targ in zip(self.segment1.events, self.event1): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.events, self.event2): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'eventarrays')) self.assertTrue(hasattr(self.segment2, 'eventarrays')) self.assertEqual(len(self.segment1.eventarrays), 2) self.assertEqual(len(self.segment2.eventarrays), 2) for res, targ in zip(self.segment1.eventarrays, self.eventarr1): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.eventarrays, self.eventarr2): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals')) self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals')) self.assertEqual(len(self.segment1.irregularlysampledsignals), 2) self.assertEqual(len(self.segment2.irregularlysampledsignals), 2) for res, targ in zip(self.segment1.irregularlysampledsignals, self.irsig1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.irregularlysampledsignals, self.irsig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spikes')) self.assertTrue(hasattr(self.segment2, 'spikes')) self.assertEqual(len(self.segment1.spikes), 2) self.assertEqual(len(self.segment2.spikes), 2) for res, targ in zip(self.segment1.spikes, self.spike1): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spikes, self.spike2): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spiketrains')) self.assertTrue(hasattr(self.segment2, 'spiketrains')) self.assertEqual(len(self.segment1.spiketrains), 2) self.assertEqual(len(self.segment2.spiketrains), 2) for res, targ in zip(self.segment1.spiketrains, self.train1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spiketrains, self.train2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_merge(self): self.segment1.merge(self.segment2) create_many_to_one_relationship(self.segment1, force=True) assert_neo_object_is_compliant(self.segment1) self.assertEqual(self.segment1.name, 'test') self.assertEqual(self.segment2.name, 'test') self.assertEqual(self.segment1.description, 'tester 1') self.assertEqual(self.segment2.description, 'tester 2') self.assertEqual(self.segment1.file_origin, 'test.file') self.assertEqual(self.segment2.file_origin, 'test.file') self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3]) self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3]) self.assertEqual(self.segment1.annotations['testarg1'], 1.1) self.assertEqual(self.segment2.annotations['testarg1'], 1) self.assertEqual(self.segment2.annotations['testarg11'], 1.1) self.assertEqual(self.segment1.annotations['testarg2'], 'yes') self.assertEqual(self.segment2.annotations['testarg2'], 'yes') self.assertTrue(self.segment1.annotations['testarg3']) self.assertTrue(self.segment2.annotations['testarg3']) self.assertTrue(hasattr(self.segment1, 'analogsignals')) self.assertTrue(hasattr(self.segment2, 'analogsignals')) self.assertEqual(len(self.segment1.analogsignals), 4) self.assertEqual(len(self.segment2.analogsignals), 2) for res, targ in zip(self.segment1.analogsignals, self.sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignals, self.sig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'analogsignalarrays')) self.assertTrue(hasattr(self.segment2, 'analogsignalarrays')) self.assertEqual(len(self.segment1.analogsignalarrays), 4) self.assertEqual(len(self.segment2.analogsignalarrays), 3) for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epochs')) self.assertTrue(hasattr(self.segment2, 'epochs')) self.assertEqual(len(self.segment1.epochs), 4) self.assertEqual(len(self.segment2.epochs), 2) for res, targ in zip(self.segment1.epochs, self.epoch): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epochs, self.epoch2): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epocharrays')) self.assertTrue(hasattr(self.segment2, 'epocharrays')) self.assertEqual(len(self.segment1.epocharrays), 4) self.assertEqual(len(self.segment2.epocharrays), 2) for res, targ in zip(self.segment1.epocharrays, self.epocharr): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epocharrays, self.epocharr2): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'events')) self.assertTrue(hasattr(self.segment2, 'events')) self.assertEqual(len(self.segment1.events), 4) self.assertEqual(len(self.segment2.events), 2) for res, targ in zip(self.segment1.events, self.event): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.events, self.event2): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'eventarrays')) self.assertTrue(hasattr(self.segment2, 'eventarrays')) self.assertEqual(len(self.segment1.eventarrays), 4) self.assertEqual(len(self.segment2.eventarrays), 2) for res, targ in zip(self.segment1.eventarrays, self.eventarr): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.eventarrays, self.eventarr2): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals')) self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals')) self.assertEqual(len(self.segment1.irregularlysampledsignals), 4) self.assertEqual(len(self.segment2.irregularlysampledsignals), 2) for res, targ in zip(self.segment1.irregularlysampledsignals, self.irsig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.irregularlysampledsignals, self.irsig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spikes')) self.assertTrue(hasattr(self.segment2, 'spikes')) self.assertEqual(len(self.segment1.spikes), 4) self.assertEqual(len(self.segment2.spikes), 2) for res, targ in zip(self.segment1.spikes, self.spike): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spikes, self.spike2): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spiketrains')) self.assertTrue(hasattr(self.segment2, 'spiketrains')) self.assertEqual(len(self.segment1.spiketrains), 4) self.assertEqual(len(self.segment2.spiketrains), 2) for res, targ in zip(self.segment1.spiketrains, self.train): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spiketrains, self.train2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_all_data(self): result1 = self.segment1.all_data targs = (self.epoch1 + self.epocharr1 + self.event1 + self.eventarr1 + self.sig1 + self.sigarr1 + self.irsig1 + self.spike1 + self.train1) for res, targ in zip(result1, targs): if hasattr(res, 'ndim') and res.ndim: assert_arrays_equal(res, targ) else: self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_spikes_by_unit(self): result1 = self.segment1.take_spikes_by_unit() result21 = self.segment1.take_spikes_by_unit([self.unit1]) result22 = self.segment1.take_spikes_by_unit([self.unit2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.unit1spike): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.unit2spike): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_spiketrains_by_unit(self): result1 = self.segment1.take_spiketrains_by_unit() result21 = self.segment1.take_spiketrains_by_unit([self.unit1]) result22 = self.segment1.take_spiketrains_by_unit([self.unit2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.unit1train): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.unit2train): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_analogsignal_by_unit(self): result1 = self.segment1.take_analogsignal_by_unit() result21 = self.segment1.take_analogsignal_by_unit([self.unit1]) result22 = self.segment1.take_analogsignal_by_unit([self.unit2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.chan1sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.chan2sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_analogsignal_by_channelindex(self): result1 = self.segment1.take_analogsignal_by_channelindex() result21 = self.segment1.take_analogsignal_by_channelindex([1]) result22 = self.segment1.take_analogsignal_by_channelindex([2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.chan1sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.chan2sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_slice_of_analogsignalarray_by_unit(self): segment = self.segment1 unit1 = self.unit1 unit2 = self.unit2 result1 = segment.take_slice_of_analogsignalarray_by_unit() result21 = segment.take_slice_of_analogsignalarray_by_unit([unit1]) result22 = segment.take_slice_of_analogsignalarray_by_unit([unit2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.chan1sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.chan2sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_slice_of_analogsignalarray_by_channelindex(self): segment = self.segment1 result1 = segment.take_slice_of_analogsignalarray_by_channelindex() result21 = segment.take_slice_of_analogsignalarray_by_channelindex([1]) result22 = segment.take_slice_of_analogsignalarray_by_channelindex([2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.chan1sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.chan2sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_size(self): result1 = self.segment1.size() targ1 = {"epochs": 2, "events": 2, "analogsignals": 2, "irregularlysampledsignals": 2, "spikes": 2, "spiketrains": 2, "epocharrays": 2, "eventarrays": 2, "analogsignalarrays": 2} self.assertEqual(result1, targ1) def test_segment_filter(self): result1 = self.segment1.filter() result2 = self.segment1.filter(name='analogsignal 1 1') result3 = self.segment1.filter(testattr=True) self.assertEqual(result1, []) self.assertEqual(len(result2), 1) assert_arrays_equal(result2[0], self.sig1[0]) self.assertEqual(len(result3), 2) self.assertEqual(result3[0], self.epoch1[0]) self.assertEqual(result3[1], self.event1[0])
class TestSegment(unittest.TestCase): def setUp(self): self.setup_analogsignals() self.setup_analogsignalarrays() self.setup_epochs() self.setup_epocharrays() self.setup_events() self.setup_eventarrays() self.setup_irregularlysampledsignals() self.setup_spikes() self.setup_spiketrains() self.setup_units() self.setup_segments() def setup_segments(self): params = {'testarg2': 'yes', 'testarg3': True} self.segment1 = Segment(name='test', description='tester 1', file_origin='test.file', testarg1=1, **params) self.segment2 = Segment(name='test', description='tester 2', file_origin='test.file', testarg1=1, **params) self.segment1.annotate(testarg1=1.1, testarg0=[1, 2, 3]) self.segment2.annotate(testarg11=1.1, testarg10=[1, 2, 3]) self.segment1.analogsignals = self.sig1 self.segment2.analogsignals = self.sig2 self.segment1.analogsignalarrays = self.sigarr1 self.segment2.analogsignalarrays = self.sigarr2 self.segment1.epochs = self.epoch1 self.segment2.epochs = self.epoch2 self.segment1.epocharrays = self.epocharr1 self.segment2.epocharrays = self.epocharr2 self.segment1.events = self.event1 self.segment2.events = self.event2 self.segment1.eventarrays = self.eventarr1 self.segment2.eventarrays = self.eventarr2 self.segment1.irregularlysampledsignals = self.irsig1 self.segment2.irregularlysampledsignals = self.irsig2 self.segment1.spikes = self.spike1 self.segment2.spikes = self.spike2 self.segment1.spiketrains = self.train1 self.segment2.spiketrains = self.train2 self.segment1.create_many_to_one_relationship() self.segment2.create_many_to_one_relationship() def setup_units(self): params = {'testarg2': 'yes', 'testarg3': True} self.unit1 = Unit(name='test', description='tester 1', file_origin='test.file', channel_indexes=np.array([1]), testarg1=1, **params) self.unit2 = Unit(name='test', description='tester 2', file_origin='test.file', channel_indexes=np.array([2]), testarg1=1, **params) self.unit1.annotate(testarg1=1.1, testarg0=[1, 2, 3]) self.unit2.annotate(testarg11=1.1, testarg10=[1, 2, 3]) self.unit1train = [self.train1[0], self.train2[1]] self.unit2train = [self.train1[1], self.train2[0]] self.unit1.spiketrains = self.unit1train self.unit2.spiketrains = self.unit2train self.unit1spike = [self.spike1[0], self.spike2[1]] self.unit2spike = [self.spike1[1], self.spike2[0]] self.unit1.spikes = self.unit1spike self.unit2.spikes = self.unit2spike self.unit1.create_many_to_one_relationship() self.unit2.create_many_to_one_relationship() def setup_analogsignals(self): signame11 = 'analogsignal 1 1' signame12 = 'analogsignal 1 2' signame21 = 'analogsignal 2 1' signame22 = 'analogsignal 2 2' sigdata11 = np.arange(0, 10) * pq.mV sigdata12 = np.arange(10, 20) * pq.mV sigdata21 = np.arange(20, 30) * pq.V sigdata22 = np.arange(30, 40) * pq.V self.signames1 = [signame11, signame12] self.signames2 = [signame21, signame22] self.signames = [signame11, signame12, signame21, signame22] sig11 = AnalogSignal(sigdata11, name=signame11, channel_index=1, sampling_rate=1*pq.Hz) sig12 = AnalogSignal(sigdata12, name=signame12, channel_index=2, sampling_rate=1*pq.Hz) sig21 = AnalogSignal(sigdata21, name=signame21, channel_index=1, sampling_rate=1*pq.Hz) sig22 = AnalogSignal(sigdata22, name=signame22, channel_index=2, sampling_rate=1*pq.Hz) self.sig1 = [sig11, sig12] self.sig2 = [sig21, sig22] self.sig = [sig11, sig12, sig21, sig22] self.chan1sig = [self.sig1[0], self.sig2[0]] self.chan2sig = [self.sig1[1], self.sig2[1]] def setup_analogsignalarrays(self): sigarrname11 = 'analogsignalarray 1 1' sigarrname12 = 'analogsignalarray 1 2' sigarrname21 = 'analogsignalarray 2 1' sigarrname22 = 'analogsignalarray 2 2' sigarrdata11 = np.arange(0, 10).reshape(5, 2) * pq.mV sigarrdata12 = np.arange(10, 20).reshape(5, 2) * pq.mV sigarrdata21 = np.arange(20, 30).reshape(5, 2) * pq.V sigarrdata22 = np.arange(30, 40).reshape(5, 2) * pq.V sigarrdata112 = np.hstack([sigarrdata11, sigarrdata11]) * pq.mV self.sigarrnames1 = [sigarrname11, sigarrname12] self.sigarrnames2 = [sigarrname21, sigarrname22, sigarrname11] self.sigarrnames = [sigarrname11, sigarrname12, sigarrname21, sigarrname22] sigarr11 = AnalogSignalArray(sigarrdata11, name=sigarrname11, sampling_rate=1*pq.Hz, channel_index=np.array([1, 2])) sigarr12 = AnalogSignalArray(sigarrdata12, name=sigarrname12, sampling_rate=1*pq.Hz, channel_index=np.array([2, 1])) sigarr21 = AnalogSignalArray(sigarrdata21, name=sigarrname21, sampling_rate=1*pq.Hz, channel_index=np.array([1, 2])) sigarr22 = AnalogSignalArray(sigarrdata22, name=sigarrname22, sampling_rate=1*pq.Hz, channel_index=np.array([2, 1])) sigarr23 = AnalogSignalArray(sigarrdata11, name=sigarrname11, sampling_rate=1*pq.Hz, channel_index=np.array([1, 2])) sigarr112 = AnalogSignalArray(sigarrdata112, name=sigarrname11, sampling_rate=1*pq.Hz, channel_index=np.array([1, 2])) self.sigarr1 = [sigarr11, sigarr12] self.sigarr2 = [sigarr21, sigarr22, sigarr23] self.sigarr = [sigarr112, sigarr12, sigarr21, sigarr22] self.chan1sigarr1 = [sigarr11[:, 0:1], sigarr12[:, 1:2]] self.chan2sigarr1 = [sigarr11[:, 1:2], sigarr12[:, 0:1]] self.chan1sigarr2 = [sigarr21[:, 0:1], sigarr22[:, 1:2], sigarr23[:, 0:1]] self.chan2sigarr2 = [sigarr21[:, 1:2], sigarr22[:, 0:1], sigarr23[:, 0:1]] def setup_epochs(self): epochname11 = 'epoch 1 1' epochname12 = 'epoch 1 2' epochname21 = 'epoch 2 1' epochname22 = 'epoch 2 2' epochtime11 = 10 * pq.ms epochtime12 = 20 * pq.ms epochtime21 = 30 * pq.s epochtime22 = 40 * pq.s epochdur11 = 11 * pq.s epochdur12 = 21 * pq.s epochdur21 = 31 * pq.ms epochdur22 = 41 * pq.ms self.epochnames1 = [epochname11, epochname12] self.epochnames2 = [epochname21, epochname22] self.epochnames = [epochname11, epochname12, epochname21, epochname22] epoch11 = Epoch(epochtime11, epochdur11, label=epochname11, name=epochname11, channel_index=1, testattr=True) epoch12 = Epoch(epochtime12, epochdur12, label=epochname12, name=epochname12, channel_index=2, testattr=False) epoch21 = Epoch(epochtime21, epochdur21, label=epochname21, name=epochname21, channel_index=1) epoch22 = Epoch(epochtime22, epochdur22, label=epochname22, name=epochname22, channel_index=2) self.epoch1 = [epoch11, epoch12] self.epoch2 = [epoch21, epoch22] self.epoch = [epoch11, epoch12, epoch21, epoch22] def setup_epocharrays(self): epocharrname11 = 'epocharr 1 1' epocharrname12 = 'epocharr 1 2' epocharrname21 = 'epocharr 2 1' epocharrname22 = 'epocharr 2 2' epocharrtime11 = np.arange(0, 10) * pq.ms epocharrtime12 = np.arange(10, 20) * pq.ms epocharrtime21 = np.arange(20, 30) * pq.s epocharrtime22 = np.arange(30, 40) * pq.s epocharrdur11 = np.arange(1, 11) * pq.s epocharrdur12 = np.arange(11, 21) * pq.s epocharrdur21 = np.arange(21, 31) * pq.ms epocharrdur22 = np.arange(31, 41) * pq.ms self.epocharrnames1 = [epocharrname11, epocharrname12] self.epocharrnames2 = [epocharrname21, epocharrname22] self.epocharrnames = [epocharrname11, epocharrname12, epocharrname21, epocharrname22] epocharr11 = EpochArray(epocharrtime11, epocharrdur11, label=epocharrname11, name=epocharrname11) epocharr12 = EpochArray(epocharrtime12, epocharrdur12, label=epocharrname12, name=epocharrname12) epocharr21 = EpochArray(epocharrtime21, epocharrdur21, label=epocharrname21, name=epocharrname21) epocharr22 = EpochArray(epocharrtime22, epocharrdur22, label=epocharrname22, name=epocharrname22) self.epocharr1 = [epocharr11, epocharr12] self.epocharr2 = [epocharr21, epocharr22] self.epocharr = [epocharr11, epocharr12, epocharr21, epocharr22] def setup_events(self): eventname11 = 'event 1 1' eventname12 = 'event 1 2' eventname21 = 'event 2 1' eventname22 = 'event 2 2' eventtime11 = 10 * pq.ms eventtime12 = 20 * pq.ms eventtime21 = 30 * pq.s eventtime22 = 40 * pq.s self.eventnames1 = [eventname11, eventname12] self.eventnames2 = [eventname21, eventname22] self.eventnames = [eventname11, eventname12, eventname21, eventname22] params1 = {'testattr': True} params2 = {'testattr': 5} event11 = Event(eventtime11, label=eventname11, name=eventname11, **params1) event12 = Event(eventtime12, label=eventname12, name=eventname12, **params2) event21 = Event(eventtime21, label=eventname21, name=eventname21) event22 = Event(eventtime22, label=eventname22, name=eventname22) self.event1 = [event11, event12] self.event2 = [event21, event22] self.event = [event11, event12, event21, event22] def setup_eventarrays(self): eventarrname11 = 'eventarr 1 1' eventarrname12 = 'eventarr 1 2' eventarrname21 = 'eventarr 2 1' eventarrname22 = 'eventarr 2 2' eventarrtime11 = np.arange(0, 10) * pq.ms eventarrtime12 = np.arange(10, 20) * pq.ms eventarrtime21 = np.arange(20, 30) * pq.s eventarrtime22 = np.arange(30, 40) * pq.s self.eventarrnames1 = [eventarrname11, eventarrname12] self.eventarrnames2 = [eventarrname21, eventarrname22] self.eventarrnames = [eventarrname11, eventarrname12, eventarrname21, eventarrname22] eventarr11 = EventArray(eventarrtime11, label=eventarrname11, name=eventarrname11) eventarr12 = EventArray(eventarrtime12, label=eventarrname12, name=eventarrname12) eventarr21 = EventArray(eventarrtime21, label=eventarrname21, name=eventarrname21) eventarr22 = EventArray(eventarrtime22, label=eventarrname22, name=eventarrname22) self.eventarr1 = [eventarr11, eventarr12] self.eventarr2 = [eventarr21, eventarr22] self.eventarr = [eventarr11, eventarr12, eventarr21, eventarr22] def setup_irregularlysampledsignals(self): irsigname11 = 'irregularsignal 1 1' irsigname12 = 'irregularsignal 1 2' irsigname21 = 'irregularsignal 2 1' irsigname22 = 'irregularsignal 2 2' irsigdata11 = np.arange(0, 10) * pq.mA irsigdata12 = np.arange(10, 20) * pq.mA irsigdata21 = np.arange(20, 30) * pq.A irsigdata22 = np.arange(30, 40) * pq.A irsigtimes11 = np.arange(0, 10) * pq.ms irsigtimes12 = np.arange(10, 20) * pq.ms irsigtimes21 = np.arange(20, 30) * pq.s irsigtimes22 = np.arange(30, 40) * pq.s self.irsignames1 = [irsigname11, irsigname12] self.irsignames2 = [irsigname21, irsigname22] self.irsignames = [irsigname11, irsigname12, irsigname21, irsigname22] irsig11 = IrregularlySampledSignal(irsigtimes11, irsigdata11, name=irsigname11) irsig12 = IrregularlySampledSignal(irsigtimes12, irsigdata12, name=irsigname12) irsig21 = IrregularlySampledSignal(irsigtimes21, irsigdata21, name=irsigname21) irsig22 = IrregularlySampledSignal(irsigtimes22, irsigdata22, name=irsigname22) self.irsig1 = [irsig11, irsig12] self.irsig2 = [irsig21, irsig22] self.irsig = [irsig11, irsig12, irsig21, irsig22] def setup_spikes(self): spikename11 = 'spike 1 1' spikename12 = 'spike 1 2' spikename21 = 'spike 2 1' spikename22 = 'spike 2 2' spikedata11 = 10 * pq.ms spikedata12 = 20 * pq.ms spikedata21 = 30 * pq.s spikedata22 = 40 * pq.s self.spikenames1 = [spikename11, spikename12] self.spikenames2 = [spikename21, spikename22] self.spikenames = [spikename11, spikename12, spikename21, spikename22] spike11 = Spike(spikedata11, t_stop=100*pq.s, name=spikename11) spike12 = Spike(spikedata12, t_stop=100*pq.s, name=spikename12) spike21 = Spike(spikedata21, t_stop=100*pq.s, name=spikename21) spike22 = Spike(spikedata22, t_stop=100*pq.s, name=spikename22) self.spike1 = [spike11, spike12] self.spike2 = [spike21, spike22] self.spike = [spike11, spike12, spike21, spike22] def setup_spiketrains(self): trainname11 = 'spiketrain 1 1' trainname12 = 'spiketrain 1 2' trainname21 = 'spiketrain 2 1' trainname22 = 'spiketrain 2 2' traindata11 = np.arange(0, 10) * pq.ms traindata12 = np.arange(10, 20) * pq.ms traindata21 = np.arange(20, 30) * pq.s traindata22 = np.arange(30, 40) * pq.s self.trainnames1 = [trainname11, trainname12] self.trainnames2 = [trainname21, trainname22] self.trainnames = [trainname11, trainname12, trainname21, trainname22] train11 = SpikeTrain(traindata11, t_stop=100*pq.s, name=trainname11) train12 = SpikeTrain(traindata12, t_stop=100*pq.s, name=trainname12) train21 = SpikeTrain(traindata21, t_stop=100*pq.s, name=trainname21) train22 = SpikeTrain(traindata22, t_stop=100*pq.s, name=trainname22) self.train1 = [train11, train12] self.train2 = [train21, train22] self.train = [train11, train12, train21, train22] def test_init(self): seg = Segment(name='a segment', index=3) assert_neo_object_is_compliant(seg) self.assertEqual(seg.name, 'a segment') self.assertEqual(seg.file_origin, None) self.assertEqual(seg.index, 3) def test__construct_subsegment_by_unit(self): nb_seg = 3 nb_unit = 7 unit_with_sig = np.array([0, 2, 5]) signal_types = ['Vm', 'Conductances'] sig_len = 100 #recordingchannelgroups rcgs = [RecordingChannelGroup(name='Vm', channel_indexes=unit_with_sig), RecordingChannelGroup(name='Conductance', channel_indexes=unit_with_sig)] # Unit all_unit = [] for u in range(nb_unit): un = Unit(name='Unit #%d' % u, channel_indexes=np.array([u])) assert_neo_object_is_compliant(un) all_unit.append(un) blk = Block() blk.recordingchannelgroups = rcgs for s in range(nb_seg): seg = Segment(name='Simulation %s' % s) for j in range(nb_unit): st = SpikeTrain([1, 2, 3], units='ms', t_start=0., t_stop=10) st.unit = all_unit[j] for t in signal_types: anasigarr = AnalogSignalArray(np.zeros((sig_len, len(unit_with_sig))), units='nA', sampling_rate=1000.*pq.Hz, channel_indexes=unit_with_sig) seg.analogsignalarrays.append(anasigarr) blk.create_many_to_one_relationship() for unit in all_unit: assert_neo_object_is_compliant(unit) for rcg in rcgs: assert_neo_object_is_compliant(rcg) assert_neo_object_is_compliant(blk) # what you want newseg = seg.construct_subsegment_by_unit(all_unit[:4]) assert_neo_object_is_compliant(newseg) def test_segment_creation(self): assert_neo_object_is_compliant(self.segment1) assert_neo_object_is_compliant(self.segment2) assert_neo_object_is_compliant(self.unit1) assert_neo_object_is_compliant(self.unit2) self.assertEqual(self.segment1.name, 'test') self.assertEqual(self.segment2.name, 'test') self.assertEqual(self.segment1.description, 'tester 1') self.assertEqual(self.segment2.description, 'tester 2') self.assertEqual(self.segment1.file_origin, 'test.file') self.assertEqual(self.segment2.file_origin, 'test.file') self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3]) self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3]) self.assertEqual(self.segment1.annotations['testarg1'], 1.1) self.assertEqual(self.segment2.annotations['testarg1'], 1) self.assertEqual(self.segment2.annotations['testarg11'], 1.1) self.assertEqual(self.segment1.annotations['testarg2'], 'yes') self.assertEqual(self.segment2.annotations['testarg2'], 'yes') self.assertTrue(self.segment1.annotations['testarg3']) self.assertTrue(self.segment2.annotations['testarg3']) self.assertTrue(hasattr(self.segment1, 'analogsignals')) self.assertTrue(hasattr(self.segment2, 'analogsignals')) self.assertEqual(len(self.segment1.analogsignals), 2) self.assertEqual(len(self.segment2.analogsignals), 2) for res, targ in zip(self.segment1.analogsignals, self.sig1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignals, self.sig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'analogsignalarrays')) self.assertTrue(hasattr(self.segment2, 'analogsignalarrays')) self.assertEqual(len(self.segment1.analogsignalarrays), 2) self.assertEqual(len(self.segment2.analogsignalarrays), 3) for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epochs')) self.assertTrue(hasattr(self.segment2, 'epochs')) self.assertEqual(len(self.segment1.epochs), 2) self.assertEqual(len(self.segment2.epochs), 2) for res, targ in zip(self.segment1.epochs, self.epoch1): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epochs, self.epoch2): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epocharrays')) self.assertTrue(hasattr(self.segment2, 'epocharrays')) self.assertEqual(len(self.segment1.epocharrays), 2) self.assertEqual(len(self.segment2.epocharrays), 2) for res, targ in zip(self.segment1.epocharrays, self.epocharr1): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epocharrays, self.epocharr2): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'events')) self.assertTrue(hasattr(self.segment2, 'events')) self.assertEqual(len(self.segment1.events), 2) self.assertEqual(len(self.segment2.events), 2) for res, targ in zip(self.segment1.events, self.event1): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.events, self.event2): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'eventarrays')) self.assertTrue(hasattr(self.segment2, 'eventarrays')) self.assertEqual(len(self.segment1.eventarrays), 2) self.assertEqual(len(self.segment2.eventarrays), 2) for res, targ in zip(self.segment1.eventarrays, self.eventarr1): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.eventarrays, self.eventarr2): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals')) self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals')) self.assertEqual(len(self.segment1.irregularlysampledsignals), 2) self.assertEqual(len(self.segment2.irregularlysampledsignals), 2) for res, targ in zip(self.segment1.irregularlysampledsignals, self.irsig1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.irregularlysampledsignals, self.irsig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spikes')) self.assertTrue(hasattr(self.segment2, 'spikes')) self.assertEqual(len(self.segment1.spikes), 2) self.assertEqual(len(self.segment2.spikes), 2) for res, targ in zip(self.segment1.spikes, self.spike1): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spikes, self.spike2): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spiketrains')) self.assertTrue(hasattr(self.segment2, 'spiketrains')) self.assertEqual(len(self.segment1.spiketrains), 2) self.assertEqual(len(self.segment2.spiketrains), 2) for res, targ in zip(self.segment1.spiketrains, self.train1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spiketrains, self.train2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_merge(self): self.segment1.merge(self.segment2) self.segment1.create_many_to_one_relationship(force=True) assert_neo_object_is_compliant(self.segment1) self.assertEqual(self.segment1.name, 'test') self.assertEqual(self.segment2.name, 'test') self.assertEqual(self.segment1.description, 'tester 1') self.assertEqual(self.segment2.description, 'tester 2') self.assertEqual(self.segment1.file_origin, 'test.file') self.assertEqual(self.segment2.file_origin, 'test.file') self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3]) self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3]) self.assertEqual(self.segment1.annotations['testarg1'], 1.1) self.assertEqual(self.segment2.annotations['testarg1'], 1) self.assertEqual(self.segment2.annotations['testarg11'], 1.1) self.assertEqual(self.segment1.annotations['testarg2'], 'yes') self.assertEqual(self.segment2.annotations['testarg2'], 'yes') self.assertTrue(self.segment1.annotations['testarg3']) self.assertTrue(self.segment2.annotations['testarg3']) self.assertTrue(hasattr(self.segment1, 'analogsignals')) self.assertTrue(hasattr(self.segment2, 'analogsignals')) self.assertEqual(len(self.segment1.analogsignals), 4) self.assertEqual(len(self.segment2.analogsignals), 2) for res, targ in zip(self.segment1.analogsignals, self.sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignals, self.sig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'analogsignalarrays')) self.assertTrue(hasattr(self.segment2, 'analogsignalarrays')) self.assertEqual(len(self.segment1.analogsignalarrays), 4) self.assertEqual(len(self.segment2.analogsignalarrays), 3) for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epochs')) self.assertTrue(hasattr(self.segment2, 'epochs')) self.assertEqual(len(self.segment1.epochs), 4) self.assertEqual(len(self.segment2.epochs), 2) for res, targ in zip(self.segment1.epochs, self.epoch): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epochs, self.epoch2): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epocharrays')) self.assertTrue(hasattr(self.segment2, 'epocharrays')) self.assertEqual(len(self.segment1.epocharrays), 4) self.assertEqual(len(self.segment2.epocharrays), 2) for res, targ in zip(self.segment1.epocharrays, self.epocharr): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epocharrays, self.epocharr2): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'events')) self.assertTrue(hasattr(self.segment2, 'events')) self.assertEqual(len(self.segment1.events), 4) self.assertEqual(len(self.segment2.events), 2) for res, targ in zip(self.segment1.events, self.event): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.events, self.event2): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'eventarrays')) self.assertTrue(hasattr(self.segment2, 'eventarrays')) self.assertEqual(len(self.segment1.eventarrays), 4) self.assertEqual(len(self.segment2.eventarrays), 2) for res, targ in zip(self.segment1.eventarrays, self.eventarr): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.eventarrays, self.eventarr2): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals')) self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals')) self.assertEqual(len(self.segment1.irregularlysampledsignals), 4) self.assertEqual(len(self.segment2.irregularlysampledsignals), 2) for res, targ in zip(self.segment1.irregularlysampledsignals, self.irsig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.irregularlysampledsignals, self.irsig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spikes')) self.assertTrue(hasattr(self.segment2, 'spikes')) self.assertEqual(len(self.segment1.spikes), 4) self.assertEqual(len(self.segment2.spikes), 2) for res, targ in zip(self.segment1.spikes, self.spike): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spikes, self.spike2): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spiketrains')) self.assertTrue(hasattr(self.segment2, 'spiketrains')) self.assertEqual(len(self.segment1.spiketrains), 4) self.assertEqual(len(self.segment2.spiketrains), 2) for res, targ in zip(self.segment1.spiketrains, self.train): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spiketrains, self.train2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_all_data(self): result1 = self.segment1.all_data targs = (self.epoch1 + self.epocharr1 + self.event1 + self.eventarr1 + self.sig1 + self.sigarr1 + self.irsig1 + self.spike1 + self.train1) for res, targ in zip(result1, targs): if hasattr(res, 'ndim') and res.ndim: assert_arrays_equal(res, targ) else: self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_spikes_by_unit(self): result1 = self.segment1.take_spikes_by_unit() result21 = self.segment1.take_spikes_by_unit([self.unit1]) result22 = self.segment1.take_spikes_by_unit([self.unit2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.unit1spike): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.unit2spike): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_spiketrains_by_unit(self): result1 = self.segment1.take_spiketrains_by_unit() result21 = self.segment1.take_spiketrains_by_unit([self.unit1]) result22 = self.segment1.take_spiketrains_by_unit([self.unit2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.unit1train): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.unit2train): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_analogsignal_by_unit(self): result1 = self.segment1.take_analogsignal_by_unit() result21 = self.segment1.take_analogsignal_by_unit([self.unit1]) result22 = self.segment1.take_analogsignal_by_unit([self.unit2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.chan1sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.chan2sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_analogsignal_by_channelindex(self): result1 = self.segment1.take_analogsignal_by_channelindex() result21 = self.segment1.take_analogsignal_by_channelindex([1]) result22 = self.segment1.take_analogsignal_by_channelindex([2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.chan1sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.chan2sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_slice_of_analogsignalarray_by_unit(self): segment = self.segment1 unit1 = self.unit1 unit2 = self.unit2 result1 = segment.take_slice_of_analogsignalarray_by_unit() result21 = segment.take_slice_of_analogsignalarray_by_unit([unit1]) result22 = segment.take_slice_of_analogsignalarray_by_unit([unit2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.chan1sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.chan2sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_take_slice_of_analogsignalarray_by_channelindex(self): segment = self.segment1 result1 = segment.take_slice_of_analogsignalarray_by_channelindex() result21 = segment.take_slice_of_analogsignalarray_by_channelindex([1]) result22 = segment.take_slice_of_analogsignalarray_by_channelindex([2]) self.assertEqual(result1, []) for res, targ in zip(result21, self.chan1sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(result22, self.chan2sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) def test_segment_size(self): result1 = self.segment1.size() targ1 = {"epochs": 2, "events": 2, "analogsignals": 2, "irregularlysampledsignals": 2, "spikes": 2, "spiketrains": 2, "epocharrays": 2, "eventarrays": 2, "analogsignalarrays": 2} self.assertEqual(result1, targ1) def test_segment_filter(self): result1 = self.segment1.filter() result2 = self.segment1.filter(name='analogsignal 1 1') result3 = self.segment1.filter(testattr=True) self.assertEqual(result1, []) self.assertEqual(len(result2), 1) assert_arrays_equal(result2[0], self.sig1[0]) self.assertEqual(len(result3), 2) self.assertEqual(result3[0], self.epoch1[0]) self.assertEqual(result3[1], self.event1[0]) def test__children(self): blk = Block(name='block1') blk.segments = [self.segment1] blk.create_many_to_one_relationship() self.assertEqual(self.segment1._container_child_objects, ()) self.assertEqual(self.segment1._data_child_objects, ('AnalogSignal', 'AnalogSignalArray', 'Epoch', 'EpochArray', 'Event', 'EventArray', 'IrregularlySampledSignal', 'Spike', 'SpikeTrain')) self.assertEqual(self.segment1._single_parent_objects, ('Block',)) self.assertEqual(self.segment1._multi_child_objects, ()) self.assertEqual(self.segment1._multi_parent_objects, ()) self.assertEqual(self.segment1._child_properties, ()) self.assertEqual(self.segment1._single_child_objects, ('AnalogSignal', 'AnalogSignalArray', 'Epoch', 'EpochArray', 'Event', 'EventArray', 'IrregularlySampledSignal', 'Spike', 'SpikeTrain')) self.assertEqual(self.segment1._container_child_containers, ()) self.assertEqual(self.segment1._data_child_containers, ('analogsignals', 'analogsignalarrays', 'epochs', 'epocharrays', 'events', 'eventarrays', 'irregularlysampledsignals', 'spikes', 'spiketrains')) self.assertEqual(self.segment1._single_child_containers, ('analogsignals', 'analogsignalarrays', 'epochs', 'epocharrays', 'events', 'eventarrays', 'irregularlysampledsignals', 'spikes', 'spiketrains')) self.assertEqual(self.segment1._single_parent_containers, ('block',)) self.assertEqual(self.segment1._multi_child_containers, ()) self.assertEqual(self.segment1._multi_parent_containers, ()) self.assertEqual(self.segment1._child_objects, ('AnalogSignal', 'AnalogSignalArray', 'Epoch', 'EpochArray', 'Event', 'EventArray', 'IrregularlySampledSignal', 'Spike', 'SpikeTrain')) self.assertEqual(self.segment1._child_containers, ('analogsignals', 'analogsignalarrays', 'epochs', 'epocharrays', 'events', 'eventarrays', 'irregularlysampledsignals', 'spikes', 'spiketrains')) self.assertEqual(self.segment1._parent_objects, ('Block',)) self.assertEqual(self.segment1._parent_containers, ('block',)) self.assertEqual(len(self.segment1.children), (len(self.sig1) + len(self.sigarr1) + len(self.epoch1) + len(self.epocharr1) + len(self.event1) + len(self.eventarr1) + len(self.irsig1) + len(self.spike1) + len(self.train1))) self.assertEqual(self.segment1.children[0].name, self.signames1[0]) self.assertEqual(self.segment1.children[1].name, self.signames1[1]) self.assertEqual(self.segment1.children[2].name, self.sigarrnames1[0]) self.assertEqual(self.segment1.children[3].name, self.sigarrnames1[1]) self.assertEqual(self.segment1.children[4].name, self.epochnames1[0]) self.assertEqual(self.segment1.children[5].name, self.epochnames1[1]) self.assertEqual(self.segment1.children[6].name, self.epocharrnames1[0]) self.assertEqual(self.segment1.children[7].name, self.epocharrnames1[1]) self.assertEqual(self.segment1.children[8].name, self.eventnames1[0]) self.assertEqual(self.segment1.children[9].name, self.eventnames1[1]) self.assertEqual(self.segment1.children[10].name, self.eventarrnames1[0]) self.assertEqual(self.segment1.children[11].name, self.eventarrnames1[1]) self.assertEqual(self.segment1.children[12].name, self.irsignames1[0]) self.assertEqual(self.segment1.children[13].name, self.irsignames1[1]) self.assertEqual(self.segment1.children[14].name, self.spikenames1[0]) self.assertEqual(self.segment1.children[15].name, self.spikenames1[1]) self.assertEqual(self.segment1.children[16].name, self.trainnames1[0]) self.assertEqual(self.segment1.children[17].name, self.trainnames1[1]) self.assertEqual(len(self.segment1.parents), 1) self.assertEqual(self.segment1.parents[0].name, 'block1') self.segment1.create_many_to_one_relationship() self.segment1.create_many_to_many_relationship() self.segment1.create_relationship() assert_neo_object_is_compliant(self.segment1)