def get_expts(self):
expt_query = db.query(db.Experiment)
synapse_none = self.data_type['Synapse is None']
if synapse_none:
subquery = db.query(db.Pair.experiment_id).filter(
db.Pair.has_synapse == None).subquery()
expt_query = expt_query.filter(db.Experiment.id.in_(subquery))
selected_rigs = [
rig.name() for rig in self.rig_select.children()
if rig.value() is True
]
if len(selected_rigs) != 0:
expt_query = expt_query.filter(
db.Experiment.rig_name.in_(selected_rigs))
selected_operators = [
operator.name() for operator in self.operator_select.children()
if operator.value() is True
]
if len(selected_operators) != 0:
expt_query = expt_query.filter(
db.Experiment.operator_name.in_(selected_operators))
selected_hashtags = [
ht.name() for ht in self.hash_select.children()[1:]
if ht.value() is True
]
if len(selected_hashtags) != 0:
timestamps = self.get_expts_hashtag(selected_hashtags)
expt_query = expt_query.filter(
db.Experiment.ext_id.in_(timestamps))
expts = expt_query.all()
self.set_expts(expts)
def n_test_spikes(pair):
syn_type = pair.pre_cell.cell_class_nonsynaptic
if syn_type not in ['ex', 'in']:
return np.nan
p = db.query(db.Pair).filter(db.Pair.id == pair.id).all()[0]
n_spikes = getattr(p, 'n_%s_test_spikes' % syn_type)
n_spikes = n_spikes if n_spikes <= 800 else 800
return n_spikes
def baseline_rms_noise(pair):
post_cell = pair.post_cell
q = db.query(db.PatchClampRecording)
q = q.join(db.Recording).join(db.Electrode).join(db.Cell)
q = q.filter(db.Cell.id == post_cell.id).filter(
db.PatchClampRecording.clamp_mode == 'ic')
pcrs = q.all()
pcr_noise = [pcr.baseline_rms_noise for pcr in pcrs if pcr.qc_pass]
if len(pcr_noise) > 1:
return np.mean(pcr_noise)
else:
return np.nan
def scatter_plot_clicked(self, plt, points):
for plt in self.data_plots + self.dec_plots + self.spike_plots:
plt.clear()
# query raw data for selected points
ids = [int(pt.data()['pulse_response_id']) for pt in points]
q = db.query(db.PulseResponse, db.PulseResponse.data,
db.PulseResponseFit).outerjoin(
db.PulseResponseFit).filter(
db.PulseResponse.id.in_(ids))
recs = q.all()
print("Selected pulse responses:")
for rec in recs:
print(rec.PulseResponse.id, rec.PulseResponse.meta)
self._plot_pulse_response(rec)
self.scatter_plot.setSelectedPoints(points)
def load_pair(self, pair):
if pair is not self.loaded_pair:
print("Loading:", pair)
self.loaded_pair = pair
# Load data for scatter plot
cols = [
spec['column'].label(name)
for name, spec in self.fields.items()
]
q = db.query(*cols)
q = q.outerjoin(
db.PulseResponseFit,
db.PulseResponseFit.pulse_response_id == db.PulseResponse.id)
q = q.outerjoin(
db.PulseResponseStrength,
db.PulseResponseStrength.pulse_response_id ==
db.PulseResponse.id)
q = q.join(db.StimPulse, db.PulseResponse.stim_pulse)
q = q.join(db.Recording,
db.PulseResponse.recording_id == db.Recording.id)
q = q.join(db.PatchClampRecording,
db.PatchClampRecording.recording_id == db.Recording.id)
q = q.join(db.MultiPatchProbe)
q = q.filter(db.PulseResponse.pair_id == pair.id)
recs = q.all()
print("loaded %d/%s pulse responses" %
(len(recs), len(pair.pulse_responses)))
self.loaded_recs = recs
data = np.empty(len(recs), dtype=self.dtype)
for i, rec in enumerate(recs):
for name, spec in self.dtype:
data[i][name] = getattr(rec, name)
self.loaded_data = data
self.scatter_plot.setData(data)
def __init__(self, default_session, notes_session):
pg.QtGui.QWidget.__init__(self)
self.default_session = default_session
self.notes_session = notes_session
self.layout = pg.QtGui.QGridLayout()
self.setLayout(self.layout)
self.h_splitter = pg.QtGui.QSplitter()
self.h_splitter.setOrientation(pg.QtCore.Qt.Horizontal)
self.pair_analyzer = PairAnalysis()
self.fit_explorer = None
self.ctrl_panel = self.pair_analyzer.ctrl_panel
self.user_params = self.ctrl_panel.user_params
self.output_params = self.ctrl_panel.output_params
self.ptree = ptree.ParameterTree(showHeader=False)
self.pair_param = Parameter.create(name='Current Pair', type='str', readonly=True)
self.ptree.addParameters(self.pair_param)
self.ptree.addParameters(self.user_params, showTop=False)
self.fit_ptree = ptree.ParameterTree(showHeader=False)
self.fit_ptree.addParameters(self.output_params, showTop=False)
self.save_btn = pg.FeedbackButton('Save Analysis')
self.expt_btn = pg.QtGui.QPushButton('Set Experiments')
self.fit_btn = pg.QtGui.QPushButton('Fit Responses')
self.ic_plot = self.pair_analyzer.ic_plot
self.vc_plot = self.pair_analyzer.vc_plot
self.select_ptree = ptree.ParameterTree(showHeader=False)
self.hash_select = Parameter.create(name='Hashtags', type='group', children=
[{'name': 'With multiple selected:', 'type': 'list', 'values': ['Include if any appear', 'Include if all appear'], 'value': 'Include if any appear'}]+
[{'name': '#', 'type': 'bool'}] +
[{'name': ht, 'type': 'bool'} for ht in comment_hashtag[1:]])
self.rigs = db.query(db.Experiment.rig_name).distinct().all()
self.operators = db.query(db.Experiment.operator_name).distinct().all()
self.rig_select = Parameter.create(name='Rig', type='group', children=[{'name': rig[0], 'type': 'bool'} for rig in self.rigs])
self.operator_select = Parameter.create(name='Operator', type='group', children=[{'name': operator[0], 'type': 'bool'} for operator in self.operators])
self.data_type = Parameter.create(name='Reduce data to:', type='group', children=[
{'name': 'Pairs with data', 'type': 'bool', 'value': True},
{'name': 'Synapse is None', 'type': 'bool'}])
[self.select_ptree.addParameters(param) for param in [self.data_type, self.rig_select, self.operator_select, self.hash_select]]
self.experiment_browser = self.pair_analyzer.experiment_browser
self.v_splitter = pg.QtGui.QSplitter()
self.v_splitter.setOrientation(pg.QtCore.Qt.Vertical)
self.expt_splitter = pg.QtGui.QSplitter()
self.expt_splitter.setOrientation(pg.QtCore.Qt.Vertical)
self.h_splitter.addWidget(self.expt_splitter)
self.expt_splitter.addWidget(self.select_ptree)
self.expt_splitter.addWidget(self.expt_btn)
self.h_splitter.addWidget(self.v_splitter)
self.v_splitter.addWidget(self.experiment_browser)
self.v_splitter.addWidget(self.ptree)
self.v_splitter.addWidget(self.fit_btn)
self.v_splitter.addWidget(self.fit_ptree)
self.v_splitter.addWidget(self.save_btn)
self.v_splitter.setSizes([200, 20, 20,400, 20])
# self.next_pair_button = pg.QtGui.QPushButton("Load Next Pair")
# self.v_splitter.addWidget(self.next_pair_button)
self.h_splitter.addWidget(self.vc_plot.grid)
self.h_splitter.addWidget(self.ic_plot.grid)
self.fit_compare = self.pair_analyzer.fit_compare
self.meta_compare = self.pair_analyzer.meta_compare
self.v2_splitter = pg.QtGui.QSplitter()
self.v2_splitter.setOrientation(pg.QtCore.Qt.Vertical)
self.v2_splitter.addWidget(self.fit_compare)
self.v2_splitter.addWidget(self.meta_compare)
self.h_splitter.addWidget(self.v2_splitter)
self.h_splitter.setSizes([100, 200, 200, 200, 500])
self.layout.addWidget(self.h_splitter)
self.fit_compare.hide()
self.meta_compare.hide()
self.setGeometry(280, 130, 1500, 900)
self.show()
# self.next_pair_button.clicked.connect(self.load_next_pair)
self.experiment_browser.itemSelectionChanged.connect(self.selected_pair)
self.save_btn.clicked.connect(self.save_to_db)
self.expt_btn.clicked.connect(self.get_expts)
self.fit_btn.clicked.connect(self.pair_analyzer.fit_response_update)
parser.add_argument('--check', action='store_true')
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()
]
mw = MainWindow(default_session, notes_session)
if args.check is True:
pair_in_notes = []
pair_not_in_notes = []
ghost_pair = []
print('checking %d pairs...' % len(synapses))
for pair in synapses:
pair_notes = pair_notes_query(notes_session, pair).all()
if len(pair_notes) == 0:
pair_not_in_notes.append(pair)
elif len(pair_notes) == 1:
pair_in_notes.append(pair)
else:
import re, argparse, sys
from datetime import datetime
from aisynphys.database import default_db as db
if __name__ == '__main__':
args = sys.argv[1:]
start = datetime.strptime(args[0], "%y%m%d")
stop = datetime.strptime(args[1], "%y%m%d")
tubes = db.query(db.PatchSeq.tube_id).all()
n_tubes = 0
for tube in tubes:
name_check = re.match(r'P(M|T)S4_(?P<date>\d{6})_(?P<tube_id>\d{3})_A01', tube[0])
if name_check is not None:
date=name_check.group('date')
date=datetime.strptime(date, "%y%m%d")
if date >= start and date <= stop:
n_tubes+=1
print("Number of tubes from %s - %s: %d" % (start.date(), stop.date(), n_tubes))
import pyqtgraph as pg
import numpy as np
import time, random, sys, argparse
pg.dbg()
parser = argparse.ArgumentParser()
parser.add_argument('--timeline', action='store_true')
parser.add_argument('--hist', action='store_true')
args = parser.parse_args(sys.argv[1:])
species = {'mouse': ['o', (0, 0, 255, 150)], 'human': ['s', (0, 255, 0, 150)]}
metrics = ['area_400_10000bp', 'picogreen_yield','norm_marker_sum', 'genes_detected', 'tree_call']
q = db.query(db.PatchSeq, db.Experiment.acq_timestamp)
q = q.join(db.Cell, db.PatchSeq.cell_id==db.Cell.id)
q = q.join(db.Experiment, db.Cell.experiment_id==db.Experiment.id)
q = q.join(db.Slice, db.Experiment.slice_id==db.Slice.id)
q = q.filter(db.Experiment.operator_name=='Operator Z')
for metric in metrics:
ticks = None
if args.timeline:
time_plt = pg.plot()
time_plt.addLegend()
if args.hist:
hist_plt = pg.plot()
hist_plt.addLegend()
for organism, symbols in species.items():
patchseq_cells = q.filter(db.Slice.species==organism)
parser = argparse.ArgumentParser(parents=[config.parser])
parser.add_argument('experiment_id', type=str)
parser.add_argument('pre_cell_id', type=str, nargs='?')
parser.add_argument('post_cell_id', type=str, nargs='?')
args = parser.parse_args()
cell_ids = [
cid for cid in (args.pre_cell_id, args.post_cell_id) if cid is not None
]
expt = db.experiment_from_ext_id(args.experiment_id)
pipeline_jobs = {
job.module_name: job
for job in db.query(db.Pipeline).filter(
db.Pipeline.job_id == args.experiment_id).all()
}
def print_attrs(obj, attrs, indent=0, prefix=""):
maxlen = max([len(a) for a in attrs])
for attr in attrs:
if isinstance(attr, tuple):
attr, fmt, fn = attr
else:
fmt = str(maxlen) + "s"
fn = str
print(" " * indent +
("{prefix}{attr:" + fmt + "} : {val:s}"
).format(attr=attr, val=fn(getattr(obj, attr)), prefix=prefix))
