def create_startingtime_series(fname, name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("starting time test")
settings["mode"] = "w"
settings["description"] = "time series starting time test"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
# stime = neurodata.create_timeseries("TimeSeries", name, target)
# stime.set_data([0, 1, 2, 3], unit="n/a", conversion=1, resolution=1)
# stime.set_value("num_samples", 4)
# stime.set_time_by_rate(0.125, 2)
#
stime = f.make_group("<TimeSeries>", name, path=target)
stime.set_dataset("data", [0, 1, 2, 3], attrs={"unit": "n/a",
"conversion":1, "resolution": 1})
stime.set_dataset("num_samples", 4)
# stime.set_time_by_rate(0.125, 2)
stime.set_dataset("starting_time", 0.125, attrs={ "rate":2, "unit":"Seconds"})
# stime.finalize()
# neurodata.close()
f.close()
def create_notime_series(fname, name, target):
settings = {}
# settings["filename"] = fname
settings["file_name"] = fname
# settings["identifier"] = nwb.create_identifier("notime example")
settings["identifier"] = utils.create_identifier("notime example")
# settings["overwrite"] = True
settings["mode"] = "w"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["description"] = "Test no time"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
# notime = neurodata.create_timeseries("TimeSeries", name, target)
# notime.ignore_time()
# notime.set_data([0], unit="n/a", conversion=1, resolution=1)
notime = f.make_group("<TimeSeries>", name, path=target)
# following used for testing more missing_fields
# notime = f.make_group("<VoltageClampSeries>", name, path=target)
notime.set_dataset("data", [0], attrs={"unit":"n/a",
"conversion":1, "resolution":1})
#
# notime.finalize()
# neurodata.close()
f.close()
def create_general_optogen(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier(
"metadata optogenetic test")
settings["mode"] = "w"
settings["description"] = "test elements in /general/optogentics"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# neurodata.set_metadata(OPTOGEN_CUSTOM("optogen_custom"), "OPTOGEN_CUSTOM")
# #
# neurodata.set_metadata(OPTOGEN_SITE_DESCRIPTION("p1"), "DESCRIPTION")
# neurodata.set_metadata(OPTOGEN_SITE_DEVICE("p1"), "DEVICE")
# neurodata.set_metadata(OPTOGEN_SITE_LAMBDA("p1"), "LAMBDA")
# neurodata.set_metadata(OPTOGEN_SITE_LOCATION("p1"), "LOCATION")
# neurodata.set_metadata(OPTOGEN_SITE_CUSTOM("p1", "optogen_site_custom"), "OPTOGEN_SITE_CUSTOM")
#
g = f.make_group("optogenetics")
g.set_custom_dataset("optogen_custom", "OPTOGEN_CUSTOM")
p1 = g.make_group("<site_X>", "p1")
p1.set_dataset("description", "DESCRIPTION")
p1.set_dataset("device", "DEVICE")
p1.set_dataset("excitation_lambda", "EXCITATION_LAMBDA")
p1.set_dataset("location", "LOCATION")
p1.set_custom_dataset("optogen_site_custom", "OPTOGEN_SITE_CUSTOM")
# neurodata.close()
f.close()
def create_iface_series(fname, newfile):
settings = {}
settings["file_name"] = fname
settings["verbosity"] = "none"
if newfile:
settings["identifier"] = utils.create_identifier("interface timeseries example")
settings["mode"] = "w"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["description"] = "Test interface timeseries file"
else:
settings["mode"] = "r+"
f = nwb_file.open(**settings)
#
# mod = neurodata.create_module("test module")
# iface = mod.create_interface("BehavioralEvents")
# ts = neurodata.create_timeseries("TimeSeries", "Ones")
# ts.set_data(np.ones(10), unit="Event", conversion=1.0, resolution=float('nan'))
# ts.set_value("num_samples", 10)
# ts.set_time(np.arange(10))
# iface.add_timeseries(ts)
# iface.finalize()
# mod.finalize()
mod = f.make_group("<Module>", "test module")
iface = mod.make_group("BehavioralEvents")
ts = iface.make_group("<TimeSeries>", "Ones")
ts.set_dataset("data", np.ones(10), attrs={'unit':"Event",
"conversion":1.0, "resolution": float('nan')})
ts.set_dataset("num_samples", 10)
ts.set_dataset("timestamps",np.arange(10))
#
# neurodata.close()
f.close()
def create_general_subject(fname):
settings = {}
# settings["filename"] = fname
settings["file_name"] = fname
# settings["identifier"] = nwb.create_identifier("general top test")
settings["identifier"] = utils.create_identifier("general top test")
# settings["overwrite"] = True
settings["mode"] = "w"
settings["description"] = "test top-level elements in /general"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
# neurodata.set_metadata(SUBJECT, "SUBJECT")
# neurodata.set_metadata(SUBJECT_ID, "SUBJECT_ID")
# neurodata.set_metadata(SPECIES, "SPECIES")
# neurodata.set_metadata(GENOTYPE, "GENOTYPE")
# neurodata.set_metadata(SEX, "SEX")
# neurodata.set_metadata(AGE, "AGE")
# neurodata.set_metadata(WEIGHT, "WEIGHT")
#
g = f.make_group("subject")
g.set_dataset("description", "SUBJECT")
g.set_dataset("subject_id", "SUBJECT_ID")
g.set_dataset("species", "SPECIES")
g.set_dataset("genotype", "GENOTYPE")
g.set_dataset("sex", "SEX")
g.set_dataset("age", "AGE")
g.set_dataset("weight", "WEIGHT")
# neurodata.close()
f.close()
def create_general_optogen(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("metadata optogenetic test")
settings["mode"] = "w"
settings["description"] = "test elements in /general/optogentics"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# neurodata.set_metadata(OPTOGEN_CUSTOM("optogen_custom"), "OPTOGEN_CUSTOM")
# #
# neurodata.set_metadata(OPTOGEN_SITE_DESCRIPTION("p1"), "DESCRIPTION")
# neurodata.set_metadata(OPTOGEN_SITE_DEVICE("p1"), "DEVICE")
# neurodata.set_metadata(OPTOGEN_SITE_LAMBDA("p1"), "LAMBDA")
# neurodata.set_metadata(OPTOGEN_SITE_LOCATION("p1"), "LOCATION")
# neurodata.set_metadata(OPTOGEN_SITE_CUSTOM("p1", "optogen_site_custom"), "OPTOGEN_SITE_CUSTOM")
#
g = f.make_group("optogenetics")
g.set_custom_dataset("optogen_custom", "OPTOGEN_CUSTOM")
p1 = g.make_group("<site_X>", "p1")
p1.set_dataset("description","DESCRIPTION")
p1.set_dataset("device", "DEVICE")
p1.set_dataset("excitation_lambda","EXCITATION_LAMBDA")
p1.set_dataset("location", "LOCATION")
p1.set_custom_dataset("optogen_site_custom", "OPTOGEN_SITE_CUSTOM")
# neurodata.close()
f.close()
def write_block(self, block, **kwargs):
# todo: handle block.file_datetime, block.file_origin, block.index, block.annotations
if block.rec_datetime:
start_time = block.rec_datetime.isoformat()
else:
start_time = "unknown"
self._file = nwb_file.open(self.filename,
start_time=start_time,
mode="w",
identifier=block.name or "_neo",
description=block.description or "no description",
core_spec="nwb_core.py", extensions=self.extensions,
default_ns="core", keep_original=False, auto_compress=True)
for segment in block.segments:
self._write_segment(segment)
self._file.close()
if block.file_origin is None:
block.file_origin = self.filename
# The nwb module sets 'file_create_date' automatically. Here, if the block
# already contains a 'file_datetime', we wish to set that as the first entry
# in 'file_create_date'
self._file = h5py.File(self.filename, "r+")
nwb_create_date = self._file['file_create_date'].value
if block.file_datetime:
del self._file['file_create_date']
self._file['file_create_date'] = np.array([block.file_datetime.isoformat(), nwb_create_date])
else:
block.file_datetime = parse_datetime(nwb_create_date[0])
self._file.close()
def create_nodata_series(fname, name, target):
settings = {}
# settings["filename"] = fname
settings["file_name"] = fname
# settings["identifier"] = nwb.create_identifier("nodata example")
settings["identifier"] = utils.create_identifier("nodata example")
# settings["overwrite"] = True
settings["mode"] = "w"
settings["description"] = "time series no data test"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
# nodata = neurodata.create_timeseries("TimeSeries", name, target)
# nodata.ignore_data()
# nodata.set_time([0])
nodata = f.make_group("<TimeSeries>", name, path=target)
nodata.set_dataset("timestamps", [0])
#
# nodata.finalize()
# neurodata.close()
f.close()
def create_general_subject(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("general top test")
settings["mode"] = "w"
settings["description"] = "test top-level elements in /general"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
# neurodata.set_metadata(SUBJECT, "SUBJECT")
# neurodata.set_metadata(SUBJECT_ID, "SUBJECT_ID")
# neurodata.set_metadata(SPECIES, "SPECIES")
# neurodata.set_metadata(GENOTYPE, "GENOTYPE")
# neurodata.set_metadata(SEX, "SEX")
# neurodata.set_metadata(AGE, "AGE")
# neurodata.set_metadata(WEIGHT, "WEIGHT")
#
g = f.make_group("subject")
g.set_dataset("description", "SUBJECT")
g.set_dataset("subject_id", "SUBJECT_ID")
g.set_dataset("species", "SPECIES")
g.set_dataset("genotype", "GENOTYPE")
g.set_dataset("sex", "SEX")
g.set_dataset("age", "AGE")
g.set_dataset("weight", "WEIGHT")
# neurodata.close()
f.close()
def validate_file(name, core_spec="nwb_core.py", extensions=None, verbosity="all"):
"""
Parameters
----------
name: string
Name (including path) of file to be validated
core_spec: string (default: 'nwb_core.py')
Name of core specification file or '-' to load specification(s) from HDF5 file.
extensions: array
Array of extension files
verbosity: string (default: 'all')
Controls how much validation output is displayed. Options are:
'all', 'summary', and 'none'
Returns
-------
validation_result: dict
Result of validation. Has keys: 'errors', 'warnings', 'added' which
contain counts of errors, warnings and additions. Additions are groups,
datasets or attributes added which are not defined by the core_spec
specification.
"""
if extensions is None:
extensions = []
# to validate, open the file in read-only mode, then close it
f = nwb_file.open(name, mode="r", core_spec=core_spec, extensions=extensions, verbosity=verbosity)
validation_result = f.close()
return validation_result
def create_notime_series(fname, name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("notime example")
settings["mode"] = "w"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["description"] = "Test no time"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
# notime = neurodata.create_timeseries("TimeSeries", name, target)
# notime.ignore_time()
# notime.set_data([0], unit="n/a", conversion=1, resolution=1)
notime = f.make_group("<TimeSeries>", name, path=target)
# following used for testing more missing_fields
# notime = f.make_group("<VoltageClampSeries>", name, path=target)
notime.set_dataset("data", [0],
attrs={
"unit": "n/a",
"conversion": 1,
"resolution": 1
})
#
# notime.finalize()
# neurodata.close()
f.close()
def validate_file(name, core_spec="nwb_core.py", extensions=None, verbosity="all"):
"""
Parameters
----------
name: string
Name (including path) of file to be validated
core_spec: string (default: 'nwb_core.py')
Name of core specification file or '-' to load specification(s) from HDF5 file.
extensions: array
Array of extension files
verbosity: string (default: 'all')
Controls how much validation output is displayed. Options are:
'all', 'summary', and 'none'
Returns
-------
validation_result: dict
Result of validation. Has keys: 'errors', 'warnings', 'added' which
contain counts of errors, warnings and additions. Additions are groups,
datasets or attributes added which are not defined by the core_spec
specification.
"""
if extensions is None:
extensions = []
# to validate, open the file in read-only mode, then close it
f = nwb_file.open(name, mode="r", core_spec=core_spec, extensions=extensions, verbosity=verbosity)
validation_result = f.close()
return validation_result
def top_datasets(self, string, dict, project_dir):
dict["verbosity"] = "none"
if debug:
util.print_dict_keys(dict)
h5_object = nwb_file.open(**dict)
if verbose:
print "Creating partial NWB file: ", os.path.join(
project_dir, string + ".h5")
h5_object.close()
def create_isi_iface(fname, name):
settings = {}
# settings["filename"] = fname
settings["file_name"] = fname
# settings["identifier"] = nwb.create_identifier("reference image test")
settings["identifier"] = utils.create_identifier("reference image test")
# settings["overwrite"] = True
settings["mode"] = "w"
settings["description"] = "reference image test"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
# module = neurodata.create_module(name)
# iface = module.create_interface("ImagingRetinotopy")
# iface.add_axis_1_phase_map([[1.0, 1.1, 1.2],[2.0,2.1,2.2]], "altitude", .1, .1)
# iface.add_axis_2_phase_map([[3.0, 3.1, 3.2],[4.0,4.1,4.2]], "azimuth", .1, .1, unit="degrees")
# iface.add_axis_1_power_map([[0.1, 0.2, 0.3],[0.4, 0.5, 0.6]], .1, .1)
# iface.add_sign_map([[-.1, .2, -.3],[.4,-.5,.6]])
# iface.add_vasculature_image([[1,0,129],[2,144,0]], height=.22, width=.35)
# iface.add_focal_depth_image([[1,0,129],[2,144,0]], bpp=8)
# iface.finalize()
# module.finalize()
module = f.make_group("<Module>", name)
iface = module.make_group("ImagingRetinotopy")
# iface.add_axis_1_phase_map([[1.0, 1.1, 1.2],[2.0,2.1,2.2]], "altitude", .1, .1)
iface.set_dataset("axis_1_phase_map", [[1.0, 1.1, 1.2],[2.0,2.1,2.2]], attrs={
"dimension": [2,3], "field_of_view": [0.1, 0.1], "unit":"degrees"})
# iface.add_axis_2_phase_map([[3.0, 3.1, 3.2],[4.0,4.1,4.2]], "azimuth", .1, .1, unit="degrees")
iface.set_dataset("axis_2_phase_map", [[3.0, 3.1, 3.2],[4.0,4.1,4.2]], attrs={
"dimension": [2,3], "field_of_view": [0.1, 0.1], "unit":"degrees"})
iface.set_dataset("axis_descriptions", ["altitude", "azimuth"])
# iface.add_axis_1_power_map([[0.1, 0.2, 0.3],[0.4, 0.5, 0.6]], .1, .1)
iface.set_dataset("axis_1_power_map", [[0.1, 0.2, 0.3],[0.4, 0.5, 0.6]], attrs={
"dimension": [2,3], "field_of_view": [0.1, 0.1]})
# iface.add_sign_map([[-.1, .2, -.3],[.4,-.5,.6]])
iface.set_dataset("sign_map", [[-.1, .2, -.3],[.4,-.5,.6]], attrs={
"dimension": [2,3]})
# iface.add_vasculature_image([[1,0,129],[2,144,0]], height=.22, width=.35)
iface.set_dataset("vasculature_image", [[1,0,129],[2,144,0]], attrs={
"field_of_view":[0.22, 0.35], "bits_per_pixel":8, "dimension":[2,3], "format": "raw"})
# iface.add_focal_depth_image([[1,0,129],[2,144,0]], bpp=8)
iface.set_dataset("focal_depth_image", [[1,0,129],[2,144,0]], attrs={
"bits_per_pixel":8, "dimension":[2,3], "format": "raw"})
# iface.finalize()
# module.finalize()
# neurodata.close()
f.close()
def create_empty_file(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("UnitTimes example")
settings["mode"] = "w"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["description"] = "Test file with spike times in processing module"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
return f
def create_empty_file(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("UnitTimes example")
settings["mode"] = "w"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["description"] = "Test file with spike times in processing module"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
return f
def create_general_intra(fname):
settings = {}
# settings["filename"] = fname
settings["file_name"] = fname
# settings["identifier"] = nwb.create_identifier("general optophysiology test")
settings["identifier"] = utils.create_identifier("general optophysiology test")
# settings["overwrite"] = True
settings["mode"] = "w"
settings["description"] = "test elements in /general/optophysiology"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
#neurodata.set_metadata(IMAGE_CUSTOM("image_custom"), "IMAGE_CUSTOM")
g = f.make_group("optophysiology")
g.set_custom_dataset("image_custom", "IMAGE_CUSTOM")
#
# neurodata.set_metadata(IMAGE_SITE_DESCRIPTION("p1"), "DESCRIPTION")
p1 = g.make_group("<imaging_plane_X>", "p1")
p1.set_dataset("description", "DESCRIPTION")
# MANUAL CHECK
# try storing string - -type system should balk
#neurodata.set_metadata(IMAGE_SITE_MANIFOLD("p1"), "MANIFOLD")
# neurodata.set_metadata(IMAGE_SITE_MANIFOLD("p1"), [[[1,2,3],[2,3,4]],[[3,4,5],[4,5,6]]])
# neurodata.set_metadata(IMAGE_SITE_INDICATOR("p1"), "INDICATOR")
# neurodata.set_metadata(IMAGE_SITE_EXCITATION_LAMBDA("p1"), "EXCITATION_LAMBDA")
# neurodata.set_metadata(IMAGE_SITE_CHANNEL_LAMBDA("p1", "red"), "CHANNEL_LAMBDA")
# neurodata.set_metadata(IMAGE_SITE_CHANNEL_DESCRIPTION("p1", "red"), "DESCRIPTION")
# neurodata.set_metadata(IMAGE_SITE_CHANNEL_LAMBDA("p1", "green"), "CHANNEL_LAMBDA")
# neurodata.set_metadata(IMAGE_SITE_CHANNEL_DESCRIPTION("p1", "green"), "DESCRIPTION")
# neurodata.set_metadata(IMAGE_SITE_IMAGING_RATE("p1"), "IMAGING_RATE")
# neurodata.set_metadata(IMAGE_SITE_LOCATION("p1"), "LOCATION")
# neurodata.set_metadata(IMAGE_SITE_DEVICE("p1"), "DEVICE")
# neurodata.set_metadata(IMAGE_SITE_CUSTOM("p1", "image_site_custom"), "IMAGE_SITE_CUSTOM")
#
p1.set_dataset("manifold", [[[1,2,3],[2,3,4]],[[3,4,5],[4,5,6]]])
p1.set_dataset("indicator", "INDICATOR")
p1.set_dataset("excitation_lambda","EXCITATION_LAMBDA")
p1_red = p1.make_group("<channel_X>", "red")
p1_red.set_dataset("emission_lambda","CHANNEL_LAMBDA")
p1_red.set_dataset("description","DESCRIPTION")
p1_green = p1.make_group("<channel_X>", "green")
p1_green.set_dataset("emission_lambda","CHANNEL_LAMBDA")
p1_green.set_dataset("description","DESCRIPTION")
p1.set_dataset("imaging_rate", "IMAGING_RATE")
p1.set_dataset("location", "LOCATION")
p1.set_dataset("device", "DEVICE")
p1.set_custom_dataset("image_site_custom", "IMAGE_SITE_CUSTOM")
# neurodata.close()
f.close()
def create_refimage(fname, name):
settings = {}
settings["file_name"] = fname
settings["identifier"] = "vwx"
settings["mode"] = "w"
settings["description"] = "wxy"
settings["start_time"] = "xyz"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# neurodata.close()
f.close()
def create_refimage(fname, name):
settings = {}
settings["file_name"] = fname
settings["identifier"] = "vwx"
settings["mode"] = "w"
settings["description"] = "wxy"
settings["start_time"] = "xyz"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# neurodata.close()
f.close()
def create_linked_series(fname, root):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("link test")
settings["mode"] = "w"
settings["description"] = "time series link test"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["verbosity"] = "none"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
# first = neurodata.create_timeseries("TimeSeries", root+"1", "template")
# first.ignore_time()
# first.set_value("num_samples", 1)
# first.set_data([1], unit="parsec", conversion=1, resolution=1e-12)
# first.finalize()
#
first = f.make_group("<TimeSeries>", root+"1", path="/stimulus/templates")
# first.ignore_time()
# first.set_value("num_samples", 1)
first.set_dataset("num_samples", 1)
d1 = first.set_dataset("data", [1], attrs={"unit":"parsec", "conversion":1,
"resolution":1e-12})
# first.finalize()
# second = neurodata.create_timeseries("TimeSeries", root+"2", "stimulus")
# second.set_time([2])
# second.set_value("num_samples", 1)
# second.set_data_as_link(first)
# second.finalize()
#
second = f.make_group("<TimeSeries>", root+"2", path="/stimulus/presentation")
t2 = second.set_dataset("timestamps", [2])
second.set_dataset("num_samples", 1)
second.set_dataset("data", d1)
# third = neurodata.create_timeseries("TimeSeries", root+"3", "acquisition")
# third.set_time_as_link(second)
# third.set_value("num_samples", 1)
# third.set_data([3], unit="parsec", conversion=1, resolution=1e-9)
# third.finalize()
third = f.make_group("<TimeSeries>", root+"3", path="/acquisition/timeseries")
third.set_dataset("timestamps", t2)
third.set_dataset("num_samples", 1)
third.set_dataset("data", [3], attrs={"unit":"parsec", "conversion":1,
"resolution":1e-9})
#
# neurodata.close()
f.close()
def create_isi_iface(fname, name):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("reference image test")
settings["mode"] = "w"
settings["description"] = "reference image test"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# module = neurodata.create_module(name)
# iface = module.create_interface("ImagingRetinotopy")
# iface.add_axis_1_phase_map([[1.0, 1.1, 1.2],[2.0,2.1,2.2]], "altitude", .1, .1)
# iface.add_axis_2_phase_map([[3.0, 3.1, 3.2],[4.0,4.1,4.2]], "azimuth", .1, .1, unit="degrees")
# iface.add_axis_1_power_map([[0.1, 0.2, 0.3],[0.4, 0.5, 0.6]], .1, .1)
# iface.add_sign_map([[-.1, .2, -.3],[.4,-.5,.6]])
# iface.add_vasculature_image([[1,0,129],[2,144,0]], height=.22, width=.35)
# iface.add_focal_depth_image([[1,0,129],[2,144,0]], bpp=8)
# iface.finalize()
# module.finalize()
module = f.make_group("<Module>", name)
iface = module.make_group("ImagingRetinotopy")
# iface.add_axis_1_phase_map([[1.0, 1.1, 1.2],[2.0,2.1,2.2]], "altitude", .1, .1)
iface.set_dataset("axis_1_phase_map", [[1.0, 1.1, 1.2],[2.0,2.1,2.2]], attrs={
"dimension": [2,3], "field_of_view": [0.1, 0.1], "unit":"degrees"})
# iface.add_axis_2_phase_map([[3.0, 3.1, 3.2],[4.0,4.1,4.2]], "azimuth", .1, .1, unit="degrees")
iface.set_dataset("axis_2_phase_map", [[3.0, 3.1, 3.2],[4.0,4.1,4.2]], attrs={
"dimension": [2,3], "field_of_view": [0.1, 0.1], "unit":"degrees"})
iface.set_dataset("axis_descriptions", ["altitude", "azimuth"])
# iface.add_axis_1_power_map([[0.1, 0.2, 0.3],[0.4, 0.5, 0.6]], .1, .1)
iface.set_dataset("axis_1_power_map", [[0.1, 0.2, 0.3],[0.4, 0.5, 0.6]], attrs={
"dimension": [2,3], "field_of_view": [0.1, 0.1]})
# iface.add_sign_map([[-.1, .2, -.3],[.4,-.5,.6]])
iface.set_dataset("sign_map", [[-.1, .2, -.3],[.4,-.5,.6]], attrs={
"dimension": [2,3]})
# iface.add_vasculature_image([[1,0,129],[2,144,0]], height=.22, width=.35)
iface.set_dataset("vasculature_image", [[1,0,129],[2,144,0]], attrs={
"field_of_view":[0.22, 0.35], "bits_per_pixel":8, "dimension":[2,3], "format": "raw"})
# iface.add_focal_depth_image([[1,0,129],[2,144,0]], bpp=8)
iface.set_dataset("focal_depth_image", [[1,0,129],[2,144,0]], attrs={
"bits_per_pixel":8, "dimension":[2,3], "format": "raw"})
# iface.finalize()
# module.finalize()
# neurodata.close()
f.close()
def initialize_h5_object(self, h5_file, dict):
vargs = {"start_time" : 0.0, "description" : "default", \
"file_name" : h5_file, "identifier" : h5_file[0:-4], \
"mode" : "w", "verbosity" : "none"}
for k in ["start_time", "description", "identifier"]:
if k in dict.keys():
vargs[k] = dict[k]
if os.path.exists(h5_file):
os.remove(h5_file)
h5_object = nwb_file.open(**vargs)
return h5_object
def create_annotation_series(fname, name, target, newfile):
settings = {}
settings["file_name"] = fname
if newfile:
# settings["identifier"] = nwb.create_identifier("append example")
settings["identifier"] = utils.create_identifier("append example")
# settings["overwrite"] = True
settings["mode"] = "w"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["description"] = "Test append file"
else:
# settings["modify"] = True
settings["mode"] = "r+"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
# annot = neurodata.create_timeseries("AnnotationSeries", name, target)
annot = f.make_group("<AnnotationSeries>", name, path="/" + target)
# annot.set_description("This is an AnnotationSeries '%s' with sample data" % name)
# annot.set_comment("The comment and description fields can store arbitrary human-readable data")
# annot.set_source("Observation of Dr. J Doe")
annot.set_attr("description", "This is an AnnotationSeries '%s' with sample data" % name)
annot.set_attr("comments", "The comment and description fields can store arbitrary human-readable data")
annot.set_attr("source", "Observation of Dr. J Doe")
#
# annot.add_annotation("Rat in bed, beginning sleep 1", 15.0)
# annot.add_annotation("Rat placed in enclosure, start run 1", 933.0)
# annot.add_annotation("Rat taken out of enclosure, end run 1", 1456.0)
# annot.add_annotation("Rat in bed, start sleep 2", 1461.0)
# annot.add_annotation("Rat placed in enclosure, start run 2", 2401.0)
# annot.add_annotation("Rat taken out of enclosure, end run 2", 3210.0)
# annot.add_annotation("Rat in bed, start sleep 3", 3218.0)
# annot.add_annotation("End sleep 3", 4193.0)
#
andata = []
andata.append(("Rat in bed, beginning sleep 1", 15.0))
andata.append(("Rat placed in enclosure, start run 1", 933.0))
andata.append(("Rat taken out of enclosure, end run 1", 1456.0))
andata.append(("Rat in bed, start sleep 2", 1461.0))
andata.append(("Rat placed in enclosure, start run 2", 2401.0))
andata.append(("Rat taken out of enclosure, end run 2", 3210.0))
andata.append(("Rat in bed, start sleep 3", 3218.0))
andata.append(("End sleep 3", 4193.0))
annotations = [x[0] for x in andata]
times = [x[1] for x in andata]
annot.set_dataset("data",annotations)
annot.set_dataset("timestamps", times)
# annot.finalize()
# neurodata.close()
f.close()
def create_general_top(fname):
settings = {}
# settings["filename"] = fname
settings["file_name"] = fname
# settings["identifier"] = nwb.create_identifier("general top test")
settings["identifier"] = utils.create_identifier("general top test")
# settings["overwrite"] = True
settings["mode"] = "w"
settings["description"] = "test top-level elements in /general"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
# neurodata.set_metadata(DATA_COLLECTION, "DATA_COLLECTION")
# neurodata.set_metadata(EXPERIMENT_DESCRIPTION, "EXPERIMENT_DESCRIPTION")
# neurodata.set_metadata(EXPERIMENTER, "EXPERIMENTER")
# neurodata.set_metadata(INSTITUTION, "INSTITUTION")
# neurodata.set_metadata(LAB, "LAB")
# neurodata.set_metadata(NOTES, "NOTES")
# neurodata.set_metadata(PROTOCOL, "PROTOCOL")
# neurodata.set_metadata(PHARMACOLOGY, "PHARMACOLOGY")
# neurodata.set_metadata(RELATED_PUBLICATIONS, "RELATED_PUBLICATIONS")
# neurodata.set_metadata(SESSION_ID, "SESSION_ID")
# neurodata.set_metadata(SLICES, "SLICES")
# neurodata.set_metadata(STIMULUS, "STIMULUS")
# neurodata.set_metadata(SURGERY, "SURGERY")
# neurodata.set_metadata(VIRUS, "VIRUS")
# #
# neurodata.set_metadata_from_file("source_script", __file__)
#
f.set_dataset("data_collection","DATA_COLLECTION")
f.set_dataset("experiment_description","EXPERIMENT_DESCRIPTION")
f.set_dataset("experimenter","EXPERIMENTER")
f.set_dataset("institution","INSTITUTION")
f.set_dataset("lab","LAB")
f.set_dataset("notes","NOTES")
f.set_dataset("protocol","PROTOCOL")
f.set_dataset("pharmacology","PHARMACOLOGY")
f.set_dataset("related_publications", "RELATED_PUBLICATIONS")
f.set_dataset("session_id","SESSION_ID")
f.set_dataset("slices","SLICES")
f.set_dataset("stimulus","STIMULUS")
f.set_dataset("surgery","SURGERY")
f.set_dataset("virus", "VIRUS")
# f.neurodata.set_metadata_from_file("source_script", __file__)
f.set_dataset("source_script", utils.load_file(__file__))
# neurodata.close()
f.close()
def create_general_intra(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("general optophysiology test")
settings["mode"] = "w"
settings["description"] = "test elements in /general/optophysiology"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
#neurodata.set_metadata(IMAGE_CUSTOM("image_custom"), "IMAGE_CUSTOM")
g = f.make_group("optophysiology")
g.set_custom_dataset("image_custom", "IMAGE_CUSTOM")
#
# neurodata.set_metadata(IMAGE_SITE_DESCRIPTION("p1"), "DESCRIPTION")
p1 = g.make_group("<imaging_plane_X>", "p1")
p1.set_dataset("description", "DESCRIPTION")
# MANUAL CHECK
# try storing string - -type system should balk
#neurodata.set_metadata(IMAGE_SITE_MANIFOLD("p1"), "MANIFOLD")
# neurodata.set_metadata(IMAGE_SITE_MANIFOLD("p1"), [[[1,2,3],[2,3,4]],[[3,4,5],[4,5,6]]])
# neurodata.set_metadata(IMAGE_SITE_INDICATOR("p1"), "INDICATOR")
# neurodata.set_metadata(IMAGE_SITE_EXCITATION_LAMBDA("p1"), "EXCITATION_LAMBDA")
# neurodata.set_metadata(IMAGE_SITE_CHANNEL_LAMBDA("p1", "red"), "CHANNEL_LAMBDA")
# neurodata.set_metadata(IMAGE_SITE_CHANNEL_DESCRIPTION("p1", "red"), "DESCRIPTION")
# neurodata.set_metadata(IMAGE_SITE_CHANNEL_LAMBDA("p1", "green"), "CHANNEL_LAMBDA")
# neurodata.set_metadata(IMAGE_SITE_CHANNEL_DESCRIPTION("p1", "green"), "DESCRIPTION")
# neurodata.set_metadata(IMAGE_SITE_IMAGING_RATE("p1"), "IMAGING_RATE")
# neurodata.set_metadata(IMAGE_SITE_LOCATION("p1"), "LOCATION")
# neurodata.set_metadata(IMAGE_SITE_DEVICE("p1"), "DEVICE")
# neurodata.set_metadata(IMAGE_SITE_CUSTOM("p1", "image_site_custom"), "IMAGE_SITE_CUSTOM")
#
p1.set_dataset("manifold", [[[1,2,3],[2,3,4]],[[3,4,5],[4,5,6]]])
p1.set_dataset("indicator", "INDICATOR")
p1.set_dataset("excitation_lambda","EXCITATION_LAMBDA")
p1_red = p1.make_group("<channel_X>", "red")
p1_red.set_dataset("emission_lambda","CHANNEL_LAMBDA")
p1_red.set_dataset("description","DESCRIPTION")
p1_green = p1.make_group("<channel_X>", "green")
p1_green.set_dataset("emission_lambda","CHANNEL_LAMBDA")
p1_green.set_dataset("description","DESCRIPTION")
p1.set_dataset("imaging_rate", "IMAGING_RATE")
p1.set_dataset("location", "LOCATION")
p1.set_dataset("device", "DEVICE")
p1.set_custom_dataset("image_site_custom", "IMAGE_SITE_CUSTOM")
# neurodata.close()
f.close()
def assemble_nwb_from_partial_files(project_dir, options):
# Initialize NWB object
vargs = {}
vargs["file_name"] = project_dir + ".nwb"
if not options.output_name == "<project_dir>.nwb":
vargs["file_name"] = options.output_name
vargs["identifier"] = nwb_utils.create_identifier(project_dir)
vargs["mode"] = "w"
try:
first_infut_file = os.path.join(project_dir, "top_datasets.h5")
top_h5 = h5py.File(first_infut_file, "r")
vargs["start_time"] = np.array(
top_h5["session_start_time"]).tolist()[0]
vargs["description"] = np.array(
top_h5["session_description"]).tolist()[0]
top_h5.close()
except:
vargs["start_time"] = "session_start_time"
vargs["description"] = "session_description"
if os.path.exists(vargs["file_name"]):
os.remove(vargs["file_name"])
nwb_object = nwb_file.open(**vargs)
# nwb_object.create_group('/acquisition/images')
for file in os.listdir(project_dir):
if file == "top_datasets.py":
pass
path_str = file[0:-3]
if options.verbose:
print "\nInput file=", file, " path_str=", path_str, "\n"
file_path = os.path.join(project_dir, file)
h5_object = h5py.File(file_path, "r")
# Create a pointer to the current location in H5 file
groups = path_str.split(".")
last_group = groups[-1]
if last_group == "top_datasets":
groups.pop(-1)
if options.verbose:
print "path_str=", path_str, " groups=", groups
# Sinchronize paths between the input H5 and output NWB files
curr_h5_path = "/"
nwb_object = update_nwb_object(nwb_object, nwb_object, "/", h5_object,
options)
nwb_object.close()
def create_general_extra(fname):
settings = {}
# settings["filename"] = fname
settings["file_name"] = fname
# settings["identifier"] = nwb.create_identifier("general extracellular test")
settings["identifier"] = utils.create_identifier("general extracellular test")
# settings["overwrite"] = True
settings["mode"] = "w"
settings["description"] = "test elements in /general/extracellular_ephys"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
# neurodata.set_metadata(EXTRA_ELECTRODE_MAP, [[1,1,1], [1,2,3]])
# neurodata.set_metadata(EXTRA_ELECTRODE_GROUP, ["p1", "p2"])
# neurodata.set_metadata(EXTRA_IMPEDANCE, [1.0e6, 2.0e6])
# neurodata.set_metadata(EXTRA_FILTERING, "EXTRA_FILTERING")
# neurodata.set_metadata(EXTRA_CUSTOM("EXTRA_CUSTOM"), "EXTRA_CUSTOM")
g = f.make_group("extracellular_ephys")
g.set_dataset("electrode_map", [[1,1,1], [1,2,3]])
g.set_dataset("electrode_group", ["p1", "p2"])
g.set_dataset("impedance", [1.0e6, 2.0e6])
g.set_dataset("filtering", "EXTRA_FILTERING")
g.set_custom_dataset("EXTRA_CUSTOM", "EXTRA_CUSTOM")
# neurodata.set_metadata(EXTRA_SHANK_DESCRIPTION("p1"), "DESCRIPTION")
# neurodata.set_metadata(EXTRA_SHANK_LOCATION("p1"), "LOCATION")
# neurodata.set_metadata(EXTRA_SHANK_DEVICE("p1"), "DEVICE")
# neurodata.set_metadata(EXTRA_SHANK_CUSTOM("p1", "extra_shank_custom"), "EXTRA_SHANK_CUSTOM")
p1 = g.make_group("<electrode_group_X>", "p1")
p1.set_dataset("description", "DESCRIPTION")
p1.set_dataset("location", "LOCATION")
p1.set_dataset("device", "DEVICE")
p1.set_custom_dataset("extra_shank_custom", "EXTRA_SHANK_CUSTOM")
#
# neurodata.set_metadata(EXTRA_SHANK_DESCRIPTION("p2"), "DESCRIPTION")
# neurodata.set_metadata(EXTRA_SHANK_LOCATION("p2"), "LOCATION")
# neurodata.set_metadata(EXTRA_SHANK_DEVICE("p2"), "DEVICE")
# neurodata.set_metadata(EXTRA_SHANK_CUSTOM("p2", "extra_shank_custom"), "EXTRA_SHANK_CUSTOM")
#
p2 = g.make_group("<electrode_group_X>", "p2")
p2.set_dataset("description", "DESCRIPTION")
p2.set_dataset("location", "LOCATION")
p2.set_dataset("device", "DEVICE")
p2.set_custom_dataset("extra_shank_custom", "EXTRA_SHANK_CUSTOM")
# neurodata.close()
f.close()
def create_annotation_series(fname, name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("annotation example")
settings["mode"] = "w"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["description"] = "Test file with AnnotationSeries"
settings["verbosity"] = "none"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
# annot = neurodata.create_timeseries("AnnotationSeries", name, target)
annot = f.make_group("<AnnotationSeries>", name, path="/" + target)
# annot.set_description("This is an AnnotationSeries with sample data")
annot.set_attr('description',
"This is an AnnotationSeries with sample data")
# annot.set_comment("The comment and description fields can store arbitrary human-readable data")
annot.set_attr(
"comments",
"The comment and desscription fields can store arbitrary human-readable data"
)
# annot.set_source("Observation of Dr. J Doe")
annot.set_attr("source", "Observation of Dr. J Doe")
#
# annot.add_annotation("Rat in bed, beginning sleep 1", 15.0)
# annot.add_annotation("Rat placed in enclosure, start run 1", 933.0)
# annot.add_annotation("Rat taken out of enclosure, end run 1", 1456.0)
# annot.add_annotation("Rat in bed, start sleep 2", 1461.0)
# annot.add_annotation("Rat placed in enclosure, start run 2", 2401.0)
# annot.add_annotation("Rat taken out of enclosure, end run 2", 3210.0)
# annot.add_annotation("Rat in bed, start sleep 3", 3218.0)
# annot.add_annotation("End sleep 3", 4193.0)
# store pretend data
# all time is stored as seconds
andata = []
andata.append(("Rat in bed, beginning sleep 1", 15.0))
andata.append(("Rat placed in enclosure, start run 1", 933.0))
andata.append(("Rat taken out of enclosure, end run 1", 1456.0))
andata.append(("Rat in bed, start sleep 2", 1461.0))
andata.append(("Rat placed in enclosure, start run 2", 2401.0))
andata.append(("Rat taken out of enclosure, end run 2", 3210.0))
andata.append(("Rat in bed, start sleep 3", 3218.0))
andata.append(("End sleep 3", 4193.0))
annotations = [x[0] for x in andata]
times = [x[1] for x in andata]
annot.set_dataset("data", annotations)
annot.set_dataset("timestamps", times)
#
#annot.finalize()
f.close()
def create_general_extra(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier(
"general extracellular test")
settings["mode"] = "w"
settings["description"] = "test elements in /general/extracellular_ephys"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
# neurodata.set_metadata(EXTRA_ELECTRODE_MAP, [[1,1,1], [1,2,3]])
# neurodata.set_metadata(EXTRA_ELECTRODE_GROUP, ["p1", "p2"])
# neurodata.set_metadata(EXTRA_IMPEDANCE, [1.0e6, 2.0e6])
# neurodata.set_metadata(EXTRA_FILTERING, "EXTRA_FILTERING")
# neurodata.set_metadata(EXTRA_CUSTOM("EXTRA_CUSTOM"), "EXTRA_CUSTOM")
g = f.make_group("extracellular_ephys")
g.set_dataset("electrode_map", [[1, 1, 1], [1, 2, 3]])
g.set_dataset("electrode_group", ["p1", "p2"])
g.set_dataset("impedance", [1.0e6, 2.0e6])
g.set_dataset("filtering", "EXTRA_FILTERING")
g.set_custom_dataset("EXTRA_CUSTOM", "EXTRA_CUSTOM")
# neurodata.set_metadata(EXTRA_SHANK_DESCRIPTION("p1"), "DESCRIPTION")
# neurodata.set_metadata(EXTRA_SHANK_LOCATION("p1"), "LOCATION")
# neurodata.set_metadata(EXTRA_SHANK_DEVICE("p1"), "DEVICE")
# neurodata.set_metadata(EXTRA_SHANK_CUSTOM("p1", "extra_shank_custom"), "EXTRA_SHANK_CUSTOM")
p1 = g.make_group("<electrode_group_X>", "p1")
p1.set_dataset("description", "DESCRIPTION")
p1.set_dataset("location", "LOCATION")
p1.set_dataset("device", "DEVICE")
p1.set_custom_dataset("extra_shank_custom", "EXTRA_SHANK_CUSTOM")
#
# neurodata.set_metadata(EXTRA_SHANK_DESCRIPTION("p2"), "DESCRIPTION")
# neurodata.set_metadata(EXTRA_SHANK_LOCATION("p2"), "LOCATION")
# neurodata.set_metadata(EXTRA_SHANK_DEVICE("p2"), "DEVICE")
# neurodata.set_metadata(EXTRA_SHANK_CUSTOM("p2", "extra_shank_custom"), "EXTRA_SHANK_CUSTOM")
#
p2 = g.make_group("<electrode_group_X>", "p2")
p2.set_dataset("description", "DESCRIPTION")
p2.set_dataset("location", "LOCATION")
p2.set_dataset("device", "DEVICE")
p2.set_custom_dataset("extra_shank_custom", "EXTRA_SHANK_CUSTOM")
# neurodata.close()
f.close()
def create_refimage(fname, name):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("reference image test")
settings["mode"] = "w"
settings["description"] = "reference image test"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# neurodata.create_reference_image([1,2,3,4,5], name, "raw", "test")
f.set_dataset("<image_X>", [1,2,3,4,5], dtype="uint8", name=name, attrs={
"description": "test", "format":"raw"})
# neurodata.close()
f.close()
def create_general_top(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("general top test")
settings["mode"] = "w"
settings["description"] = "test top-level elements in /general"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
# neurodata.set_metadata(DATA_COLLECTION, "DATA_COLLECTION")
# neurodata.set_metadata(EXPERIMENT_DESCRIPTION, "EXPERIMENT_DESCRIPTION")
# neurodata.set_metadata(EXPERIMENTER, "EXPERIMENTER")
# neurodata.set_metadata(INSTITUTION, "INSTITUTION")
# neurodata.set_metadata(LAB, "LAB")
# neurodata.set_metadata(NOTES, "NOTES")
# neurodata.set_metadata(PROTOCOL, "PROTOCOL")
# neurodata.set_metadata(PHARMACOLOGY, "PHARMACOLOGY")
# neurodata.set_metadata(RELATED_PUBLICATIONS, "RELATED_PUBLICATIONS")
# neurodata.set_metadata(SESSION_ID, "SESSION_ID")
# neurodata.set_metadata(SLICES, "SLICES")
# neurodata.set_metadata(STIMULUS, "STIMULUS")
# neurodata.set_metadata(SURGERY, "SURGERY")
# neurodata.set_metadata(VIRUS, "VIRUS")
# #
# neurodata.set_metadata_from_file("source_script", __file__)
#
f.set_dataset("data_collection", "DATA_COLLECTION")
f.set_dataset("experiment_description", "EXPERIMENT_DESCRIPTION")
f.set_dataset("experimenter", "EXPERIMENTER")
f.set_dataset("institution", "INSTITUTION")
f.set_dataset("lab", "LAB")
f.set_dataset("notes", "NOTES")
f.set_dataset("protocol", "PROTOCOL")
f.set_dataset("pharmacology", "PHARMACOLOGY")
f.set_dataset("related_publications", "RELATED_PUBLICATIONS")
f.set_dataset("session_id", "SESSION_ID")
f.set_dataset("slices", "SLICES")
f.set_dataset("stimulus", "STIMULUS")
f.set_dataset("surgery", "SURGERY")
f.set_dataset("virus", "VIRUS")
# f.neurodata.set_metadata_from_file("source_script", __file__)
f.set_dataset("source_script", utils.load_file(__file__))
# neurodata.close()
f.close()
def write_block(self, block, **kwargs):
# todo: handle block.file_datetime, block.file_origin, block.index, block.annotations
self._file = nwb_file.open(self.filename,
start_time=block.rec_datetime or "unknown",
mode="w",
identifier=block.name or "neo",
description=block.description or "no description",
core_spec="nwb_core.py", extensions=self.extensions,
default_ns="core", keep_original=False, auto_compress=True)
for segment in block.segments:
self._write_segment(segment)
self._file.close()
def create_softlink_source(fname, name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("softlink source")
settings["mode"] = "w"
settings["description"] = "time series no data test"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# source = neurodata.create_timeseries("TimeSeries", name, target)
source = f.make_group("<TimeSeries>", name, path=target)
# source.set_data([234], unit="parsec", conversion=1, resolution=1e-3)
source.set_dataset("data", [234], attrs={"unit":"parsec",
"conversion":1, "resolution":1e-3})
# source.set_time([123])
source.set_dataset("timestamps", [123])
# source.finalize()
# neurodata.close()
f.close()
def create_nodata_series(fname, name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("nodata example")
settings["mode"] = "w"
settings["description"] = "time series no data test"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
# nodata = neurodata.create_timeseries("TimeSeries", name, target)
# nodata.ignore_data()
# nodata.set_time([0])
nodata = f.make_group("<TimeSeries>", name, path=target)
nodata.set_dataset("timestamps", [0])
#
# nodata.finalize()
# neurodata.close()
f.close()
def create_iface_series(fname, newfile):
settings = {}
settings["file_name"] = fname
settings["verbosity"] = "none"
if newfile:
settings["identifier"] = utils.create_identifier(
"interface timeseries example")
settings["mode"] = "w"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["description"] = "Test interface timeseries file"
else:
settings["mode"] = "r+"
f = nwb_file.open(**settings)
#
# mod = neurodata.create_module("test module")
# iface = mod.create_interface("BehavioralEvents")
# ts = neurodata.create_timeseries("TimeSeries", "Ones")
# ts.set_data(np.ones(10), unit="Event", conversion=1.0, resolution=float('nan'))
# ts.set_value("num_samples", 10)
# ts.set_time(np.arange(10))
# iface.add_timeseries(ts)
# iface.finalize()
# mod.finalize()
mod = f.make_group("<Module>", "test module")
iface = mod.make_group("BehavioralEvents")
ts = iface.make_group("<TimeSeries>", "Ones")
ts.set_dataset("data",
np.ones(10),
attrs={
'unit': "Event",
"conversion": 1.0,
"resolution": float('nan')
})
ts.set_dataset("num_samples", 10)
ts.set_dataset("timestamps", np.arange(10))
#
# neurodata.close()
f.close()
def write_block(self, block, **kwargs):
# todo: handle block.file_datetime, block.file_origin, block.index, block.annotations
if block.rec_datetime:
start_time = block.rec_datetime.isoformat()
else:
start_time = "unknown"
self._file = nwb_file.open(self.filename,
start_time=start_time,
mode="w",
identifier=block.name or "_neo",
description=block.description
or "no description",
core_spec="nwb_core.py",
extensions=self.extensions,
default_ns="core",
keep_original=False,
auto_compress=True)
for segment in block.segments:
self._write_segment(segment)
self._file.close()
if block.file_origin is None:
block.file_origin = self.filename
# The nwb module sets 'file_create_date' automatically. Here, if the block
# already contains a 'file_datetime', we wish to set that as the first entry
# in 'file_create_date'
self._file = h5py.File(self.filename, "r+")
nwb_create_date = self._file['file_create_date'].value
if block.file_datetime:
del self._file['file_create_date']
self._file['file_create_date'] = np.array(
[block.file_datetime.isoformat(), nwb_create_date])
else:
block.file_datetime = parse_datetime(nwb_create_date[0])
self._file.close()
def create_softlink_source(fname, name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("softlink source")
settings["mode"] = "w"
settings["description"] = "time series no data test"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# source = neurodata.create_timeseries("TimeSeries", name, target)
source = f.make_group("<TimeSeries>", name, path=target)
# source.set_data([234], unit="parsec", conversion=1, resolution=1e-3)
source.set_dataset("data", [234],
attrs={
"unit": "parsec",
"conversion": 1,
"resolution": 1e-3
})
# source.set_time([123])
source.set_dataset("timestamps", [123])
# source.finalize()
# neurodata.close()
f.close()
def create_softlink_reader(fname, name, src_fname, src_name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("softlink reader")
settings["mode"] = "w"
settings["description"] = "softlink test"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# source = neurodata.create_timeseries("TimeSeries", name, target)
# source.set_data_as_remote_link(src_fname, "acquisition/timeseries/"+src_name+"/data")
# source.set_time([345])
# source.finalize()
# neurodata.close()
source = f.make_group("<TimeSeries>", name, path=target)
# source.set_data_as_remote_link(src_fname, "acquisition/timeseries/"+src_name+"/data")
extlink = "extlink:%s,%s" % (src_fname, "acquisition/timeseries/"+src_name+"/data")
source.set_dataset("data", extlink)
source.set_dataset("timestamps", [345])
# source.finalize()
# neurodata.close()
f.close()
def create_softlink_reader(fname, name, src_fname, src_name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("softlink reader")
settings["mode"] = "w"
settings["description"] = "softlink test"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
# source = neurodata.create_timeseries("TimeSeries", name, target)
# source.set_data_as_remote_link(src_fname, "acquisition/timeseries/"+src_name+"/data")
# source.set_time([345])
# source.finalize()
# neurodata.close()
source = f.make_group("<TimeSeries>", name, path=target)
# source.set_data_as_remote_link(src_fname, "acquisition/timeseries/"+src_name+"/data")
extlink = "extlink:%s,%s" % (src_fname, "acquisition/timeseries/" +
src_name + "/data")
source.set_dataset("data", extlink)
source.set_dataset("timestamps", [345])
# source.finalize()
# neurodata.close()
f.close()
def create_startingtime_series(fname, name, target):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("starting time test")
settings["mode"] = "w"
settings["description"] = "time series starting time test"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
# stime = neurodata.create_timeseries("TimeSeries", name, target)
# stime.set_data([0, 1, 2, 3], unit="n/a", conversion=1, resolution=1)
# stime.set_value("num_samples", 4)
# stime.set_time_by_rate(0.125, 2)
#
stime = f.make_group("<TimeSeries>", name, path=target)
stime.set_dataset("data", [0, 1, 2, 3],
attrs={
"unit": "n/a",
"conversion": 1,
"resolution": 1
})
stime.set_dataset("num_samples", 4)
# stime.set_time_by_rate(0.125, 2)
stime.set_dataset("starting_time",
0.125,
attrs={
"rate": 2,
"unit": "Seconds"
})
# stime.finalize()
# neurodata.close()
f.close()
=======
>>>>>>> 131f06f... rebase onto master
def write_block(self, block, **kwargs):
# todo: handle block.file_datetime, block.file_origin, block.index, block.annotations
<<<<<<< HEAD
if block.rec_datetime:
start_time = block.rec_datetime.isoformat()
else:
start_time = "unknown"
self._file = nwb_file.open(self.filename,
start_time=start_time,
mode="w",
identifier=block.name or "_neo",
description=block.description or "no description",
core_spec="nwb_core.py", extensions=self.extensions,
default_ns="core", keep_original=False, auto_compress=True)
for segment in block.segments:
self._write_segment(segment)
self._file.close()
if block.file_origin is None:
block.file_origin = self.filename
# The nwb module sets 'file_create_date' automatically. Here, if the block
# already contains a 'file_datetime', we wish to set that as the first entry
# in 'file_create_date'
self._file = h5py.File(self.filename, "r+")
nwb_create_date = self._file['file_create_date'].value
# prepare files
orig_h5 = h5py.File(INFILE, "r")
meta_h5 = h5py.File(META, "r")
ifile_name = INFILE.split("/")[-1]
session_id = ifile_name[15:-3]
bfile_name = ifile_name[15:-3] + ".nwb"
vargs = {}
vargs["start_time"] = find_exp_time(meta_h5)
vargs["identifier"] = ut.create_identifier(session_id)
vargs["mode"] = "w"
vargs[
"description"
] = "Extracellular ephys recording of mouse doing discrimination task (lick left/right), with optogenetic stimulation plus pole and auditory stimulus"
vargs["file_name"] = OUTPUT_DIR + bfile_name
nuo = nwb_file.open(**vargs)
nuo.set_dataset("session_id", session_id)
print "Reading meta data"
# general
an_gene_copy = parse_h5_obj(meta_h5["animalGeneCopy"])[0][0]
an_gene_bg = parse_h5_obj(meta_h5["animalGeneticBackground"])[0]
an_gene_mod = parse_h5_obj(meta_h5["animalGeneModification"])[0]
an_gene = (
"Animal gene modification: "
+ extract_encoded_str(an_gene_mod)
+ ";\nAnimal genetic background: "
+ extract_encoded_str(an_gene_bg)
+ ";\nAnimal gene copy: "
+ str(an_gene_copy)
)
def create_linked_series(fname, root):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("link test")
settings["mode"] = "w"
settings["description"] = "time series link test"
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
settings["verbosity"] = "none"
# neurodata = nwb.NWB(**settings)
f = nwb_file.open(**settings)
#
# first = neurodata.create_timeseries("TimeSeries", root+"1", "template")
# first.ignore_time()
# first.set_value("num_samples", 1)
# first.set_data([1], unit="parsec", conversion=1, resolution=1e-12)
# first.finalize()
#
first = f.make_group("<TimeSeries>",
root + "1",
path="/stimulus/templates")
# first.ignore_time()
# first.set_value("num_samples", 1)
first.set_dataset("num_samples", 1)
d1 = first.set_dataset("data", [1],
attrs={
"unit": "parsec",
"conversion": 1,
"resolution": 1e-12
})
# first.finalize()
# second = neurodata.create_timeseries("TimeSeries", root+"2", "stimulus")
# second.set_time([2])
# second.set_value("num_samples", 1)
# second.set_data_as_link(first)
# second.finalize()
#
second = f.make_group("<TimeSeries>",
root + "2",
path="/stimulus/presentation")
t2 = second.set_dataset("timestamps", [2])
second.set_dataset("num_samples", 1)
second.set_dataset("data", d1)
# third = neurodata.create_timeseries("TimeSeries", root+"3", "acquisition")
# third.set_time_as_link(second)
# third.set_value("num_samples", 1)
# third.set_data([3], unit="parsec", conversion=1, resolution=1e-9)
# third.finalize()
third = f.make_group("<TimeSeries>",
root + "3",
path="/acquisition/timeseries")
third.set_dataset("timestamps", t2)
third.set_dataset("num_samples", 1)
third.set_dataset("data", [3],
attrs={
"unit": "parsec",
"conversion": 1,
"resolution": 1e-9
})
#
# neurodata.close()
f.close()
def _make_tuples(self, key):
fname = key['nwb_file']
print('Session()._make_tuples: nwb_file', key['nwb_file'])
use_nwb_file = False # slower due to validation; more memory use
if use_nwb_file:
f = nwb_file.open(key['nwb_file'], None, 'r').file_pointer
else:
f = h5py.File(key['nwb_file'], 'r')
#
# General Session information
#
g_gen = f['general']
# fname: /path/to/file/data_structure_ANM210861_20130701.nwb
(__, __, aid, sdate) = os.path.split(fname)[-1:][0].split('_')
# animal id / session id / session_date / session_suffix
aid = aid[3:] # ANMNNN -> NNN
key['animal_id'] = aid
sdate = sdate.split('.')[:-1][0] # drop '.nwb'
if len(sdate) == 9:
(sdate, sfx) = (
sdate[:-1],
sdate[-1:],
)
else:
(sdate, sfx) = (
sdate,
'',
)
if sfx is not '':
sid = int(sdate +
str(ord(sfx) - ord('a') + 1).zfill(2)) # sfx -> NN
else:
sid = int(sdate + '00')
key['session'] = sid
key['session_date'] = sdate
key['session_suffix'] = sfx
stime = f['session_start_time'][()].decode()
stime = datetime.strptime(stime, '%a %b %d %Y %H:%M:%S')
key['session_start_time'] = stime
key['experimenter'] = g_gen['experimenter'][()].decode()
key['raw_data_path'] = f['acquisition']['timeseries'][
'extracellular_traces']['ephys_raw_data'][()].decode()
key['recording_type'] = 'TODO' # TODO: recording_type
#
# Common Study information - should only need to load 1x per fileset
#
try:
Study()._from_nwb(f)
except IntegrityError as e:
if 'Duplicate entry' in e.args[1]:
pass
else:
raise
#
# Animal
#
akey = {'animal_id': aid}
if not (Animal() & akey):
g_subj = g_gen['subject']
akey['species'] = g_subj['species'][()].decode()
# calculate mouse DOB from age
subj_age = g_gen['subject']['age'][()].decode()
age_rx = re.compile(' *?(.*?) months *(.*?) days (.*?) weeks')
try:
(subj_m, subj_d, subj_w) = \
[g if g != '' else '0'
for g in age_rx.match(subj_age).groups()]
# XXX: assuming 4wks-per-month
subj_aged = timedelta(days=int(subj_d),
weeks=(int(subj_w) + (int(subj_m) * 4)))
subj_dob = stime - subj_aged
akey['date_of_birth'] = subj_dob
except AttributeError:
# TODO?: all errors seem to be string '3 to 5 months weeks'
print('warning: subject', sid, 'age parse error:', subj_age)
akey['date_of_birth'] = '1970-01-01'
Animal().insert1(akey, ignore_extra_fields=True)
if not (Surgery() & akey):
akey['surgery'] = g_gen['surgery'][()].decode()
Surgery().insert1(akey, ignore_extra_fields=True)
if not (Virus() & akey):
'''
>>> print(fh['general']['virus'][()].decode())
infectionCoordinates: [2.5, -1.5, 0.5],[2.5, -1.5, 0.85]
infectionLocation: M2
injectionDate: 20130523
injectionVolume: 30,30
virusID: Addgene41015
virusLotNumber:
virusSource: Janelia core
virusTiter: untitered
'''
Virus().insert1(akey, ignore_extra_fields=True)
# fun with miniparsers! (yaml/json didn't "take")
virstr = g_gen['virus'][()].decode()
virlex = re.compile(' *(.*?): (.*)')
akey['site'] = 'some site!'
i = 0
for line in virstr.split('\n'):
kvmatch = virlex.match(line)
if kvmatch:
(k, v) = kvmatch.groups()
if k == 'infectionCoordinates':
if '[' in v:
for s in v.split('],['): # 3d triplet list
(x, y, z) = s[1:-1].split(', ')
i = i + 1
akey['site'] = i
akey['infection_x'] = Decimal(x)
akey['infection_y'] = Decimal(y)
akey['infection_z'] = Decimal(z)
Virus.InfectionSite().insert1(
akey, ignore_extra_fields=True)
else: # single triplet list
(x, y, z) = [s[1:-1].split(', ')]
i = i + 1
akey['site'] = i
akey['infection_x'] = Decimal(x)
akey['infection_y'] = Decimal(y)
akey['infection_z'] = Decimal(z)
Virus.InfectionSite().insert1(
akey, ignore_extra_fields=True)
f.close()
self.insert1(key)
import test_utils as ut
# create two epochs, add different subset of tags to each
# verify main epoch folder has tag attribute that contains
# exactly the unique tags of each epoch and that each
# epoch contains the assigned tags
if __file__.startswith("./"):
fname = "s" + __file__[3:-3] + ".nwb"
else:
fname = "s" + __file__[1:-3] + ".nwb"
# borg = ut.create_new_file(fname, "Epoch tags")
f = nwb_file.open(fname,
mode="w",
identifier=utils.create_identifier("Epoch tags"),
description="softlink test",
verbosity="none")
tags = ["tag-a", "tag-b", "tag-c"]
# epoch1 = borg.create_epoch("epoch-1", 0, 3);
epoch1 = f.make_group("<epoch_X>", "epoch-1")
epoch1.set_dataset("start_time", 0)
epoch1.set_dataset("stop_time", 3)
# for i in range(len(tags)-1):
# epoch1.add_tag(tags[i+1])
epoch1.set_dataset("tags", tags[1:])
def create_general_intra(fname):
settings = {}
settings["file_name"] = fname
settings["identifier"] = utils.create_identifier("general intracellular test")
settings["mode"] = "w"
settings["description"] = "test elements in /general/intracellular_ephys"
settings["verbosity"] = "none"
f = nwb_file.open(**settings)
#
# neurodata.set_metadata(INTRA_CUSTOM("intra_custom"), "INTRA_CUSTOM")
g = f.make_group("intracellular_ephys")
g.set_custom_dataset("intra_custom", "INTRA_CUSTOM")
#
# neurodata.set_metadata(INTRA_ELECTRODE_DESCRIPTION("p1"), "DESCRIPTION")
# neurodata.set_metadata(INTRA_ELECTRODE_FILTERING("p1"), "FILTERING")
# neurodata.set_metadata(INTRA_ELECTRODE_DEVICE("p1"), "DEVICE")
# neurodata.set_metadata(INTRA_ELECTRODE_LOCATION("p1"), "LOCATION")
# neurodata.set_metadata(INTRA_ELECTRODE_RESISTANCE("p1"), "RESISTANCE")
# neurodata.set_metadata(INTRA_ELECTRODE_SEAL("p1"), "SEAL")
# neurodata.set_metadata(INTRA_ELECTRODE_SLICE("p1"), "SLICE")
# neurodata.set_metadata(INTRA_ELECTRODE_INIT_ACCESS_RESISTANCE("p1"), "INITIAL_ACCESS_RESISTANCE")
# neurodata.set_metadata(INTRA_ELECTRODE_CUSTOM("p1", "intra_electrode_custom"), "INTRA_ELECTRODE_CUSTOM")
p1 = g.make_group("<electrode_X>", "p1")
p1.set_dataset("description", "DESCRIPTION")
p1.set_dataset("filtering", "FILTERING")
p1.set_dataset("device","DEVICE")
p1.set_dataset("location","LOCATION")
p1.set_dataset("resistance","RESISTANCE")
p1.set_dataset("seal","SEAL")
p1.set_dataset("slice","SLICE")
p1.set_dataset("initial_access_resistance","INITIAL_ACCESS_RESISTANCE")
p1.set_custom_dataset("intra_electrode_custom","INTRA_ELECTRODE_CUSTOM")
#
# neurodata.set_metadata(INTRA_ELECTRODE_DESCRIPTION("e2"), "DESCRIPTION")
# neurodata.set_metadata(INTRA_ELECTRODE_FILTERING("e2"), "FILTERING")
# neurodata.set_metadata(INTRA_ELECTRODE_DEVICE("e2"), "DEVICE")
# neurodata.set_metadata(INTRA_ELECTRODE_LOCATION("e2"), "LOCATION")
# neurodata.set_metadata(INTRA_ELECTRODE_RESISTANCE("e2"), "RESISTANCE")
# neurodata.set_metadata(INTRA_ELECTRODE_SEAL("e2"), "SEAL")
# neurodata.set_metadata(INTRA_ELECTRODE_SLICE("e2"), "SLICE")
# neurodata.set_metadata(INTRA_ELECTRODE_INIT_ACCESS_RESISTANCE("e2"), "INITIAL_ACCESS_RESISTANCE")
# neurodata.set_metadata(INTRA_ELECTRODE_CUSTOM("e2", "intra_electrode_custom"), "INTRA_ELECTRODE_CUSTOM")
#
e2 = g.make_group("<electrode_X>", "e2")
e2.set_dataset("description", "DESCRIPTION")
e2.set_dataset("filtering", "FILTERING")
e2.set_dataset("device","DEVICE")
e2.set_dataset("location","LOCATION")
e2.set_dataset("resistance","RESISTANCE")
e2.set_dataset("seal","SEAL")
e2.set_dataset("slice","SLICE")
e2.set_dataset("initial_access_resistance","INITIAL_ACCESS_RESISTANCE")
e2.set_custom_dataset("intra_electrode_custom","INTRA_ELECTRODE_CUSTOM")
# neurodata.close()
f.close()
# files. create a map between the h5 plane name and the
# identifier used between files
plane_map = {}
create_plane_map()
# create output file
file_name = OUTPUT_DIR + session_id + ".nwb"
print file_name
vargs = {}
vargs["file_name"] = file_name
vargs["start_time"] = find_exp_time(orig_h5)
vargs["identifier"] = ut.create_identifier(session_id)
vargs["description"] = "Two-photon imaging of mouse barrel cortex in discrimination task (lick left/right) using pole and auditory stimulus"
vargs["mode"] = "w"
#-- simon = nwb.NWB(**vargs)
simon = nwb_file.open(**vargs)
#- simon.set_metadata(SESSION_ID, session_id)
#- simon.set_metadata(DEVICE("two-photon microscope"), "Custom two-photon microscope, see http://openwiki.janelia.org/wiki/display/shareddesigns/MIMMS. Images acquired using 16X 0.8 NA objective (Nikon)")
gg = simon.make_group("general", abort=False)
gg.set_dataset("session_id", session_id)
gd = gg.make_group("devices")
desc = "Custom two-photon microscope, see http://openwiki.janelia.org/wiki/display/shareddesigns/MIMMS. Images acquired using 16X 0.8 NA objective (Nikon)"
gd.set_dataset("<device_X>", desc, name="two-photon microscope")
sg = gg.make_group("subject")
print "Reading meta data"
meta = parse_h5_obj(orig_h5['metaDataHash/value'])[0]
species = meta[0]
stim_pixel_cnt[name] = n_pix
for i in range(len(file_list)):
fname = file_list[i][len(path):]
print "Processing " + fname
mfile = sio.loadmat(file_list[i], struct_as_record=True)
# prepare matlab data
data_info = mfile['datainfo'][0,0]
# prepare output file
vargs = {}
vargs["start_time"] = find_exp_time(fname, data_info)
vargs["identifier"] = ut.create_identifier("Meister test data")
vargs["mode"] = "w"
vargs["description"] ="Optical stimulation and extracellular recording of retina"
vargs["file_name"] = OUTPUT_DIR + fname[:-4]+".nwb"
bfile = nwb_file.open(**vargs)
print "Creating " + vargs["file_name"]
# get stimulus offset times
stim_offset = find_stim_times(fname, data_info)
stim_end = []
#
for i in range(len(stim_offset)):
# create stimuli
# read data from mat file
stimulus = mfile["stimulus"][0,i]
n_frames = stimulus["Nframes"][0,0]
frame = stimulus["frame"][0,0]
onset = stimulus["onset"][0,0]
type_s = stimulus["type"][0]
seed = stimulus["param"]["seed"][0,0][0,0]
x = stimulus["param"]["x"][0,0][0,0]
import test_utils as ut
# create two epochs, add different subset of tags to each
# verify main epoch folder has tag attribute that contains
# exactly the unique tags of each epoch and that each
# epoch contains the assigned tags
if __file__.startswith("./"):
fname = "s" + __file__[3:-3] + ".nwb"
else:
fname = "s" + __file__[1:-3] + ".nwb"
# borg = ut.create_new_file(fname, "Epoch tags")
f = nwb_file.open(fname,
mode="w",
identifier=utils.create_identifier("Epoch tags"),
description="softlink test",
verbosity="none")
tags = ["tag-a", "tag-b", "tag-c"]
# epoch1 = borg.create_epoch("epoch-1", 0, 3);
epoch1 = f.make_group("<epoch_X>", "epoch-1")
epoch1.set_dataset("start_time", 0)
epoch1.set_dataset("stop_time", 3)
# for i in range(len(tags)-1):
# epoch1.add_tag(tags[i+1])
epoch1.set_dataset("tags", tags[1:])
# ("w-") does not overwrite an existing file.
settings["mode"] = "w"
# specify the start time of the experiment. all times in the NWB file
# are relative to experiment start time
# if the start time is not specified the present time will be used
settings["start_time"] = "Sat Jul 04 2015 3:14:16"
# provide one or two sentences that describe the experiment and what
# data is in the file
settings[
"description"] = "Test file demonstrating use of the AbstractFeatureSeries"
# create the NWB File object. this manages the file
print("Creating " + settings["file_name"])
f = nwb_file.open(**settings)
########################################################################
# create an AbstractFeatureSeries
# this will be stored as a 'stimulus' in this example for this example. that
# means that it will be stored in the following location in the hdf5
# file: stimulus/presentation/
abs = f.make_group("<AbstractFeatureSeries>",
"my_drifting_grating_features",
path="/stimulus/presentation")
abs.set_attr(
"description",
"This is a simulated visual stimulus that presents a moving grating")
# an AbstractFeatureSeries is an instance of a TimeSeries, with addition
The "code_descriptions" data set, provides the description of each code.
"""
# create a new NWB file
OUTPUT_DIR = "../created_nwb_files/"
file_name = __file__[0:-3] + ".nwb"
settings = {}
settings["file_name"] = OUTPUT_DIR + file_name
settings["identifier"] = utils.create_identifier("extended interval example")
settings["mode"] = "w"
settings["start_time"] = "2016-04-07T03:16:03.604121"
settings["description"] = "Test file demonstrating use of an extended IntervalSeries"
# specify the extension (Could be more than one. Only one used now).
settings['extensions'] = ["extensions/e-interval.py"]
f = nwb_file.open(**settings)
########################################################################
# Make some fake interval series data
# store in codes and times
event_codes = [
7, # 300 hz tone turned on at
-7, # 300 hz tone turned off
3, # blue light turned on
4, # 200 hz tone turned on
6, # red light turned on
-3, # blue light turned off
-6, # red light turned off
-4 # 200 hz tone turned off
]
#ep.ts_self_check()
#sys.exit(0)
# prepare files
orig_h5 = h5py.File(INFILE, "r")
meta_h5 = h5py.File(META, "r")
ifile_name = INFILE.split('/')[-1]
session_id = ifile_name[15:-3]
bfile_name = ifile_name[15:-3] + ".nwb"
vargs = {}
vargs["start_time"] = find_exp_time(meta_h5)
vargs["identifier"] = ut.create_identifier(session_id)
vargs["mode"] = "w"
vargs["description"] = "Extracellular ephys recording of mouse doing discrimination task (lick left/right), with optogenetic stimulation plus pole and auditory stimulus"
vargs["file_name"] = OUTPUT_DIR + bfile_name
nuo = nwb_file.open(**vargs)
nuo.set_dataset("session_id", session_id)
print "Reading meta data"
#general
an_gene_copy = parse_h5_obj(meta_h5["animalGeneCopy"])[0][0]
an_gene_bg= parse_h5_obj(meta_h5["animalGeneticBackground"])[0]
an_gene_mod = parse_h5_obj(meta_h5["animalGeneModification"])[0]
an_gene = "Animal gene modification: " + extract_encoded_str(an_gene_mod) +\
";\nAnimal genetic background: " + extract_encoded_str(an_gene_bg) +\
";\nAnimal gene copy: " + str(an_gene_copy)
gg = nuo.make_group("general", abort=False)
s = gg.make_group('subject')
s.set_dataset("genotype", an_gene)
an_strain = parse_h5_obj(meta_h5["animalStrain"])[0]
