def __init__(self):
pg.QtCore.QObject.__init__(self)
# global session for querying from DB
self.session = db.session()
win = pg.QtGui.QSplitter()
win.setOrientation(pg.QtCore.Qt.Horizontal)
win.resize(1000, 800)
win.show()
b = ExperimentBrowser()
b.populate()
win.addWidget(b)
rs_plots = ResponseStrengthPlots(self.session)
win.addWidget(rs_plots)
b.itemSelectionChanged.connect(self._selected)
b.doubleClicked.connect(self._dbl_clicked)
self.win = win
self.rs_plots = rs_plots
self.browser = b
self.nwb_viewer = MultipatchNwbViewer()
def populate(self, experiments=None):
self.items_by_pair_id = {}
self.session = db.session()
if experiments is None:
experiments = db.list_experiments(session=self.session)
# preload all cells,pairs so they are not queried individually later on
pairs = self.session.query(
db.Pair, db.Experiment, db.Cell,
db.Slice).join(db.Experiment,
db.Pair.experiment_id == db.Experiment.id).join(
db.Cell,
db.Cell.id == db.Pair.pre_cell_id).join(
db.Slice).all()
experiments.sort(key=lambda e: e.acq_timestamp)
for expt in experiments:
date = expt.acq_timestamp
date_str = datetime.fromtimestamp(date).strftime('%Y-%m-%d')
slice = expt.slice
expt_item = pg.TreeWidgetItem(
map(str, [
date_str,
'%0.3f' % expt.acq_timestamp, expt.rig_name, slice.species,
expt.project_name, expt.target_region, slice.genotype,
expt.acsf
]))
expt_item.expt = expt
self.addTopLevelItem(expt_item)
for pair in expt.pair_list:
# if pair.n_ex_test_spikes == 0 and pair.n_in_test_spikes == 0:
# continue
cells = '%s => %s' % (pair.pre_cell.ext_id,
pair.post_cell.ext_id)
conn = {True: "syn", False: "-", None: "?"}[pair.has_synapse]
types = 'L%s %s => L%s %s' % (pair.pre_cell.target_layer
or "?", pair.pre_cell.cre_type,
pair.post_cell.target_layer
or "?", pair.post_cell.cre_type)
pair_item = pg.TreeWidgetItem([cells, conn, types])
expt_item.addChild(pair_item)
pair_item.pair = pair
pair_item.expt = expt
self.items_by_pair_id[pair.id] = pair_item
# also allow select by ext id
self.items_by_pair_id[(expt.acq_timestamp,
pair.pre_cell.ext_id,
pair.post_cell.ext_id)] = pair_item
self.verticalScrollBar().setValue(self.verticalScrollBar().maximum())
def __init__(self, analyzer_mode):
s = db.session()
self._signalHandler = SignalHandler()
self.sigOutputChanged = self._signalHandler.sigOutputChanged
self.analyzer_mode = analyzer_mode
self.pairs = None
self.acsf = None
projects = s.query(db.Experiment.project_name).distinct().all()
projects = [
project[0] for project in projects if project[0] is not None or ''
]
acsfs = s.query(db.Experiment.acsf).distinct().all()
acsfs = [acsf[0] for acsf in acsfs if acsf[0] is not None or '']
acsf_expand = False
internals = s.query(db.Experiment.internal).distinct().all()
internals = [
internal[0] for internal in internals
if internal[0] is not None or ''
]
internal_expand = False
if self.analyzer_mode == 'external':
self.project_keys = {
'Mouse': ['mouse V1 pre-production', 'mouse V1 coarse matrix'],
'Human': ['human coarse matrix']
}
projects = self.project_keys.keys()
self.internal_keys = {
'0.3mM EGTA': ['Standard K-Gluc'],
'1mM EGTA': ['K-Gluc 1uM EGTA', ' K-Gluc 1uM EGTA'],
'No EGTA': ['K-Gluc -EGTA']
}
internals = self.internal_keys.keys()
self.acsf_keys = {
'1.3mM': ['1.3mM Ca & 1mM Mg'],
'2mM': ['2mM Ca & Mg']
}
acsfs = self.acsf_keys.keys()
acsf_expand = True
internal_expand = True
project_list = [{
'name': str(project),
'type': 'bool'
} for project in projects]
acsf_list = [{'name': str(acsf), 'type': 'bool'} for acsf in acsfs]
internal_list = [{
'name': str(internal),
'type': 'bool'
} for internal in internals]
self.params = Parameter.create(name='Data Filters',
type='group',
children=[
{
'name': 'Projects',
'type': 'group',
'children': project_list
},
{
'name': 'ACSF [Ca2+]',
'type': 'group',
'children': acsf_list,
'expanded': acsf_expand
},
{
'name': 'Internal [EGTA]',
'type': 'group',
'children': internal_list,
'expanded': internal_expand
},
])
self.params.sigTreeStateChanged.connect(self.invalidate_output)
if __name__ == '__main__':
app = pg.mkQApp()
parser = argparse.ArgumentParser()
parser.add_argument('--timestamps', type=str, nargs='*')
parser.add_argument('--dbg', default=False, action='store_true')
parser.add_argument('expt_id', type=str, nargs='?', default=None)
parser.add_argument('pre_cell_id', type=str, nargs='?', default=None)
parser.add_argument('post_cell_id', type=str, nargs='?', default=None)
args = parser.parse_args(sys.argv[1:])
if args.dbg:
pg.dbg()
default_session = db.session()
notes_session = notes_db.db.session()
# timestamps = [r.acq_timestamp for r in db.query(db.Experiment.acq_timestamp).all()]
timestamps = []
mw = MainWindow(default_session, notes_session)
if args.timestamps is not None:
timestamps = args.timestamps
elif args.expt_id is not None:
timestamps = [args.expt_id]
q = default_session.query(db.Experiment).filter(db.Experiment.acq_timestamp.in_(timestamps))
expts = q.all()
mw.set_expts(expts)
if None not in (args.expt_id, args.pre_cell_id, args.post_cell_id):
from collections import OrderedDict
if __name__ == '__main__':
app = pg.mkQApp()
if sys.flags.interactive == 1:
pg.dbg()
# pg.setConfigOption('background', 'w')
# pg.setConfigOption('foreground', 'k')
parser = argparse.ArgumentParser()
parser.add_argument('--mode', type=str, default='external')
args = parser.parse_args(sys.argv[1:])
analyzer_mode = args.mode
session = db.session()
# Define cell classes
cell_class_groups = OrderedDict([
(
'All Transgenic Classes',
[
# {'cre_type': 'unknown', 'target_layer': '2/3','cortical_layer': '2/3'},
{
'dendrite_type': 'spiny',
'target_layer': '2/3',
'cortical_layer': '2/3',
'display_names': ('L2/3', 'Pyr\nspiny')
},
{
'cre_type': 'pvalb',
def query_all_pairs(classifier=None):
columns = [
"synapse_prediction.*",
"experiment.id as experiment_id",
"experiment.acq_timestamp as acq_timestamp",
"experiment.rig_name",
"experiment.acsf",
"slice.species as donor_species",
"slice.genotype as donor_genotype",
"slice.age as donor_age",
"slice.sex as donor_sex",
"slice.quality as slice_quality",
"slice.weight as donor_weight",
"slice.slice_time",
"pre_cell.ext_id as pre_cell_id",
"pre_cell.cre_type as pre_cre_type",
"pre_cell.target_layer as pre_target_layer",
"pre_morphology.pyramidal as pre_pyramidal",
"post_cell.ext_id as post_cell_id",
"post_cell.cre_type as post_cre_type",
"post_cell.target_layer as post_target_layer",
"post_morphology.pyramidal as post_pyramidal",
"pair.has_synapse",
"pair.distance",
"pair.crosstalk_artifact",
# "abs(post_cell.ext_id - pre_cell.ext_id) as electrode_distance",
]
# columns.extend([
# "detection_limit.minimum_amplitude",
# ])
joins = [
"join pair on synapse_prediction.pair_id=pair.id",
"join cell pre_cell on pair.pre_cell_id=pre_cell.id",
"join cell post_cell on pair.post_cell_id=post_cell.id",
"join morphology pre_morphology on pre_morphology.cell_id=pre_cell.id",
"join morphology post_morphology on post_morphology.cell_id=post_cell.id",
"join experiment on pair.experiment_id=experiment.id",
"join slice on experiment.slice_id=slice.id",
]
# joins.extend([
# "left join detection_limit on detection_limit.pair_id=pair.id",
# ])
query = ("""
select
{columns}
from synapse_prediction
{joins}
order by acq_timestamp
""").format(
columns=", ".join(columns),
joins=" ".join(joins),
)
session = db.session()
df = pandas.read_sql(query, session.bind)
recs = df.to_records()
if classifier is None:
return recs
# Fit classifier and add results of classifier prediction in to records
classifier.fit(recs)
prediction = classifier.predict(recs)
recs = join_struct_arrays([recs, prediction])
return recs
def populate(self, experiments=None, all_pairs=False, synapses=False):
"""Populate the browser with a list of experiments.
Parameters
----------
experiments : list | None
A list of Experiment instances. If None, then automatically query experiments from the default database.
all_pairs : bool
If False, then pairs with no qc-passed pulse responses are excluded
synapses : bool
If True, then only synaptically connected pairs are shown
"""
with pg.BusyCursor():
# if all_pairs is set to True, all pairs from an experiment will be included regardless of whether they have data
self.items_by_pair_id = {}
self.session = db.session()
if experiments is None:
# preload all cells,pairs so they are not queried individually later on
q = self.session.query(db.Pair, db.Experiment, db.Cell, db.Slice)
q = q.join(db.Experiment, db.Pair.experiment_id==db.Experiment.id)
q = q.join(db.Cell, db.Cell.id==db.Pair.pre_cell_id)
q = q.join(db.Slice)
if synapses:
q = q.filter(db.Pair.has_synapse==True)
recs = q.all()
experiments = list(set([rec.Experiment for rec in recs]))
experiments.sort(key=lambda e: e.acq_timestamp)
for expt in experiments:
date = expt.acq_timestamp
date_str = datetime.fromtimestamp(date).strftime('%Y-%m-%d')
slice = expt.slice
expt_item = pg.TreeWidgetItem(map(str, [date_str, '%0.3f'%expt.acq_timestamp, expt.rig_name, slice.species, expt.project_name, expt.target_region, slice.genotype, expt.acsf]))
expt_item.expt = expt
self.addTopLevelItem(expt_item)
for pair in expt.pair_list:
if all_pairs is False and pair.n_ex_test_spikes == 0 and pair.n_in_test_spikes == 0:
continue
if synapses and not pair.has_synapse:
continue
cells = '%s => %s' % (pair.pre_cell.ext_id, pair.post_cell.ext_id)
conn = {True:"syn", False:"-", None:"?"}[pair.has_synapse]
gap = {True:"gap", False:"-", None:"?"}[pair.has_electrical]
pre_type = pair.pre_cell.cre_type
if pre_type == 'unknown':
dendrite_type = pair.pre_cell.morphology.dendrite_type if pair.pre_cell.morphology is not None else None
pre_type = dendrite_type if dendrite_type in ['spiny', 'aspiny', 'sparsely spiny'] else pre_type
post_type = pair.post_cell.cre_type
if post_type == 'unknown':
dendrite_type = pair.post_cell.morphology.dendrite_type if pair.pre_cell.morphology is not None else None
post_type = dendrite_type if dendrite_type in ['spiny', 'aspiny', 'sparsely spiny'] else post_type
types = 'L%s %s => L%s %s' % (pair.pre_cell.target_layer or "?", pre_type, pair.post_cell.target_layer or "?", post_type)
pair_item = pg.TreeWidgetItem([cells, conn+' ; '+gap, types])
expt_item.addChild(pair_item)
pair_item.pair = pair
pair_item.expt = expt
self.items_by_pair_id[pair.id] = pair_item
# also allow select by ext id
self.items_by_pair_id[(expt.acq_timestamp, pair.pre_cell.ext_id, pair.post_cell.ext_id)] = pair_item
self.verticalScrollBar().setValue(self.verticalScrollBar().maximum())
