Functions
wirecell.sigproc.plots Namespace Reference

Functions

def fine_response (rflist_fine, regions=None, shaped=False)
 
def average_shaping (rflist_avg, gain_mVfC=14, shaping=2.0 *units.us, nbins=5000)
 
def one_electronics (gain, shaping, tick=0.1 *units.us)
 
def electronics ()
 
def field_response_spectra (frses)
 
def plane_impact_blocks (pibs)
 
def plane_impact_blocks_full (pibs)
 
def response_by_wire_region (rflist_averages)
 
def response_averages_colz (avgtriple, time)
 
def plot_digitized_line (uvw_rfs, gain=14.0 *units.mV/units.fC, shaping=2.0 *units.us, tick=0.5 *units.us, adc_per_voltage=1.2 *4096/(2.0 *units.volt), detector="MicroBooNE", ymin=None, ymax=None, msg="", tick_padding=0)
 
def garfield_exhaustive (rflist, pdffile)
 

Function Documentation

def wirecell.sigproc.plots.average_shaping (   rflist_avg,
  gain_mVfC = 14,
  shaping = 2.0*units.us,
  nbins = 5000 
)
Plot average field responses and with electronics shaping.

Definition at line 42 of file plots.py.

42 def average_shaping(rflist_avg, gain_mVfC=14, shaping=2.0*units.us, nbins=5000):
43  '''
44  Plot average field responses and with electronics shaping.
45  '''
46  byplane = response.group_by(rflist_avg, 'plane')
47  nfields = len(byplane[0])
48  main_field = [rf for rf in byplane[2] if rf.region == 0][0]
49  main_field_sum = numpy.max(numpy.abs(main_field.response))
50  main_shaped = main_field.shaped(gain_mVfC, shaping, nbins)
51  main_shaped_sum = numpy.max(numpy.abs(main_shaped.response))
52  rat = main_shaped_sum / main_field_sum
53 
54 
55  fig, axes = plt.subplots(nfields, 3, sharex=True)
56 
57  for iplane, plane_frs in enumerate(byplane):
58  plane_frs.sort(key=lambda x: x.region)
59 
60  for ifr, fr in enumerate(plane_frs):
61  ax = axes[ifr][iplane]
62  ax.set_title('plane %s, region %d' % (fr.plane, fr.region,))
63 
64  sh = fr.shaped(gain_mVfC, shaping, nbins)
65  ax.plot(fr.times/units.us, fr.response*rat)
66  ax.plot(sh.times/units.us, sh.response)
67 
68 
69 
70 
def average_shaping(rflist_avg, gain_mVfC=14, shaping=2.0 *units.us, nbins=5000)
Definition: plots.py:42
auto enumerate(Iterables &&...iterables)
Range-for loop helper tracking the number of iteration.
Definition: enumerate.h:69
def wirecell.sigproc.plots.electronics ( )
Plot electronics response functions

Definition at line 93 of file plots.py.

94  '''
95  Plot electronics response functions
96  '''
97  fig, axes = plt.subplots(4,1, sharex=True)
98 
99  want_gains = [1.0, 4.7, 7.8, 14.0, 25.0]
100 
101  engs = numpy.vectorize(response.electronics_no_gain_scale) # by time
102  def engs_maximum(gain, shaping=2.0*units.us):
103  resp = engs(numpy.linspace(0,10*units.us, 100), gain, shaping)
104  return numpy.max(resp)
105  engs_maximum = numpy.vectorize(engs_maximum) # by gain
106 
107  gainpar = numpy.linspace(0,300,6000)
108  for ishaping, shaping in enumerate([0.5, 1.0, 2.0, 3.0]):
109  gain = engs_maximum(gainpar, shaping*units.us)
110  slope, inter = numpy.polyfit(gainpar, gain, 1)
111  hits = list()
112  for wg in want_gains:
113  amin = numpy.argmin(numpy.abs(gain-wg))
114  hits.append((gainpar[amin], gain[amin]))
115  hits = numpy.asarray(hits).T
116 
117  ax = axes[ishaping]
118  ax.set_title("shaping %.1f" % shaping)
119  ax.plot(gainpar, gain)
120  ax.scatter(hits[0], hits[1], alpha=0.5)
121  for hit in hits.T:
122  p,g = hit
123  ax.text(p,g, "%.2f"%p, verticalalignment='top', horizontalalignment='center')
124  ax.text(p,g, "%.2f"%g, verticalalignment='bottom', horizontalalignment='center')
125  ax.text(250,10, "%f slope" % slope, verticalalignment='top', horizontalalignment='center')
126  ax.text(250,10, "%f mV/fC/par" % (1.0/slope,), verticalalignment='bottom', horizontalalignment='center')
127  return fig
128 
129 
auto enumerate(Iterables &&...iterables)
Range-for loop helper tracking the number of iteration.
Definition: enumerate.h:69
def wirecell.sigproc.plots.field_response_spectra (   frses)

Definition at line 130 of file plots.py.

131  uvw='UVW'
132  fig, axes = plt.subplots(3, 2, sharex=True, sharey=True)
133 
134  for ind,frs in enumerate(frses):
135  ax = axes[ind,0]
136  im1 = ax.imshow(numpy.absolute(frs), aspect='auto')
137  ax.set_title('%s response amp' % uvw[ind])
138 
139  ax = axes[ind,1]
140  im2 = ax.imshow(numpy.angle(frs), aspect='auto')
141  ax.set_title('%s response phase' % uvw[ind])
142 
143  fig.colorbar(im1, ax=axes[:,0].tolist())
144  fig.colorbar(im2, ax=axes[:,1].tolist())
145 
146 
147 
auto enumerate(Iterables &&...iterables)
Range-for loop helper tracking the number of iteration.
Definition: enumerate.h:69
def field_response_spectra(frses)
Definition: plots.py:130
def wirecell.sigproc.plots.fine_response (   rflist_fine,
  regions = None,
  shaped = False 
)
Plot fine response functions

Definition at line 8 of file plots.py.

8 def fine_response(rflist_fine, regions = None, shaped=False):
9  '''
10  Plot fine response functions
11  '''
12  if regions is None:
13  regions = sorted(set([x.region for x in rflist_fine]))
14  nregions = len(regions)
15  impacts = sorted(set([x.impact for x in rflist_fine]))
16 
17  fig, axes = plt.subplots(nregions, 3, sharex=True)
18 
19  byplane = response.group_by(rflist_fine, 'plane')
20 
21  for iplane, plane_rfs in enumerate(byplane):
22  print ('plane %d, %d regions' % (iplane, len(plane_rfs)))
23  byregion = response.group_by(plane_rfs,'region')
24 
25  byregion = [lst for lst in byregion if lst[0].region in regions]
26 
27  for iregion, region_rfs in enumerate(byregion):
28  region_rfs.sort(key=lambda x: x.impact)
29  first = region_rfs[0]
30 
31  ax = axes[iregion][iplane]
32  ax.set_title('region %d' % (first.region,))
33  # print ("plane=%s, region=%d, impacts: " % (first.plane,first.region))
34  for rf in region_rfs:
35  if shaped:
36  rf = rf.shaped()
37  times = numpy.linspace(*rf.domainls)/units.us
38  ax.plot(times, rf.response)
39  # print "[%f] " % rf.impact,
40 
41 
auto enumerate(Iterables &&...iterables)
Range-for loop helper tracking the number of iteration.
Definition: enumerate.h:69
def fine_response(rflist_fine, regions=None, shaped=False)
Definition: plots.py:8
def wirecell.sigproc.plots.garfield_exhaustive (   rflist,
  pdffile 
)
Make detailed plots of all the Garfield current responses. 

Definition at line 486 of file plots.py.

486 def garfield_exhaustive(rflist, pdffile):
487  '''
488  Make detailed plots of all the Garfield current responses.
489  '''
490  from matplotlib.backends.backend_pdf import PdfPages
491 
492  uvw = list()
493  for letter in "uvw":
494  byplane = [rf for rf in rflist if rf.plane == letter]
495  uvw.append(byplane)
496 
497  impacts = set()
498  for rf in rflist:
499  impacts.add(rf.impact)
500 
501  with PdfPages(pdffile) as pdf:
502 
503  for impact in sorted(impacts):
504 
505  fig, axes = plt.subplots(nrows=3, ncols=1)
506 
507  for letter, byplane, ax in zip("uvw", uvw, axes):
508  byimpact = [rf for rf in byplane if rf.impact == impact]
509 
510  ax.set_title("%s impact %.1f" % (letter.upper(), impact))
511  ax.set_xlabel("time [$\mu$s]")
512  ax.set_ylabel("current [pAmp]")
513 
514  for rf in byimpact:
515  ax.plot(rf.times/units.us, rf.response/units.picoampere,
516  label="wire:%d" % (rf.region))
517  xmmymm = list(ax.axis())
518  xmmymm[0] = 70
519  xmmymm[1] = 85
520  ax.axis(xmmymm)
521  #ax.legend(loc="center left")
522  plt.tight_layout()
523  pdf.savefig(fig)
524  plt.close()
525 
526 
527 
528 
def garfield_exhaustive(rflist, pdffile)
Definition: plots.py:486
auto zip(Iterables &&...iterables)
Range-for loop helper iterating across many collections at the same time.
Definition: zip.h:295
def wirecell.sigproc.plots.one_electronics (   gain,
  shaping,
  tick = 0.1*units.us 
)
Plot one electronics response function

Definition at line 71 of file plots.py.

71 def one_electronics(gain, shaping, tick=0.1*units.us):
72  '''
73  Plot one electronics response function
74  '''
75  tmax = 10*units.us
76  nticks = tmax/tick
77  times = numpy.linspace(0, tmax, nticks)
78  res = response.electronics(times, gain, shaping)
79  fig, axes = plt.subplots(1, 1)
80 
81  x = times/units.us
82  y = res/(units.mV/units.fC)
83 
84  axes.plot(x, y)
85  axes.set_title('Electronics response for gain=%.1f mV/fC, peaking=%.1f us' % \
86  (gain/(units.mV/units.fC), shaping/units.us))
87  axes.set_xlabel('Sample time [$\mu$s]')
88  axes.set_ylabel('Response')
89  return fig
90 
91 
92 
def one_electronics(gain, shaping, tick=0.1 *units.us)
Definition: plots.py:71
def wirecell.sigproc.plots.plane_impact_blocks (   pibs)
Make a "contact sheet" of different responses on wires nearest a
path.  Wire 0 is the wire most nearest.  Each thumbnail shows
responses as a function of wire and time and thumbnails are
organized in rows of the same impact position and columns of the
same plane.

Note, for the upper-most and lower-most impacts each neighboring wires there are impacts which start at
the same point

Definition at line 148 of file plots.py.

149  '''
150  Make a "contact sheet" of different responses on wires nearest a
151  path. Wire 0 is the wire most nearest. Each thumbnail shows
152  responses as a function of wire and time and thumbnails are
153  organized in rows of the same impact position and columns of the
154  same plane.
155 
156  Note, for the upper-most and lower-most impacts each neighboring wires there are impacts which start at
157  the same point
158  '''
159 
160  uvw='uvw'
161  times, regions = numpy.meshgrid(
162  numpy.linspace(pibs.tmin, pibs.tmax, pibs.ntbins),
163  numpy.linspace(pibs.region_keys[0], pibs.region_keys[-1], len(pibs.region_keys)))
164  times /= units.us
165 
166  #xylim = (times.min(), times.max(), regions.min(), regions.max())
167  xylim = (60, 90, -10, 10)
168 
169  impact_keys = list(pibs.impact_keys)
170  impact_keys.reverse()
171 
172  fig, axes = plt.subplots(len(impact_keys), 3, sharex=True, sharey=True)
173  plt.subplots_adjust(left=0.05, right=0.95,
174  bottom=0.02, top=0.98,
175  wspace=0.2, hspace=0.2)
176 
177  minres = [numpy.min(pibs.response(p, 0.0, 0)) for p in 'uvw']
178  maxres = [numpy.max(pibs.response(p, 0.0, 0)) for p in 'uvw']
179 
180 
181  for iplane, plane in enumerate(pibs.plane_keys):
182  plane_axes = list()
183  ims = list()
184  for iimpact, impact in enumerate(impact_keys):
185 
186  block = pibs.region_block(plane, impact)
187  ax = axes[iimpact,iplane]
188  plane_axes.append(ax)
189  im = ax.pcolormesh(times, regions, block)
190  ims.append(im)
191 
192  ax.set_title('%s-plane, impact %0.1f' % (plane, impact))
193  if impact == impact_keys[-1]:
194  ax.set_xlabel('time [us]')
195  ax.set_ylabel('wire')
196  ax.axis(xylim)
197 
198  fig.colorbar(im, ax=[ax])
199 
200 
auto enumerate(Iterables &&...iterables)
Range-for loop helper tracking the number of iteration.
Definition: enumerate.h:69
def plane_impact_blocks(pibs)
Definition: plots.py:148
def wirecell.sigproc.plots.plane_impact_blocks_full (   pibs)
Make a plot for each plane of the response on its central wire due
to paths a all impacts running through the wire regions.

Note, the two impacts at the boundary between two wire regions are
explicitly shown.  Each can be considered epsilon over the line of
symmetry.

Definition at line 201 of file plots.py.

202  '''
203  Make a plot for each plane of the response on its central wire due
204  to paths a all impacts running through the wire regions.
205 
206  Note, the two impacts at the boundary between two wire regions are
207  explicitly shown. Each can be considered epsilon over the line of
208  symmetry.
209  '''
210 
211  region_keys = list(pibs.region_keys)
212  nregions = len(region_keys)
213  print ('%d regions: %s' % (nregions, region_keys))
214 
215  impact_keys = list(pibs.impact_keys) # put positive numbers on top
216  nimpacts = len(impact_keys)
217  print ('%d impacts: %s' % (nimpacts, impact_keys))
218 
219  print ("t=(%f,%f)" % (pibs.tmin, pibs.tmax))
220  times, regions = numpy.meshgrid(
221  numpy.linspace(pibs.tmin, pibs.tmax, pibs.ntbins),
222  numpy.linspace(impact_keys[0]+region_keys[0],
223  impact_keys[-1]+region_keys[-1],
224  nimpacts*nregions))
225  times /= units.us
226  xylim = (times.min(), times.max(), regions.min(), regions.max())
227  print ('limits: ', xylim)
228 
229  fig, axes = plt.subplots(3, 1, sharex=True, sharey=True)
230 
231  for iplane, plane in enumerate(pibs.plane_keys):
232 
233  block = numpy.zeros((nregions*nimpacts, pibs.ntbins))
234  print ('%s-plane shapes: times=%s regions=%s block=%s ' % (plane, times.shape, regions.shape, block.shape))
235 
236  for iregion, region in enumerate(region_keys):
237  for iimpact, impact in enumerate(impact_keys):
238  row = nimpacts * iregion + iimpact
239  block[row] = pibs.response(plane,impact,-region)
240 
241  ax = axes[iplane]
242  im = ax.pcolormesh(times, regions, block)
243  #im = ax.imshow(block, extent=xylim, aspect='auto', interpolation="nearest")
244  ax.axis(xylim)
245  ax.set_title('%s-plane' % plane)
246  ax.set_xlabel('time [us]')
247  ax.set_ylabel('impact position [pitch]')
248  fig.colorbar(im, ax=[ax])
249 
250 
251 #
252 # stuff below may be bit rotted
253 #
254 
255 
auto enumerate(Iterables &&...iterables)
Range-for loop helper tracking the number of iteration.
Definition: enumerate.h:69
def plane_impact_blocks_full(pibs)
Definition: plots.py:201
def wirecell.sigproc.plots.plot_digitized_line (   uvw_rfs,
  gain = 14.0*units.mV/units.fC,
  shaping = 2.0*units.us,
  tick = 0.5*units.us,
  adc_per_voltage = 1.2*4096/(2.0*units.volt),
  detector = "MicroBooNE",
  ymin = None,
  ymax = None,
  msg = "",
  tick_padding = 0 
)
Make plot of shaped and digitized response functions.

>>> dat = garfield.load("/home/bviren/projects/wire-cell/garfield-data/ub_10.tar.gz")
>>> uvw = response.line.responses(dat)
>>> plots.plot_digitized_line(uvw)

See also wirecell.sigproc.paper.noise.

See also `wirecell-sigproc plot-garfield-track-response` command line.

Definition at line 358 of file plots.py.

358  tick_padding=0):
359  '''
360  Make plot of shaped and digitized response functions.
361 
362  >>> dat = garfield.load("/home/bviren/projects/wire-cell/garfield-data/ub_10.tar.gz")
363  >>> uvw = response.line.responses(dat)
364  >>> plots.plot_digitized_line(uvw)
365 
366  See also wirecell.sigproc.paper.noise.
367 
368  See also `wirecell-sigproc plot-garfield-track-response` command line.
369  '''
370  u, v, w = uvw_rfs
371  time_offset = 50*units.us
372 
373  # deal with some round off.
374  dt_hi = int(round(w.times[1] - w.times[0]))
375  n_hi = len(w.times)
376 
377  n_lo = int(round(dt_hi/tick * n_hi))
378 
379  colors = ['red', 'blue', 'black']
380  legends = ['U-wire', 'V-wire', 'Y-wire']
381 
382  fig, axes = plt.subplots(1, 1, dpi=144)
383 
384  ymaxs=list()
385  ymins=list()
386  data = list()
387  for ind, rf in enumerate(uvw_rfs):
388  print (rf.plane, legends[ind], numpy.sum(rf.response)*dt_hi/units.eplus, " electrons")
389 
390  if shaping:
391  sig = rf.shaped(gain, shaping)
392  else:
393  print ('No shaping')
394  sig = rf
395  samp = sig.resample(n_lo)
396  x = (samp.times-time_offset)/units.us
397 
398  lstype = 'default'
399 
400  # figure out what to plot
401  if shaping:
402  print ('Shaped:', ind, sum(samp.response))
403  if adc_per_voltage: # full shaping + ADC
404  adcf = numpy.floor(samp.response * adc_per_voltage)
405  y = numpy.array(adcf, dtype=int) #digitize
406  lstype = 'steps'
407  else: # magic ADC, directly measuring voltage
408  y = samp.response/units.mV
409  else: # measure input current
410  nonzero = [q for q in samp.response if q>0]
411  itot = sum(nonzero)
412  dt = len(nonzero)*tick
413  qtot = itot*dt
414  print ("qtot=%e C, itot=%e uA, dt=%d us, nele=%f" % \
415  (qtot/units.coulomb,itot/units.microampere,dt/units.us,qtot/units.eplus))
416 
417  y = samp.response/units.nanoampere
418  if tick_padding:
419  print ("padding waveforms by %d ticks" % tick_padding)
420  y = numpy.hstack((numpy.zeros((tick_padding,), dtype=int), y[:-tick_padding]))
421 
422  ymins.append(numpy.min(y))
423  ymaxs.append(numpy.max(y))
424 
425  if lstype == "steps":
426  print(x.shape, y.shape)
427  axes.step(x, y, color=colors[ind], label=legends[ind])
428  else:
429  axes.plot(x, y, ls=lstype, color=colors[ind], label=legends[ind])
430  if not data:
431  data.append(x)
432  data.append(y)
433 
434  axes.legend(loc="upper left")
435  xmmymm = list(axes.axis())
436 
437  # limit time
438  xmmymm[0] = 0.0
439  xmmymm[1] = 50.0
440  #if "dune" in detector.lower():
441  # xmmymm[1] = 25.0
442 
443  # fixme: this plotter should work on other response functions than Garfield
444  # 2D with MB-style 3mm pitch. This titling is for the MB noise paper.
445  if shaping:
446  axes.set_xlabel('Sample time [$\mu$s]')
447  if adc_per_voltage:
448  axes.set_title('ADC Waveform with 2D %s Wire Plane Model' % detector)
449  axes.set_ylabel('ADC (baseline subtracted)')
450  #xmmymm[3] = 65.0
451  xmmymm[3] = max(ymaxs)
452  xmmymm[2] = min(ymins)
453  else:
454  axes.set_title('Voltage Waveform')
455  axes.set_ylabel('Voltage Sample (baseline subtracted) [mV]')
456  else:
457  axes.set_title('Induced Current')
458  axes.set_xlabel('Time [$\mu$s]')
459  axes.set_ylabel('Instantaneous current (nanoamp)')
460 
461  if ymin is not None:
462  xmmymm[2] = ymin
463  if ymax is not None:
464  xmmymm[3] = ymax
465 
466  axes.axis(xmmymm)
467  textx = 5
468  if "microboone" in detector.lower():
469  axes.text(textx, 20,
470  " Garfield 2D calculation\n(perpendicular line source)")
471  if msg:
472  axes.text(textx,-20, msg)
473 
474  if "dune" in detector.lower():
475  if tick_padding == 0:
476  textx = 15
477 
478  axes.text(textx, 40,
479  " Garfield 2D calculation\n(perpendicular line source)")
480 
481 
482  return fig, numpy.vstack(data).T
483 
484 
485 
auto enumerate(Iterables &&...iterables)
Range-for loop helper tracking the number of iteration.
Definition: enumerate.h:69
static int max(int a, int b)
T min(sqlite3 *const db, std::string const &table_name, std::string const &column_name)
Definition: statistics.h:55
def wirecell.sigproc.plots.response_averages_colz (   avgtriple,
  time 
)
Plot averages as 2D colz type plot

Definition at line 297 of file plots.py.

297 def response_averages_colz(avgtriple, time):
298  '''
299  Plot averages as 2D colz type plot
300  '''
301  use_imshow = False
302  mintbin=700
303  maxtbin=850
304  nwires = avgtriple[0].shape[0]
305  maxwires = nwires//2
306  minwires = -maxwires
307  mintime = time[mintbin]
308  maxtime = time[maxtbin-1]
309  ntime = maxtbin-mintbin
310  deltatime = (maxtime-mintime)/ntime
311 
312  x,y = numpy.meshgrid(numpy.linspace(mintime, maxtime, ntime),
313  numpy.linspace(minwires, maxwires, nwires))
314  x *= 1.0e6 # put into us
315 
316  # print (x.shape, mintbin, maxtbin, mintime, maxtime, nwires, minwires, maxwires)
317 
318  fig = plt.figure()
319  cmap = 'seismic'
320 
321  toplot=list()
322  for iplane in range(3):
323  avg = avgtriple[iplane]
324  main = avg[:,mintbin:maxtbin]
325  edge = avg[:,maxtbin:]
326  ped = numpy.sum(edge) / (edge.shape[0] * edge.shape[1])
327  toplot.append(main - ped)
328 
329  maxpix = max(abs(numpy.min(avgtriple)), numpy.max(avgtriple))
330  clim = (-maxpix/2.0, maxpix/2.0)
331 
332  ims = list()
333  axes = list()
334 
335  for iplane in range(3):
336  ax = fig.add_subplot(3,1,iplane+1) # two rows, one column, first plot
337  if use_imshow:
338  im = plt.imshow(toplot[iplane], cmap=cmap, clim=clim,
339  extent=[mintime, maxtime, minwires, maxwires], aspect='auto')
340  else:
341  im = plt.pcolormesh(x,y, toplot[iplane], cmap=cmap, vmin=clim[0], vmax=clim[1])
342  ims.append(im)
343  axes.append(ax)
344 
345  fig.subplots_adjust(right=0.8)
346  cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])
347  fig.colorbar(ims[0], ax=axes[0], cmap=cmap, cax=cbar_ax)
348 
349 
350 
def response_averages_colz(avgtriple, time)
Definition: plots.py:297
T abs(T value)
static int max(int a, int b)
def wirecell.sigproc.plots.response_by_wire_region (   rflist_averages)
Plot response functions as 1D graphs.

Definition at line 256 of file plots.py.

256 def response_by_wire_region(rflist_averages):
257  '''
258  Plot response functions as 1D graphs.
259  '''
260  one = rflist_averages[0]
261  byplane = response.group_by(rflist_averages, 'plane')
262 
263  nwires = map(len, byplane)
264  print ("%d planes, nwires: %s" % (len(nwires), str(nwires)))
265  nwires = min(nwires)
266 
267  region0s = response.by_region(rflist_averages)
268  shaped0s = [r.shaped() for r in region0s]
269 
270  central_sum_field = sum(region0s[2].response)
271  central_sum_shape = sum(shaped0s[2].response)
272 
273 
274  fig, axes = plt.subplots(nwires, 2, sharex=True)
275 
276  for wire_region in range(nwires):
277  axf = axes[wire_region][0]
278  axf.set_title('Wire region %d (field)' % wire_region)
279  axs = axes[wire_region][1]
280  axs.set_title('Wire region %d (shaped)' % wire_region)
281 
282  for iplane in range(3):
283  field_rf = byplane[iplane][wire_region]
284  shape_rf = field_rf.shaped()
285 
286  field = field_rf.response
287  shape = shape_rf.response
288  field /= central_sum_field
289  shape /= central_sum_shape
290 
291  ftime = 1.0e6*numpy.linspace(*field_rf.domainls)
292  stime = 1.0e6*numpy.linspace(*shape_rf.domainls)
293 
294  axf.plot(ftime, field)
295  axs.plot(stime, shape)
296 
T min(sqlite3 *const db, std::string const &table_name, std::string const &column_name)
Definition: statistics.h:55
static QCString str
def response_by_wire_region(rflist_averages)
Definition: plots.py:256