def main_analyze(argv=sys.argv):
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("input")
parser.add_argument("output")
parser.add_argument("--uw", action='store_true', help="Weighted analysis")
parser.add_argument("--timescale", type=float, help="time scale")
parser.add_argument("--nitems", type=int, help="number of items to analyze")
args = parser.parse_args(argv[1:])
time_scale = 1.
if args.timescale:
time_scale = args.timescale
weighted = not args.uw
evs = Events(args.input)
e_last_time = { }
inter_event_times = [ ]
t_min = evs.t_min()
nitems = args.nitems
for i, (t, e, w) in enumerate(evs.iter_ordered()):
if nitems and i > nitems:
break
#print t, e, w
if e not in e_last_time:
e_last_time[e] = t
inter_event_times.append(t-t_min)
continue
dt = t - e_last_time[e]
inter_event_times.append(dt)
for t_lastseen in e_last_time.itervalues():
inter_event_times.append(t-t_lastseen)
if weighted:
weights = inter_event_times
else:
weights = None
import numpy
hist, bin_edges = numpy.histogram(inter_event_times,
weights=weights,
bins=50, normed=True)
#print hist
#print bin_edges
import pcd.support.matplotlibutil as mplutil
bin_edges /= time_scale
ax, extra = mplutil.get_axes(args.output+'.[png,pdf]')
ax.plot(bin_edges[:-1], hist)
ax.set_xlabel('$\Delta t$')
ax.set_ylabel('PDF')
ax.set_title('total t: [%s, %s], Dt=%4.2f'%(t_min, t, (t-t_min)/time_scale))
mplutil.save_axes(ax, extra)
def __init__(self):
print("==", self.__class__.__name__)
evs_list = list(self.model())
evs = events.Events()
evs.add_events((t,e,1) for t,e in evs_list)
_, results = dynsnap.main([None,
#'--dtmode=linear',
#'--dtmax=10',
#'--dtextra=5',
#'--dont-merge-first',
#'--peakfinder=greedy',
]+self.dsargs,
evs=evs)
results = results['results']
if results.thighs[-1] > evs.t_max():
results.thighs[-1] = evs.t_max()+1
import pcd.support.matplotlibutil as mplutil
ax, extra = mplutil.get_axes(self.fname,
figsize=self.figsize)
ts, es = zip(*evs_list)
ax.scatter(ts, es, s=self.ps, facecolor='b', edgecolor='b')
#for thigh in results.thighs[:-1]:
# ax.axvline(x=thigh-0.5)
results.plot_intervals_patches(ax, shift=-.5)
from matplotlib.font_manager import FontProperties
font = FontProperties()
font.set_family('serif')
ax.set_xlabel('time', fontproperties=font)
ax.set_ylabel('event ID', fontproperties=font)
ax.set_xticks([])
ax.set_yticks([])
ax.autoscale(tight=True)
if hasattr(self, 'xlim'): ax.set_xlim(*self.xlim)
if hasattr(self, 'ylim'): ax.set_ylim(*self.ylim)
#axB = ax.twinx()
#results.plot_Jfinding(axB)
mplutil.save_axes(ax, extra)
def write(self, fname, axopts={}, title=None):
from pcd.support import matplotlibutil
ax, extra = matplotlibutil.get_axes(fname, **axopts)
data = self._data
# Do the actual plotting
import matplotlib.cm as cm
import matplotlib.colors as mcolors
colormap = cm.get_cmap('jet')
normmap = mcolors.Normalize(vmin=0, vmax=len(self.label_order))
from functools import partial
if self.bin and self.log_y:
binparams = {'ints': self.bin_ints}
binfunc = log_bin
binwidth = log_bin_width
elif self.bin:
binparams = {'bins':20, 'ints': self.bin_ints}
binfunc = lin_bin
binwidth = lin_bin_width
else:
binparams = {'ints': self.bin_ints}
binfunc = lambda x: x
binwidth = lambda x: 1
if hasattr(self, 'binparams'):
binparams.update(self.binparams)
label_order = self.label_order
if not label_order:
label_order = sorted(data.keys())
for i, label in enumerate(label_order):
points = data[label]
if self.colormap and label in self.colormap:
color = self.colormap[label]
else:
color = colormap(normmap(i))
# Line type
if label in self.plotstyle:
plotstyle = self.plotstyle[label]
elif self.markers:
plotstyle = '-%s'%(self.markers[i%len(self.markers)])
else:
plotstyle = self.plotstyle[label]
#
vals = []
[vals.extend(x) for x in points.values() ]
vals = map(partial(binfunc, **binparams), vals)
# Set a domain of all values to include
if self.domain is not None:
domain = set(binfunc(x, **binparams) for x in self.domain)
else:
domain = set()
vals, vals_counts = counts(vals, domain=domain)
if self.dist_is_counts:
lines = ax.plot(vals, vals_counts, plotstyle, color=color,
label=label)
# Complimentary cumulative distribution function plotting.
elif self.dist_is_ccdf or self.dist_is_cccf:
vals, vals_counts = \
zip(*sorted(zip(vals, vals_counts), key=lambda x: x[0])
)
total = float(sum(vals_counts))
import pcd.util
counts_cumul = list(pcd.util._accumulate(vals_counts))
counts_cumul = [counts_cumul[-1]-x for x in counts_cumul]
if self.dist_is_ccdf:
counts_cumul = [ x/total for x in counts_cumul ]
lines = ax.plot(vals, counts_cumul, plotstyle,
color=color, label=label)
else:
vals_counts = [ c/binwidth(s, **binparams)
for s,c in zip(vals, vals_counts) ]
p_vals = norm(vals_counts)
lines = ax.plot(vals, p_vals, plotstyle, color=color,
label=label)
if hasattr(self, '_hook_lines'):
self._hook_lines(locals())
if self.log_y:
ax.set_xscale('log')
if self.dist_xlim: ax.set_xlim(*self.dist_xlim)
if self.dist_ylim: ax.set_ylim(*self.dist_ylim)
if self.log_p:
ax.minorticks_on()
ax.set_yscale('log', basey=10)
if self.decorate:
if self.ylabel: ax.set_xlabel(self.ylabel)
if self.ylabel_dist:
ax.set_ylabel(self.ylabel_dist)
elif self.dist_is_counts:
if self.ylabel: ax.set_ylabel("Count(%s)"%self.ylabel)
elif self.dist_is_ccdf:
if self.ylabel:
ax.set_ylabel("CCDF(%s)"%self.ylabel)
elif self.dist_is_cccf:
if self.ylabel:
ax.set_ylabel("Complimentary cumulative count(%s)"%self.ylabel)
else:
if self.ylabel: ax.set_ylabel("P(%s)"%self.ylabel)
if title: ax.set_title(self.title)
elif self.title: ax.set_title(self.title)
if len(data) > 1 and self.legend_make:
ax.legend(loc=self.legend_loc, **self.legend_kwargs)
self._hook_write_setup_plot(locals())
matplotlibutil.save_axes(ax, extra)
def write(self, fname, axopts={}, title=None):
"""Write data.
`fname` can be an matplotlib.axes.Axes object, in which case
no new files are created and lines are added to this axis.
"""
from pcd.support import matplotlibutil
ax, extra = matplotlibutil.get_axes(fname, **axopts)
data = self._data
# Do the actual plotting
# Get colors and styles.
import matplotlib.cm as cm
import matplotlib.colors as mcolors
colormap = cm.get_cmap('jet')
normmap = mcolors.Normalize(vmin=0, vmax=len(self.label_order))
label_order = self.label_order
if not label_order:
label_order = sorted(data.keys())
for i, label in enumerate(label_order):
# Colors
if self.colormap and label in self.colormap:
color = self.colormap[label]
else:
color = colormap(normmap(i))
# Line type
if label in self.plotstyle:
plotstyle = self.plotstyle[label]
elif self.markers:
plotstyle = '-%s'%(self.markers[i%len(self.markers)])
else:
plotstyle = self.plotstyle[label]
# Make all points data. `points` is a list of (cmty_size,
# [list of <measure> values]) pairs and `xy` is a list of
# (cmty_size, <mean_measure>) pairs.
points = data[label]
if len(points) == 0:
print "skipping %s with no data"%label
continue
xy = sorted((a, numpy.mean(b)) for a,b in points.iteritems())
xvals, y = zip(*xy)
# Plot the mean:
ax.plot(xvals, y, plotstyle, lw=2, color=color, label=label)
# If we are a subclass of QuantileStatter, plot quantiles,
# too.
if self.quantiles is not None and len(self.quantiles):
quantiles = [ ]
for x in xvals:
values = sorted(points[x])
quantiles.append(tuple(quantile(values, p)
for p in self.quantiles))
p_quantiles = zip(*quantiles)
# This does a little bit of "offset" to make the
# quantiles more visible.
#min_v = min(p_quantiles[0])
#max_v = max(p_quantiles[-1])
#epsilon = (max_v - min_v)*.001
#def adjust(i):
# return epsilon * (i-len(p_quantiles)/2.)
adjust = lambda i: 0
# Do the actual plotting
for i, qtl in enumerate(p_quantiles):
#print colormap(normmap(i))
qtl = numpy.asarray(qtl) + adjust(i)
ax.plot(xvals, qtl, color=color,
lw=.5)
# General plot layout and configuration.
ylims = ax.get_ylim()
if self.log_x:
ax.set_xscale('log')
if self.log_y:
ax.minorticks_on()
ax.set_yscale('log', basey=10)
if self.xlim: ax.set_xlim(*self.xlim)
if self.ylim: ax.set_ylim(*self.ylim)
if self.decorate:
if self.xlabel: ax.set_xlabel(self.xlabel)
if self.ylabel: ax.set_ylabel(self.ylabel)
if title: ax.set_title(self.title)
elif self.title: ax.set_title(self.title)
if len(data) > 1 and self.legend_make:
ax.legend(loc=self.legend_loc, **self.legend_kwargs)
self._hook_write_setup_plot(locals())
matplotlibutil.save_axes(ax, extra)
