def run(self, bead):
"Creates the display"
plot = self.__fcn(bead) if np.isscalar(bead) else bead
crvs = [(i[1], j) for i, j in plot.data.items()
if i[0] == 'Curve'][::2]
quad = self.__quadmesh(crvs)
text = self.__quadmeshtext(crvs)
sp1 = [
self.__getx(j.data) for i, j in plot.data.items()
if i[0] == 'Scatter'
][1::2]
sp2 = [(np.ones((len(j), 3)) * (i + .5) + [-.5, .5, np.NaN]).ravel()
for i, j in enumerate(sp1)]
if self._reference is not None:
ref = self.__quadmeshref(sp1, sp2)
if len(sp1):
pks = hv.Curve(
(np.repeat(np.concatenate(sp1), 3), np.concatenate(sp2)),
label='peaks').options(**self._peakstyle)
else:
pks = hv.Curve(([], []), label='peaks').options(**self._peakstyle)
if self._reference is not None:
return (quad * ref * pks * text).redim(x='z', y='key', z='events')
return (quad * pks * text).redim(x='z', y='key', z='events')
def __errorbars(cls, det, params, opts, pstyle, hist):
if 'size' in pstyle:
pstyle = dict(pstyle)
pstyle.pop('size')
if len(det.positions) == 0:
return hv.Curve(([], []), **opts).options(**pstyle)
means = [((i - params[1]) * params[0], Probability.resolution(j))
for i, j in det.output]
xvals = np.hstack([[i - j, i + j, np.NaN] for i, j in means])
yvals = np.hstack([[hist[i], hist[i], np.NaN] for i, j in means])
return hv.Curve((xvals, yvals), **opts).options(**pstyle)
def temperatures(self):
"displays the temperatures"
get = lambda i, j: getattr(self._items, i)[j]
fcn = lambda i, j: hv.Curve(
(get(i, 'index'), get(i, 'value')), 'image id', '°C', label=j)
return fcn('tservo', 'T° Servo') * fcn('tsink', 'T° Sink') * fcn(
'tsample', 'T° Sample')
def __quadmeshref(self, sp1, sp2):
ind = 0
sp2.pop(ind)
ref2 = (np.zeros((len(sp1[ind]), 3)) + [0., len(sp1), np.NaN]).ravel()
ref = hv.Curve((np.repeat(sp1.pop(ind), 3), ref2),
label=f'{self._reference}')
return ref.options(**self._refstyle)
def run(self, bead):
"creates the display"
if self.__pins is None:
self.__pins = self._hpins()
if isinstance(self._fit, dict):
cnf = dict(sequence=self._sequence,
oligos=self._oligos,
**dict(self._fit))
elif self._fit is not True:
cnf = dict(sequence=self._sequence,
oligos=self._oligos,
fit=self._fit)
else:
cnf = dict(sequence=self._sequence, oligos=self._oligos)
self.__fits = self._items.new(FitToHairpinDict, config=cnf)
if 'rescaling' in getattr(getattr(self._items, 'track', None),
'instrument', ()):
self.__fits.config = self.__fits.config.rescale(
float(self._items.track.instrument['rescaling']))
cache = self.__cache
if bead not in cache:
try:
cache[bead] = min(self.__fits[bead].distances.items(),
key=lambda i: i[1][0])
except Exception as exc: # pylint: disable=broad-except
cache[bead] = None, exc
key, dist = cache[bead]
if isinstance(dist, Exception):
return hv.Overlay([hv.Curve(([0], [0])), hv.Text(0, 1, str(dist))])
tmp = self(stretch=dist.stretch, bias=dist.bias)
crv = tmp.elements(self._items[[bead]], group=key) # pylint: disable=no-member
hpc = self.__pins[key]
data = np.copy(hpc.data)
tmp = next(iter(crv)).data
if isinstance(tmp, np.ndarray):
data[:, 1] *= np.nanmax(tmp[:, 1])
else:
data[:, 1] *= np.nanmax(tmp['events'])
def _pos(val):
return .8 * np.nanmax(val) + .2 * np.nanmin(val)
pars = np.round(dist.stretch, 1), np.round(dist.bias, 4)
if pars[1] < 0:
txt = f'{hpc.vdims[0]} = {pars[0]}·({hpc.kdims[0]}+{-pars[1]})'
else:
txt = f'{hpc.vdims[0]} = {pars[0]}·({hpc.kdims[0]}-{pars[1]})'
text = hv.Text(_pos(data[:, 0]),
_pos(data[:, 1]),
txt,
kdims=hpc.kdims + hpc.vdims)
return hv.Overlay(crv + [hpc.clone(data=data), text], group=key)
def fixed(self, display=True, zrange=(-.02, .04), **kwa):
"displays aligned cycles for fixed beads only"
data = super().fixed(**kwa)
if display:
alg = FixedBeadDetection(**kwa)
hmap = getattr(data.withphases(*alg.diffphases),
'display').display()
spread = lambda x: hv.Curve(
np.diff(self.fixedspread(x, **kwa), axis=0).ravel(),
label="spread").redim(y="z", x="frames")
hmap = hmap * hv.DynamicMap(spread, kdims=['bead'])
return hmap.redim.range(z=zrange) if zrange else hmap
return data
def _crv(data, opts, labl, ind): # pylint: disable=inconsistent-return-statements
cols = sorted(
[i for i in data.columns if i.split("@")[0].strip() == ind])
cols = [hv.Dimension(i, label=labl) for i in cols]
tmp = dict(opts)
if ind == "consensus":
tmp.pop('color', None)
ind = hv.Dimension(ind, label=labl)
if len(cols) == 1 or len(cols) == 3:
crv = hv.Curve(data, "zmag", ind, label=ind.name).options(**tmp)
if len(cols) == 1:
return crv
if len(cols) == 2:
return hv.Area(data, "zmag", cols, label=ind.name).options(**tmp)
if len(cols) == 3:
return hv.Area(data, "zmag", cols[1:],
label=ind.name).options(**tmp) * crv
assert False
def _show(bead):
try:
info = self.beaddata(bead=bead)
exc = ""
except Exception as _: # pylint: disable=broad-except
zcyc = self._concat(
self._items.secondaries.zmagcycles.values())
info = pd.DataFrame({
"zmag": zcyc,
"z": np.zeros_like(zcyc),
"phase": np.ones_like(zcyc),
"cycle": np.ones_like(zcyc)
})
exc = str(_)
crv = (hv.Curve(info, 'zmag',
["z", "phase"]).options(alpha=self._alpha,
color="gray"))
return (crv * crv.to.scatter().opts(color="phase", cmap="greens") *
hv.Text((info.zmag.min() + info.zmag.max()) / 2, .5, exc))
def _hpins(self):
"returns haipin positions"
opts = deepcopy(self._opts)
for i, j in self.graphdims().items():
opts.setdefault(i, j)
pks = {}
if self._labels is True:
opts['label'] = 'sequence'
tmp = sequences.peaks(self._sequence, self._oligos)
if isinstance(tmp, np.ndarray):
tmp = (('hairpin 1', tmp), )
for key, vals in cast(Sequence[Tuple[str, np.ndarray]], tmp):
xvals = np.repeat(vals['position'], 3)
yvals = np.concatenate([[(0., .1)[plus], (.9, 1.)[plus], np.NaN]
for plus in vals['orientation']])
pks[key] = (hv.Curve((xvals, yvals),
**opts).options(**self._sequencestyle))
return pks
def _beadextent(self, bead): # pylint: disable=too-many-locals
act = lambda _, info: (info[0], np.nanmedian(info[1]))
extr = lambda i, j: {
k[0][1]: k[1]
for k in (i.cleancycles[bead, ...].withphases(j).withaction(act))
}
ovr = {}
dim = hv.Dimension('extents', unit='µm')
for key, track in self.tracks.items():
if bead in set(track.beads.keys()):
mins = extr(track, PHASE.initial)
maxs = extr(track, PHASE.pull)
keys = sorted(set(mins) & set(maxs))
extents = np.full(max(keys) + 1, np.NaN, dtype='f4')
extents[keys] = [maxs[i] - mins[i] for i in keys]
frame = pd.DataFrame(
dict(cycles=np.arange(len(extents), dtype='i4'),
extents=extents))
else:
frame = pd.DataFrame(
dict(cycles=np.empty(0, dtype='i4'),
extents=np.empty(0, dtype='f4')))
ovr[key] = hv.Curve(frame, 'cycles', dim)
data = pd.concat(
[j.data.dropna().assign(track=i) for i, j in ovr.items()])
miss = list(set(ovr) - set(data.track.unique()))
data = pd.concat(
[data,
pd.DataFrame({
'track': miss,
'extents': [0] * len(miss)
})])
return (hv.BoxWhisker(data, "track", dim) +
hv.NdOverlay(ovr).options(show_grid=True)).cols(1)
def __histogram(det, params, norm, opts):
return hv.Curve((det.xaxis(*params), det.yaxis(norm)), **opts)
