def test_nested_busy_cursors_clear_after_all_exit():
with pg.BusyCursor():
wait_cursor = pg.Qt.QtCore.Qt.CursorShape.WaitCursor
with pg.BusyCursor():
assert pg.Qt.QtGui.QApplication.overrideCursor().shape(
) == wait_cursor, "Cursor should be waiting"
assert pg.Qt.QtGui.QApplication.overrideCursor().shape(
) == wait_cursor, "Cursor should be waiting"
assert pg.Qt.QtGui.QApplication.overrideCursor(
) is None, "No override cursor should be set"
def plot_all(self):
with pg.BusyCursor():
self.clear()
show_spikes = self.params['show spikes']
for i, stim_key in enumerate(self.stim_keys):
if self.params['stimulus filter', str(stim_key)] is False:
continue
plt = DynamicsPlot()
self.plots.append(plt)
self.view.addItem(plt)
self.view.nextRow()
plt.set_title("%s %0.0f Hz %0.2f s" % stim_key)
prs = self.sorted_recs[stim_key]
plt.set_data(
prs,
show_spikes=show_spikes,
subtract_baseline=self.params['subtract baseline'])
plt_height = max(400 if show_spikes else 250,
self.scroll_area.height() / len(self.stim_keys))
self.view.setFixedHeight(plt_height * len(self.plots))
self.view.setFixedWidth(
self.scroll_area.width() -
self.scroll_area.verticalScrollBar().width())
def run():
global results # allow inspection from console
n_types = params['n_types']
Wab = np.array(
[[float(str(wab_table.item(i, j).text())) for j in range(n_types)]
for i in range(n_types)])
with pg.BusyCursor():
results = run_expt(Wab,
n_cells=params['n_cells'],
n_expts=params['n_expts'],
n_trials=params['n_trials'])
cprobs = results['conn'].sum(axis=1) / results['probed'].sum(axis=1)
rprobs = results['recip'].sum(axis=1) / results['probed'].sum(axis=1)
ex_rprobs = cprobs**2
ratios = rprobs / ex_rprobs
y = pg.pseudoScatter(cprobs)
c_plt.plot(cprobs, y, clear=True, pen=None, symbol='o')
c_plt.addLine(x=Wab.mean())
y = pg.pseudoScatter(rprobs)
r_plt.plot(rprobs, y, clear=True, pen=None, symbol='o')
y = pg.pseudoScatter(ratios)
ratio_plt.plot(ratios, y, clear=True, pen=None, symbol='o')
ratio_plt.addLine(x=1)
rr_plt.plot(ex_rprobs, rprobs, clear=True, pen=None, symbol='o')
l = pg.InfiniteLine(angle=45)
rr_plt.addItem(l)
def update_image_data(self):
if self.atlas_data.image is None or self.atlas_data.label is None:
return
axis = self.display_ctrl.params['Orientation']
axes = {
'right': ('right', 'anterior', 'dorsal'),
'dorsal': ('dorsal', 'right', 'anterior'),
'anterior': ('anterior', 'right', 'dorsal')
}[axis]
order = [self.atlas_data.image._interpretAxis(ax) for ax in axes]
# transpose, flip, downsample images
ds = self.display_ctrl.params['Downsample']
self.display_atlas = self.atlas_data.image.view(
np.ndarray).transpose(order)
with pg.BusyCursor():
for ax in (0, 1, 2):
self.display_atlas = pg.downsample(self.display_atlas,
ds,
axis=ax)
self.display_label = self.atlas_data.label.view(
np.ndarray).transpose(order)[::ds, ::ds, ::ds]
# make sure atlas/label have the same size after downsampling
scale = self.atlas_data.image._info[-1]['vxsize'] * ds
self.scale = (scale, scale)
self.zslider.setMaximum(self.display_atlas.shape[0])
self.zslider.setValue(self.display_atlas.shape[0] // 2)
self.angle_slider.setValue(0)
self.update_ortho_image()
self.update_slice_image()
self.lut.setLevels(self.display_atlas.min(), self.display_atlas.max())
def selected_pair(self):
with pg.BusyCursor():
self.fit_compare.hide()
self.meta_compare.hide()
selected = self.experiment_browser.selectedItems()
if len(selected) != 1:
return
item = selected[0]
if hasattr(item, 'pair') is False:
return
pair = item.pair
## check to see if the pair has already been analyzed
expt_id = pair.experiment.ext_id
pre_cell_id = pair.pre_cell.ext_id
post_cell_id = pair.post_cell.ext_id
record = notes_db.get_pair_notes_record(expt_id, pre_cell_id, post_cell_id, session=self.notes_session)
self.pair_param.setValue(pair)
if record is None:
self.pair_analyzer.load_pair(pair, self.default_session)
self.pair_analyzer.analyze_responses()
# self.pair_analyzer.fit_responses()
else:
self.pair_analyzer.load_pair(pair, self.default_session, record=record)
self.pair_analyzer.analyze_responses()
self.pair_analyzer.load_saved_fit(record)
def load_pair(self, pair, default_session, record=None):
self.record = record
self.initial_fit_parameters = OrderedDict([
('vc', {'-55': {}, '-70': {}}),
('ic', {'-55': {}, '-70': {}}),
])
self.output_fit_parameters = OrderedDict([
('vc', {'-55': {}, '-70': {}}),
('ic', {'-55': {}, '-70': {}}),
])
self.fit_params = {'initial': self.initial_fit_parameters, 'fit': self.output_fit_parameters}
with pg.BusyCursor():
self.reset_display()
self.pair = pair
print ('loading responses for %s...' % pair)
q = response_query(default_session, pair)
self.pulse_responses = [q.PulseResponse for q in q.all()]
print('got %d pulse responses' % len(self.pulse_responses))
if pair.has_synapse is True:
synapse_type = pair.synapse.synapse_type
else:
synapse_type = None
pair_params = {'Synapse call': synapse_type, 'Gap junction call': pair.has_electrical}
self.ctrl_panel.update_user_params(**pair_params)
self.ctrl_panel.update_fit_params(self.fit_params['fit'], fit_pass=True)
def updateImage(self):
if self.atlas is None or self.label is None:
return
axis = self.displayCtrl.params['Orientation']
axes = {
'right': ('right', 'anterior', 'dorsal'),
'dorsal': ('dorsal', 'right', 'anterior'),
'anterior': ('anterior', 'right', 'dorsal')
}[axis]
order = [self.atlas._interpretAxis(ax) for ax in axes]
# transpose, flip, downsample images
ds = self.displayCtrl.params['Downsample']
self.displayAtlas = self.atlas.view(np.ndarray).transpose(order)
with pg.BusyCursor():
for ax in (0, 1, 2):
self.displayAtlas = pg.downsample(self.displayAtlas,
ds,
axis=ax)
self.displayLabel = self.label.view(
np.ndarray).transpose(order)[::ds, ::ds, ::ds]
# make sure atlas/label have the same size after downsampling
self.view.setData(self.displayAtlas,
self.displayLabel,
scale=self.atlas._info[-1]['vxsize'] * ds)
def load_pair(self, pair=None):
pair = pair or self.pair
if pair is None:
return
limit = self.params['data', 'limit']
with pg.BusyCursor():
pre_prec = db.aliased(db.PatchClampRecording)
post_prec = db.aliased(db.PatchClampRecording)
q = db.query(db.PulseResponse).join(db.StimPulse).join(db.Pair)
q = q.join(pre_prec,
db.PulseResponse.recording_id == pre_prec.recording_id)
q = q.join(post_prec,
db.StimPulse.recording_id == post_prec.recording_id)
q = q.filter(db.Pair.id == pair.id)
q = q.filter(pre_prec.clamp_mode == self.params['data',
'pre mode'])
q = q.filter(post_prec.clamp_mode == self.params['data',
'post mode'])
prs = q.limit(limit).all()
# preload pulse response data
ids = [pr.id for pr in prs]
db.query(db.PulseResponse.data).filter(
db.PulseResponse.id.in_(ids)).all()
self.response_list = StimResponseList(prs)
self.update_analysis()
def display_matrix_element_data(self, matrix_item, event, row, col):
with pg.BusyCursor():
field_name = self.matrix_display.matrix_display_filter.get_colormap_field()
pre_class, post_class = [k for k, v in self.matrix_display.matrix_map.items() if v==[row, col]][0]
#element = self.results.groupby(['pre_class', 'post_class']).get_group((pre_class, post_class))
element = self.results.loc[self.pair_groups[(pre_class, post_class)]]
if len(element) == 0:
print ('%s->%s has no data, please select another element' % (pre_class, post_class))
return
analyzer = self.field_map[field_name]
analyzer.print_element_info(pre_class, post_class, element, field_name)
# from here row and col are tuples (row, pre_class) and (col, post_class) respectively
row = (row, pre_class)
col = (col, post_class)
if int(event.modifiers() & pg.QtCore.Qt.ControlModifier)>0:
self.selected += 1
if self.selected >= len(self.colors):
self.selected = 0
color = self.colors[self.selected]
self.matrix_display.color_element(row, col, color)
self.hist_plot.plot_element_data(element, analyzer, color, self.trace_panel)
self.distance_plot.element_distance(element, color)
self.element_scatter.color_selected_element(color, pre_class, post_class)
self.pair_scatter.color_selected_element(color, pre_class, post_class)
# self.pair_scatter.filter_selected_element(pre_class, post_class)
else:
self.display_matrix_element_reset()
color = self.colors[self.selected]
self.matrix_display.color_element(row, col, color)
self.hist_plot.plot_element_data(element, analyzer, color, self.trace_panel)
self.distance_plot.element_distance(element, color)
self.element_scatter.color_selected_element(color, pre_class, post_class)
self.pair_scatter.color_selected_element(color, pre_class, post_class)
def select_complete_clicked(param):
with pg.BusyCursor():
n_frames = raw_imgs.shape[2]
for child in p_cell_selection.children()[0]:
cell_id = int(child.name())
visibility = (len(cell_frame_presence[cell_id]) == n_frames)
child.setValue(visibility)
def update_clicked(self):
p = cProfile.Profile()
# p.enable()
try:
with pg.BusyCursor():
# self.analyzers_needed()
self.update_results()
pre_cell_classes = self.cell_class_filter.get_pre_or_post_classes(
'presynaptic')
post_cell_classes = self.cell_class_filter.get_pre_or_post_classes(
'postsynaptic')
self.matrix_display.update_matrix_display(
self.results,
self.group_results,
self.cell_groups,
self.field_map,
pre_cell_classes=pre_cell_classes,
post_cell_classes=post_cell_classes)
self.hist_plot.matrix_histogram(
self.results, self.group_results,
self.matrix_display.matrix_display_filter.colorMap,
self.field_map)
self.element_scatter.set_data(self.group_results)
self.pair_scatter.set_data(self.results)
self.dist_plot = self.distance_plot.plot_distance(
self.results,
color=(128, 128, 128),
name='All Connections',
suppress_scatter=True)
if self.main_window.matrix_widget.matrix is not None:
self.display_matrix_element_reset()
finally:
p.disable()
def load_conn(self, pair):
with pg.BusyCursor():
amp_recs = get_amps(self.session, pair)
base_recs = get_baseline_amps(self.session, pair, limit=len(amp_recs))
for analyzer in self.analyzers:
analyzer.load_conn(pair, amp_recs, base_recs)
def deploy(self):
with pg.BusyCursor():
# Calculate detector translation required in x and y
dx = self.parent.pixelSize * 1e6 * (self.parent.roi.centreX - self.parent.cx) # microns
dy = self.parent.pixelSize * 1e6 * (self.parent.roi.centreY - self.parent.cy) # microns
dz = np.mean(-self.parent.det.coords_z(self.parent.evt)) - self.parent.detectorDistance * 1e6 # microns
geo = self.parent.det.geometry(self.parent.evt)
top = geo.get_top_geo()
children = top.get_list_of_children()[0]
geo.move_geo(children.oname, 0, dx=-dy, dy=-dx, dz=dz)
fname = self.parent.psocakeRunDir + "/"+str(self.parent.runNumber)+'-end.data'
geo.save_pars_in_file(fname)
print("#################################################")
print("Deploying psana detector geometry: ", fname)
print("#################################################")
cmts = {'exp': self.parent.experimentName, 'app': 'psocake', 'comment': 'recentred geometry'}
if self.parent.args.localCalib:
calibDir = './calib'
elif self.parent.args.outDir is None:
calibDir = self.parent.rootDir + '/calib'
else:
calibDir = self.parent.dir + '/' + self.parent.experimentName[:3] + '/' + \
self.parent.experimentName + '/calib'
deploy_calib_file(cdir=calibDir, src=str(self.parent.det.name), type='geometry',
run_start=self.parent.runNumber, run_end=None, ifname=fname, dcmts=cmts, pbits=0)
# Reload new psana geometry
self.parent.exp.setupExperiment()
self.parent.img.getDetImage(self.parent.eventNumber)
self.updateRings()
self.parent.index.updateIndex()
self.drawCentre()
# Show mask
self.parent.mk.updatePsanaMaskOn()
def _dbl_clicked(self, index):
"""Item double clicked; load in NWB viewer
"""
with pg.BusyCursor():
item = self.browser.itemFromIndex(index)[0]
self.nwb_viewer.load_nwb(item.expt.nwb_file)
self.nwb_viewer.show()
def clicked(self, points):
with pg.BusyCursor():
if self.parent.args.v >= 1:
print("curve clicked", points)
from pprint import pprint
pprint(vars(points.scatter))
for i in range(len(points.scatter.data)):
if points.scatter.ptsClicked[0] == points.scatter.data[i][7]:
ind = i
break
indX = points.scatter.data[i][0]
indY = points.scatter.data[i][1]
if self.parent.args.v >= 1: print "x,y: ", indX, indY
if self.quantifier_sort:
ind = self.quantifierIndSorted[ind]
if self.parent.eventNumber != self.quantifierEvent[ind]:
self.parent.eventNumber = self.quantifierEvent[ind]
self.parent.calib, self.parent.data = self.parent.img.getDetImage(
self.parent.eventNumber)
self.parent.img.win.setImage(self.parent.data,
autoRange=False,
autoLevels=False,
autoHistogramRange=False)
self.parent.exp.p.param(self.parent.exp.exp_grp,
self.parent.exp.exp_evt_str).setValue(
self.parent.eventNumber)
def set_expts(self, expts):
with pg.BusyCursor():
self.experiment_browser.clear()
has_data = self.data_type['Pairs with data']
if not has_data:
self.experiment_browser.populate(experiments=expts, all_pairs=True)
else:
self.experiment_browser.populate(experiments=expts)
def deploy(self):
with pg.BusyCursor():
# Calculate detector translation in x and y
dx = self.parent.pixelSize * 1e6 * (
self.parent.cx - self.parent.roi.centreX) # microns
dy = self.parent.pixelSize * 1e6 * (
self.parent.cy - self.parent.roi.centreY) # microns
dz = np.mean(self.parent.det.coords_z(self.parent.evt)
) - self.parent.detectorDistance * 1e6 # microns
geo = self.parent.det.geometry(self.parent.evt)
if 'cspad' in self.parent.detInfo.lower(
) and 'cxi' in self.parent.experimentName:
geo.move_geo('CSPAD:V1', 0, dx=dx, dy=dy, dz=-dz)
elif 'rayonix' in self.parent.detInfo.lower(
) and 'mfx' in self.parent.experimentName:
top = geo.get_top_geo()
children = top.get_list_of_children()[0]
geo.move_geo(children.oname, 0, dx=dx, dy=dy, dz=-dz)
elif 'rayonix' in self.parent.detInfo.lower(
) and 'xpp' in self.parent.experimentName:
top = geo.get_top_geo()
children = top.get_list_of_children()[0]
geo.move_geo(children.oname, 0, dx=dx, dy=dy, dz=-dz)
else:
print "deploy not implemented"
fname = self.parent.psocakeRunDir + "/" + str(
self.parent.runNumber) + '-end.data'
geo.save_pars_in_file(fname)
print "#################################################"
print "Deploying psana detector geometry: ", fname
print "#################################################"
cmts = {
'exp': self.parent.experimentName,
'app': 'psocake',
'comment': 'recentred geometry'
}
if self.parent.args.localCalib:
calibDir = './calib'
elif self.parent.args.outDir is None:
calibDir = self.parent.rootDir + '/calib'
else:
calibDir = '/reg/d/psdm/' + self.parent.experimentName[:
3] + '/' + self.parent.experimentName + '/calib'
deploy_calib_file(cdir=calibDir,
src=str(self.parent.det.name),
type='geometry',
run_start=self.parent.runNumber,
run_end=None,
ifname=fname,
dcmts=cmts,
pbits=0)
# Reload new psana geometry
self.parent.exp.setupExperiment()
self.parent.img.getDetImage(self.parent.eventNumber)
self.updateRings()
self.parent.index.updateIndex()
self.drawCentre()
def createMuliColorAndList(self):
""" Finally Load Images and poplulate the list widget from the dictionary"""
with pg.BusyCursor(): # gives the circle showing gui is doing something
self.generateImageDictionary()
if self.image_dict:
self.createMultiColorView(self.image_dict)
self.displayImageNames(self.image_dict)
else:
pass
def mkData():
with pg.BusyCursor():
global data, cache, ui, xp
frames = ui.framesSpin.value()
width = ui.widthSpin.value()
height = ui.heightSpin.value()
cacheKey = (ui.dtypeCombo.currentText(), ui.rgbCheck.isChecked(),
frames, width, height)
if cacheKey not in cache:
if cacheKey[0] == 'uint8':
dt = xp.uint8
loc = 128
scale = 64
mx = 255
elif cacheKey[0] == 'uint16':
dt = xp.uint16
loc = 4096
scale = 1024
mx = 2**16 - 1
elif cacheKey[0] == 'float':
dt = xp.float32
loc = 1.0
scale = 0.1
mx = 1.0
else:
raise ValueError(f"unable to handle dtype: {cacheKey[0]}")
chan_shape = (height, width)
if ui.rgbCheck.isChecked():
frame_shape = chan_shape + (3, )
else:
frame_shape = chan_shape
data = xp.empty((frames, ) + frame_shape, dtype=dt)
view = data.reshape((-1, ) + chan_shape)
for idx in range(view.shape[0]):
subdata = xp.random.normal(loc=loc,
scale=scale,
size=chan_shape)
# note: gaussian filtering has been removed as it slows down array
# creation greatly.
if cacheKey[0] != 'float':
xp.clip(subdata, 0, mx, out=subdata)
view[idx] = subdata
data[:, 10:50, 10] = mx
data[:, 48, 9:12] = mx
data[:, 47, 8:13] = mx
cache = {
cacheKey: data
} # clear to save memory (but keep one to prevent unnecessary regeneration)
data = cache[cacheKey]
updateLUT()
updateSize()
def browser_item_selected(self):
with pg.BusyCursor():
selected = self.browser.selectedItems()
if len(selected) != 1:
return
item = selected[0]
if not hasattr(item, 'pair'):
return
pair = item.pair
self.load_pair(pair)
def syncGeom(self):
with pg.BusyCursor():
print "#################################################"
print "Updating psana geometry with CrystFEL geometry"
print "#################################################"
self.parent.geom.findPsanaGeometry()
psanaGeom = self.parent.psocakeRunDir + "/.temp.data"
if self.parent.args.localCalib:
cmd = [
"crystfel2psana", "-e", self.parent.experimentName, "-r",
str(self.parent.runNumber), "-d",
str(self.parent.det.name), "--rootDir", '.', "-c",
self.geom, "-p", psanaGeom, "-z",
str(self.parent.clen)
]
else:
cmd = [
"crystfel2psana", "-e", self.parent.experimentName, "-r",
str(self.parent.runNumber), "-d",
str(self.parent.det.name), "--rootDir",
self.parent.rootDir, "-c", self.geom, "-p", psanaGeom,
"-z",
str(self.parent.clen)
]
if self.parent.args.v >= 0: print "cmd: ", cmd
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
output = p.communicate()[0]
p.stdout.close()
# Reload new psana geometry
cmts = {
'exp': self.parent.experimentName,
'app': 'psocake',
'comment': 'converted from crystfel geometry'
}
if self.parent.args.localCalib:
calibDir = './calib'
elif self.parent.args.outDir is None:
calibDir = self.parent.rootDir + '/calib'
else:
calibDir = '/reg/d/psdm/' + self.parent.experimentName[:
3] + '/' + self.parent.experimentName + '/calib'
deploy_calib_file(cdir=calibDir,
src=str(self.parent.det.name),
type='geometry',
run_start=self.parent.runNumber,
run_end=None,
ifname=psanaGeom,
dcmts=cmts,
pbits=0)
self.parent.exp.setupExperiment()
self.parent.img.getDetImage(self.parent.eventNumber)
self.parent.geom.updateRings()
self.parent.index.updateIndex()
self.parent.geom.drawCentre()
def save_selected_clicked(param):
if not any(cell_visibility.values()):
pg.Qt.QtGui.QMessageBox.error(
b_save_selected, 'Save failed',
'Please select at least one cell before saving')
return
with pg.BusyCursor():
save_results(path_in, trj, col_tuple, col_weights, id_masks, cell_ids,
background_id, color_list, cell_color_idx,
cell_visibility, params['Pixel scale'][0],
params['Pixel scale'][3], params['Show id\'s'][0], True,
params['Show tracks'][0], params['Mask extension'][0])
def autoDeploy(self):
with pg.BusyCursor():
powderHits = np.load(self.parent.psocakeRunDir + '/' + self.parent.experimentName + '_' + str(self.parent.runNumber).zfill(4) + '_maxHits.npy')
powderMisses = np.load(self.parent.psocakeRunDir + '/' + self.parent.experimentName + '_' + str(self.parent.runNumber).zfill(4) + '_maxMisses.npy')
powderImg = self.parent.det.image(self.parent.evt, np.maximum(powderHits,powderMisses))
centreRow, centreCol = findDetectorCentre(np.log(abs(powderImg)), self.parent.cx, self.parent.cy, range=200)
print("Current centre along row,centre along column: ", self.parent.cx, self.parent.cy)
print("Optimum centre along row,centre along column: ", centreRow, centreCol)
allowedDeviation = 175 # pixels
if abs(self.parent.cx - centreRow) <= allowedDeviation and \
abs(self.parent.cy - centreCol) <= allowedDeviation:
deploy = True
else:
deploy = False
print "Too far away from current centre. I will not deploy the auto centred geometry."
if deploy:
# Calculate detector translation in x and y
dx = self.parent.pixelSize * 1e6 * (self.parent.cx - centreRow) # microns
dy = self.parent.pixelSize * 1e6 * (self.parent.cy - centreCol) # microns
dz = np.mean(self.parent.det.coords_z(self.parent.evt)) - self.parent.detectorDistance * 1e6 # microns
geo = self.parent.det.geometry(self.parent.evt)
if 'cspad' in self.parent.detInfo.lower() and 'cxi' in self.parent.experimentName:
geo.move_geo('CSPAD:V1', 0, dx=dx, dy=dy, dz=-dz)
elif 'rayonix' in self.parent.detInfo.lower() and 'mfx' in self.parent.experimentName:
top = geo.get_top_geo()
children = top.get_list_of_children()[0]
geo.move_geo(children.oname, 0, dx=dx, dy=dy, dz=-dz)
elif 'rayonix' in self.parent.detInfo.lower() and 'xpp' in self.parent.experimentName:
top = geo.get_top_geo()
children = top.get_list_of_children()[0]
geo.move_geo(children.oname, 0, dx=dx, dy=dy, dz=-dz)
else:
print "autoDeploy not implemented"
fname = self.parent.psocakeRunDir + "/" + str(self.parent.runNumber) + '-end.data'
geo.save_pars_in_file(fname)
print "#################################################"
print "Deploying psana detector geometry: ", fname
print "#################################################"
cmts = {'exp': self.parent.experimentName, 'app': 'psocake', 'comment': 'auto recentred geometry'}
if self.parent.args.localCalib:
calibDir = './calib'
elif self.parent.args.outDir is None:
calibDir = self.parent.rootDir + '/calib'
else:
calibDir = '/reg/d/psdm/' + self.parent.experimentName[:3] + '/' + self.parent.experimentName + '/calib'
deploy_calib_file(cdir=calibDir, src=str(self.parent.det.name), type='geometry',
run_start=self.parent.runNumber, run_end=None, ifname=fname, dcmts=cmts, pbits=0)
# Reload new psana geometry
self.parent.exp.setupExperiment()
self.parent.img.getDetImage(self.parent.eventNumber)
self.updateRings()
self.parent.index.updateIndex()
self.drawCentre()
def autoDeploy(self): #FIXME: yet to verify this works correctly on new lab coordinate
with pg.BusyCursor():
powderHits = np.load(self.parent.psocakeRunDir + '/' + self.parent.experimentName + '_' + str(self.parent.runNumber).zfill(4) + '_maxHits.npy')
powderMisses = np.load(self.parent.psocakeRunDir + '/' + self.parent.experimentName + '_' + str(self.parent.runNumber).zfill(4) + '_maxMisses.npy')
powderImg = self.parent.det.image(self.parent.evt, np.maximum(powderHits,powderMisses))
centreRow, centreCol = findDetectorCentre(np.log(abs(powderImg)), self.parent.cx, self.parent.cy, range=200)
print("Current centre along row,centre along column: ", self.parent.cx, self.parent.cy)
print("Optimum centre along row,centre along column: ", centreRow, centreCol)
allowedDeviation = 175 # pixels
if abs(self.parent.cx - centreRow) <= allowedDeviation and \
abs(self.parent.cy - centreCol) <= allowedDeviation:
deploy = True
else:
deploy = False
print("Too far away from current centre. I will not deploy the auto centred geometry.")
if deploy:
# Calculate detector translation in x and y
dx = self.parent.pixelSize * 1e6 * (self.parent.cx - centreRow) # microns
dy = self.parent.pixelSize * 1e6 * (self.parent.cy - centreCol) # microns
dz = np.mean(-self.parent.det.coords_z(self.parent.evt)) - self.parent.detectorDistance * 1e6 # microns
dx = self.parent.pixelSize * 1e6 * (self.parent.roi.centreX - self.parent.cx) # microns
dy = self.parent.pixelSize * 1e6 * (self.parent.roi.centreY - self.parent.cy) # microns
dz = np.mean(-self.parent.det.coords_z(self.parent.evt)) - self.parent.detectorDistance * 1e6 # microns
geo = self.parent.det.geometry(self.parent.evt)
top = geo.get_top_geo()
children = top.get_list_of_children()[0]
geo.move_geo(children.oname, 0, dx=-dy, dy=-dx, dz=dz)
fname = self.parent.psocakeRunDir + "/" + str(self.parent.runNumber) + '-end.data'
geo.save_pars_in_file(fname)
print("#################################################")
print("Deploying psana detector geometry: ", fname)
print("#################################################")
cmts = {'exp': self.parent.experimentName, 'app': 'psocake', 'comment': 'auto recentred geometry'}
if self.parent.args.localCalib:
calibDir = './calib'
elif self.parent.args.outDir is None:
calibDir = self.parent.rootDir + '/calib'
else:
calibDir = self.parent.dir + '/' + self.parent.experimentName[:3] + '/' + self.parent.experimentName + \
'/calib'
deploy_calib_file(cdir=calibDir, src=str(self.parent.det.name), type='geometry',
run_start=self.parent.runNumber, run_end=None, ifname=fname, dcmts=cmts, pbits=0)
# Reload new psana geometry
self.parent.exp.setupExperiment()
self.parent.img.getDetImage(self.parent.eventNumber)
self.updateRings()
self.parent.index.updateIndex()
self.drawCentre()
# Show mask
self.parent.mk.updatePsanaMaskOn()
def mkData():
with pg.BusyCursor():
global data, cache, ui, xp
frames = ui.framesSpin.value()
width = ui.widthSpin.value()
height = ui.heightSpin.value()
cacheKey = (ui.dtypeCombo.currentText(), ui.rgbCheck.isChecked(),
frames, width, height)
if cacheKey not in cache:
if cacheKey[0] == 'uint8':
dt = xp.uint8
loc = 128
scale = 64
mx = 255
elif cacheKey[0] == 'uint16':
dt = xp.uint16
loc = 4096
scale = 1024
mx = 2**16
elif cacheKey[0] == 'float':
dt = xp.float
loc = 1.0
scale = 0.1
mx = 1.0
else:
raise ValueError(f"unable to handle dtype: {cacheKey[0]}")
if ui.rgbCheck.isChecked():
data = xp.random.normal(size=(frames, width, height, 3),
loc=loc,
scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6, 0))
else:
data = xp.random.normal(size=(frames, width, height),
loc=loc,
scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6))
if cacheKey[0] != 'float':
data = xp.clip(data, 0, mx)
data = data.astype(dt)
data[:, 10, 10:50] = mx
data[:, 9:12, 48] = mx
data[:, 8:13, 47] = mx
cache = {
cacheKey: data
} # clear to save memory (but keep one to prevent unnecessary regeneration)
data = cache[cacheKey]
updateLUT()
updateSize()
def mkData():
with pg.BusyCursor():
global data, cache, ui
frames = ui.framesSpin.value()
width = ui.widthSpin.value()
height = ui.heightSpin.value()
dtype = (ui.dtypeCombo.currentText(), ui.rgbCheck.isChecked(), frames,
width, height)
if dtype not in cache:
if dtype[0] == 'uint8':
dt = np.uint8
loc = 128
scale = 64
mx = 255
elif dtype[0] == 'uint16':
dt = np.uint16
loc = 4096
scale = 1024
mx = 2**16
elif dtype[0] == 'float':
dt = np.float
loc = 1.0
scale = 0.1
if ui.rgbCheck.isChecked():
data = np.random.normal(size=(frames, width, height, 3),
loc=loc,
scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6, 0))
else:
data = np.random.normal(size=(frames, width, height),
loc=loc,
scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6))
if dtype[0] != 'float':
data = np.clip(data, 0, mx)
data = data.astype(dt)
cache = {
dtype: data
} # clear to save memory (but keep one to prevent unnecessary regeneration)
data = cache[dtype]
updateLUT()
updateSize()
def readNRRDAtlas(nrrdFile=None):
"""
Download atlas files from:
http://help.brain-map.org/display/mouseconnectivity/API#API-DownloadAtlas
"""
import nrrd
if nrrdFile is None:
displayMessage('Please Select NRRD Atlas File')
nrrdFile = QtGui.QFileDialog.getOpenFileName(None,
"Select NRRD atlas file")
with pg.BusyCursor():
data, header = nrrd.read(nrrdFile)
# convert to ubyte to compress a bit
np.multiply(data, 255. / data.max(), out=data, casting='unsafe')
data = data.astype('ubyte')
# data must have axes (anterior, dorsal, right)
# rearrange axes to fit -- CCF data comes in (posterior, inferior, right) order.
data = data[::-1, ::-1, :]
# voxel size in um
vxsize = 1e-6 * float(header['space directions'][0][0])
info = [{
'name': 'anterior',
'values': np.arange(data.shape[0]) * vxsize,
'units': 'm'
}, {
'name': 'dorsal',
'values': np.arange(data.shape[1]) * vxsize,
'units': 'm'
}, {
'name': 'right',
'values': np.arange(data.shape[2]) * vxsize,
'units': 'm'
}, {
'vxsize': vxsize
}]
ma = metaarray.MetaArray(data, info=info)
return ma
def update_display(self):
with pg.BusyCursor():
align = 'pre' if self.params['display',
'plot spike aligned'] else 'stim'
self.clear_plots()
rl = self.corrected_response_list
if len(rl) == 0:
return
stim_ts = rl.get_tseries('stim', align=align)
self._plot_ts(stim_ts, self.plt1)
pre_ts = rl.get_tseries('pre', align=align)
self._plot_ts(pre_ts, self.plt2)
post_ts = rl.get_tseries('post', align=align)
dvdt = self.params['display', 'plot dv/dt']
lowpass = self.params['display', 'plot lowpass']
self._plot_ts(post_ts, self.plt3, dvdt=dvdt, lowpass=lowpass)
def find_files(self):
self.prev_item = None
self.pattern_list.clear()
name = self.path_edit.text()
self.new = True
if any([i in name for i in '[*?']):
self.flist = glob.glob(name)
if not self.flist:
self.image_label.setText('no files found')
return
else:
# use all files in folder
dirname = os.path.dirname(name)
self.flist = [
os.path.join(dirname, i)
for i in os.listdir(os.path.dirname(name))
]
self.flist = list(
filter(lambda x: x.endswith('.cbf') or x.endswith('.nxs'),
self.flist))
self.flist = sorted(self.flist, key=self._sort_keys)
#print(self.flist)
with pg.BusyCursor():
for f in self.flist:
if f.endswith('.cbf'):
self._add_cbf(f)
elif f.endswith('.nxs'):
m = self._lambda3m_regex.match(f)
if m:
self._add_lambda3m(f)
else:
self._add_lambda(f)
try:
self.pattern_list.setCurrentItem(self.pattern_list.topLevelItem(0),
0, QItemSelectionModel.Select)
except:
pass
def selection_changed(self):
with pg.BusyCursor():
sel = self.syn_tree.selectedItems()[0]
expt = sel.expt
self.expt_info.set_experiment(expt)
pre_cell = sel.cells[0].cell_id
post_cell = sel.cells[1].cell_id
key = (expt, pre_cell, post_cell)
if key not in self.analyzers:
self.analyzers[key] = DynamicsAnalyzer(*key)
analyzer = self.analyzers[key]
if len(analyzer.pulse_responses) == 0:
raise Exception(
"No suitable data found for cell %d -> cell %d in expt %s"
% (pre_cell, post_cell, expt))
# Plot all individual and averaged train responses for all sets of stimulus parameters
self.train_plots.clear()
analyzer.plot_train_responses(plot_grid=self.train_plots)
