def test_append_data(self): """Try appending data to existing NaN-padded event dataset""" # start over for appending data writer = nsdf.NSDFWriter(self.filepath, mode='a', dialect=nsdf.dialect.NANPADDED) source_ds = writer.mapping[nsdf.EVENT][self.popname] rate = 100.0 new_dlen = np.random.poisson(lam=rate, size=len(self.sources)) for ii, cell in enumerate(self.mdict['mitral_cells']): uid = cell.uid data = np.cumsum( np.random.exponential(scale=1.0 / rate, size=new_dlen[ii])) self.data_object.put_data(uid, data) writer.add_event_nan(source_ds, self.data_object) del writer with h5.File(self.filepath, 'r') as fd: dataset = fd['/data'][nsdf.EVENT][self.popname][self.varname] for ii, cell in enumerate(self.mdict['mitral_cells']): uid = cell.uid orig_data = self.data_object.get_data(uid) file_data = dataset[ii, self.dlen[ii]:self.dlen[ii] + new_dlen[ii]] nptest.assert_allclose(orig_data, file_data) nptest.assert_allclose(dataset[self.dlen[ii] + new_dlen[ii]:], np.nan) os.remove(self.filepath)
def setUp(self): self.mdict = create_ob_model_tree() self.filepath = '{}.h5'.format(self.id()) writer = nsdf.NSDFWriter(self.filepath, mode='w', dialect=nsdf.dialect.NANPADDED) writer.creator = ['Subhasis Ray'] writer.title = self.id() mitral_somata = [] for cell in self.mdict['mitral_cells']: for name, comp in list(cell.children.items()): if name == 'mc_0': mitral_somata.append(comp.uid) self.sources = mitral_somata self.popname = 'pop1' ds = writer.add_nonuniform_ds(self.popname, self.sources) rate = 100.0 self.dlen = np.random.poisson(lam=rate, size=len(self.sources)) self.data_object = nsdf.NonuniformData(name='Vm', unit='mV', tunit='ms') self.src_name_dict = {} for ii, uid in enumerate(mitral_somata): data = np.random.uniform(-65, -55, size=self.dlen[ii]) time = np.random.uniform(0, 1, size=self.dlen[ii]) self.data_object.put_data(uid, (data, time)) dd = writer.add_nonuniform_nan(ds, self.data_object)
def setUp(self): """Create a poisson spike train for each cell in mitral population and save the data as 1D event data""" self.mdict = create_ob_model_tree() self.filepath = '{}.h5'.format(self.id()) writer = nsdf.NSDFWriter(self.filepath, mode='w', dialect=nsdf.dialect.NANPADDED) writer.title = self.id() self.sources = [cell.uid for cell in self.mdict['mitral_cells']] self.popname = 'pop1' self.field = 'spike' self.unit = 's' self.varname = 'spike' ds = writer.add_event_ds(self.popname, self.sources) self.data_object = nsdf.EventData(self.varname, unit=self.unit, field=self.field) self.src_name_dict = {} rate = 100.0 self.dlen = np.random.poisson(lam=rate, size=len(self.sources)) for ii, cell in enumerate(self.mdict['mitral_cells']): uid = cell.uid data = np.cumsum( np.random.exponential(scale=1.0 / rate, size=self.dlen[ii])) self.data_object.put_data(uid, data) # this is not required to be cell.name, any valid hdf5 # name will do self.src_name_dict[uid] = cell.name dd = writer.add_event_nan(ds, self.data_object)
def test_append_data(self): """Try appending data to existing NaN-padded nonuniform dataset""" # start over for appending data writer = nsdf.NSDFWriter(self.filepath, mode='a', dialect=nsdf.dialect.NANPADDED) source_ds = writer.mapping[nsdf.NONUNIFORM][self.popname] self.assertTrue(nsdf.match_datasets(self.sources, source_ds)) rate = 100.0 new_dlen = np.random.poisson(lam=rate, size=len(self.sources)) for ii, uid in enumerate(self.sources): data = np.cumsum( np.random.exponential(scale=1.0 / rate, size=new_dlen[ii])) time = np.random.uniform(0, 1, size=new_dlen[ii]) self.data_object.put_data(uid, (data, time)) writer.add_nonuniform_nan(source_ds, self.data_object) del writer with h5.File(self.filepath, 'r') as fd: data_path = '/data/{}/{}/{}'.format(nsdf.NONUNIFORM, self.popname, self.data_object.name) dataset = fd[data_path] time_ds = dataset.dims[1]['time'] for ii, uid in enumerate(self.sources): orig_data, orig_time = self.data_object.get_data(uid) file_data = dataset[ii, self.dlen[ii]:self.dlen[ii] + new_dlen[ii]] nptest.assert_allclose(orig_data, file_data) nptest.assert_allclose(dataset[self.dlen[ii] + new_dlen[ii]:], np.nan) file_time = time_ds[ii, self.dlen[ii]:self.dlen[ii] + new_dlen[ii]] nptest.assert_allclose(orig_time, file_time) nptest.assert_allclose( time_ds[ii, self.dlen[ii] + new_dlen[ii]:], np.nan) os.remove(self.filepath)
def hh_compartment_with_channels(): filename = 'hh_compartment_with_channels.h5' compartment = nsdf.ModelComponent('compartment', uid=uuid1().hex) na_channel = nsdf.ModelComponent('NaChannel', uid=uuid1().hex, parent=compartment) k_channel = nsdf.ModelComponent('KChannel', uid=uuid1().hex, parent=compartment) writer = nsdf.NSDFWriter(filename, mode='w') writer.add_modeltree(compartment) source_ds = writer.add_static_ds(compartment.name, [compartment.uid]) # Add membrane resitance data_obj = nsdf.StaticData('Rm', unit='Mohm') data_obj.put_data(compartment.uid, 1e3) writer.add_static_data(source_ds, data_obj) # Add membrane capacitance data_obj = nsdf.StaticData('Cm', unit='pF') data_obj.put_data(compartment.uid, 0.9) writer.add_static_data(source_ds, data_obj) # Add leak reversal potential data_obj = nsdf.StaticData('Em', unit='mV') data_obj.put_data(compartment.uid, -65.0) writer.add_static_data(source_ds, data_obj) # Add membrane potential source_ds = writer.add_uniform_ds(compartment.name, [compartment.uid]) data_obj = nsdf.UniformData('Vm', unit='mV') data_obj.put_data(compartment.uid, np.random.uniform(low=-67.0, high=-63.0, size=100)) data_obj.set_dt(0.1, unit='ms') writer.add_uniform_data(source_ds, data_obj) source_ds = writer.add_uniform_ds('channel', [na_channel.uid, k_channel.uid]) data_obj = nsdf.UniformData('Ik', unit='nA', dt=0.1, tunit='ms') data_obj.update_source_data_dict([(na_channel.uid, ina), (k_channel.uid, ik)]) writer.add_uniform_data(source_ds, data_obj)
def setUp(self): self.mdict = create_ob_model_tree() self.filepath = '{}.h5'.format(self.id()) writer = nsdf.NSDFWriter(self.filepath, mode='w', dialect=nsdf.dialect.NUREGULAR) writer.title = self.id() mitral_somata = [] for cell in self.mdict['mitral_cells']: for name, comp in list(cell.children.items()): if name == 'mc_0': mitral_somata.append(comp.uid) self.popname = 'pop1' ds = writer.add_nonuniform_ds(self.popname, mitral_somata) self.dlen = 1000 self.data_object = nsdf.NonuniformRegularData(name='Vm', unit='mV', tunit='ms') self.data_object.set_times(np.random.uniform(0, 1, size=self.dlen)) self.src_name_dict = {} for ii, uid in enumerate(mitral_somata): data = np.random.uniform(-65, -55, size=self.dlen) self.data_object.put_data(uid, data) dd = writer.add_nonuniform_regular(ds, self.data_object)
def setUp(self): self.mdict = create_ob_model_tree() self.filepath = '{}.h5'.format(self.id()) writer = nsdf.NSDFWriter(self.filepath, mode='w', dialect=nsdf.dialect.VLEN) writer.title = self.id() mitral_somata = [] for cell in self.mdict['mitral_cells']: for name, comp in list(cell.children.items()): if name == 'mc_0': mitral_somata.append(comp.uid) self.popname = 'pop1' self.dlen = np.random.randint(10, 100, size=len(mitral_somata)) self.field = 'Vm' self.unit = 'mV' self.tunit = 's' self.varname = 'Vm' ds = writer.add_nonuniform_ds(self.popname, mitral_somata) # FIXME: vlen does not support float64 self.data_object = nsdf.NonuniformData(self.varname, unit=self.unit, field=self.field, tunit=self.tunit, dtype=np.float32) self.src_name_dict = {} for ii, uid in enumerate(mitral_somata): data = np.random.uniform(-65, -55, size=self.dlen[ii]) times = np.cumsum( np.random.exponential(scale=0.01, size=self.dlen[ii])) self.data_object.put_data(uid, (data, times)) dd = writer.add_nonuniform_vlen(ds, self.data_object)
def test_append_data(self): """Try appending data to existing nonuniform 1d datasets""" # start over for appending data writer = nsdf.NSDFWriter(self.filepath, mode='a') ds = writer.mapping[nsdf.NONUNIFORM][self.popname][ self.data_object.name] for uid in ds['source']: data = np.random.uniform(-65, -55, size=self.dlen) times = np.cumsum(np.random.exponential(scale=0.01, size=self.dlen)) self.data_object.put_data(uid, (data, times)) data = writer.add_nonuniform_1d(ds, self.data_object, self.src_name_dict) del writer with h5.File(self.filepath, 'r') as fd: nucontainer = fd['/data'][nsdf.NONUNIFORM] data_grp = nucontainer[self.popname][self.data_object.name] for dataset_name in data_grp: dataset = data_grp[dataset_name] srcuid = dataset.attrs['source'] nptest.assert_allclose( self.data_object.get_data(srcuid)[0], dataset[-self.dlen:]) ts = dataset.dims[0]['time'] nptest.assert_allclose( self.data_object.get_data(srcuid)[1], ts[-self.dlen:]) os.remove(self.filepath)
def setUp(self): self.mdict = create_ob_model_tree() self.filepath = '{}.h5'.format(self.id()) writer = nsdf.NSDFWriter(self.filepath, mode='w', dialect=nsdf.dialect.ONED) writer.title = self.id() mitral_somata = [] for cell in self.mdict['mitral_cells']: for name, comp in list(cell.children.items()): if name == 'mc_0': mitral_somata.append(comp.uid) self.popname = 'pop1' self.data_object = nsdf.NonuniformData('Vm', unit='mV', field='Vm', tunit='ms') ds = writer.add_nonuniform_ds_1d(self.popname, self.data_object.name, mitral_somata) self.dlen = 1000 self.src_name_dict = {} for ii, uid in enumerate(mitral_somata): data = np.random.uniform(-65, -55, size=self.dlen) times = np.cumsum(np.random.exponential(scale=0.01, size=self.dlen)) self.data_object.put_data(uid, (data, times)) self.src_name_dict[uid] = str('vm_{}'.format(ii)) dd = writer.add_nonuniform_1d(ds, self.data_object, self.src_name_dict)
def example(): directory = os.path.dirname(granule.__file__) current = os.getcwd() os.chdir(directory) start_time = datetime.now() granule.loadGran98NeuroML_L123(granule.filename) end_time = datetime.now() tvec = np.arange(0.0, granule.runtime, granule.plotdt) soma_path = '/cells[0]/Gran_0[0]/Soma_0[0]' ca = moose.element('{}/Gran_CaPool_98/data/somaCa'.format(soma_path)) vm = moose.element('{}/data[0]/somaVm[0]'.format(soma_path)) os.chdir(current) writer = nsdf.NSDFWriter('granulecell.h5', mode='w', compression='gzip') writer.add_model_filecontents([directory]) ca_data = nsdf.UniformData('Ca', unit='mM', dt=granule.plotdt, tunit='s') ca_data.put_data(soma_path, ca.vector) source_ds = writer.add_uniform_ds('GranuleSoma', [soma_path]) writer.add_uniform_data(source_ds, ca_data) vm_data = nsdf.UniformData('Vm', unit='V', dt=granule.plotdt, tunit='s') vm_data.put_data(soma_path, vm.vector) writer.add_uniform_data(source_ds, vm_data) writer.title = 'Sample NSDF file for olfactory bulb granule cell model' writer.description = 'This file stores the entire model' \ ' directory in `/model/filecontent`' writer.tstart = start_time writer.tend = end_time writer.creator = [os.environ['USER']] writer.contributor = ['Subhasis Ray', 'Aditya Gilra'] writer.license = 'CC BY-SA' writer.software = ['Python2.7', 'moose', 'nsdf python library'] writer.method = ['exponential Euler'] print 'Finished writing example NSDF file for GranuleCell demo'
def setUp(self): self.mdict = create_ob_model_tree() # self.mdict['model_tree'].print_tree() self.filepath = '{}.h5'.format(self.id()) writer = nsdf.NSDFWriter(self.filepath, mode='w', dialect=nsdf.dialect.ONED) writer.add_modeltree(self.mdict['model_tree']) # print '######## Model Tree ################' # writer.modelroot.print_tree() # print '========================' self.granule_somata = [] self.popname = 'pop0' for cell in self.mdict['granule_cells']: for name, comp in list(cell.children.items()): if name == 'gc_0': self.granule_somata.append(comp.uid) uds = writer.add_uniform_ds(self.popname, self.granule_somata) self.data_object = nsdf.UniformData('Vm', unit='mV', field='Vm') self.dlen = 5 for uid in self.granule_somata: self.data_object.put_data( uid, np.random.uniform(-65, -55, size=self.dlen)) self.data_object.set_dt(1e-4, 's') self.tstart = 0.0 data = writer.add_uniform_data(uds, self.data_object, tstart=self.tstart)
def create_example(): # First create the model tree model = nsdf.ModelComponent('LeisureCenter', uid=uuid1().hex) poolroom = nsdf.ModelComponent('PoolRoom', uid=uuid1().hex, parent=model) tables = [] balls = [] for ii in range(2): tables.append( nsdf.ModelComponent('table_{}'.format(ii), uid=uuid1().hex, parent=poolroom)) for jj in range(3): balls.append( nsdf.ModelComponent('ball_{}'.format(jj), uid=uuid1().hex, parent=tables[-1])) id_path_dict = model.get_id_path_dict() path_id_dict = {value: key for key, value in id_path_dict.items()} # Create the NSDF writer object writer = nsdf.NSDFWriter('poolroom.h5', mode='w') writer.add_modeltree(model) dataobj = nsdf.StaticData('area', unit='m^2') dataobj.put_data(poolroom.uid, [100.0]) source_ds = writer.add_static_ds('rooms', [poolroom.uid]) writer.add_static_data(source_ds, dataobj) source_ds = writer.add_static_ds('tables', [tab.uid for tab in tables]) dataobj = nsdf.StaticData('height', unit='m') for tab in tables: dataobj.put_data(tab.uid, 1.2) writer.add_static_data(source_ds, dataobj) source_ds = writer.add_nonuniform_ds_1d('tables', 'players', [tab.uid for tab in tables]) dataobj = nsdf.NonuniformData('players', unit='item', tunit='hour', dtype=np.int32) for tab in tables: times = np.cumsum(np.random.exponential(1 / 10.0, size=10)) dataobj.put_data(tab.uid, (np.random.randint(10, size=10), times)) writer.add_nonuniform_1d(source_ds, dataobj, {tab.uid: tab.name for tab in tables}) source_ds = writer.add_uniform_ds('balls', [ball.uid for ball in balls]) dataobj = nsdf.UniformData('x', unit='cm') for ball in balls: dataobj.put_data(ball.uid, np.random.rand(10) * 10) dataobj.set_dt(1e-2, 's') writer.add_uniform_data(source_ds, dataobj) source_ds = writer.add_event_ds_1d('balls', 'hit', [ball.uid for ball in balls]) dataobj = nsdf.EventData('hit', unit='s') source_name_dict = {} for ball in balls: source_name_dict[ball.uid] = '{}_{}'.format(ball.name, ball.uid) data = np.cumsum(np.random.exponential(1 / 100.0, size=10)) dataobj.put_data(ball.uid, data) writer.add_event_1d(source_ds, dataobj, source_name_dict)
def save_NSDF(cPlotDt, ePlotDt, voxel_val_dict, vox_info): #added by Chaitanya sys.path.append('../..') import nsdf chem_sources = [] writer = nsdf.NSDFWriter('moose_multi.h5', mode='w') data_obj = nsdf.UniformData('conc', unit='mM') for x in moose.wildcardFind('/graphs/chem/#[ISA=Table]'): chem_sources.append(x.name) data_obj.put_data(x.name, x.vector) chem_source_ds = writer.add_uniform_ds('chem', chem_sources) data_obj.set_dt(cPlotDt, unit='s') writer.add_uniform_data(chem_source_ds, data_obj) data_obj = nsdf.UniformData('Vm', unit='V') elec_sources = [] for x in moose.wildcardFind('/graphs/elec/#[ISA=Table]'): elec_sources.append(x.name) data_obj.put_data(x.name, x.vector) elec_source_ds = writer.add_uniform_ds('elec', elec_sources) data_obj.set_dt(ePlotDt, unit='s') writer.add_uniform_data(elec_source_ds, data_obj) data_obj = nsdf.UniformData('[Ca]', unit='mM') ca_sources = [] for x in moose.wildcardFind('/graphs/ca/#[ISA=Table]'): ca_sources.append(x.name) data_obj.put_data(x.name, x.vector) ca_source_ds = writer.add_uniform_ds('Ca', ca_sources) data_obj.set_dt(ePlotDt, unit='s') writer.add_uniform_data(ca_source_ds, data_obj) h5 = writer._fd #Falling back to using native h5py operations. Multidimensional uniform dataset. ds = h5.create_dataset('/data/uniform/chem/voxel', dtype=numpy.float32, shape=(vox_info[0], vox_info[1], len(voxel_val_dict))) idx = 0 label_list = [] for ii, jj in voxel_val_dict.iteritems(): ds[:, :, idx] = jj label_list.append(ii) idx += 1 label_ds = h5.create_dataset('/map/uniform/spine_vox', data=label_list) voxel_ds = h5.create_dataset('/map/uniform/vox_number', data=range(vox_info[0])) tie_data_map(ds, label_ds, 'source', axis=2) tie_data_map(ds, voxel_ds, 'voxel_number', axis=0) ds.attrs.create('dt', data=vox_info[2]) ds.attrs.create('field', data='conc') ds.attrs.create('tstart', data=0.0) ds.attrs.create('unit', data='mM') ds.attrs.create('timeunit', data='s')
def create_example(dialect=nsdf.dialect.ONED, simtime=10.0, dt=1e-4): """Create a sample NSDF file using the specified dialect. The file stores the model tree (down to single compartments) and spike times from all the cells, categorized into populations by celltype. Vm for 10% of the cells of each type as uniformly sampled data. """ start_time = datetime.now() writer = nsdf.NSDFWriter('traub_et_al_2005_{}.h5'.format(dialect), mode='w', dialect=dialect) print('Start add_modeltree') writer.add_modeltree(model) print('End add_modeltree') for celltype, cell_list in list(model.cells.items()): event_sources = [cell.compartments[cell.presyn - 1] \ for cell in cell_list] event_data = nsdf.EventData('spiketime', unit='s', dtype=FLOATDTYPE) for src in event_sources: num_spikes = np.random.randint(EVENT_MAX) times = np.cumsum(np.random.exponential(1 / 10.0, size=num_spikes)) times = times[times < simtime].copy() event_data.put_data(src.uid, times) if dialect in (nsdf.dialect.ONED, nsdf.dialect.NUREGULAR): event_ds = writer.add_event_ds_1d(celltype, 'spiketime', event_data.get_sources()) writer.add_event_1d(event_ds, event_data) else: event_ds = writer.add_event_ds(celltype, event_data.get_sources()) dialect_eventwriter_map[dialect](writer, event_ds, event_data) vm_sources = random.sample(event_sources, len(event_sources) // 10) vm_data = nsdf.UniformData('Vm', unit='V', field='Vm') vm_data.set_dt(dt, unit='s') for src in vm_sources: vm = np.random.uniform(-120e-3, 40e-3, size=int(simtime // dt)) vm_data.put_data(src.uid, vm) vm_ds = writer.add_uniform_ds(celltype, vm_data.get_sources()) writer.add_uniform_data(vm_ds, vm_data) end_time = datetime.now() writer.title = 'Sample NSDF file for Traub et al 2005 model' writer.description = 'This file uses {} dialect of NSDF'.format(dialect) writer.tstart = start_time writer.tend = end_time writer.creator = [os.environ['USER']] writer.license = 'CC BY-SA' writer.software = ['Python2.7', 'nsdf python library'] print('Finished writing example NSDF file for dialect {}'.format(dialect))
def benchmark_write_nanpadded(**kwargs): compression = kwargs.get('compression', '') filename = '{}_NAN_{}.h5'.format(DATAFILE.split('.')[0], compression) filepath = os.path.join(DATADIR, filename) writer = nsdf.NSDFWriter(filepath, mode='w', dialect=nsdf.dialect.VLEN, **kwargs) cont_rec_sources = writer.add_uniform_ds('continuous_recorded', ca_data.get_sources()) writer.add_uniform_data(cont_rec_sources, ca_data, fixed=True) writer.add_uniform_data(cont_rec_sources, Vm_data, fixed=True) spike_sources = writer.add_event_ds('all_cells', spike_data.get_sources()) writer.add_event_vlen(spike_sources, spike_data, fixed=True)
def benchmark_write_oned(**kwargs): """Write LFP, Vm, spike trains, and any other data.""" compression = kwargs.get('compression', '') filename = '{}_ONED_{}.h5'.format(DATAFILE.split('.')[0], compression) filepath = os.path.join(DATADIR, filename) writer = nsdf.NSDFWriter(filepath, mode='w', dialect=nsdf.dialect.ONED, **kwargs) cont_rec_sources = writer.add_uniform_ds('continuous_recorded', ca_data.get_sources()) writer.add_uniform_data(cont_rec_sources, ca_data) writer.add_uniform_data(cont_rec_sources, Vm_data) spike_sources = writer.add_event_ds_1d('all_cells', 'spike', spike_data.get_sources()) writer.add_event_1d(spike_sources, spike_data)
def test_append_data(self): """Try appending data to existing uniformly sampled dataset""" # start over for appending data writer = nsdf.NSDFWriter(self.filepath, mode='a') ds = writer.mapping['uniform'][self.popname] for uid in self.granule_somata: self.data_object.put_data( uid, np.random.uniform(-65, -55, size=self.dlen)) data = writer.add_uniform_data(ds, self.data_object) del writer with h5.File(self.filepath, 'r') as fd: uniform_container = fd['/data'][nsdf.UNIFORM] data = uniform_container[self.popname][self.data_object.name] for row, source in zip(data, data.dims[0]['source']): nptest.assert_allclose(row[-self.dlen:], self.data_object.get_data(source)) os.remove(self.filepath)
def hh_vm(): model = nsdf.ModelComponent('compartment') data_container = nsdf.UniformData('Vm', unit='mV', dt=0.1, tunit='ms') data_container.put_data(model.uid, vm_array) writer = nsdf.NSDFWriter('hh_vm.h5', mode='w') writer.set_properties({'title': 'Example Vm recording', 'creator': 'user', 'software': ['python2.7', 'python-nsdf-0.1'], 'method': ['np.random.rand'], 'description': 'Randomly generated Vm for a single' \ 'compartment', 'rights': 'CC-BY-SA', 'tstart': datetime.now(), 'tend': (datetime.now() + timedelta(seconds=3)), 'contributor': ['Chaitanya Chintaluri', 'Daniel Wocjcik', 'Upinder Bhalla']}) writer.add_modeltree(model) source_ds = writer.add_uniform_ds('compartment_population', [model.uid]) writer.add_uniform_data(source_ds, data_container)
def benchmark_write_oned_incremental(**kwargs): compression = kwargs.get('compression', '') prefix = DATAFILE.split('.')[0] filename = '{}_ONED_{}_incr.h5'.format(prefix, compression) filepath = os.path.join(DATADIR, filename) writer = nsdf.NSDFWriter(filepath, dialect=nsdf.dialect.ONED, mode='w', **kwargs) cont_src = writer.add_uniform_ds('continuous_recorded', ca_data.get_sources()) spike_sources = writer.add_event_ds_1d('all_cells', 'spike', spike_data.get_sources()) for ii in range( 0, int(DATA['simtime'] / DATA['dt'] + 0.5) + INCREMENTAL_STEP / 2, INCREMENTAL_STEP): ca_data_tmp = nsdf.UniformData(ca_data.name, unit=ca_data.unit, dt=ca_data.dt, tunit=ca_data.tunit) for src, data in ca_data.get_source_data_dict().items(): ca_data_tmp.put_data(src, data[ii:ii + INCREMENTAL_STEP]) writer.add_uniform_data(cont_src, ca_data_tmp) Vm_data_tmp = nsdf.UniformData(Vm_data.name, unit=Vm_data.unit, dt=Vm_data.dt, tunit=Vm_data.tunit) for src, data in Vm_data.get_source_data_dict().items(): Vm_data_tmp.put_data(src, data[ii:ii + INCREMENTAL_STEP]) writer.add_uniform_data(cont_src, Vm_data_tmp) tstart = ii * Vm_data.dt tend = (ii + INCREMENTAL_STEP) * Vm_data.dt spike_data_tmp = nsdf.EventData(spike_data.name, unit=spike_data.unit, dtype=spike_data.dtype) for src, data in spike_data.get_source_data_dict().items(): spike_data_tmp.put_data(src, data[(data >= tstart) & (data < tend)]) writer.add_event_1d(spike_sources, spike_data_tmp)
def hh_compartment(): filename = 'hh_compartment.h5' model = nsdf.ModelComponent('compartment', uid=uuid1().hex) writer = nsdf.NSDFWriter(filename, mode='w') writer.add_modeltree(model) source_ds = writer.add_static_ds(model.name, [model.uid]) # Add membrane resitance data_obj = nsdf.StaticData('Rm', unit='Mohm') data_obj.put_data(model.uid, 1e3) writer.add_static_data(source_ds, data_obj) # Add membrane capacitance data_obj = nsdf.StaticData('Cm', unit='pF') data_obj.put_data(model.uid, 0.9) writer.add_static_data(source_ds, data_obj) # Add leak reversal potential data_obj = nsdf.StaticData('Em', unit='mV') data_obj.put_data(model.uid, -65.0) writer.add_static_data(source_ds, data_obj) # Add membrane potential source_ds = writer.add_uniform_ds(model.name, [model.uid]) data_obj = nsdf.UniformData('Vm', unit='mV', dt=0.1, tunit='ms') data_obj.put_data(model.uid, vm_array) writer.add_uniform_data(source_ds, data_obj)
def test_append_data(self): """Try appending data to existing 1D event dataset""" # start over for appending data writer = nsdf.NSDFWriter(self.filepath, mode='a') ds = writer.mapping[nsdf.EVENT][self.popname][self.data_object.name] rate = 100.0 new_dlen = np.random.poisson(lam=rate, size=len(self.sources)) for ii, cell in enumerate(self.mdict['mitral_cells']): uid = cell.uid data = np.cumsum( np.random.exponential(scale=1.0 / rate, size=new_dlen[ii])) self.data_object.put_data(uid, data) writer.add_event_1d(ds, self.data_object, self.src_name_dict) del writer with h5.File(self.filepath, 'r') as fd: eventcontainer = fd['/data'][nsdf.EVENT] data_grp = eventcontainer[self.popname][self.data_object.name] for ii, cell in enumerate(self.mdict['mitral_cells']): uid = cell.uid dataset = data_grp[cell.name] nptest.assert_allclose(self.data_object.get_data(uid), dataset[self.dlen[ii]:]) os.remove(self.filepath)
def test_append_data(self): """Try appending data to existing nonuniformly sampled vlen dataset""" # start over for appending data writer = nsdf.NSDFWriter(self.filepath, mode='a', dialect=nsdf.dialect.VLEN) ds = writer.mapping[nsdf.NONUNIFORM][self.popname] dlen = np.random.randint(10, 100, size=ds.shape[0]) for iii, uid in enumerate(ds): data = np.random.uniform(-65, -55, size=dlen[iii]) times = np.cumsum(np.random.exponential(scale=0.01, size=dlen[iii])) self.data_object.put_data(uid, (data, times)) data = writer.add_nonuniform_vlen(ds, self.data_object) del writer with h5.File(self.filepath, 'r') as fd: ds = fd['map'][nsdf.NONUNIFORM][self.popname] dataset = fd['/data'][nsdf.NONUNIFORM][self.popname][self.varname] ts = dataset.dims[0]['time'] for iii, source in enumerate(ds): data, times = self.data_object.get_data(source) nptest.assert_allclose(data, dataset[iii][-len(data):]) nptest.assert_allclose(times, ts[iii][-len(data):]) os.remove(self.filepath)
def _init_writing(self): return nsdf.NSDFWriter(self.filename, mode='w')
def create_test_data_file(filename, dialect): """Create a datafile at path `filename` using dialect `dialect`. """ tstart = datetime.now() mdict = create_ob_model_tree() uniform_data = nsdf.UniformData('Vm', unit='mV', field='Vm', dt=1e-2, tunit='ms') for cell in mdict['granule_cells']: uniform_data.put_data(cell.children['gc_0'].uid, np.random.uniform(-63, -57, 100)) if dialect == nsdf.dialect.NUREGULAR: size = 150 nonuniform_data = nsdf.NonuniformRegularData('Im', unit='pA', field='Im', tunit='ms') nonuniform_data.set_times(np.cumsum(np.random.rand(size))) for ii, cell in enumerate(mdict['mitral_cells']): nonuniform_data.put_data(cell.children['mc_0'].uid, np.random.rand(size)) else: nonuniform_data = nsdf.NonuniformData('Im', unit='pA', field='Im', tunit='ms', dtype=np.float32) sizes = 150 + np.random.randint(-50, 50, len(mdict['mitral_cells'])) for ii, cell in enumerate(mdict['mitral_cells']): data = np.random.rand(sizes[ii]) times = np.cumsum(np.random.rand(sizes[ii])) assert len(data) == len(times) nonuniform_data.put_data(cell.children['mc_0'].uid, (data, times)) sizes = 200 + np.random.randint(-50, 50, len(mdict['cells'])) event_data = nsdf.EventData('spike', unit='ms', dtype=np.float32) for ii, cell in enumerate(mdict['cells']): times = np.cumsum(np.random.exponential(scale=0.01, size=sizes[ii])) event_data.put_data(cell.uid, times) writer = nsdf.NSDFWriter(filename, dialect=dialect, mode='w') writer.add_modeltree(mdict['model_tree']) uniform_ds = writer.add_uniform_ds('granule', uniform_data.get_sources()) writer.add_uniform_data(uniform_ds, uniform_data) if dialect == nsdf.dialect.ONED: nonuniform_ds = writer.add_nonuniform_ds_1d( 'mitral', 'Im', nonuniform_data.get_sources()) else: nonuniform_ds = writer.add_nonuniform_ds('mitral', nonuniform_data.get_sources()) if (dialect == nsdf.dialect.ONED) or (dialect == nsdf.dialect.NUREGULAR): event_ds = writer.add_event_ds_1d('cells', 'spike', event_data.get_sources()) else: event_ds = writer.add_event_ds('cells', event_data.get_sources()) if dialect == nsdf.dialect.ONED: writer.add_nonuniform_1d(nonuniform_ds, nonuniform_data) writer.add_event_1d(event_ds, event_data) elif dialect == nsdf.dialect.NUREGULAR: writer.add_nonuniform_regular(nonuniform_ds, nonuniform_data) writer.add_event_1d(event_ds, event_data) elif dialect == nsdf.dialect.VLEN: writer.add_nonuniform_vlen(nonuniform_ds, nonuniform_data) writer.add_event_vlen(event_ds, event_data) elif dialect == nsdf.dialect.NANPADDED: writer.add_nonuniform_nan(nonuniform_ds, nonuniform_data) writer.add_event_nan(event_ds, event_data) else: raise Exception('unknown dialect: {}'.format(dialect)) tend = datetime.now() description = 'Testing nsdf reader' title = 'NSDFReader.test' creator = ['Subhasis Ray'] contributor = ['Chaitanya Chintaluri', 'Daniel Wojcik', 'Upinder Bhalla'] software = ['Python'] method = ['manual'] license = 'CC-BY-SA' rights = 'Subhasis Ray, 2014' writer.tstart = tstart writer.tend = tend writer.title = title writer.creator = creator writer.description = description writer.contributor = contributor writer.software = software writer.method = method writer.rights = rights writer.license = license return { 'uniform_data': uniform_data, 'nonuniform_data': nonuniform_data, 'event_data': event_data, 'title': title, 'creator': creator, 'contributor': contributor, 'software': software, 'tstart': tstart, 'tend': tend, 'description': description, 'method': method, 'rights': rights, 'license': license, }
morp_dset[:, 'y1'] = loc_array[:, 5] morp_dset[:, 'z1'] = loc_array[:, 6] morp_dset[:, 'd1'] = loc_array[:, 7] morp_dset.attrs.create( 'unit', ['um', 'um', 'um', 'um', 'um', 'um', 'um', 'um']) morp_dset.attrs.create( 'field', ['x0', 'y0', 'z0', 'd0', 'x1', 'y1', 'z1', 'd1']) morp_names = h5.create_dataset('/map/static/Hay', data=loc_names) tie_data_map(morp_dset, morp_names, 'source', 0) elif dump_type == 2: sys.path.append('../../') import nsdf writer = nsdf.NSDFWriter('hay_currents_nsdf.h5', mode='w') curr_source_ds = writer.add_uniform_ds('hay_currs', i_cp_names) data_obj_1 = nsdf.UniformData('i', unit='nA') data_obj_2 = nsdf.UniformData('i_pas', unit='nA') data_obj_3 = nsdf.UniformData('i_cap', unit='nA') data_obj_4 = nsdf.UniformData('i_ca', unit='nA') data_obj_5 = nsdf.UniformData('i_na', unit='nA') data_obj_6 = nsdf.UniformData('i_k', unit='nA') data_obj_7 = nsdf.UniformData('i_ih', unit='nA') for ii, source in enumerate(i_cp_names): data_obj_1.put_data(source, total_hdf5[ii]) data_obj_2.put_data(source, i_pas_hdf5[ii]) data_obj_3.put_data(source, i_cap_hdf5[ii]) data_obj_4.put_data(source, i_ca_hdf5[ii]) data_obj_5.put_data(source, i_na_hdf5[ii])