#!/bin/env python3

# written 2019-01-28 by mza
# last updated 2023-09-26 by mza

import threading # Thread()
from math import *
from B2L_common import *
from B2L_defs import *
from get_status import get_status
import ethudp
from DebugInfoWarningError import debug, info, warning, error, debug2, debug3, set_verbosity
import time # sleep()
import struct # unpack_from
import pytz # pytz - sudo apt install -y python-pip; sudo pip2 install pytz
#import datetime
import matplotlib.dates as mdates # sudo pip2 install matplotlib
from mpl_toolkits.axes_grid1.inset_locator import inset_axes
from math import ceil
# sudo apt install -y python-pip python3-pip python-tk
# python -m pip install --user -U pip
# python -m pip install --user -U matplotlib
# python -m pip install --user -U scipy
import matplotlib.pyplot as plt # sudo apt install -y python-cairocffi
import matplotlib.gridspec as gridspec
#import matplotlib.image as mpl_img
from matplotlib.ticker import (MultipleLocator, FormatStrFormatter, AutoMinorLocator)
import numpy
import tkinter # sudo apt install -y python3-tk
from PIL import Image, ImageTk # sudo apt-get install -y python3-pil.imagetk

def print_ROOT_usage():
	print("ROOT environment not setup yet")
	HOME = os.environ['HOME']
	potential_locations = [ "/usr/local/bin", HOME + "/build/root/bin" ]
	filename = "thisroot.sh"
	for location in potential_locations:
		potential_filename = location + "/" + filename
		if os.path.isfile(potential_filename):
			#print(". " + HOME + "/build/root/bin/thisroot.sh; " + str(sys.argv))
			print(". " + potential_filename)
	#info(sys.argv[0] + sys.argv[1:])
	#info(" ".join(sys.argv[0:]))
	sys.exit(1)

try:
	import ROOT # TH1F
	info("using ROOT")
	should_use_ROOT = True
except:
	should_use_ROOT = False
	info("not using ROOT")
	#print_ROOT_usage()
#ROOT.gROOT.SetBatch(True)

BS = 0
frame_mask_shift = 16
frame_mask_all = 0b111111111 << frame_mask_shift
bunch_marker_first_valid = 4
initial_bunch_marker_of_interest = 1701
desired_RF_bucket = initial_bunch_marker_of_interest
RF_buckets = 5120
bunch_marker_last_valid = RF_buckets - 1
#number_of_64_sample_windows_per_beam_orbit = 427

pedestal_subtraction_amount = 1000
stagger_amount = 50
ch_adc_min = 0 - 300
ch_adc_max = 128 * stagger_amount + 300
maximum_absolute_value_before_issuing_warning = 1000
slice_lower_limit = -250
slice_upper_limit = 300

should_plot_slice = 0
#should_plot_sweep = 1
#should_plot_zoomed_waveforms = 1
#number_of_zoomed_waveforms_to_plot = 4
should_generate_png = 1
should_generate_pdf = 0

gui_update_period_ms = 200

linewidth = 0.3
dpi = 100.0

duration_in_ns_of_64_sample_waveform = 23.58
desired_x_axis = "time"
desired_physical_window_numbers = [ w for w in range(425) ]
starting_physical_window_number = 0
ending_physical_window_number = starting_physical_window_number + 425

revolution_marker_offset_in_RF_buckets = 4370.5
bunch_current_offset = -260.0
bunch_current_scale = 350.0

current_gridstep = 200.0 # in mA
nbunches_gridstep = 400

def set_trigger_mask(s, c0, c1, c2, c3):
	write_register(SCROD_AxiCommon_trigMask, s, BS)
	write_register(CARRIER_AxiCommon_trigMask, c0, BS, 0)
	write_register(CARRIER_AxiCommon_trigMask, c1, BS, 1)
	write_register(CARRIER_AxiCommon_trigMask, c2, BS, 2)
	write_register(CARRIER_AxiCommon_trigMask, c3, BS, 3)

def mask_triggers(s=0xf, c0=0xf, c1=0xf, c2=0xf, c3=0xf):
	set_trigger_mask(s, c0, c1, c2, c3)

def unmask_triggers(s=0, c0=0, c1=0, c2=0, c3=0):
	set_trigger_mask(s, c0, c1, c2, c3)

def set_trig_prescale_N_log2(N_log2):
	write_register(SCROD_AxiCommon_trig_prescale_N_log2, N_log2, BS)

def get_xrm_trigger_enable_status():
	return read_register(SCROD_AxiCommon_xrm_trigger_enabled, BS)

def enable_xrm_triggers():
	write_register(SCROD_AxiCommon_xrm_trigger_enabled, 1, BS)

def disable_xrm_triggers():
	write_register(SCROD_AxiCommon_xrm_trigger_enabled, 0, BS)

def allow_xrm_triggers_for_a_while(duration=1.0):
	if be_verbose_when_collecting_data:
		info("allowing xrm triggers for " + str(int(1000.0*duration)/1000.0) + " seconds...")
	a = get_SCROD_eventCnt()
	enable_xrm_triggers()
	time.sleep(duration)
	disable_xrm_triggers()
	b = get_SCROD_eventCnt()
	diff = b - a
	info("eventCnt difference: " + str(diff))
	return diff

def trigger_and_wait_for_xrm_triggers(duration=1.0):
#	if be_verbose_when_collecting_data:
#		info("allowing xrm triggers for " + str(int(1000.0*duration)/1000.0) + " seconds...")
	a = get_SCROD_eventCnt()
	if should_software_trigger:
		software_trigger(BS)
	else:
		write_register_without_readback_verification(SCROD_AxiCommon_clear_count_of_triggers_for_bunch_markers, 0xf, BS)
	wait_at_least_until_next_frame9()
	time.sleep(duration)
	b = get_SCROD_eventCnt()
	diff = b - a
	info("eventCnt difference: " + str(diff))
	return diff

expected_trigger_rate = { 0:11150.0, 1:5560.0, 2:2780.0, 3:1390.0, 4:690.0, 5:350.0, 6:170.0, 7:90.0, 8:40.0, 9:20.0, 10:10.0, 11:5.0, 12:2.0, 13:1.0, 14:1.0, 15:1.0, 16:1.0, 17:1.0, 18:1.0 }
def generate_histogram_of_trigger_rate_versus_prescale_N_log2(start, end):
	global expected_trigger_rate
	old_desired_trigger_quantities = set_desired_trigger_quantities(0, 0, 0, 0)
	mask_triggers()
	#max_rate = 151000.0
	for i in range(start, end+1):
		set_trig_prescale_N_log2(i)
		#duration = 40.0 * (2.0**i) / max_rate
		duration = 0.1
		#info(duration)
		if i > 10:
			duration = 1.0
		diff = allow_xrm_triggers_for_a_while(duration)
		#info(str(diff))
		rate = diff / duration
		expected_trigger_rate[i] = rate
		info("[" + str(i) + "]: " + str(rate))
	set_desired_trigger_quantities(old_desired_trigger_quantities[0], old_desired_trigger_quantities[1], old_desired_trigger_quantities[2], old_desired_trigger_quantities[3])

def get_SCROD_eventCnt(should_show_it=0):
	SCROD_eventCnt = read_register(SCROD_AxiCommon_eventCnt, BS)
	if should_show_it:
		info("SCROD_eventCnt: " + str(SCROD_eventCnt))
	return SCROD_eventCnt

def get_carrier_eventCnts(should_show_them=0):
	if 5==number_of_carriers[BS] or 0==number_of_carriers[BS]:
		return
	eventCnt = []
	if 1 <= number_of_carriers[BS]:
		carrier0_eventCnt = read_register(CARRIER_AxiCommon_eventCnt, BS, 0)
		eventCnt.append(carrier0_eventCnt)
		if should_show_them:
			info("carrier0_eventCnt: " + str(carrier0_eventCnt))
	if 2 <= number_of_carriers[BS]:
		carrier1_eventCnt = read_register(CARRIER_AxiCommon_eventCnt, BS, 1)
		eventCnt.append(carrier1_eventCnt)
		if should_show_them:
			info("carrier1_eventCnt: " + str(carrier1_eventCnt))
	if 3 <= number_of_carriers[BS]:
		carrier2_eventCnt = read_register(CARRIER_AxiCommon_eventCnt, BS, 2)
		eventCnt.append(carrier2_eventCnt)
		if should_show_them:
			info("carrier2_eventCnt: " + str(carrier2_eventCnt))
	if 4 <= number_of_carriers[BS]:
		carrier3_eventCnt = read_register(CARRIER_AxiCommon_eventCnt, BS, 3)
		eventCnt.append(carrier3_eventCnt)
		if should_show_them:
			info("carrier3_eventCnt: " + str(carrier3_eventCnt))
	return eventCnt

def set_desired_trigger_quantities(a, b, c, d):
	old_a = read_register(SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_a, BS)
	old_b = read_register(SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_b, BS)
	old_c = read_register(SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_c, BS)
	old_d = read_register(SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_d, BS)
	write_register(SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_a, a, BS)
	write_register(SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_b, b, BS)
	write_register(SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_c, c, BS)
	write_register(SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_d, d, BS)
	return old_a, old_b, old_c, old_d

def calculate_parameters(SST_clock_divide_ratio=6, should_print_info=0):
	# 5120 / 4 = 1280 FTSW clocks per frame
	# 5120 buckets / 508.8875 MHz = 10.0611628307 us per frame
	#
	# 127.221875 MHz / 6 = 21.203645833 MHz
	# 128 samples per write window * 21.203645833 MHz SST = 2714.066666 MHz sampling rate
	# 1/21.203645833 MHz = 47.1617007689 ns per write window
	# 10.0611628307 us / 47.1617007689 ns = 213.333333 write windows per revolution
	# 5120 / 213.333333 = 24.0 bunches per window
	# 6.0 FTSW bunches per window
	#
	# 127.221875 MHz / 8 = 15.902734375 MHz
	# 128 samples per write window * 15.902734375 MHz SST = 2035.55 MHz sampling rate
	# 1/15.902734375 MHz = 62.882268 ns per write window
	# 10.0611628307 us / 62.882268 ns = 160 write windows per revolution
	# 5120 / 160 = 32.0 bunches per window
	# 8.0 FTSW bunches per window
	global RF_clock_Hz
	RF_clock_Hz = 508.8875e6
	global period_of_RF_clock_ns
	period_of_RF_clock_ns = 1.0e9 / RF_clock_Hz
	global asic_samples_per_write_window
	asic_samples_per_write_window = 128
	global asic_samples_per_read_window
	asic_samples_per_read_window = asic_samples_per_write_window // 2
	global FTSW_clock_divide_ratio
	FTSW_clock_divide_ratio = 4
	global revolution_duration_s
	revolution_duration_s = RF_buckets / RF_clock_Hz
	global SST_clock_Hz
	SST_clock_Hz = RF_clock_Hz / FTSW_clock_divide_ratio / SST_clock_divide_ratio
	global sampling_rate_Hz
	sampling_rate_Hz = SST_clock_Hz * asic_samples_per_write_window
	global write_window_duration_s
	write_window_duration_s = 1.0 / SST_clock_Hz
	global read_window_duration_s
	read_window_duration_s = write_window_duration_s / 2.0
	global write_windows_per_revolution
	write_windows_per_revolution = revolution_duration_s / write_window_duration_s
	global read_windows_per_revolution
	read_windows_per_revolution = revolution_duration_s / read_window_duration_s
	global RF_buckets_per_write_window
	RF_buckets_per_write_window = RF_buckets // write_windows_per_revolution
	global RF_buckets_per_read_window
	RF_buckets_per_read_window = RF_buckets // read_windows_per_revolution
	global FTSW_clocks_per_write_window
	FTSW_clocks_per_write_window = RF_buckets_per_write_window // FTSW_clock_divide_ratio
	global FTSW_clocks_per_read_window
	FTSW_clocks_per_read_window = RF_buckets_per_read_window // FTSW_clock_divide_ratio
	global asic_samples_per_RF_bucket
	asic_samples_per_RF_bucket = asic_samples_per_read_window // RF_buckets_per_read_window
	global total_number_of_physical_windows
	total_number_of_physical_windows = 512
	if should_print_info:
		info("revolution_duration_us: " + str(revolution_duration_s*1.0e6))
		info("SST_clock_MHz: " + str(SST_clock_Hz/1.0e6))
		info("sampling_rate_GHz: " + str(sampling_rate_Hz/1.0e9))
		info("write_window_duration_ns : " + str(write_window_duration_s*1.0e9))
		info("read_window_duration_ns : " + str(read_window_duration_s*1.0e9))
		info("write_windows_per_revolution: " + str(write_windows_per_revolution))
		info("read_windows_per_revolution: " + str(read_windows_per_revolution))
		info("RF_buckets_per_write_window: " + str(RF_buckets_per_write_window))
		info("RF_buckets_per_read_window: " + str(RF_buckets_per_read_window))
		info("FTSW_clocks_per_write_window: " + str(FTSW_clocks_per_write_window))
		info("FTSW_clocks_per_read_window: " + str(FTSW_clocks_per_read_window))

def show_xrm_trigger_enable_status():
	en = read_register(SCROD_AxiCommon_xrm_trigger_enabled, BS)
	info("xrm trigger enabled: " + str(en))

def show_relevant_registers():
	#get_SCROD_eventCnt(1)
	#get_carrier_eventCnts(1)
	show_frame_masks()
	nlog2 = read_register(SCROD_AxiCommon_trig_prescale_N_log2, BS)
	info("N_log2 prescale: " + str(nlog2))
	show_xrm_trigger_enable_status()
	show_asic_timeouts(BS)
	show_SEM_status(BS)

def show_some_info():
	info("")
	show_current_time()
	show_asic_timeouts(BS)
	get_SCROD_eventCnt(1)
	get_carrier_eventCnts(1)
	show_relevant_registers()
	#show_scalers(BS)
	#get_status(BS)

# https://stackoverflow.com/a/1158096/5728815
def touch(filename):
	if os.path.exists(filename):
		os.utime(filename, None)
	else:
		open(filename, 'a').close()

def get_mtime(filename):
	return os.stat(filename).st_mtime

def set_mtime(destination, source):
	reftime = get_mtime(source)
	os.utime(destination, (reftime, reftime))
	newtime = get_mtime(destination)
	#info(hex(reftime))
	#info(hex(newtime))

# from https://matplotlib.org/3.1.1/gallery/text_labels_and_annotations/date.html
def plot_beam_conditions(x, current, nbunches, xcenter=0, xwidth=10800):
	#global fig3
	global axes3
	global axes4
#	try:
#		axes3
#	except:
	#fig3 = plt.figure(figsize=(3.0, 1.0))
	#fig3.tight_layout(pad=2)
#	if not already_plotted:
#		axes3 = fig.add_subplot(1, 1, 1)
#	else:
	if already_plotted:
		axes3.clear()
		#axes4.clear()
	axes4 = axes3.twinx()
	axes3.set_autoscaley_on(False)
	axes4.set_autoscaley_on(False)
	#axes3.set_ylim([129, -2])
	if 0==xcenter:
		xcenter = datetime.datetime.strptime(timestring, "%Y-%m-%d.%H%M%S")
		#xcenter = datetime.datetime(2019, 11, 15, 8, 45)
		#info(str(xcenter))
		xcenter = mdates.date2num(xcenter)
		#info(str(xcenter))
		xcenter = mdates.num2epoch(xcenter)
		#info(str(xcenter))
	x0 = xcenter - xwidth / 2.0
	x1 = xcenter + xwidth / 2.0
	#info("x:[" + str(x0) + "," + str(xcenter) + "," + str(x1) + "]")
	i0 = 0
	i1 = 0
	for i in range(len(x)): # find start and end indices
		if 0==i0:
			if x0<x[i]:
				i0 = i
		if x[i]<x1:
			i1 = i
	#info("i:[" + str(i0) + "," + str(i1) + "]")
	if 0==i0 or len(x)-1==i1:
		error("range of dates not contained in current/nbunches files")
		axes3.clear()
		axes4.clear()
		return
#	minx = mdates.num2epoch(mdates.date2num(datetime.datetime(2100, 1, 1))) # far in the future
#	maxx = 0.0
	#min_current = 5000.0 # in mA; more current than is ever expected
	max_current = 0.0
	#min_nbunches = 6000.0 # more than the maximum number of bunches in superkekb
	max_nbunches = 0.0
#	for i in range(i0, i1+1):
	for i in range(len(x)):
#		minx = min(minx, x[i])
#		maxx = max(maxx, x[i])
		#min_current = min(min_current, current[i])
		max_current = max(max_current, current[i])
		#min_nbunches = min(min_nbunches, nbunches[i])
		max_nbunches = max(max_nbunches, nbunches[i])
	#info(str(len(max_current)))
	#info(str(len(max_nbunches)))
	#info("x:[" + str(minx) + "," + str(maxx) + "]")
	min_current = 0.0 # measurement is sometimes negative, but we disregard that...
	min_nbunches = 0.0
	max_current = current_gridstep * ceil(max_current/current_gridstep)
	#info("y: [" + str(miny) + "," + str(maxy) + "] mA")
	#info("x: [" + str(minx) + "," + str(maxx) + "] s since 1970")
	#axes3.set_ylim([66, -2])
	axes3.set_ylim([min_current, max_current])
	axes3.yaxis.set_major_locator(MultipleLocator(current_gridstep))
	#axes3.set_ylabel("HER (mA)")
	axes3.set_ylabel("HER\n(mA)", color="blue")
	t = mdates.epoch2num(x[i0:i1])
	I = current[i0:i1]
	nb = nbunches[i0:i1]
#	axes3.set_yticklabels([])
#	axes3.set_yticks([])
	#axes3.set_xlabel("time")
#	axes3.set_title("RF bucket #" + str(desired_RF_bucket))
	#years = mdates.YearLocator()   # every year
	#months = mdates.MonthLocator()  # every month
	#threehours = mdates.HourLocator(interval = 3)   # every 3 hours
	hours = mdates.HourLocator()
	halfhours = mdates.MinuteLocator(interval = 30)
	#mydateformat = mdates.DateFormatter('%m-%d\n%H:%M')
	#mydateformat = mdates.DateFormatter('%Hh')
	mydateformat = mdates.DateFormatter('%H')
	axes3.xaxis.set_major_locator(hours)
	axes3.xaxis.set_major_formatter(mydateformat)
	#axes3.xaxis.set_minor_locator(halfhours)
	axes3.xaxis.set_ticks_position("top")
	#axes3.xaxis.set_ticks_position("bottom")
	#ax.xaxis.set_minor_locator(months)
	# round to nearest years.
	#datemin = np.datetime64(data['date'][0], 'Y')
	#datemax = np.datetime64(data['date'][-1], 'Y') + np.timedelta64(1, 'Y')
	#axex3.set_xlim(datemin, datemax)
	axes3.set_xlim([mdates.epoch2num(x[i0]), mdates.epoch2num(x[i1])])
	axes3.set_xticklabels([])
	axes3.axvline(x=mdates.epoch2num(xcenter), linewidth=2.0*linewidth, color="red")
	#axes3.set_xticks([])
	# format the coords message box
#	axes3.format_xdata = mdates.DateFormatter('%Y-%m-%d %H:%M:%S')
	#ax.format_ydata = lambda x: '$%1.2f' % x  # format the price.
	axes3.grid(True)
	#axes3.grid(axis='xy', which='major')
	# rotates and right aligns the x labels, and moves the bottom of the
	# axes up to make room for them
	#fig3.autofmt_xdate()
	axes3.plot(t, I, color="blue", linewidth=2.0*linewidth)
	#axes4.set_ylabel("nbunches")
	axes4.set_ylabel("nb", color="green")
	axes4.yaxis.set_major_locator(MultipleLocator(nbunches_gridstep))
	max_nbunches = nbunches_gridstep * ceil(max_nbunches/nbunches_gridstep)
	axes4.set_ylim([min_nbunches, max_nbunches])
	axes4.plot(t, nb, color="green", linewidth=2.0*linewidth)
	#fig3.savefig("beam_currents.pdf")
	#plt.ion()
	#plt.show()
	#plt.connect("close_event", plotquit)
	#fig3.canvas.draw()
	#fig3.canvas.flush_events()
	#plt.pause(0)

def read_beam_conditions_from_file(filename):
	array = []
	if not os.path.exists(filename):
		warning("file " + filename + " does not exist")
		return array
	datetime_1970 = datetime.datetime(1970, 1, 1)
	i = 0
	with open(filename, "r") as f:
		#info("opened " + filename + " ...")
		for line in f.readlines():
			line = line.rstrip()
			#info(line)
			match = re.search("([0-9][0-9]/[0-9][0-9]/20[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\.[0-9][0-9])	([:a-zA-Z0-9]+)	(.*)", line) # y2100 bug
			if match:
				time = match.group(1) + "0000"
				key = match.group(2)
				#value = float(match.group(3))
				valuestring = match.group(3)
				length = len(valuestring)
				values = re.split(r'	', valuestring)
				if 1==len(values):
					match = re.search("Connected", valuestring)
					if match:
						continue
#					info(values[0])
					value = float(values[0])
				else:
					if not RF_buckets==len(values):
						error("found " + str(len(values)) + " items on line")
						error(line)
					value = []
					for i in range(len(values)):
						value.append(float(values[i]))
#				if 37==i:
#					info(str(time) + " " + key + " (" + str(length) + ") " + str(value))
				utc_time = datetime.datetime.strptime(time, "%m/%d/%Y %H:%M:%S.%f")
				epoch_time = (utc_time - datetime_1970).total_seconds()
				#utc_time = (utc_time-0).total_seconds()
				#info(str(epoch_time))
				array.append([epoch_time, value])
				#beam_current.append([epoch_time, value])
				#ts = datetime.datetime.fromtimestamp(epoch_time, pytz.timezone('Asia/Tokyo'))
				#ts = datetime.datetime.fromtimestamp(epoch_time)
				#time= ts.strftime("%Y-%m-%d.%H%M%S")
				#beam_current.append([time, value])
				#beam_current.append([time, value])
				i += 1
	#info("read " + str(i) + " lines from " + filename)
	return array

def read_beam_conditions_from_files():
	global beam_current
	global nbunches
	global bunch_current
	if beam_conditions_need_to_be_read_again:
		info("reading beam conditions from files for " + datestring + " ...")
		global datestring_we_last_used_to_read_beam_conditions
		datestring_we_last_used_to_read_beam_conditions = datestring
		#beam_current = read_beam_conditions_from_file(beam_current_filename[1])
		#nbunches = read_beam_conditions_from_file(nbunches_filename[1])
		#bunch_current = read_beam_conditions_from_file(bunch_current_filename[1])
		beam_current = read_beam_conditions_from_file(beam_current_filename[0])
		beam_current.extend(read_beam_conditions_from_file(beam_current_filename[1]))
		#beam_current.extend(read_beam_conditions_from_file(beam_current_filename[2]))
		nbunches = read_beam_conditions_from_file(nbunches_filename[0])
		nbunches.extend(read_beam_conditions_from_file(nbunches_filename[1]))
		#nbunches.extend(read_beam_conditions_from_file(nbunches_filename[2]))
		bunch_current = read_beam_conditions_from_file(bunch_current_filename[0])
		bunch_current.extend(read_beam_conditions_from_file(bunch_current_filename[1]))
		#bunch_current.extend(read_beam_conditions_from_file(bunch_current_filename[2]))
		#info("datestring_we_last_used_to_read_beam_conditions: " + datestring_we_last_used_to_read_beam_conditions)

def plot_beam_conditions_from_filename():
	read_beam_conditions_from_files()
	if len(beam_current):
		#for time, current in beam_current:
		#	info(str(time) + " " + str(current))
		t_bc, bc = zip(*beam_current)
		t_nb, nb = zip(*nbunches)
		plot_beam_conditions(t_bc, bc, nb)
	if len(bunch_current):
		t_now = datetime.datetime.strptime(timestring, "%Y-%m-%d.%H%M%S")
		t_now = mdates.date2num(t_now)
		t_now = mdates.num2epoch(t_now)
		#info("t_now: " + str(t_now))
		t, bc = zip(*bunch_current)
		ti = 0
		for i in range(len(t)):
			if t[i]<t_now:
				ti = i
		if 0==ti or len(t)-1==ti:
			error("range of dates not contained in bunch_current file")
			return
		#info("t[" + str(ti) + "]: " + str(t[ti]))
		scaling = 2
		scaling = int(scaling)
		number_of_datapoints_in_orbit = scaling * RF_buckets
		#info("number_of_datapoints_in_orbit: " + str(number_of_datapoints_in_orbit))
		x = numpy.array([ i for i in range(number_of_datapoints_in_orbit) ])
		alberta = numpy.array([ i for i in range(number_of_datapoints_in_orbit) ])
		bcm_time_series = numpy.array([ i for i in range(number_of_datapoints_in_orbit) ])
		bcm_quantization = 0.0000001 # in 100s of nA
		bcm_quantization *= 96598.0 # in minimum quantization units
		for i in range(number_of_datapoints_in_orbit):
			x[i] = i/scaling
			j = (int(scaling*revolution_marker_offset_in_RF_buckets)+i)%number_of_datapoints_in_orbit
			alberta[j] = bunch_current_offset + bunch_current_scale*bc[ti][i/scaling]
			if i%2:
				bcm_time_series[i] = int(0.5+bc[ti][i/scaling]/bcm_quantization) # bcm_time_series in canonical units
			else:
				bcm_time_series[i] = 0
		axes1.plot(x, alberta, color="black", linewidth=linewidth)
		#axes1.text(-32.0, bunch_current_offset + 145.0, "BCM", rotation=90, size=6.0)
		axes1.text(-32.0, bunch_current_offset + 50.0, "BCM", size=6.0, ha='center', va='center')
		time_series_string = timestring + ","
		ordered_set_string = ""
		bcm_ordered_set = set()
		for i in range(number_of_datapoints_in_orbit):
			time_series_string += str(bcm_time_series[i]) + ","
			if bcm_time_series[i]:
				bcm_ordered_set.add(bcm_time_series[i])
		for value in sorted(bcm_ordered_set):
			ordered_set_string += str(value) + ","
		if len(time_series_string):
			#info(len(time_series_string))
			time_series_string = time_series_string[:-1]
		if len(ordered_set_string):
			#info(len(ordered_set_string))
			ordered_set_string = ordered_set_string[:-1]
		#info(time_series_string)
		#info(ordered_set_string)
		#info(bcm_ordered_set)
		bcm_outputfile_name = "bcm.csv"
		bcm_outputfile = open(bcm_outputfile_name, "a")
		#bcm_outputfile.seek(0, os.SEEK_END)
		#info(bcm_outputfile.tell())
		bcm_outputfile.write(time_series_string + "\n")
		#bcm_outputfile.write(ordered_set_string + "\n")
		#bcm_outputfile.flush()
		#bcm_outputfile.seek(0, os.SEEK_END)
		#info(bcm_outputfile.tell())
		bcm_outputfile.close()

def gcd_2(a, b):
	#string = "gcd(" + str(a) + "," + str(b) + ") = "
	d = 0
	while (0==(a%2) and 0==(b%2)):
		a >>= 1
		b >>= 1
		d += 1
	while (a!=b):
		if (0==(a%2)):
			a >>= 1
		elif (0==(b%2)):
			b >>= 1
		elif (a>b):
			a = (a-b)>>1
		else:
			b = (b-a)>>1
	#return (a, d)
	result = a * 2**d
	#string += str(result)
	#info(string)
	return result

def gcd(numbers, top_level=1):
	# https://stackoverflow.com/a/16628379/5728815
	result = 0
	string = "gcd(" + str(numbers) + ") = "
	if len(numbers)>2:
		result = reduce(lambda x,y: gcd([x, y], 0), numbers)
	elif len(numbers)>1:
		result = gcd_2(numbers[0], numbers[1])
	else:
		result = numbers[0]
	string += str(result)
	if top_level:
		info(string)
	return result

def test_gcd():
	gcd([14, 49])
	gcd([144, 169])
	gcd([45, 95])
	gcd([2*3*7*9,3*7*9*5])
	gcd([3*5, 3*7, 3*11])
	gcd([2*3*5, 2*3*7, 2*3*11])
	gcd([3*5, 3*7, 5*11])
	gcd([2*3*5, 2*3*7, 2*5*11])
	gcd([34, 56, 78, 90])
	gcd([2*3*5, 2*3*7, 2*5*11])
	gcd([2*3*5, 2*3*7, 5*11])

def inner_product(numbers, top_level=1):
	string = "inner_product(" + str(numbers) + ") = "
	product = 1.0
	for number in numbers:
		product *= number
	string += str(product)
	if top_level:
		info(string)
	return product

def lcm(numbers, top_level=1):
	string = "lcm(" + str(numbers) + ") = "
	gcd_result = gcd(numbers, 0)
	ip_result = inner_product(numbers, 0)
	result = int(ip_result / gcd_result)
	string += str(result)
	if top_level:
		info(string)
	return result

def differential(numbers):
	result_set = set()
	for i in range(len(numbers)):
		if i==0:
			continue
		result_set.add(numbers[i]-numbers[i-1])
	result = []
	for value in sorted(result_set):
		result.append(value)
	info(str(result))
	return result

def histogram_differential(numbers):
	result = {}
	for i in range(len(numbers)):
		if i==0:
			continue
		diff = numbers[i]-numbers[i-1]
		try:
			result[diff] += 1
		except:
			result[diff] = 1
	result_list = []
	for key in sorted(result.keys()):
		value = result[key]
		result_list.append([key, value])
		#result_list.append(key : value)
	info(str(result_list))
	return result

def log2(number):
	return log(number)/log(2.0)

def split_bigword_into_smallwords(bigword, number_of_bits_in_each_smallword=8):
	number_of_bits_in_bigword = len(bigword)
	number_of_smallwords = int(ceil(number_of_bits_in_bigword/number_of_bits_in_each_smallword))
	smallword = []
	k = 0
	for i in range(number_of_smallwords):
		smallword.append("")
		for j in range(number_of_bits_in_each_smallword):
			if k<number_of_bits_in_bigword:
				smallword[i] += bigword[k]
				k += 1
			else:
				smallword[j] += "0"
	#info(smallword)
	return smallword

def show_bcm_array(numbers):
	string = ""
	for i in range(len(numbers)):
		current_value = numbers[i]
		if 0!=current_value:
			string += "\n"
		string += str(current_value) + ","
	info(string)

def run_length_encode_gaps(numbers):
	#show_bcm_array(numbers)
	# 5,0,0,0,0,0,0,0,0,0,0,0,
	# 4,0,0,0,0,0,0,0,0,0,0,0,
	# 4,0,0,0,0,0,0,0,0,0,0,0,0,0,
	# -> [ [5, 1], [0, 11], [4, 1], [0, 11], [4, 1], [0, 13] ]
	rle = []
	current_value = -1
	old_value = -1
	current_count = 0
	if len(numbers):
		for i in range(len(numbers)):
			current_value = numbers[i]
			if 0==i:
				old_value = current_value
			if old_value==current_value:
				current_count += 1
			else:
				rle.append([old_value, current_count])
				old_value = current_value
				current_count = 1
		rle.append([old_value, current_count])
	string = dec(0, 5) + ": "
	count = 0
	i = 0
	for kv in rle:
		k, v = kv
		count += v
		i += v
		string += "[" + str(k) + "," + str(v) + "],"
		if 11<v:
			lcm_result = int(lcm([count, 8], 0)/8)
			string += " (" + str(count) + "," + str(lcm_result) + ")\n" + dec(i+1, 5) + ":"
			count = 0
	string = string[:-1]
	#info(string)
# loop_counter_5120
# loop_counter_4
	return rle

def compress(array, width):
	values_array = []
	index_array = []
	#partial_line = ""
	partial_line = []
	i = 0
	MAX = len(array)
	for j in range(MAX/width):
		for k in range(width):
			#partial_line += hex(array[i], 2)
			partial_line.append(array[i])
			i += 1
		found_it = 0
		for l in range(len(values_array)):
			if values_array[l] == partial_line:
				index_array.append(l)
				found_it = 1
		if not found_it:
			index_array.append(len(values_array))
			values_array.append(partial_line)
		#partial_line = ""
		partial_line = []
#	values_array = [ [9, 9, 9, 9], [6, 6, 6, 6], [3, 3, 3, 3], [0, 0, 0, 0] ]
#	index_array = [ 0,0,1,0,1,1,2,1,2,2,3,2,3,3,3,3,3,3,3,3,3,0,3 ]
	return values_array, index_array

def get_most_frequently_used_item(array):
	most_frequently_used_index = {}
	for i in range(len(array)):
		try:
			most_frequently_used_index[array[i]] += 1
		except:
			most_frequently_used_index[array[i]] = 1
	most_frequently_used_index = sorted(most_frequently_used_index.items(), key = lambda kv:(kv[1], kv[0]), reverse=True)
	return most_frequently_used_index[0][0]

def rearrange_compressed_array(values_array, index_array):
	alternate_values_array = list(values_array)
	alternate_index_array = list(index_array)
#	info(str(most_frequently_used_index))
#	for i in most_frequently_used_index:
#		#info(str(i) + ": " + str(most_frequently_used_index[i]))
#		info(str(i))
#	show_values_array_and_index_array(alternate_values_array, alternate_index_array)
#	for i in range(len(values_array)):
#		swap_index = get_most_frequently_used_item(values_array[i])
#		for j in range(len(values_array[i])):
#			if j==0:
#				alternate_values_array[i][0] = values_array[i][swap_index]
#			elif j==swap_index:
#				alternate_values_array[i][swap_index] = values_array[i][0]
#	show_values_array_and_index_array(alternate_values_array, alternate_index_array)
	swap_index = get_most_frequently_used_item(index_array)
	#info(str(most_frequently_used_index[0][0]))
	alternate_values_array[0] = values_array[swap_index]
	alternate_values_array[swap_index] = values_array[0]
#	for i in range(len(values_array)):
#		for j in range(len(values_array[i])):
#			if i==0:
#				alternate_values_array[0][j] = values_array[swap_index][j]
#			elif i==swap_index:
#				alternate_values_array[swap_index][j] = values_array[0][j]
#			else:
#				alternate_values_array[i][j] = values_array[i][j]
#	show_values_array_and_index_array(alternate_values_array, alternate_index_array)
	for i in range(len(index_array)):
		if index_array[i]==0:
			alternate_index_array[i] = swap_index
		elif index_array[i]==swap_index:
			alternate_index_array[i] = 0
#		else:
#			alternate_index_array[i] = index_array[i]
#	alternate_index_array[0] = index_array[swap_index]
#	alternate_index_array[swap_index] = index_array[0]
#	for i in range(len(values_array)):
#		for j in range(len(values_array[i])):
	return alternate_values_array, alternate_index_array

def show_values_array_and_index_array(values_array, index_array):
	string = "["
	for i in range(len(values_array)):
		string += " [ "
		for j in range(len(values_array[i])):
			string += hex(values_array[i][j], 2) + ","
		string = string[:-1]
		string += " ]\n"
	string = string[:-1]
	string += " ]\n"
	string += "[ "
	for i in range(len(index_array)):
		string += hex(index_array[i], 1) + ","
		string = string[:-1]
	string += " ]\n"
	info(string)

def show_array(array, width):
	MAX = len(array)
	k = 0
	string = ""
	for i in range(MAX//width):
		for j in range(width):
			string += hex(array[k], 2)
			k += 1
		string += "\n"
	string = string[:-1]
	info(string)

def write_array(array, output_filename):
	k = 0
	outfile = open(output_filename, "w")
	for i in range(len(array)):
		outfile.write(struct.pack('B', array[i]))
	outfile.close()

def kolmogorov(array, function):
	kolmogorov_scores = []
	#for width in range(2, 500):
	for width in range(2, 100):
		values_array, index_array = function(array, width)
		kolmogorov_score = len(index_array)
		for values in values_array:
			kolmogorov_score += len(values)
		kolmogorov_scores.append([width, kolmogorov_score])
		#info("width=" + str(width) + " score=" + str(score))
	kolmogorov_scores.sort(key=lambda z: z[1])
	if (1):
		num = 4
		i = 0
		for ws in kolmogorov_scores:
			w, s = ws
			if i<num:
				info("width=" + str(w) + " score=" + str(s))
			i += 1
	return kolmogorov_scores[0]

def kolmogorov_optimize(array):
#	last_partial_string = ""
#	WIDTH = 49 # 4 unique
#	WIDTH = 3 # 14 unique
#	WIDTH = 9 # 38 unique
#	WIDTH = 12 # 50 unique
	ideal_width, kolmogorov_score = kolmogorov(array, compress)
	info("ideal width = " + str(ideal_width) + "  kolmogorov score = " + str(kolmogorov_score))
	show_array(array, ideal_width)
	write_array(array, "bcm.array")
	values_array, index_array = compress(array, ideal_width)
	string = ""
	for values in values_array:
		string += str(values) + "\n"
	for index in index_array:
		string += " [" + str(index) + "]"
	info(string)
	return array

def block_encode(numbers, strength):
	MAX = 2**14
	#MAX = int(len(numbers)/8)
	array = [ 0 for i in range(MAX) ]
	for i in range(len(numbers)):
		value = numbers[i]
		if value:
			mod8 = i%8
			index = int((i-mod8)/8)
			if 4==strength:
				if 0==mod8:
					array[index] = 0xf0
				elif 1==mod8:
					array[index] = 0xf0
				elif 2==mod8:
					array[index] = 0xf0
				elif 3==mod8:
					array[index] = 0xf0
				elif 4==mod8:
					array[index] = 0x0f
				elif 5==mod8:
					array[index] = 0x0f
				elif 6==mod8:
					array[index] = 0x0f
				else:
					array[index] = 0x0f
			elif 3==strength:
				if 0==mod8:
					array[index] = 0xe0
				elif 1==mod8:
					array[index] = 0x70
				elif 2==mod8:
					array[index] = 0x38
				elif 3==mod8:
					array[index] = 0x38
				elif 4==mod8:
					array[index] = 0x1c
				elif 5==mod8:
					array[index] = 0x1c
				elif 6==mod8:
					array[index] = 0x0e
				else:
					array[index] = 0x07
			elif 2==strength:
				if 0==mod8:
					array[index] = 0xc0
				elif 1==mod8:
					array[index] = 0x60
				elif 2==mod8:
					array[index] = 0x30
				elif 3==mod8:
					array[index] = 0x18
				elif 4==mod8:
					array[index] = 0x18
				elif 5==mod8:
					array[index] = 0x0c
				elif 6==mod8:
					array[index] = 0x06
				else:
					array[index] = 0x03
			else:
				if 0==mod8:
					array[index] = 0x80
				elif 1==mod8:
					array[index] = 0x40
				elif 2==mod8:
					array[index] = 0x20
				elif 3==mod8:
					array[index] = 0x10
				elif 4==mod8:
					array[index] = 0x08
				elif 5==mod8:
					array[index] = 0x04
				elif 6==mod8:
					array[index] = 0x02
				else:
					array[index] = 0x01
	return array

def mem_encode(numbers):
	rle = run_length_encode_gaps(numbers)
	result = []
	#string = ""
	count = 0
	i = 0
	for kv in rle:
		k, v = kv
		count += v
		i += v
		if k:
			mod8 = i%8
			#info(str(mod8))
			index = int((i-mod8)/8)
			if 0==mod8:
				#word = "10000000"
				#word = "80"
				value = 0x80
			elif 1==mod8:
				#word = "01000000"
				#word = "40"
				value = 0x40
			elif 2==mod8:
				#word = "00100000"
				#word = "20"
				value = 0x20
			elif 3==mod8:
				#word = "00010000"
				#word = "10"
				value = 0x10
			elif 4==mod8:
				#word = "00001000"
				#word = "08"
				value = 0x08
			elif 5==mod8:
				#word = "00000100"
				#word = "04"
				value = 0x04
			elif 6==mod8:
				#word = "00000010"
				#word = "02"
				value = 0x02
			else:
				#word = "00000001"
				#word = "01"
				value = 0x01
			result.append([index, value])
			#string += "\n@" + hex(index, 4) + " " + word
			#string += " " + str(i) + " " + str(mod8) + " " + word # + "\n"
		#string += "[" + str(k) + "," + str(v) + "],"
		if 100<v:
			#lcm_result = int(lcm([count, 8], 0)/8)
			info("gap starting at " + hex(index, 4))
			#count = 0
	#string = string[:-1]
	#info(string)
# loop_counter_5120
# loop_counter_4
	return result
	#return string

def read_bcm_csv(input_filename, date_string):
	scaling = 2
	values = []
	if os.path.isfile(input_filename):
		input_file = open(input_filename)
		lines = input_file.readlines()
		for line in lines:
			match = re.search("^" + date_string + ",(.*)", line)
			if match:
				valuestring = match.group(1)
				values = re.split(r',', valuestring)
				count = len(values)
				if not count==scaling*RF_buckets:
					warning("read in " + str(count) + " datapoints")
	max_value = 0
	if len(values)==0:
		warning("no data found in file")
		return
	for i in range(len(values)):
		values[i] = int(values[i])
		max_value = max(max_value, values[i])
	info("max_value: " + str(max_value))
	if max_value==0:
		warning("no data found in file")
		return
	normalization = 8.0 / max_value
	info("normalization: " + str(normalization))
	for i in range(len(values)):
		values[i] = int(values[i]*normalization)
	return values

def generate_verilog_init_file_from_bcm_csv_1(input_filename, output_filename, date_string):
	values = read_bcm_csv(input_filename, date_string)
	#show_bcm_array(values)
	run_length_encode_gaps(values)
	the1s = []
	the2s = []
	the3s = []
	the4s = []
	the5s = []
	the6s = []
	the7s = []
	the8s = []
	i = 0
	theeverything = []
	for value in values:
		if value!=0:
			theeverything.append(i)
			if value==1:
				the1s.append(i)
			elif value==2:
				the2s.append(i)
			elif value==3:
				the3s.append(i)
			elif value==4:
				the4s.append(i)
			elif value==5:
				the5s.append(i)
			elif value==6:
				the6s.append(i)
			elif value==7:
				the7s.append(i)
			elif value==8:
				the8s.append(i)
		i += 1
	if len(theeverything):
		#gcd(theeverything)
		#differential(theeverything)
		hdiff = histogram_differential(theeverything)
	if (0):
		if len(the1s):
			info("1: " + str(the1s))
			#gcd(the1s)
			#histogram_differential(the1s)
		if len(the2s):
			info("2: " + str(the2s))
			#gcd(the2s)
			#histogram_differential(the2s)
		if len(the3s):
			info("3: " + str(the3s))
			#gcd(the3s)
			#histogram_differential(the3s)
		if len(the4s):
			info("4: " + str(the4s))
			#gcd(the4s)
			#histogram_differential(the4s)
		if len(the5s):
			info("5: " + str(the5s))
			#gcd(the5s)
			#histogram_differential(the5s)
		if len(the6s):
			info("6: " + str(the6s))
			#gcd(the6s)
			#histogram_differential(the6s)
		if len(the7s):
			info("7: " + str(the7s))
			#gcd(the7s)
			#histogram_differential(the7s)
		if len(the8s):
			info("8: " + str(the8s))
			#gcd(the8s)
			#histogram_differential(the8s)
	string = "					data_in <= 8'h00;\n"
	first_time_through = 1
	did_something = 0
	i = 0
	if (0):
		for value in values:
			if not value==0:
				did_something = 1
				if first_time_through:
					string += "					if (counter==" + str(i) + ") begin\n"
					first_time_through = 0
				else:
					string += "					end else if (counter==" + str(i) + ") begin\n"
				if value==1:
					substring = "8'b10000000;"
				elif value==2:
					substring = "8'b11000000;"
				elif value==3:
					substring = "8'b11100000;"
				elif value==4:
					substring = "8'b11110000;"
				elif value==5:
					substring = "8'b11111000;"
				elif value==6:
					substring = "8'b11111100;"
				elif value==7:
					substring = "8'b11111110;"
				else:
					substring = "8'b11111111;"
				string += "						data_in <= " + substring + "\n"
			i += 1
	elif (0):
		if len(the1s):
			string += "					if ("
			for i in the1s:
				string += " (counter==" + str(i) + ") ||"
			string = string[:-2]
			string += ") begin\n"
			string += "						data_in <= 8'b10000000;\n"
			did_something = 1
		if len(the2s):
			if did_something:
				string += "					end else if ("
			else:
				string += "					if ("
			for i in the2s:
				string += " (counter==" + str(i) + ") ||"
			string = string[:-2]
			string += ") begin\n"
			string += "						data_in <= 8'b11000000;\n"
			did_something = 1
		if len(the3s):
			if did_something:
				string += "					end else if ("
			else:
				string += "					if ("
			for i in the3s:
				string += " (counter==" + str(i) + ") ||"
			string = string[:-2]
			string += ") begin\n"
			string += "						data_in <= 8'b11100000;\n"
			did_something = 1
		if len(the4s):
			if did_something:
				string += "					end else if ("
			else:
				string += "					if ("
			for i in the4s:
				string += " (counter==" + str(i) + ") ||"
			string = string[:-2]
			string += ") begin\n"
			string += "						data_in <= 8'b11110000;\n"
			did_something = 1
		if len(the5s):
			if did_something:
				string += "					end else if ("
			else:
				string += "					if ("
			for i in the5s:
				string += " (counter==" + str(i) + ") ||"
			string = string[:-2]
			string += ") begin\n"
			string += "						data_in <= 8'b11111000;\n"
			did_something = 1
		if len(the6s):
			if did_something:
				string += "					end else if ("
			else:
				string += "					if ("
			for i in the6s:
				string += " (counter==" + str(i) + ") ||"
			string = string[:-2]
			string += ") begin\n"
			string += "						data_in <= 8'b11111100;\n"
			did_something = 1
		if len(the7s):
			if did_something:
				string += "					end else if ("
			else:
				string += "					if ("
			for i in the7s:
				string += " (counter==" + str(i) + ") ||"
			string = string[:-2]
			string += ") begin\n"
			string += "						data_in <= 8'b11111110;\n"
			did_something = 1
		if len(the8s):
			if did_something:
				string += "					end else if ("
			else:
				string += "					if ("
			for i in the8s:
				string += " (counter==" + str(i) + ") ||"
			string = string[:-2]
			string += ") begin\n"
			string += "						data_in <= 8'b11111111;\n"
			did_something = 1
	elif (0):
		# lossy compression mode
		count = len(theeverything)
		if count:
			did_something = 1
			maxvalue = -1
			correspondingkey = -1
			for key in hdiff:
				value = hdiff[key]
				#info(str(key) + "," + str(value))
				if maxvalue<value:
					maxvalue = value
					correspondingkey = key
			#info(str(count) + "," + str(correspondingkey) + "," + str(maxvalue))
			width_of_count = int(ceil(log2(count+1)))
			width_of_correspondingkey = int(ceil(log2(correspondingkey+1)))
			#info(str(width_of_count))
			#info(str(width_of_correspondingkey))
			string += "	reg [" + str(width_of_count-1) + ":0] outer_loop_counter = " + str(count) + ";\n"
			string += "	reg [" + str(width_of_correspondingkey-1) + ":0] inner_loop_counter = " + str(correspondingkey) + ";\n"
			string += "					if (outer_loop_counter) begin\n"
			string += "						if (inner_loop_counter) begin\n"
			string += "							inner_loop_counter <= inner_loop_counter - 1;\n"
			string += "						end else begin\n"
			string += "							data_in <= 8'b10000000;\n"
			string += "							inner_loop_counter <= " + str(width_of_correspondingkey) + "'d" + str(correspondingkey) + ";\n"
			string += "							outer_loop_counter <= outer_loop_counter - 1;\n"
			string += "						end\n"
	elif (1):
		# lossy compression mode
		count = len(theeverything)
		if count:
			did_something = 1
			maxvalue = -1
			correspondingkey = -1
			for key in hdiff:
				value = hdiff[key]
				#info(str(key) + "," + str(value))
				if maxvalue<value:
					maxvalue = value
					correspondingkey = key
			#info(str(count) + "," + str(correspondingkey) + "," + str(maxvalue))
			# data bus width for the oserdes is 8
			# oserdes running at ~1 GHz so each bit is worth ~1 ns
			# to match the conditions of superkekb, we need 2 bits per RF bucket
			# the input array is already spaced out by a factor of 2
			number_of_oserdes_bits = lcm([correspondingkey, 8], 0)
			#info(str(number_of_oserdes_bits))
			number_of_oserdes_words = int(number_of_oserdes_bits / 8)
			#info(str(number_of_oserdes_words))
			bigword = ""
			#zeroword = "00000000"
			for i in range(number_of_oserdes_bits):
				if 0==i%correspondingkey:
					bigword += "1"
				else:
					bigword += "0"
			#digraph_off = "00"
			#digraph_on = "10" # other option is "11"
			#word[0] = digraph_on + digraph_off + digraph_off + digraph_off
			#info(bigword)
			word = split_bigword_into_smallwords(bigword, 8)
			#word = packetize(correspondingkey, number_of_oserdes_words)
			width_of_count = int(ceil(log2(count+1)))
			width_of_number_of_oserdes_words = int(ceil(log2(number_of_oserdes_words+1)))
			#info(str(width_of_count))
			#info(str(width_of_number_of_oserdes_words))
			count = int(count/number_of_oserdes_words)
			#info(str(count))
			string += "	reg [" + str(width_of_count-1) + ":0] outer_loop_counter = " + str(count) + ";\n"
			string += "	reg [" + str(width_of_number_of_oserdes_words-1) + ":0] inner_loop_counter = " + str(number_of_oserdes_words-1) + ";\n"
			string += "					if (outer_loop_counter) begin\n"
			#for oserdes_word_number in range(number_of_oserdes_words-1, 0, -1):
			for oserdes_word_number in range(number_of_oserdes_words-1):
				string += "						if (inner_loop_counter==" + str(number_of_oserdes_words-oserdes_word_number-1) + ") begin\n"
				string += "							inner_loop_counter <= inner_loop_counter - 1'b1;\n"
				string += "							data_in <= 8'b" + word[oserdes_word_number] + ";\n"
			string += "						end else begin\n"
			string += "							data_in <= 8'b" + word[number_of_oserdes_words-1] + ";\n"
			string += "							inner_loop_counter <= " + str(width_of_number_of_oserdes_words) + "'d" + str(number_of_oserdes_words-1) + ";\n"
			string += "							outer_loop_counter <= outer_loop_counter - 1'b1;\n"
			string += "						end\n"
	if did_something:
		string += "					end\n"
	#info(string)
	verilog_outputfile = open(output_filename, "w")
	verilog_outputfile.write(string + "\n")
	verilog_outputfile.close()

def generate_verilog_init_file_from_bcm_csv_2(input_filename, output_filename, date_string):
	values = read_bcm_csv(input_filename, date_string)
	#show_bcm_array(values)
	#rle = run_length_encode_gaps(values)
	#kolmogorov_optimize(values)
	#block_encode(values, 1)
	values = mem_encode(values)
	blah = {}
	for iv in values:
		index, value = iv
		try:
			blah[value].append(index)
		except:
			blah[value] = []
			blah[value].append(index)
	string = ""
	did_something = 0
	for key in blah.keys():
		#info(str(hex(key, 2)) + " " + str(blah[key]))
		if did_something:
			string += "					end else if ("
		else:
			string += "					if ("
			did_something = 1
		for index in blah[key]:
			string += " (counter==" + str(index) + ") ||"
		string = string[:-2]
		string += ") begin\n"
		string += "						data_in <= 8'h" + hex(key,2) + ";\n"
	string += "					end\n"
	#info(string)
	outputfile = open(output_filename, "w")
	outputfile.write(string + "\n")
	outputfile.close()

def generate_verilog_init_file_from_bcm_csv_3(input_filename, output_filename, date_string):
	values = read_bcm_csv(input_filename, date_string)
	#show_bcm_array(values)
	#rle = run_length_encode_gaps(values)
	#width = 98
	width = 49
	#width, score = kolmogorov_optimize(values)
	values = block_encode(values, 1)
	#show_array(values, width)
	values_array, index_array = compress(values, width)
#	show_values_array_and_index_array(values_array, index_array)
	values_array, index_array = rearrange_compressed_array(values_array, index_array)
	show_values_array_and_index_array(values_array, index_array)
	values_array_size_1 = len(values_array)
	values_array_size_2 = len(values_array[0])
	index_array_size = len(index_array)
	log2_values_array_size_1 = int(ceil(log2(values_array_size_1)))
	log2_values_array_size_2 = int(ceil(log2(values_array_size_2)))
	log2_index_array_size = int(ceil(log2(index_array_size)))
#	info("values_array_size_1 = " + str(values_array_size_1))
#	info("values_array_size_2 = " + str(values_array_size_2))
#	info("index_array_size = " + str(index_array_size))
#	info("log2_values_array_size_1 = " + str(log2_values_array_size_1))
#	info("log2_values_array_size_2 = " + str(log2_values_array_size_2))
#	info("log2_index_array_size = " + str(log2_index_array_size))
	string = ""
#	for values in values_array:
#		string += str(values) + "\n"
#	for index in index_array:
#		string += " [" + str(index) + "]"
	#info(string)
	today = time.strftime("%Y-%m-%d")
	string += "// this file is automatically generated by xrm.py from the uh svn repo\n"
	string += "// generated " + today + "\n"
	string += "\n"
	string += "module bcm_init #(\n"
	string += "	parameter DATA_BUS_WIDTH = 8,\n"
	string += "	parameter ADDRESS_BUS_DEPTH = 14\n"
	string += ") (\n"
	string += "	input clock,\n"
	string += "	input reset,\n"
	string += "	output reg [ADDRESS_BUS_DEPTH-1:0] write_address = 0,\n"
	string += "	output reg write_enable = 0,\n"
	string += "	output reg [DATA_BUS_WIDTH-1:0] data_out = 0,\n"
	string += "	output reg done = 0\n"
	string += ");\n"
	string += "	reg [7:0] values_array [" + str(values_array_size_1-1) + ":0][" + str(values_array_size_2-1) + ":0];\n"
	string += "	reg [" + str(log2_values_array_size_1-1) + ":0] index_array [" + str(index_array_size-1) + ":0];\n"
	string += "	reg [" + str(log2_values_array_size_1-1) + ":0] values_array_counter_1 = 0;\n"
	string += "	reg [" + str(log2_values_array_size_2-1) + ":0] values_array_counter_2 = 0;\n"
	string += "	reg [" + str(log2_index_array_size-1) + ":0] index_array_counter = 0;\n"
	string += "	reg [3:0] initializing_stage = 0;\n"
	string += "	reg [ADDRESS_BUS_DEPTH-1:0] counter = 0;\n"
	string += "	reg [" + str(log2_values_array_size_2-1) + ":0] values_array_counter_1_prime = 0;\n"
	string += "	reg [" + str(log2_values_array_size_2-1) + ":0] values_array_counter_2_prime = 0;\n"
	string += "	reg [" + str(log2_index_array_size-1) + ":0] index_array_counter_prime = 0;\n"
	string += "	always @(posedge clock) begin\n"
	string += "		if (reset) begin\n"
	string += "			initializing_stage <= 0;\n"
	string += "			values_array_counter_1 <= 0;\n"
	string += "			values_array_counter_2 <= 0;\n"
	string += "			index_array_counter <= 0;\n"
	string += "			counter <= 0;\n"
	string += "			write_enable <= 0;\n"
	string += "			write_address <= 0;\n"
	string += "			data_out <= 0;\n"
	string += "			values_array_counter_1_prime <= " + str(log2_values_array_size_1) + "'h" + hex(index_array[0], 1) + ";\n"
	string += "			values_array_counter_2_prime <= 0;\n"
	string += "			index_array_counter_prime <= 0;\n"
	string += "			done <= 0;\n"
	string += "		end else begin\n"
	string += "			values_array_counter_2 <= values_array_counter_2 + 1'b1;\n"
	for i in range(values_array_size_1):
		if i==0:
			string += "			if (initializing_stage==" + str(i) + ") begin\n"
		else:
			string += "			end else if (initializing_stage==" + str(i) + ") begin\n"
		string += "				case (values_array_counter_2)\n"
		for j in range(values_array_size_2):
			if values_array[i][j]:
				string += "					" + str(j) + ": values_array[values_array_counter_1][values_array_counter_2] <= 8'h" + hex(values_array[i][j], 2) + ";\n"
		string += "					" + str(values_array_size_2) + ": begin values_array_counter_1 <= values_array_counter_1 + 1'b1; values_array_counter_2 <= 0; initializing_stage <= initializing_stage + 1'b1; end\n"
		string += "					default: values_array[values_array_counter_1][values_array_counter_2] <= 8'h00;\n"
		string += "				endcase\n"
	string += "			end else if (initializing_stage==" + str(values_array_size_1) + ") begin\n"
	string += "				index_array_counter <= index_array_counter + 1'b1;\n"
	string += "				case (index_array_counter)\n"
	for i in range(index_array_size):
		if index_array[i]:
			string += "					" + str(i) + ": index_array[index_array_counter] <= " + str(log2_values_array_size_1) + "'h" + hex(index_array[i], 1) + ";\n"
	string += "					" + str(index_array_size) + ": begin index_array_counter <= 0; values_array_counter_2 <= 0; initializing_stage <= initializing_stage + 1'b1; end\n"
	string += "					default: index_array[index_array_counter] <= " + str(log2_values_array_size_1) + "'h0;\n"
	string += "				endcase\n"
	string += "			end else if (initializing_stage==" + str(values_array_size_1+1) + ") begin\n"
	string += "					values_array_counter_2_prime <= values_array_counter_2_prime + 1'b1;\n"
	string += "					write_enable <= 1;\n"
	string += "					write_address <= counter;\n"
	string += "					data_out <= values_array[values_array_counter_1_prime][values_array_counter_2_prime];\n"
	string += "					if (values_array_counter_2_prime==" + str(values_array_size_2-2) + ") begin\n"
	string += "						index_array_counter_prime <= index_array_counter_prime + 1'b1;\n"
	string += "					end else if (values_array_counter_2_prime==" + str(values_array_size_2-1) + ") begin\n"
	string += "						values_array_counter_1_prime <= index_array[index_array_counter_prime];\n"
	string += "						values_array_counter_2_prime <= 0;\n"
	string += "						if (index_array_counter_prime==" + str(index_array_size-1) + ") begin\n"
	string += "							initializing_stage <= initializing_stage + 1'b1;\n"
	string += "						end\n"
	string += "					end\n"
	string += "					counter <= counter + 1'b1;\n"
	string += "			end else if (initializing_stage==" + str(values_array_size_1+2) + ") begin\n"
	string += "				write_enable <= 0;\n"
	string += "				write_address <= 0;\n"
	string += "				data_out <= 0;\n"
	string += "				done <= 1;\n"
	string += "				initializing_stage <= initializing_stage + 1'b1;\n"
	string += "			end\n"
	string += "		end\n"
	string += "	end\n"
	string += "endmodule\n"
	string += "\n"
	#info(string)
	outputfile = open(output_filename, "w")
	outputfile.write(string + "\n")
	outputfile.close()

def generate_mem_bram_init_file_from_bcm_csv(input_filename, output_filename, date_string):
	values = read_bcm_csv(input_filename, date_string)
	#show_bcm_array(values)
	#rle = run_length_encode_gaps(values)
	values = mem_encode(values)
	string = ""
	for iv in values:
		index, value = iv
		string += "\n@" + hex(index, 4) + " " + hex(value, 2)
	#info(string)
	outputfile = open(output_filename, "w")
	outputfile.write(string + "\n")
	outputfile.close()

def continuously_parse_datafiles():
	set_verbosity(3)
	calculate_parameters(6, 0)
	global xrm_mode
	while True:
		read_config_file_for_xrm_stuff()
		xrm_mode = "parse"
		#parse_datafile_and_plot_waveformfile([-1])
		parse_all_datafiles_and_plot_all_waveformfiles_in_this_dirtree(parsedir)
		time.sleep(1)

def plot_waveforms_staggered_from_waveformfile(desired_event_numbers):
	png_filename = None
	parsing_and_plotting_start = mytimer()
	global number_of_physical_windows_to_plot
	number_of_physical_windows_to_plot = len(desired_event_numbers)
	if 0==number_of_physical_windows_to_plot:
		return
	N = 0 # will eventually be set to the current waveformfile_event_number
	if 1==len(desired_event_numbers):
		should_count_events_in_file = 0
		desired_event_number = desired_event_numbers[0]
		if -1==desired_event_number:
			should_count_events_in_file = 1
		if 0==desired_event_number and "parse"==xrm_mode:
			should_count_events_in_file = 1
		if should_count_events_in_file:
			N = count_events_in_waveformfile()
			#info("events in waveformfile: " + str(N))
			if -1==desired_event_number:
				desired_event_numbers = [ n for n in range(1, 1+N) ]
				number_of_physical_windows_to_plot = N
			elif 0==desired_event_number:
				desired_event_numbers = [ N ]
	number_of_events_to_plot_together = len(desired_event_numbers)
	if 0==number_of_events_to_plot_together:
		return
	info("number_of_physical_windows_to_plot: " + str(number_of_physical_windows_to_plot))
	info("number_of_events_to_plot_together: " + str(number_of_events_to_plot_together))
	slice_array = [ 0 for n in range(128) ]
	global RF_bucket_sample
	RF_bucket_sample = int(desired_RF_bucket * asic_samples_per_RF_bucket + RF_bucket_sample_offset + 0.5)
	global already_plotted
	#ch_stagger_offset = numpy.linspace(stagger_amount, stagger_amount, 32)
	global should_plot_slice
	if "parse"==xrm_mode:
		should_plot_slice = 0
	if not already_plotted:
		global fig
		fig = plt.figure(figsize=(plot_width/dpi, plot_height/dpi), constrained_layout=True)
		#fig = plt.figure(figsize=(plot_width/dpi, plot_height/dpi))
		global axes1
		global axes2
		global axes3
		mygridspec = gridspec.GridSpec(nrows=1, ncols=6, figure=fig)
		if should_plot_slice:
			axes1 = fig.add_subplot(mygridspec[0, :-1])
			axes2 = fig.add_subplot(mygridspec[0, -1])
		else:
			axes1 = fig.add_subplot(mygridspec[0, :])
		if should_plot_beam_current:
			#axes3 = inset_axes(axes1, width=beam_current_plot_width/dpi, height=beam_current_plot_height/dpi, bbox_transform=axes1.transAxes, bbox_to_anchor=(0.975, 1.0475))
			axes3 = inset_axes(axes1, width=beam_current_plot_width/dpi, height=beam_current_plot_height/dpi, bbox_transform=axes1.transAxes, bbox_to_anchor=(0.95, 1.035))
		#axes1 = fig.add_subplot(1, 2, 1)
		#fig.tight_layout(pad=2)
	if already_plotted:
		axes1.clear()
	if "time"==desired_x_axis:
		axes1.set_ylabel("channel/amplitude combination (arb. units)")
		axes1.set_autoscaley_on(False)
		if use_pedestal_subtraction_mode:
			axes1.set_ylim([ch_adc_min, ch_adc_max])
		else:
			axes1.set_ylim([ch_adc_min+pedestal_subtraction_amount, ch_adc_max+pedestal_subtraction_amount])
		#axes1.set_autoscaley_on(True)
		axes1.set_yticklabels([])
		axes1.set_yticks([])
		#axes1.set_xlabel("time (ns)")
		axes1.set_xlabel("RF bucket #")
		#axes1.xaxis.set_ticks_position("top")
		#axes1.set_xticks([])
		#axes1.set_xticklabels([])
		#axes5 = axes1.twiny()
		#axes5.xaxis.set_ticks_position("bottom")
#		xticksarray = []
#		if number_of_events_to_plot_together<5:
#			for i in range(13*number_of_events_to_plot_together):
#				x = i/0.5088875
#			#xticksarray.append(int(0.5+x*100.0)/100.0)
#				xticksarray.append(x)
#			#axes1.axvline(x=x, linewidth=1, color="grey")
#		else:
#			for i in range(number_of_events_to_plot_together+1):
#				x = i*RF_buckets_per_read_window/0.5088875
#				xticksarray.append(x)
#		axes1.set_xticks(xticksarray)
		axes1.set_autoscalex_on(False)
		if 400<number_of_events_to_plot_together:
			xlim_extra = 70
			#axes1.set_xlim([0-100, 10062+100])
			#axes1.xaxis.set_major_locator(MultipleLocator(508.8875))
			#axes1.xaxis.set_minor_locator(MultipleLocator(42.407/2.0))
			#axes1.xaxis.set_major_locator(MultipleLocator(512))
			#axes5.set_xticklabels([ int(revolution_marker_offset_in_RF_buckets+n)%RF_buckets for n in range(0, RF_buckets, 512)])
			start_bucket = RF_buckets - int(revolution_marker_offset_in_RF_buckets)
			#info(str(start_bucket))
			#axes5.set_xlim(axes1.get_xlim())
			#axes1.set_xticks([ n for n in range(0, RF_buckets, 512)])
			start_xtick = 512 * int((start_bucket + 512.0) / 512.0) - start_bucket
			axes1.set_xticks([ n for n in range(start_xtick, start_xtick+RF_buckets, 512)])
			#myxticklabels = [ (n%RF_buckets) for n in range(start_bucket, start_bucket+RF_buckets, 512)]
			myxticklabels = [ (n%RF_buckets) for n in range(start_bucket+start_xtick, start_bucket+start_xtick+RF_buckets, 512)]
			#info(str(myxticklabels))
			axes1.set_xticklabels(myxticklabels)
			#axes5.xaxis.set_major_locator(MultipleLocator(512))
			#axes1.xaxis.set_minor_locator(MultipleLocator(12))
			#axes1.grid(axis='x', which='minor')
		else:
			xlim_extra = 0.25
			#axes1.xaxis.set_major_locator(MultipleLocator(period_of_RF_clock_ns))
			gauge = int(number_of_physical_windows_to_plot * independent_axis_units / 12)
			# number_of_events_to_plot_together
			axes1.xaxis.set_major_locator(MultipleLocator(gauge))
			axes1.xaxis.set_minor_locator(MultipleLocator(24))
			#axes1.grid(axis='x', which='major')
			axes1.grid(axis='x', which='minor', linewidth=linewidth)
		if should_plot_slice:
			marker_for_desired_RF_position = RF_bucket_sample/asic_samples_per_RF_bucket
			axes1.axvline(marker_for_desired_RF_position, linewidth=1, color="blue")
	else:
		axes1.set_xlabel("channel/amplitude combination (arb. units)")
		axes1.set_autoscalex_on(False)
		axes1.set_xlim([ch_adc_min, ch_adc_max])
		axes1.set_xticklabels([])
		axes1.set_xticks([])
		axes1.set_ylabel("time (ns)")
		if number_of_events_to_plot_together<5:
			yticksarray = []
			for i in range(13*number_of_events_to_plot_together):
				y = i/0.5088875
				#yticksarray.append(int(0.5+y*100.0)/100.0)
				yticksarray.append(y)
				#axes1.axhline(y=y, linewidth=1, color="grey")
			axes1.grid(axis='y', which='major')
			axes1.set_yticks(yticksarray)
	#old_verbosity = set_verbosity(5)
	array = []
	i = 0 # i is the number of the waveform in the file
	event_number_string = ""
	#info(str(number_of_physical_windows_to_plot))
	data = lin_array(0)
	if should_show_stacked_waveform:
		value = 0.0
		value += stagger_amount * 64.5
		#value = - 2.0 * stagger_amount * (64.0/2.0*(64.0+1.0))
		#value += 6222 + stagger_amount * 64
		stacked = [ value for sample in range(asic_samples_per_read_window*total_number_of_physical_windows) ]
	#error("len(data[lin_ch])=" + str(len(data[5])))
	number_of_matching_events_found_so_far = 0
	number_of_matching_physical_windows_found = 0
	first_physical_window_seen = 512
	last_physical_window_seen  = 0
	#info("RF_bucket_sample: " + str(RF_bucket_sample))
	physical_windows = []
	global waveformfile_event_number
	for event in events_from_waveformfile():
		if 1==len(desired_event_numbers) and 0==desired_event_numbers[0]:
			desired_event_numbers = [ waveformfile_event_number ]
		for desired_event_number in desired_event_numbers:
			#info("den:waveformfile_event_number " + str(desired_event_number) + ":" + str(waveformfile_event_number))
			if desired_event_number==waveformfile_event_number:
				number_of_matching_events_found_so_far += 1
				event_number_string = dec(desired_event_number, 4)
				if 1<len(desired_event_numbers):
					axes1.set_title("\"" + waveformfilename + "\"", loc="left")
				else:
					axes1.set_title("event #" + dec(desired_event_number) + " from \"" + waveformfilename + "\"", loc="left")
				#seen_in_this_event = create_cac_matrix(0)
				i = 0
				for waveform in event:
					carrier_event_number_lsbs, carrier, asic, channel, physical_window, logical_window, n_windows, starting_sample, n_samples, array = waveform
					if physical_window not in desired_physical_window_numbers:
#						if 0==carrier and 0==asic and 0==channel:
#							info("skipping physical_window " + str(physical_window))
						continue
					first_physical_window_seen = min(first_physical_window_seen, physical_window)
					last_physical_window_seen  = max(last_physical_window_seen,  physical_window)
					#if 0==carrier and 0==asic and (0==channel or 1==channel):
					if physical_window not in physical_windows:
						physical_windows.append(physical_window)
						#info("cur_pw(" + hex(physical_window, 3) + ")=[" + hex(first_physical_window_seen,3) + "," + hex(last_physical_window_seen,3) + "]")
					debug("wie: " + hex(carrier_event_number_lsbs, 2) + " " + hex(carrier, 1) + " " + hex(asic, 1) + " " + hex(channel, 1) + " " + hex(physical_window, 3) + " " + hex(logical_window, 3) + " " + hex(n_windows, 1) + " " + hex(starting_sample, 2) + " " + hex(n_samples, 2))
					lin_ch = xrm_map_cac_to_linear(carrier, asic, channel)
					if 0==lin_ch:
						info("physical_window: " + str(physical_window))
						info("wie: " + hex(carrier_event_number_lsbs, 2) + " " + hex(carrier, 1) + " " + hex(asic, 1) + " " + hex(channel, 1) + " " + hex(physical_window, 3) + " " + hex(logical_window, 3) + " " + hex(n_windows, 1) + " " + hex(starting_sample, 2) + " " + hex(n_samples, 2))
#					if 1==number_of_physical_windows_to_plot:
#						sample = starting_sample
#					else:
					sample = asic_samples_per_read_window * physical_window + starting_sample
					#info(str(lin_ch) + " " + str(sample))
					#data[lin_ch][sample:sample+32] = array + lin_ch * ch_stagger_offset
					offset = lin_ch * stagger_amount
#					if not carrier in carriers_to_dejuice:
#						offset += 55
#						info(str(lin_ch) + " " + str(offset))
					for p in range(32):
						data[lin_ch][sample+p] = array[p] + offset
						if should_show_stacked_waveform:
							if not carrier in carriers_to_dejuice:
								stacked[sample+p] += array[p]
					#error("len(data[lin_ch])=" + str(len(data[lin_ch])))
					#RFbs = RF_bucket_sample - (asic_samples_per_read_window * physical_window + starting_sample)
					RFbs = RF_bucket_sample - sample
					#if 0==carrier and 0==asic and 0==channel:
					#	info(str(RFbs))
					if 0<=RFbs and RFbs<32:
						slice_array[lin_ch] = array[RFbs]
					i += 1
#				if be_verbose_when_collecting_data:
#					info("waveforms seen in this event: " + str(i))
#		if number_of_matching_events_found_so_far==number_of_events_to_plot_together:
#			break
	if be_verbose_when_collecting_data:
		info("number of events seen in file: " + str(waveformfile_event_number))
	#plotting_start = mytimer()
	if number_of_matching_events_found_so_far:
		if 512==first_physical_window_seen:
			error("bad first_physical_window_seen: " + str(first_physical_window_seen))
			return
		if 0==last_physical_window_seen:
			error("bad last_physical_window_seen: " + str(last_physical_window_seen))
			return
		#axes1.grid(False)
		if len(physical_windows):
			number_of_matching_physical_windows_found = last_physical_window_seen - first_physical_window_seen + 1
			info("physical windows were seen in this order: " + str(rangify(physical_windows)))
#		if last_physical_window_seen<first_physical_window_seen:
#			error("last<first")
#		if number_of_matching_physical_windows_found!=number_of_physical_windows_to_plot:
			#error("tot wrong")
#			number_of_physical_windows_to_plot = number_of_matching_physical_windows_found
#			last_physical_window_seen = number_of_physical_windows_to_plot - first_physical_window_seen - 1
		number_of_physical_windows_to_plot = ending_physical_window_number - starting_physical_window_number
		axes1.set_xlim([first_physical_window_seen*independent_axis_units-xlim_extra, (last_physical_window_seen+1)*independent_axis_units+xlim_extra])
		#for lin_ch in xrm_lin_ch_range():
		#	if should_show_stacked_waveform:
		#		for sample in range(first_physical_window_seen*asic_samples_per_read_window, (last_physical_window_seen+1)*asic_samples_per_read_window):
		#			stacked[sample] += data[lin_ch][sample]
		#info(str(stacked[0]))
		#global stacked_pedestal
		#try:
		#	stacked_pedestal
		#except:
		#	stacked_pedestal = stacked
		#for i in range(len(stacked)):
		#	stacked[i] -= stacked_pedestal[i]
		#info("first_physical_window_seen: " + str(first_physical_window_seen))
		#info("last_physical_window_seen: " + str(last_physical_window_seen))
		x = lin_ch_domain(first_physical_window_seen, last_physical_window_seen, last_physical_window_seen-first_physical_window_seen+1)
#		errors = 0
		for lin_ch in xrm_lin_ch_range():
			#if lin_ch%2:
			if 1:
				if "time"==desired_x_axis:
					#axes1.plot(lin_ch_domain(0, number_of_physical_windows_to_plot-1), data[lin_ch], color=colorarray[lin_ch%8])
#					if 128==lin_ch:
#						info(str(lin_ch))
					y = data[lin_ch][first_physical_window_seen*asic_samples_per_read_window:(last_physical_window_seen+1)*asic_samples_per_read_window]
					try:
						axes1.plot(x, y, color=colorarray_xrm(lin_ch), linewidth=linewidth)
						if should_show_stacked_waveform:
							axes1.plot(x, stacked[first_physical_window_seen*asic_samples_per_read_window:(last_physical_window_seen+1)*asic_samples_per_read_window], color="blue", linewidth=linewidth)
					except:
						#errors += 1
#						if 0==lin_ch:
						error("dimensions for plot don't match")
						error("len(lin_ch_domain(" + str(first_physical_window_seen) + "," + str(last_physical_window_seen) + "))=" + str(len(x)))
						error("len(data[lin_ch])=" + str(len(y)))
						info("first_physical_window_seen: " + str(first_physical_window_seen))
						info("last_physical_window_seen: " + str(last_physical_window_seen))
						info("number_of_physical_windows_to_plot: " + str(number_of_physical_windows_to_plot))
						return
#		if errors:
#			error("errors: " + str(errors))
		axes1.text(-31.0, stagger_amount *   1 - 106.0, "001", size=6.0, ha='center', va='center')
		axes1.text(-31.0, stagger_amount *  32 - 106.0, "032", size=6.0, ha='center', va='center')
		axes1.text(-31.0, stagger_amount *  64 - 106.0, "064", size=6.0, ha='center', va='center')
		axes1.text(-31.0, stagger_amount *  96 - 106.0, "096", size=6.0, ha='center', va='center')
		axes1.text(-32.0, stagger_amount * 128 - 106.0, "128", size=6.0, ha='center', va='center')
		for lin_ch in xrm_lin_ch_range():
			carrier, asic, channel = xrm_map_linear_to_cac(lin_ch)
			string = "%1d%1d%1d" % (carrier, asic, channel)
			#info(string)
			axes1.text(5145.0, stagger_amount * (lin_ch+2) - 106.0, string, size=6.0, ha='center', va='center')
			#axes1.text(325.0, stagger_amount * (lin_ch+2) - 106.0, string, size=6.0, ha='center', va='center')
		if should_plot_slice:
			plot_slice_centered_on_RF_bucket(slice_array)
		if should_plot_beam_current:
			plot_beam_conditions_from_filename()
		if 1<len(desired_event_numbers):
			#filename_base = waveformfilename + "." + str(number_of_matching_events_found_so_far) + "events"
			filename_base = waveformfilename + "." + str(number_of_matching_physical_windows_found) + "windows"
			png_filename = filename_base + ".png"
			pdf_filename = filename_base + ".pdf"
		else:
			filename_base = waveformfilename + "." + event_number_string
			png_filename = filename_base + ".png"
			pdf_filename = filename_base + ".pdf"
		#info("plotted event number " + str(event_number_string))
		#mymetadata = {}
		# https://stackoverflow.com/a/30478691/5728815
		#ts = datetime.datetime.fromtimestamp(get_mtime(waveformfilename), pytz.timezone('Asia/Tokyo'))
		#timestring = ts.strftime("%Y-%m-%d.%H%M%S")
		#mymetadata["tIME"] = timestring
		#info("mymetadata[tIME]: " + str(mymetadata["tIME"]))
		print("Show plot")
		if should_generate_png:
			fig.savefig(png_filename)
			#fig.savefig(png_filename, metadata=mymetadata)
			if "parse"==xrm_mode:
				set_mtime(png_filename, waveformfilename)
			info("wrote file " + png_filename)
		if should_generate_pdf:
			fig.savefig(pdf_filename)
			if "parse"==xrm_mode:
				set_mtime(pdf_filename, waveformfilename)
			info("wrote file " + pdf_filename)
		if not already_plotted:
			already_plotted = 1
			if show_plot:
				plt.ion()
				plt.show()
				plt.connect("close_event", plotquit)
		if show_plot:
			fig.canvas.draw()
			fig.canvas.flush_events()
			#plt.draw()
			#plt.pause(0.01)
			#plt.ioff()
		#show_mytimer(plotting_start, "plotting")
		#show_mytimer(parsing_and_plotting_start, "parsing and plotting")
	else:
		error("found no matching events")
	return png_filename

def plot_waveforms_from_waveformfile(desired_event_numbers):
	png_filename = plot_waveforms_staggered_from_waveformfile(desired_event_numbers)
	#plot_waveforms_overlayed_from_waveformfile(desired_event_numbers)
	return png_filename

time_to_wait_after_new_files_appear = 4
def parse_datafile_and_plot_waveformfile(desired_event_numbers, forced=0):
	#info(datafilename)
	waveformfile_exists = os.path.exists(waveformfilename)
	if forced or not waveformfile_exists:
		if waveformfile_exists:
			os.remove(waveformfilename)
		d = get_mtime(datafilename)
		nowfile = "data/nowfile." + station # needs to be on the same drive that the datafiles are on so there's no clock skew due to the NAS server
		touch(nowfile)
		now = get_mtime(nowfile)
		#info("d:" + str(d) + "  now:" + str(now))
		if now<d+time_to_wait_after_new_files_appear:
			return
		info("generating " + waveformfilename + " ...")
		if should_write_root_tree:
			open_roottreefile_for_writing()
		parse_datafile_and_dump_waveforms_to(waveformfilename)
		close_datafile_for_reading()
		set_mtime(waveformfilename, datafilename)
		info("generating plots from " + waveformfilename + " ...")
		png_filename = plot_waveforms_from_waveformfile(desired_event_numbers)
		close_waveformfile_for_reading()
		if should_write_root_tree:
			close_roottreefile_for_writing()
			set_mtime(roottreefilename, datafilename)
			#open_roottreefile_for_reading()
		return png_filename

def set_sweep_start_bucket(desired_sweep_start_bucket):
	global sweep_start_bucket
	sweep_start_bucket = desired_sweep_start_bucket

def set_sweep_end_bucket(desired_sweep_end_bucket):
	global sweep_end_bucket
	sweep_end_bucket = desired_sweep_end_bucket

def get_sweep_start_bucket():
	return sweep_start_bucket

def get_sweep_end_bucket():
	return sweep_end_bucket

def set_desired_RF_bucket(value):
	global desired_RF_bucket
	desired_RF_bucket = value

def get_desired_RF_bucket():
	return desired_RF_bucket

def set_oserdes_always_value(value):
	global oserdes_always_value
	oserdes_always_value = value

def set_oserdes_triggered_value(value):
	global oserdes_triggered_value
	oserdes_triggered_value = value

def get_oserdes_always_value():
	return oserdes_always_value

def get_oserdes_triggered_value():
	return oserdes_triggered_value

def parse_all_datafiles_and_plot_all_waveformfiles_in_this_dirtree(mydirname, forced=0):
	if "" == mydirname:
		today = time.strftime("%Y-%m-%d")
		mydirname = "data/" + station + "/" + today
		#info(mydirname)
	global dirname
	dirname = mydirname
	global desired_physical_window_numbers
	global starting_physical_window_number
	global ending_physical_window_number
	if False:
		starting_physical_window_number = 0
		ending_physical_window_number = starting_physical_window_number + 425
		#starting_physical_window_number = 344
		#ending_physical_window_number = starting_physical_window_number + 32
		#starting_physical_window_number = 32
		#ending_physical_window_number = starting_physical_window_number + 32
		#desired_physical_window_numbers = [ w for w in range(starting_physical_window_number, ending_physical_window_number) ]
	if True:
		step = int(RF_buckets_per_read_window)
		first = sweep_start_bucket
		last = sweep_end_bucket + 1
		starting_physical_window_number = first//step
		ending_physical_window_number = last//step
		desired_physical_window_numbers = [ w for w in range(starting_physical_window_number, ending_physical_window_number) ]
	#info("phy: [" + str(starting_physical_window_number) + "," + str(ending_physical_window_number) + "] " + str(desired_physical_window_numbers))
	#fudge = 25
	fudge = 425
	#for start_event in [ starting_physical_window_number ]:
	for start_event in [ 0 ]:
		for number_of_events in [ ending_physical_window_number - starting_physical_window_number + fudge ]:
			desired_event_numbers = [ n for n in range(start_event, start_event + number_of_events) ]
	#info("wen: " + str(desired_event_numbers))
	for root, dirs, files in os.walk(mydirname):
		for filename in sorted(files):
			match = re.search("(.*)\.datafile$", filename)
			if match:
				global timestring
				timestring = match.group(1)
				global basename
				basename = os.path.join(root, timestring)
				get_filenames_from_basename()
				#info(waveformfilename)
				parse_datafile_and_plot_waveformfile(desired_event_numbers, forced)

# https://stackoverflow.com/a/1035456/5728815
def bytes_from_filename(filename, chunksize=8192):
	with open(filename, "rb") as f:
		while True:
			chunk = f.read(chunksize)
			if chunk:
				for b in chunk:
					yield b
			else:
				break

def words_from_filename(filename, chunksize=8192):
	with open(filename, "rb") as f:
		while True:
			try:
				chunk = f.read(chunksize)
			except:
				break
			offset = 0
			if chunk:
				#for w in struct.iter_unpack("I", chunk):
				for i in range(chunksize>>2):
					try:
						w = struct.unpack_from("I", chunk, offset)
						offset += 4
						yield w[0]
					except:
						break
			else:
				break

def open_datafile_for_reading():
	global datafile
	global datafile_event_number
	if datafile is None:
		datafile = open(datafilename, "rb")
		datafile_event_number = 0
#	else:
#		error("datafile already open")
#		info(str(datafile.tell()))
#		sys.exit(2)

def open_waveformfile_for_reading():
	global waveformfile
	global waveformfile_event_number
	global waveformfile_waveform_number
	if waveformfile is None:
		waveformfile = open(waveformfilename, "rb")
		waveformfile_event_number = 0
		waveformfile_waveform_number = 0
#	else:
#		error("waveform file already open")
#		info(str(waveformfile.tell()))
#		sys.exit(3)
	#waveformfile.seek(0)

def open_roottreefile_for_writing():
	if not should_use_ROOT:
		return
	global roottree_events
	global roottree_waveforms
	global roottreefile
	#global roottreefile_event_number
	#global roottreefile_waveform_number
	try:
		if roottreefile is None:
			info("writing root tree file " + roottreefilename + " ...")
			roottreefile = ROOT.TFile(roottreefilename, "recreate")
			roottree_events = ROOT.TTree("events", "events")
			roottree_waveforms = ROOT.TTree("waveforms", "waveforms")
			#info("root tree file " + roottreefilename + " opened for writing ...")
	except:
		error("can't open roottreefile for writing")
		sys.exit(4)
		#roottreefile_event_number = 0
		#roottreefile_waveform_number = 0
#	else:
#		info(str(waveformfile.tell()))
	#waveformfile.seek(0)

roottreefilename = ""
def open_roottreefile_for_reading():
	if not should_use_ROOT:
		return
	if ""==roottreefilename:
		return
	#info("opening root file")
	#info("attempting to parse root file...")
	roottreefile = ROOT.TFile(roottreefilename)
	roottree_events = roottreefile.Get("events")
	#roottree_waveforms.Show()
	#roottree_events.Print()
	#roottree_waveforms.Print()
	#roottree_waveforms.Scan("waveform")
	event_index = 0
	#wfb = roottree_waveforms.GetBranch("waveform")
#	wfn = roottree_waveforms.GetBranch("waveform_number")
	if False:
		for event in roottree_events:
			event_index += 1
			event_number = event.event_number
			scrod_id = event.scrod_id
			phase = event.phase
			ctime = event.ctime
			count_since_revo9 = event.count_since_revo9
			eventQueueDepth = event.eventQueueDepth
			eventNumberByte = event.eventNumberByte
			masks = event.masks
			info("event_index: " + str(event_index))
			info("event_number: " + str(event_number))
			info("scrod_id: " + str(scrod_id))
			info("phase: " + str(phase))
			info("ctime: " + str(ctime))
			info("count_since_revo9: " + str(count_since_revo9))
			info("eventQueueDepth: " + str(eventQueueDepth))
			info("eventNumberByte: " + str(eventNumberByte))
			info("masks: " + hex(masks, 4))
	roottree_waveforms = roottreefile.Get("waveforms")
	waveform_index = 0
	num_errors_total = 0
	for waveform in roottree_waveforms:
		waveform_index += 1
		num_errors_for_this_index = 0
		event_number = waveform.event_number
		waveform_number = waveform.waveform_number
		starting_sample = waveform.starting_sample
		if not 32==starting_sample and not 0==starting_sample:
			#error("found starting_sample " + str(starting_sample))
			num_errors_for_this_index += 1
		logical_window = waveform.logical_window
		if 511<logical_window:
			#error("logical_window " + str(logical_window))
			num_errors_for_this_index += 1
		carrier_event_number = waveform.carrier_event_number
		physical_window = waveform.physical_window
		if 511<physical_window:
			#error("physical_window " + str(physical_window))
			num_errors_for_this_index += 1
		if physical_window!=logical_window:
			#error("physical_window (" + str(physical_window) + ") != logical_window (" + str(logical_window) + ")")
			num_errors_for_this_index += 1
		n_samples = waveform.n_samples
		if not 32==n_samples:
			#error("found n_samples " + str(n_samples))
			num_errors_for_this_index += 1
		n_windows = waveform.n_windows
		carrier = waveform.carrier
		if 3<carrier:
			#error("found carrier " + str(carrier))
			num_errors_for_this_index += 1
		asic = waveform.asic
		if 3<asic:
			#error("found asic " + str(asic))
			num_errors_for_this_index += 1
		channel = waveform.channel
		if 7<channel:
			#error("found channel " + str(channel))
			num_errors_for_this_index += 1
		lin_ch = waveform.lin_ch
		if num_errors_for_this_index:
			num_errors_total += num_errors_for_this_index
#			info("--------" + str(waveform_index) + "--------" + str(event_number) + "--------" + str(num_errors_for_this_index) + "--------")
		#if 10000==waveform_index:
		if 79==event_number:
			#a1 = waveform.waveform
			#a2 = numpy.array([ 0 for x in range(2*number_of_waveform_words_in_a_waveform_packet) ])
			#a3 = array.array('l', [ 0 for x in range(2*number_of_waveform_words_in_a_waveform_packet) ])
			#for i in range(len(a1)):
			#	a2[i] = a1[i]
			#	a3[i] = a1[i]
			#	info(dec(i, 2) + " " + dec(a1[i]) + " " + dec(a2[i]) + " " + dec(a3[i]))
			#a1 = array.array('h', [ 0 for x in range(2*number_of_waveform_words_in_a_waveform_packet) ])
			#a1 = ROOT.array(waveform.waveform)
			#size = a1.GetSize()
			#buf = a1.GetAddress()
			#buf.SetSize(size)
			#a1 = np.frombuffer(buf, count=size, dtype='short16')
			#a1 = array.array('h', waveform.waveform)
			#a1 = numpy.frombuffer(waveform.waveform, count=32, dtype='short16')
			#info(str(a1))
			#a1 = numpy.reshape(a1, (4,8))
			#info(str(a1))
			#a1 = waveform.AsMatrix(["waveform"])
			#info(str(a1))
			#a1.tolist()
			#info(str(a1))
			#info(str(a1))
			if False:
				x = array.array('i')
				y = array.array('i')
				string = ""
				for i in range(32):
					x.append(i)
					y.append(waveform.waveform[i])
					#info(dec(i, 2) + " " + dec(y[i]))
					string += "," + dec(waveform.waveform[i], 3)
				info(string)
				#x = array.array('l', ( n for n in range(32) ))
				#y = a3 #array.array('l', a3)
				#tg = ROOT.TGraph(32, x, y)
				#tg.Draw("ACP")
			if False:
				info("waveform_index: " + str(waveform_index))
				info("event_number: " + str(event_number))
				info("waveform_number: " + str(waveform_number))
				info("starting_sample: " + str(starting_sample))
				info("logical_window: " + str(logical_window))
				info("carrier_event_number: " + str(carrier_event_number))
				info("physical_window: " + str(physical_window))
				info("n_samples: " + str(n_samples))
				info("n_windows: " + str(n_windows))
				info("carrier: " + str(carrier))
				info("asic: " + str(asic))
				info("channel: " + str(channel))
				info("lin_ch: " + str(lin_ch))
				info("----------------------")
	if num_errors_total:
		error("saw " + str(num_errors_total) + " errors parsing root file")
	#canvas.Draw("event_number:carrier_event_number")
	#roottree_waveforms.StartViewer()
#		i += 1
#		for event in entry.carrier_event_number_lsbs:
#			j += 1
#		info(str(i) + " " + str(wfn))
	#c1 = ROOT.TCanvas("asdf", "fdsa", 1000, 700)
	#c1.SetGrid()
	#roottree_waveforms.Draw("event_number:carrier_event_number")
	if True:
		canvas = ROOT.TCanvas("asdf", "fdsa", 1000, 700)
		#roottree_waveforms.Draw("physical_window:logical_window")
		#roottree_waveforms.Draw("waveform:lin_ch:physical_window", "344<=physical_window && physical_window<=375")
		#roottree_waveforms.Draw("waveform:lin_ch", "344<=physical_window && physical_window<=375")
		roottree_waveforms.Draw("-waveform:128-lin_ch", "353==physical_window")
	#roottree_waveforms.Draw("event_number:carrier_event_number:physical_window")
	#roottree_waveforms.Draw("waveform:Iteration$", "6==channel && 100==physical_window && 0==starting_sample", "L")
		canvas.Update()
		ROOT.gApplication.Run()
		roottreefile.Close()
		# waveforms->Draw("waveform:lin_ch:physical_window", "344<=physical_window && physical_window<=375");
		# events->Draw("event_number:count_since_revo9");
	#info("done parsing root file")

def close_datafile_for_reading():
	global datafile
	if datafile is not None:
		datafile.close()
		datafile = None

def close_waveformfile_for_reading():
	global waveformfile
	if waveformfile is not None:
		waveformfile.close()
		waveformfile = None

roottreefile = None
def close_roottreefile_for_writing():
	if not should_use_ROOT:
		return
	global roottreefile
	if roottreefile is not None:
		#info("closing root file")
		roottreefile.Write()
		roottreefile.Close()
	roottreefile = None

def words_from_file(f, chunksize=16384):
	total_yield = 0
#	seek = 0
	while True:
		try:
			chunk = f.read(chunksize)
		except:
			error("can't read from file")
			break
		offset = 0
		if chunk:
			#for w in struct.iter_unpack("I", chunk):
			for i in range(chunksize>>2):
				try:
					(w,) = struct.unpack_from("I", chunk, offset)
					offset += 4
					total_yield += 1
					yield w
				except GeneratorExit:
					#info("breaking at line 463")
					close_waveformfile_for_reading()
					return
				except:
					break
		else:
#			time.sleep(1)
#			info("waiting...")
			break
#		seek += offset
	#info("reached end of file at " + str(f.tell()))
#	total_yield -= 4
	#info("yielded " + str(total_yield) + " words")
	#info("yielded " + str(4*total_yield) + " bytes")
	#yield 0x12345678

def parse_datafile_and_dump_waveforms_to(outfilename):
	#string = 'hexdump datafile -e \'5/4 \"%08X \"\' -e \'\"\\n\"\''
	#info(string)
	#response = commands.getstatusoutput(string)
	#info(response[1])
	#info("")
	if be_verbose_when_collecting_data:
		string = "# t v scr x bonu p cor s cti rev9 mask qu ## "
		debug(string)
	# i is word number from Belle 2 TOP data format (production data format 4.1)
	# j is the number of core words remaining
	# k is the number of bonus words remaining
	# n is count of the events in the file so far
	j = 0
	k = 0
	i = 999999
	global datafile_event_number
	open_datafile_for_reading()
	outfile = open(outfilename, "ab")
	debug_string = ""
	debug2_string = ""
#	old_verbosity = set_verbosity(4)
	just_finished_hits = 0
	if should_write_root_tree:
		# array.array types: B=u8 h=s16 H=u16 L=u32
		root_datafile_event_number = array.array('L', [0])
		root_scrod_id = array.array('H', [0])
		root_phase = array.array('H', [0])
		root_ctime = array.array('H', [0])
		root_count_since_revo9 = array.array('H', [0])
		root_eventQueueDepth = array.array('H', [0])
		root_eventNumberByte = array.array('H', [0])
		root_masks = array.array('H', [0])
		# root types: b=u8 S=s16 s=u16 i=u32
		roottree_events.Branch("event_number", root_datafile_event_number, "event_number/I")
		roottree_events.Branch("scrod_id", root_scrod_id, "scrod_id/s")
		roottree_events.Branch("phase", root_phase, "phase/s")
		roottree_events.Branch("ctime", root_ctime, "ctime/s")
		roottree_events.Branch("count_since_revo9", root_count_since_revo9, "count_since_revo9/s")
		roottree_events.Branch("eventQueueDepth", root_eventQueueDepth, "eventQueueDepth/s")
		roottree_events.Branch("eventNumberByte", root_eventNumberByte, "eventNumberByte/s")
		roottree_events.Branch("masks", root_masks, "masks/s")
	waveform = []
	for w in words_from_file(datafile):
		i += 1
		if 0==j and 0==k and 4==(w>>24) and 1==((w>>16)&0xff):
			i = 0
			#outfile.flush()
			if 0!=datafile_event_number:
				if be_verbose_when_collecting_data:
					debug(debug_string, 0)
					debug2(debug2_string, 0)
			datafile_event_number += 1
			debug_string = str(datafile_event_number) + " "
			debug2_string = ""
		if 0==i:
			packet_type = w>>24
			packet_version = (w>>16)&0xff
			should_be_a = (w>>12)&0xf
			scrod_id = w&0xfff
			debug_string += hex(packet_type, 1) + " " + hex(packet_version, 1) + " " + hex(scrod_id, 3) + " "
		elif 1==i:
			extra = w>>29
			bonus = (w>>16) & 0x1fff
			k = bonus
			phase = (w>>12) & 0xf
			core = w & 0xfff
			j = core - 5 # core words includes the overall event header
			debug_string += hex(extra, 1) + " " + hex(bonus, 4) + " " + hex(phase, 1) + " " + hex(core, 3) + " "
		elif 2==i:
			skipped = w>>31
			should_be_zeroes = (w>>27) & 0xf
			ctime = (w>>16) & 0x7ff
			count_since_revo9 = w & 0xffff
			debug_string += hex(skipped, 1) + " " + hex(ctime, 3) + " " + hex(count_since_revo9, 4) + " "
		elif 3==i:
			masks = w>>16
			eventQueueDepth = (w>>8) & 0xff
			eventNumberByte = w & 0xff
			debug_string += hex(masks, 4) + " " + hex(eventQueueDepth, 2) + " " + hex(eventNumberByte, 2) + " "
		else: # done with header, go on to hits (interleaved with waveforms if present)
			should_be_b = (w>>12) & 0xf
			#if 0xb==should_be_b:
			#	debug2_string += "\n [" + str(j) + "," + str(k) + "] " + hex(w, 8) + " "
			if 0<j:
				if 0==(j%5):
					carrier = (w>>30) & 0x3
					asic    = (w>>28) & 0x3
					channel = (w>>25) & 0x7
					window  = (w>>16) & 0x1ff
					waveform_present = (w>>7) & 1
					if waveform_present:
						waveform_present_string = "w"
					else:
						waveform_present_string = "-"
					if 0xb==should_be_b:
						debug2_string += "\n [" + str(j) + "," + str(k) + "] "
						#debug2_string += hex(w, 8) + " "
						debug2_string += hex(carrier, 1) + " " + hex(asic, 1) + " " + hex(channel, 1) + " " + hex(window, 3) + " " + waveform_present_string + " "
					#else:
					#	debug2_string += "\n error parsing hit "
					j -= 1
				elif 4==(j%5):
					j -= 1
				elif 3==(j%5):
					j -= 1
				elif 2==(j%5):
					j -= 1
				elif 1==(j%5):
					j -= 1
				just_finished_hits = 1
			else:
				if just_finished_hits:
					just_finished_hits = 0
					should_be_5 = (w>>9) & 0x7
					if 0x5!=should_be_5:
						debug2_string += "error "
				else: # now checkout the waveforms if present
					if 0<k:
						waveform.append(w)
						#outfile.write(struct.pack('I', w))
						#info("wrote to waveform file")
						#outfile.write(struct.pack('IIhhhhhhhhhhhhhhhh', w))
						#if 0==(k%9):
						k -= 1
						if 0==k:
							if len(waveform):
								if should_write_root_tree:
									root_datafile_event_number[0] = datafile_event_number
									root_scrod_id[0] = scrod_id
									root_phase[0] = phase
									root_ctime[0] = ctime
									root_count_since_revo9[0] = count_since_revo9
									root_eventQueueDepth[0] = eventQueueDepth
									root_eventNumberByte[0] = eventNumberByte
									root_masks[0] = masks
									roottree_events.Fill()
									#info("filling roottree_events #" + str(datafile_event_number))
								write_waveform_to_file(outfile, waveform)
								waveform = []
#					else:
#						if len(waveform):
#							outfile.write(struct.pack('I'*len(waveform), *waveform))
#							info("wrote " + str(4*len(waveform)) + " bytes to waveform file")
#							waveform = []
	if len(waveform):
		if should_write_root_tree:
			root_datafile_event_number[0] = datafile_event_number
			root_scrod_id[0] = scrod_id
			root_phase[0] = phase
			root_ctime[0] = ctime
			root_count_since_revo9[0] = count_since_revo9
			root_eventQueueDepth[0] = eventQueueDepth
			root_eventNumberByte[0] = eventNumberByte
			root_masks[0] = masks
			roottree_events.Fill()
		write_waveform_to_file(outfile, waveform)
	if be_verbose_when_collecting_data:
		debug(debug_string)
		debug2(debug2_string)
#	set_verbosity(old_verbosity)
	outfile.close()

def write_waveform_to_file(outfile, waveform):
	if outfile and len(waveform):
		outfile.write(struct.pack('I'*len(waveform), *waveform))
		#info("wrote " + str(4*len(waveform)) + " bytes to waveform file")

def old_zero_waveform(input_waveform):
	output_waveform = input_waveform
	for i in range(len(input_waveform)):
		output_waveform[i] = 0
	return output_waveform

def zero_waveform(input_waveform):
	for i in range(len(input_waveform)):
		input_waveform[i] = 0
	return input_waveform

import array
number_of_waveform_words_in_a_waveform_packet = 16
def waveforms_from_waveformfile():
	found_valid_first_word = 0
	found_valid_second_word = 0
	mode = "looking_for_start_of_header"
	#mode = "parsing_header"
	#mode = "yielding_data"
	k = 0 # k is the number of waveform words seen so far in each waveform packet
	#old_verbosity = set_verbosity(4)
	if be_verbose_when_collecting_data:
		debug_string = "   c a c sa w e# log phy st"
		debug(debug_string)
	debug_string = ""
	#debug2_string = ""
	waveform = array.array('h', [ 0 for x in range(2*number_of_waveform_words_in_a_waveform_packet) ])
	if should_write_root_tree:
		# array.array types: B=u8 h=s16 H=u16 L=u32
		root_waveformfile_event_number = array.array('L', [0])
		root_waveformfile_waveform_number = array.array('L', [0])
		root_starting_sample = array.array('H', [0])
		root_logical_window = array.array('H', [0])
		root_carrier_event_number_lsbs = array.array('H', [0])
		root_physical_window = array.array('H', [0])
		root_n_samples = array.array('H', [0])
		root_n_windows = array.array('H', [0])
		root_carrier = array.array('H', [0])
		root_asic = array.array('H', [0])
		root_channel = array.array('H', [0])
		root_lin_ch = array.array('H', [0])
		# root types: b=u8 S=s16 s=u16 i=u32
		roottree_waveforms.Branch("event_number", root_waveformfile_event_number, "event_number/I")
		roottree_waveforms.Branch("waveform_number", root_waveformfile_waveform_number, "waveform_number/I")
		roottree_waveforms.Branch("starting_sample", root_starting_sample, "starting_sample/s")
		roottree_waveforms.Branch("logical_window", root_logical_window, "logical_window/s")
		roottree_waveforms.Branch("carrier_event_number", root_carrier_event_number_lsbs, "carrier_event_number/s")
		roottree_waveforms.Branch("physical_window", root_physical_window, "physical_window/s")
		roottree_waveforms.Branch("n_samples", root_n_samples, "n_samples/s")
		roottree_waveforms.Branch("n_windows", root_n_windows, "n_windows/s")
		roottree_waveforms.Branch("carrier", root_carrier, "carrier/s")
		roottree_waveforms.Branch("asic", root_asic, "asic/s")
		roottree_waveforms.Branch("channel", root_channel, "channel/s")
		roottree_waveforms.Branch("lin_ch", root_lin_ch, "lin_ch/s")
		roottree_waveforms.Branch("waveform", waveform, "waveform[32]/S")
		#roottree_waveforms.Branch("waveform", waveform, "waveform[" + str(2*number_of_waveform_words_in_a_waveform_packet) + "]/S")
	#words = 0
	#yielding = 0
	#first = 0
	#second = 0
	#did_this = 0
	global waveformfile_waveform_number
	open_waveformfile_for_reading()
	for w in words_from_file(waveformfile):
		#words += 1
		if "yielding_data"==mode:
			#yielding += 1
			# https://stackoverflow.com/a/6727975/5728815
			one = w>>16
			if (1<<15) & one:
				one -= 1<<16
			zero = w & 0xffff
			if (1<<15) & zero:
				zero -= 1<<16
			#debug2_string += str(zero) + "," + str(one) + " "
			#debug2_string += hex(zero) + "," + hex(one) + " "
			#yield zero
			#yield one
			waveform[2*k] = zero
			waveform[2*k+1] = one
			k += 1
			#if 15==k:
			#	info("k=15")
			#if 16==k:
			#	info("k=16")
		elif "parsing_header"==mode and found_valid_first_word:
			#second += 1
			should_be_1_zero_another_one_though = w>>31
			starting_sample = (w>>25) & 0x3f
			logical_window = (w>>16) & 0x1ff
			carrier_event_number_lsbs = (w>>9) & 0x7f
			physical_window = w & 0x1ff
			if 0==should_be_1_zero_another_one_though and logical_window==physical_window and (0==starting_sample or 0x20==starting_sample):
				found_valid_second_word = 1
				debug_string += hex(carrier_event_number_lsbs, 2) + " "
				debug_string += hex(logical_window, 3) + " "
				debug_string += hex(physical_window, 3) + " "
				debug_string += hex(starting_sample, 2) + " "
				if be_verbose_when_collecting_data:
					debug(debug_string)
				debug_string = ""
				waveform = zero_waveform(waveform)
				k = 0
				mode = "yielding_data"
			else:
				debug_string += "\nerror finding second word " + hex(w, 8)
				mode = "looking_for_start_of_header"
		elif "looking_for_start_of_header"==mode:
			#first += 1
			k = 0
			found_valid_first_word = 0
			found_valid_second_word = 0
			n_samples = w>>16
			should_be_5_zeroes = (w>>11) & 0x1f
			n_windows = (w>>8) & 0x7
			should_be_1_zero = (w>>7) & 1
			carrier = (w>>5) & 0x3
			asic = (w>>3) & 0x3
			channel = w & 0x7
			if 0==should_be_5_zeroes and 0==should_be_1_zero and 0x20==n_samples:
				found_valid_first_word = 1
				waveformfile_waveform_number += 1
				#info("working on the " + str(waveformfile_waveform_number) + "th waveform in the file")
				debug_string = str(waveformfile_waveform_number) + ": "
				debug_string += hex(carrier, 1) + " "
				debug_string += hex(asic, 1) + " "
				debug_string += hex(channel, 1) + " "
				debug_string += hex(n_samples, 2) + " "
				debug_string += hex(n_windows, 1) + " "
				mode = "parsing_header"
			else:
				debug_string += "\nerror finding first word " + hex(w, 8)
				mode = "looking_for_start_of_header"
		if number_of_waveform_words_in_a_waveform_packet==k:
			mode = "looking_for_start_of_header"
			#info("on the " + str(waveformfile_waveform_number) + "th waveform in the file")
			yield (carrier_event_number_lsbs, carrier, asic, channel, physical_window, logical_window, n_windows, starting_sample, n_samples, waveform.tolist())
			if should_write_root_tree:
				root_waveformfile_event_number[0] = waveformfile_event_number
				root_waveformfile_waveform_number[0] = waveformfile_waveform_number
				root_carrier_event_number_lsbs[0] = carrier_event_number_lsbs
				root_carrier[0] = carrier
				root_asic[0] = asic
				root_channel[0] = channel
				root_lin_ch[0] = xrm_map_cac_to_linear(carrier, asic, channel)
				root_n_samples[0] = n_samples
				root_n_windows[0] = n_windows
				root_starting_sample[0] = starting_sample
				root_logical_window[0] = logical_window
				root_physical_window[0] = physical_window
				#if 0==carrier and 2==asic and 7==channel and 234==physical_window and 32==starting_sample:
				if False and 10000==waveformfile_waveform_number:
					string = ""
					for i in range(len(waveform)):
						string += "," + dec(waveform[i], 3)
						#info(dec(i, 2) + " " + dec(waveform[i]))
					info(string)
				#	#a1 = numpy.reshape(waveform, (4,8))
				#	#info(str(a1))
				roottree_waveforms.Fill()
				debug("filling roottree_waveforms #" + str(waveformfile_event_number) + " with #" + str(waveformfile_waveform_number))
			k = 0
			waveform = zero_waveform(waveform)
	#info("k=" + str(k))
	#info("first=" + str(first))
	#info("second=" + str(second))
	#info("yielding=" + str(yielding))
	#info("did_this=" + str(did_this))
	if be_verbose_when_collecting_data:
		if len(debug_string):
			debug(debug_string)
#	if len(array):
#		#info("len(array)=" + str(len(array)))
#		info("on the " + str(waveformfile_waveform_number) + "th waveform in the file")
	#yield (carrier_event_number_lsbs, carrier, asic, channel, physical_window, logical_window, n_windows, starting_sample, n_samples, array)
	#debug2(debug2_string)
	#info("words=" + str(words))
	#set_verbosity(old_verbosity)

def events_from_waveformfile():
	event = []
	array = []
	previous_carrier_event_number_lsbs = 123456789 # dummy much bigger than a real carrier event number
	if be_verbose_when_collecting_data:
		debug("     ce c a c phy log w st sa")
	#old_verbosity = set_verbosity(5)
	global waveformfile_event_number
	for waveform in waveforms_from_waveformfile():
		carrier_event_number_lsbs, carrier, asic, channel, physical_window, logical_window, n_windows, starting_sample, n_samples, array = waveform
		if 0==carrier and 0==asic and (0==channel or 1==channel):
			debug2("     " + hex(carrier_event_number_lsbs, 2) + " " + hex(carrier, 1) + " " + hex(asic, 1) + " " + hex(channel, 1) + " " + hex(physical_window, 3) + " " + hex(logical_window, 3) + " " + hex(n_windows, 1) + " " + hex(starting_sample, 2) + " " + hex(n_samples, 2))
		if previous_carrier_event_number_lsbs!=carrier_event_number_lsbs:
			debug("previous_carrier_event_number_lsbs!=carrier_event_number_lsbs")
			previous_carrier_event_number_lsbs = carrier_event_number_lsbs
			if len(event):
				#info("on the " + str(waveformfile_event_number) + "th event in the file")
				if be_verbose_when_collecting_data:
					debug("wfw: " + hex(carrier_event_number_lsbs, 2) + " " + hex(carrier, 1) + " " + hex(asic, 1) + " " + hex(channel, 1) + " " + hex(physical_window, 3) + " " + hex(logical_window, 3) + " " + hex(n_windows, 1) + " " + hex(starting_sample, 2) + " " + hex(n_samples, 2))
				debug("yielding event " + hex(waveformfile_event_number,4))
				yield event
				event = []
			debug("waveformfile_event_number+=1")
			waveformfile_event_number += 1
#		if be_verbose_when_collecting_data:
#			debug(hex(waveformfile_event_number,4) + " " + hex(carrier_event_number_lsbs, 2) + " " + hex(carrier, 1) + " " + hex(asic, 1) + " " + hex(channel, 1) + " " + hex(physical_window, 3) + " " + hex(logical_window, 3) + " " + hex(n_windows, 1) + " " + hex(starting_sample, 2) + " " + hex(n_samples, 2))
		event.append(waveform)
	if len(event):
		#info("on the " + str(waveformfile_event_number) + "th event in the file")
		if be_verbose_when_collecting_data:
			debug("wfw: " + hex(carrier_event_number_lsbs, 2) + " " + hex(carrier, 1) + " " + hex(asic, 1) + " " + hex(channel, 1) + " " + hex(physical_window, 3) + " " + hex(logical_window, 3) + " " + hex(n_windows, 1) + " " + hex(starting_sample, 2) + " " + hex(n_samples, 2))
		debug("yielding event " + hex(waveformfile_event_number,4))
		yield event
	#set_verbosity(old_verbosity)

def count_events_in_waveformfile():
	k = 0
	open_waveformfile_for_reading()
	for event in events_from_waveformfile():
		k += 1
	close_waveformfile_for_reading()
	return k

def update_gui():
	if not gui_initialized:
		error("gui not initialized")
		sys.exit(1)
	#info("updating")
	show_latest_png_if_necessary()
	gui_window.after(gui_update_period_ms, update_gui)

gui_initialized = 0
def initialize_gui():
	read_config_file_for_xrm_stuff()
	global gui_window
	global image_frame
	global gui_initialized
	if not gui_initialized:
		gui_initialized = 1
		gui_window = tkinter.Tk()
		gui_window.title("XRM " + station)
	#infotext = tkinter.Label(gui_window, text="xrm!")
	#infotext.pack()
	#quitbutton = tkinter.Button(gui_window, text="quit", command=gui_window.quit)
	#quitbutton.pack()
	image_frame = tkinter.Frame(gui_window, width=plot_width, height=plot_height)
	image_frame.pack()
	gui_window.after(gui_update_period_ms, update_gui)
	gui_window.mainloop()

def show_png(filename):
	#gui_window.geometry('+%d+%d' % (100,100))
	#gui_window.geometry('%dx%d' % (image1.size[0],image1.size[1]))
	#label_image.place(x=0,y=0,width=image1.size[0],height=image1.size[1])
	try:
		photo = ImageTk.PhotoImage(Image.open(filename))
	except:
		return
	global first_time_through
	global label
	try:
		if first_time_through:
			first_time_through = 0
	except:
		first_time_through = 0
		label = tkinter.Label(image_frame, image=photo)
		label.pack()
	label.configure(image=photo)
	label.image = photo
	gui_window.update()

def get_latest_png():
	command = "find -L data/" + station + " -type f -name '*.png' -printf '%TY-%Tm-%Td+%TH:%TM:%TS %p\n' | sort -n -k 1 | tail -n1 | awk '{ print $2 }'"
	response = commands.getstatusoutput(command)
	return response[1]

def show_latest_png():
	filename = get_latest_png()
	show_png(filename)

old_png_filename = ""
def show_latest_png_if_necessary():
	global old_png_filename
	filename = get_latest_png()
	if old_png_filename!=filename:
		old_png_filename = filename
		time.sleep(1)
		info(filename)
		show_png(filename)

def continuously_show_latest_png():
	initialize_gui()

def xrm_lin_ch_range():
	#info("xrm_lin_ch_range")
	#return [ n for n in range(128) ]
	list = []
	for carrier in range(4):
		for asic in range(4):
			for channel in range(8):
				if carrier not in carriers_to_dejuice:
					list.append(xrm_map_cac_to_linear(carrier, asic, channel))
#	for item in list:
#		info(str(item))
	return list
	#return [ lin_ch for lin_ch in range(0, 128, 2) ]

def xrm_map_linear_to_cac(element):
	#if element not in range(1, 1+128):
	if element not in range(128):
		error("called xrm_map_linear_to_cac(" + str(element) + ") which is not allowed")
		sys.exit(1)
#	string = "element" + dec(element, 3)
#	element -= 1
	carrier = element%4
	element -= carrier
	asic_l = element%8
	element -= asic_l
	asic_l //= 4
	asic_l = not asic_l
	channel = element%64
	element -= channel
	channel //= 8
	if not asic_l:
		channel = 7 - channel
	asic_h = element
	asic_h //= 64
	asic_h <<= 1
	asic = asic_h | asic_l
#	string += " carrier" + str(carrier)
#	string += " asic" + str(asic)
#	string += " channel" + str(channel)
#	if not carrier in range(4):
#		error("bad mapping: carrier cannot be " + str(carrier))
#		info(string)
#		sys.exit(0)
#	if not asic in range(4):
#		error("bad mapping: asic cannot be " + str(asic))
#		info(string)
#		sys.exit(0)
#	if not channel in range(8):
#		error("bad mapping: channel cannot be " + str(channel))
#		info(string)
#		sys.exit(0)
	return carrier, asic, channel

def xrm_map_cac_to_linear(carrier, asic, channel):
	if carrier not in range(4):
		error("called xrm_map_cac_to_linear(" + str(carrier) + ") which is not allowed")
		sys.exit(1)
	if asic not in range(4):
		error("called xrm_map_cac_to_linear(" + str(asic) + ") which is not allowed")
		sys.exit(1)
	if channel not in range(8):
		error("called xrm_map_cac_to_linear(" + str(channel) + ") which is not allowed")
		sys.exit(1)
	#return 32*carrier + 8*asic + channel # straight cac mapping
	#return 16*carrier + 8*asic + channel # straight cac mapping; only carrier0 and carrier2 populated
	if 0==asic%2:
		asic_even = True
		asic_odd = False
	else:
		asic_even = False
		asic_odd = True
	# xrm slac detector wirebond board mapping:
	lin_ch = \
+ ((asic//2)<<6) \
+ (((7-channel)*(asic_even) + (channel)*(asic_odd))<<3) \
+ (((asic+1)%2)<<2) \
+ carrier
	return lin_ch

def show_xrm_mapping():
	cac_string = ""
	for element in range(128):
		carrier, asic, channel = xrm_map_linear_to_cac(element)
		#if 0==element%2:
#		if len(cac_string):
#			info(cac_string + colorarray_xrm(element))
		if element in xrm_lin_ch_range():
			cac_string += str(carrier) + "." + str(asic) + "." + str(channel) + "(" + colorarray_xrm(element) + ")  "
		if 3==element%4:
			info(cac_string)
			cac_string = ""
	for carrier in range(4):
		for asic in range(4):
			element_string = ""
			for channel in range(8):
				element = xrm_map_cac_to_linear(carrier, asic, channel)
				element_string += dec(element, 3) + " "
			info(element_string)
	for element_in in range(128):
		carrier, asic, channel = xrm_map_linear_to_cac(element_in)
		element = xrm_map_cac_to_linear(carrier, asic, channel)
		if element != element_in:
			error("bad mapping:  cac=" + str(carrier) + " " + str(asic) + " " + str(channel) + "  lin=" + str(element))
#	for element in range(128):
#		info(colorarray_xrm(element))

def plotquit(event):
	#info("quitting plots")
	global should_keep_going
	should_keep_going = 0
	global sweep_should_keep_going
	sweep_should_keep_going = 0
	#sys.exit(0)

#def cac_phy_sub_sample_array(value):
#	return [[[[[[value for sample in range(32)] for subwindow in range(2)] for physical_window in range(512)] for channel in range(8)] for asic in range(4)] for carrier in range(4)]

#def lin_phy_sub_sample_array(value):
#	return [[[[value for sample in range(32)] for subwindow in range(2)] for physical_window in range(512)] for channel in xrm_lin_ch_range()]

def lin_array(value):
	#return [[value for sample in range(64*512)] for channel in xrm_lin_ch_range()]
	#return [[value for sample in range(asic_samples_per_read_window*number_of_physical_windows_to_plot)] for channel in xrm_lin_ch_range()]
	return [[value for sample in range(asic_samples_per_read_window*total_number_of_physical_windows)] for channel in range(128)]

#independent_axis_units = duration_in_ns_of_64_sample_waveform
independent_axis_units = 12 # RF_buckets_per_read_window but only after we've run calculate_parameters()

def lin_ch_domain(first_physical_window_to_plot, last_physical_window_to_plot, number_of_physical_windows):
	#return numpy.linspace(first_physical_window_to_plot*duration_in_ns_of_64_sample_waveform, (last_physical_window_to_plot-first_physical_window_to_plot+1)*duration_in_ns_of_64_sample_waveform, (last_physical_window_to_plot-first_physical_window_to_plot+1)*64) # in ns
	return numpy.linspace(first_physical_window_to_plot*independent_axis_units, (last_physical_window_to_plot+1)*independent_axis_units-1.0/asic_samples_per_RF_bucket, number_of_physical_windows*asic_samples_per_read_window)

#def domain(number_of_physical_windows_to_plot=1):
#	return numpy.linspace(0+duration_in_ns_of_64_sample_waveform*(number_of_physical_windows_to_plot-1), number_of_physical_windows_to_plot*duration_in_ns_of_64_sample_waveform, 64) # in ns

datafile = None
waveformfile = None

def plot_slice_centered_on_RF_bucket(array):
	if already_plotted:
		axes2.clear()
	axes2.set_autoscaley_on(False)
	axes2.plot(array[0::2], [n for n in range(64)], color="blue")
	#info(str(desired_RF_bucket))
	#axes2.set_ylim([129, -2])
	#axes2.set_ylim([66, -2])
	axes2.set_ylim([-4, 67])
	axes2.set_yticklabels([])
	axes2.set_yticks([])
	axes2.set_xlim([slice_lower_limit, slice_upper_limit])
	#axes2.set_xticklabels([])
	#axes2.set_xticks([])
	axes2.set_ylabel("channel")
	axes2.set_xlabel("amplitude (ADC counts)")
	axes2.set_title("RF bucket #" + str(desired_RF_bucket))

already_plotted = 0
#rainbow = [ "red", "orange", "yellow", "green", "teal", "blue", "indigo", "violet" ]
rainbow = [ "#dd0000", "#ff7700", "#bbbb00", "#00bb00", "#00bbbb", "#0000bb", "#4488ff", "#ff77ff" ]
#colorarray = [ "red", "green", "orange", "purple", "blue", "saddlebrown", "dodgerblue", "black" ]
#colorarray = [ "yellow", "red", "indigo", "teal", "green", "orange", "violet", "blue" ]
colorarray = [ rainbow[2], rainbow[0], rainbow[6], rainbow[4], rainbow[3], rainbow[1], rainbow[7], rainbow[5] ]

def colorarray_xrm(lin_ch):
	#if 70==lin_ch:
	#	return "blue"
	#else:
	#	return "black"
	carrier, asic, channel = xrm_map_linear_to_cac(lin_ch)
	return colorarray[int(carrier//2)*4+asic]
	#return colorarray[carrier]
	#return colorarray[asic]
	#return colorarray[channel]

def threaded_xrm_trigger_boardstack_and_capture_data(N, duration):
	if be_verbose_when_collecting_data:
		info("expecting " + str(N) + " events")
	#ethudp.attempt_to_flush(0)
	#ethudp.attempt_to_flush(1)
	mythread = threading.Thread(target=ethudp.capture_triggered_data, args=(datafilename, N, number_of_bytes_to_expect_per_event, be_verbose_when_collecting_data))
	mythread.start()
	diff = trigger_and_wait_for_xrm_triggers(duration)
	#diff = allow_xrm_triggers_for_a_while(duration)
	mythread.join()
	if not diff == N:
		IncrementErrorCount("discrepancy: " + str(diff) + " (event # difference) != " + str(N) + " (desired number of triggers)", 1)

should_software_trigger = 0
extra_duration_to_wait_for_data = 1.0
def get_triggered_data(N, n, N_log2, desired_event_numbers):
	# N is how many sets of events that we want
	# n is how many bunch markers are active per set (usually from a call to count_frame_masks())
	# plot_continuous==1 means plot each one right after acquisition
	set_desired_trigger_quantities(N, N, N, N)
	set_trig_prescale_N_log2(N_log2)
	enable_xrm_triggers()
	wait_at_least_until_next_frame9()
	duration = ((N*n)+0.0) / expected_trigger_rate[N_log2] + extra_duration_to_wait_for_data
	first_time_through = 1
	global should_keep_going
	should_keep_going = 1
	while should_keep_going:
		manualRunReset_if_necessary(BS, be_verbose_when_collecting_data)
		threaded_xrm_trigger_boardstack_and_capture_data(N*n, duration)
		if be_verbose_when_collecting_data:
			show_some_info()
		if len(desired_event_numbers):
			quick_temp_status(BS)
#			if plot_continuous:
#				parse_datafile_and_plot_waveformfile(desired_event_numbers)
			if "acquire"==xrm_mode:
				read_config_file_for_xrm_stuff()
				get_ready_for_data(BS)
				cycle_calibration_channel(BS)
#		if not xrm_run_continuous:
#			info("mode changed (from configfile) to no longer run in continuous mode")
#			if already_plotted:
#				plt.close("all")
#			should_keep_going = 0
#			break
		if first_time_through:
			first_time_through = 0
			if "acquire"==xrm_mode:
				should_keep_going = xrm_run_continuous
			if "sweep"==xrm_mode:
				should_keep_going = 0
#		if plot_continuous and not should_keep_going:
#			plt.pause(0)
		if should_keep_going and "acquire"==xrm_mode:
			if should_cycle_slowly_through_bunch_markers:
				cycle_through_bunch_marker_a()
			else:
				update_bunch_marker_from_desired_RF_bucket_with_offset(0, 0)
			time.sleep(desired_pause_between_acquisitions)
		if datafilesize<file_size(datafilename):
			generate_new_datafilename()
			info("")
#	if "acquire"==xrm_mode and be_verbose_when_collecting_data:
#		get_status(BS)
	disable_xrm_triggers()
	#show_readoutwindows_for_each_asic(BS)

def set_readout_window_to_match_bunch(bunch):
	write_register_for_each_asic(CARRIER_IRSX_readoutLookback, int(bunch//RF_buckets_per_read_window), BS)

def set_bunch_marker(bunch_marker_number, frame_mask, value):
	set_readout_window_to_match_bunch(value)
	value_with_frame_mask = value
	#value_with_frame_mask &= ~frame_mask_all
	value_with_frame_mask |= frame_mask << frame_mask_shift
	info("bunch marker " + convert_0123_to_abcd(bunch_marker_number) + " frame_mask:" + hex(frame_mask) + " value:" + hex(value) + " (value with frame mask): " + hex(value_with_frame_mask))
	if 0==bunch_marker_number:
		write_register(SCROD_AxiCommon_bunch_marker_a, value_with_frame_mask, BS)
	if 1==bunch_marker_number:
		write_register(SCROD_AxiCommon_bunch_marker_b, value_with_frame_mask, BS)
	if 2==bunch_marker_number:
		write_register(SCROD_AxiCommon_bunch_marker_c, value_with_frame_mask, BS)
	if 3==bunch_marker_number:
		write_register(SCROD_AxiCommon_bunch_marker_d, value_with_frame_mask, BS)

#def set_bunch_markers(a, b, c, d):
#	a |= frame_mask_all
#	b |= frame_mask_all
#	c |= frame_mask_all
#	d |= frame_mask_all
#	#a &= ~frame_mask_all
#	#b &= ~frame_mask_all
#	#c &= ~frame_mask_all
#	#d &= ~frame_mask_all
#	#a |= (1<<0)<<frame_mask_shift
#	#b |= (1<<5)<<frame_mask_shift
#	#c |= (1<<6)<<frame_mask_shift
#	#d |= (1<<7)<<frame_mask_shift
#	write_register(SCROD_AxiCommon_bunch_marker_a, a, BS)
#	write_register(SCROD_AxiCommon_bunch_marker_b, b, BS)
#	write_register(SCROD_AxiCommon_bunch_marker_c, c, BS)
#	write_register(SCROD_AxiCommon_bunch_marker_d, d, BS)
#
#def set_quadbunch_markers(a, b, c, d):
#	set_bunch_markers(4*a, 4*b, 4*c, 4*d)
#
#def set_asic_write_window_bunch_markers(a, b, c, d):
#	#calculate_parameters(4)
#	#calculate_parameters(6)
#	#calculate_parameters(8)
#	#set_bunch_markers(16*a, 16*b, 16*c, 16*d)
#	set_bunch_markers(24*a, 24*b, 24*c, 24*d)
#	#set_bunch_markers(32*a, 32*b, 32*c, 32*d)

def sweep_bunch_marker_positions():
	set_bunch_marker(0, 0b100000000, bunch_marker_first_valid)
	set_bunch_marker(1, 0b000000000, 0)
	set_bunch_marker(2, 0b000000000, 0)
	set_bunch_marker(3, 0b000000001, bunch_marker_last_valid)
	set_trig_prescale_N_log2(2)
	start_frame = 8
	end_frame = 0
	#info("sweep")
	for j in range(start_frame, end_frame-1, -1):
		for i in range(bunch_marker_first_valid, bunch_marker_last_valid+1):
			#info(str(j) + " " + str(i))
			set_bunch_marker(1, 1<<j, i)
			set_bunch_marker(2, 1<<(8-j), bunch_marker_last_valid + bunch_marker_first_valid - i)
		#time.sleep(0.1)
		wait_at_least_until_next_frame9()

def clear_bunch_markers():
	set_bunch_marker(0, 0, 0)
	set_bunch_marker(1, 0, 0)
	set_bunch_marker(2, 0, 0)
	set_bunch_marker(3, 0, 0)

def update_bunch_marker(bunch_marker_number):
	frame_mask = 0b100000000
	if 0==bunch_marker_number:
		set_bunch_marker(0, frame_mask, bunch_marker_a)
	if 1==bunch_marker_number:
		set_bunch_marker(1, frame_mask, bunch_marker_b)
	if 2==bunch_marker_number:
		set_bunch_marker(2, frame_mask, bunch_marker_c)
	if 3==bunch_marker_number:
		set_bunch_marker(3, frame_mask, bunch_marker_d)
	wait_at_least_until_next_frame9()

def update_bunch_marker_from_desired_RF_bucket_with_offset(bunch_marker_number, desired_offset):
	if 0==bunch_marker_number:
		global bunch_marker_a
		bunch_marker_a = desired_RF_bucket + desired_offset
	if 1==bunch_marker_number:
		global bunch_marker_b
		bunch_marker_b = desired_RF_bucket + desired_offset
	if 2==bunch_marker_number:
		global bunch_marker_c
		bunch_marker_c = desired_RF_bucket + desired_offset
	if 3==bunch_marker_number:
		global bunch_marker_d
		bunch_marker_d = desired_RF_bucket + desired_offset
	update_bunch_marker(bunch_marker_number)

def cycle_through_bunch_marker_a():
	global bunch_marker_a
	try:
		bunch_marker_a += int(RF_buckets_per_read_window)
		if bunch_marker_last_valid<bunch_marker_a:
			bunch_marker_a = bunch_marker_first_valid
	except:
		bunch_marker_a = desired_RF_bucket
	update_bunch_marker(0)

def decode_frame_mask(frame_mask):
	frame_mask &= frame_mask_all
	frame_mask >>= frame_mask_shift
	list = []
	if frame_mask & 0x100:
		list.append(0)
	if frame_mask & 0x080:
		list.append(1)
	if frame_mask & 0x040:
		list.append(2)
	if frame_mask & 0x020:
		list.append(3)
	if frame_mask & 0x010:
		list.append(4)
	if frame_mask & 0x008:
		list.append(5)
	if frame_mask & 0x004:
		list.append(6)
	if frame_mask & 0x002:
		list.append(7)
	if frame_mask & 0x001:
		list.append(8)
	return list

def show_frame_masks():
	a = read_register(SCROD_AxiCommon_bunch_marker_a, BS)
	af = decode_frame_mask(a)
	a &= ~frame_mask_all
	info("bunch_marker_a: frames:" + str(af) + " bucket:" + str(a))
	b = read_register(SCROD_AxiCommon_bunch_marker_b, BS)
	bf = decode_frame_mask(b)
	b &= ~frame_mask_all
	info("bunch_marker_b: frames:" + str(bf) + " bucket:" + str(b))
	c = read_register(SCROD_AxiCommon_bunch_marker_c, BS)
	cf = decode_frame_mask(c)
	c &= ~frame_mask_all
	info("bunch_marker_c: frames:" + str(cf) + " bucket:" + str(c))
	d = read_register(SCROD_AxiCommon_bunch_marker_d, BS)
	df = decode_frame_mask(d)
	d &= ~frame_mask_all
	info("bunch_marker_d: frames:" + str(df) + " bucket:" + str(d))
	#info("total frame masks active: " + str(count_frame_masks()))

def count_frame_masks():
	a = read_register(SCROD_AxiCommon_bunch_marker_a, BS)
	ac = len(decode_frame_mask(a))
	b = read_register(SCROD_AxiCommon_bunch_marker_b, BS)
	bc = len(decode_frame_mask(b))
	c = read_register(SCROD_AxiCommon_bunch_marker_c, BS)
	cc = len(decode_frame_mask(c))
	d = read_register(SCROD_AxiCommon_bunch_marker_d, BS)
	dc = len(decode_frame_mask(d))
	total = ac + bc + cc + dc
	info(str(total) + " frame masks")
	show_frame_masks()
	return total

def cycle_calibration_channel(BS, init=0):
	if not enable_cal_signal:
		return 500
	global calibration_channel_state
	if init or 128<calibration_channel_state or calibration_channel_state<1:
		calibration_channel_state = 1
	if multicast_cal_signal:
		channel = 7 - (calibration_channel_state>>4)%8
		select_calibration_channel_multiple_destinations(BS, channel)
		calibration_channel_state += 16
	else:
		carrier, asic, channel = xrm_map_linear_to_cac(calibration_channel_state)
		select_calibration_channel_single_destination(BS, carrier, asic, channel)
		calibration_channel_state += 2
	wait_for_PS_on_each_carrier_to_pick_up_the_changes(BS)
	#show_calibration_signal_status(BS)
	return calibration_channel_state

def change_pedestal_voltage(index, number_of_steps):
	vPed_min = 0.8
	vPed_max = 1.3
	slope = float(vPed_max-vPed_min) / (number_of_steps + 0.0)
	if index<number_of_steps:
		voltage = vPed_min + slope * index
		set_pedestal_voltage(BS, voltage)
	elif number_of_steps==index:
		set_pedestal_voltage(BS, 0.9)
	else:
		return
	time.sleep(0.2)
	#wait_for_PS_on_each_carrier_to_pick_up_the_changes(BS)

def change_sstfb_uniformly(index, number_of_steps):
	sstfb_min = 105
	#sstfb_max = sstfb_min + number_of_steps
	sstfb_max = 115
	slope = (sstfb_max - sstfb_min) / (number_of_steps + 0.0)
	#sys.exit(0)
	if index<number_of_steps:
		value = int(sstfb_min + slope * index)
		info(str(value))
		set_all_sstfb_to_the_same_value(BS, value)
	elif number_of_steps==index:
		value = 110
		info(str(value))
		set_all_sstfb_to_the_same_value(BS, value)
	else:
		return
	time.sleep(0.2)

def change_sstfb_individually(index, number_of_steps):
	global nominal_ssts
	try:
		nominal_ssts
	except:
		nominal_ssts = get_nominal_sstfb_array_from_file(BS)
	#set_sstfb_array(BS, nominal_ssts)
	#return
	half_number_of_steps = int(number_of_steps//2)
	#info("half_number_of_steps " + str(half_number_of_steps))
	width = 10
	slope = float((width+0.0)/number_of_steps)
	#info("slope " + str(slope))
	if index<number_of_steps:
		myssts = []
		offset = index - half_number_of_steps
		#info("offset " + str(offset))
		offset *= slope
		#info("offset " + str(offset))
		offset = int(offset)
		#info("offset " + str(offset))
		for i in range(16):
			#myssts.append(nominal_ssts[i] + int((0.0+index-half_number_of_steps)*slope/(number_of_steps+0.0)))
			myssts.append(nominal_ssts[i] + offset)
			#info(dec(i, 2) + " " + str(myssts[i]))
		set_sstfb_array(BS, myssts)
	elif number_of_steps==index:
		#for i in range(16):
			#info(dec(i, 2) + " " + str(nominal_ssts[i]))
		set_sstfb_array(BS, nominal_ssts)
	else:
		return
	time.sleep(0.2)

def change_things(index, number_of_steps):
	#change_pedestal_voltage(index, number_of_steps)
	#change_sstfb_uniformly(index, number_of_steps)
	#change_sstfb_individually(index, number_of_steps)
	return

should_sweep_Vbias = False
min_Vbias = 900
max_Vbias = 1100
current_Vbias = min_Vbias
Vbias_step = 12.*(max_Vbias-min_Vbias)/5120.
#print("Vbias_step: " + str(Vbias_step))

should_sweep_Vbias2 = False
min_Vbias2 = 750
max_Vbias2 = 950
current_Vbias2 = min_Vbias2
Vbias2_step = 12.*(max_Vbias2-min_Vbias2)/5120.
#print("Vbias2_step: " + str(Vbias2_step))

def set_Vbias_for_BS(desired_Vbias, BS):
	for carrier in range(number_of_carriers[BS]-1, -1, -1):
		for asic in (3, 2, 1, 0):
			write_asic_direct_register(BS, carrier, asic, Vbias, desired_Vbias)

def set_Vbias2_for_BS(desired_Vbias2, BS):
	for carrier in range(number_of_carriers[BS]-1, -1, -1):
		for asic in (3, 2, 1, 0):
			write_asic_direct_register(BS, carrier, asic, Vbias2, desired_Vbias2)

def change_to_the_next_Vbias():
	global current_Vbias
	current_Vbias += Vbias_step
	if max_Vbias<current_Vbias:
		current_Vbias = min_Vbias
	set_Vbias_for_BS(int(current_Vbias), BS)
	print("current_Vbias: " + str(int(current_Vbias)))

def change_to_the_next_Vbias2():
	global current_Vbias2
	current_Vbias2 += Vbias2_step
	if max_Vbias2<current_Vbias2:
		current_Vbias2 = min_Vbias2
	set_Vbias2_for_BS(int(current_Vbias2), BS)
	print("current_Vbias2: " + str(int(current_Vbias2)))

def sweep_bunch_marker_positions_and_take_data_at_each_position():
	frame_mask_a = 0b100000000
	frame_mask_b = 0b000000001
	frame_mask_c = 0b000010000
	frame_mask_d = 0b000000100
	how_many_bunch_markers_to_activate = 1
	step = int(RF_buckets_per_read_window)
	fullstep = how_many_bunch_markers_to_activate * step
	DIVISOR = fullstep * 22
	first_time_through = 1
	global sweep_should_keep_going
	sweep_should_keep_going = 1
	clear_bunch_markers()
	if not enable_cal_signal:
		disable_calibration_input(BS)
	#show_calibration_signal_status(BS)
	change_things(0, 64)
	if not should_sweep_Vbias:
		set_Vbias_for_BS(nominal_Vbias, BS)
	if not should_sweep_Vbias2:
		set_Vbias2_for_BS(nominal_Vbias2, BS)
	while sweep_should_keep_going:
		first = sweep_start_bucket
		last = sweep_end_bucket + 1
		global starting_physical_window_number
		starting_physical_window_number = first//step
		global ending_physical_window_number
		ending_physical_window_number = last//step
		global desired_physical_window_numbers
		desired_physical_window_numbers = [ w for w in range(starting_physical_window_number, ending_physical_window_number) ]
		if enable_cal_signal and should_cycle_calibration_channel:
			calch = cycle_calibration_channel(BS, 1)
		start = mytimer()
		num_steps = (last - first) // fullstep
		info("setting bunch_marker_a to RF_bucket #s:")
		string = ""
		for i in range(first, last, fullstep):
			#info(str(i) + " " + str((i-first)%16) + " " + str((i-first)%16))
			if 0==(i-first)%DIVISOR:
				string = dec(i, 4)
			else:
				string += " " + dec(i, 4)
			if (DIVISOR-fullstep)==(i-first)%DIVISOR or (last-1)==i:
				info(string)
			#info("setting bunch_marker_a to RF_bucket # " + str(i), 0)
			set_bunch_marker(0, frame_mask_a, i)
#			if 1<how_many_bunch_markers_to_activate:
#				info("setting bunch_marker_b to RF_bucket # " + str(i+1*step), 0)
#				set_bunch_marker(1, frame_mask_b, i+1*step)
#			if 2<how_many_bunch_markers_to_activate:
#				info("setting bunch_marker_c to RF_bucket # " + str(i+2*step), 0)
#				set_bunch_marker(2, frame_mask_c, i+2*step)
#			if 3<how_many_bunch_markers_to_activate:
#				info("setting bunch_marker_d to RF_bucket # " + str(i+3*step), 0)
#				set_bunch_marker(3, frame_mask_d, i+3*step)
			if should_sweep_Vbias:
				change_to_the_next_Vbias()
			if should_sweep_Vbias2:
				change_to_the_next_Vbias2()
			wait_at_least_until_next_frame9()
			if sweep_should_keep_going:
				desired_event_numbers = []
				#if 1300==i or 2596==i or 3892==i or 5104==i:
				if sweep_end_bucket==i:
					#desired_event_numbers = [x for x in range(1, int(i/step) + 1)]
					desired_event_numbers = [ -1 ] # this means plot everything found in the file
					#info(str(desired_event_numbers))
				#start = mytimer()
				get_triggered_data(1, count_frame_masks(), trig_prescale_N_log2, desired_event_numbers)
				#show_mytimer(start)
				change_things(int(i/step), num_steps)
				if enable_cal_signal and should_cycle_calibration_channel:
#					if calch<129:
					calch = cycle_calibration_channel(BS)
#					elif 129==calch:
#						calch = 500
#						disable_calibration_input(BS)
#						wait_for_PS_on_each_carrier_to_pick_up_the_changes(BS)
			else:
				return
		#show_calibration_signal_status(BS)
		show_mytimer(start, "sweep of entire revolution")
		if xrm_run_continuous:
			#get_status(BS)
			if desired_pause_between_acquisitions:
				info("waiting for " + str(desired_pause_between_acquisitions) + " seconds...")
				time.sleep(desired_pause_between_acquisitions)
			info("")
			read_config_file_for_xrm_stuff()
			generate_new_datafilename()
		if first_time_through:
			first_time_through = 0
			sweep_should_keep_going = xrm_run_continuous
#	if be_verbose_when_collecting_data:
#		get_status(BS)
	#show_calibration_signal_status(BS)
	disable_calibration_input(BS)
	if should_write_root_tree:
		close_roottreefile_for_writing()
		#open_roottreefile_for_reading()

def threshold_tweak(BS):
	#show_scalers(BS)
	#info("")
#	for carrier in range(2, 3):
#		for asic in range(2,4):
#			for channel in range(4,8):
#				tweak_asic_trigger_comparator_threshold(BS, carrier, asic, channel, -5)
#				time.sleep(0.01)
	scrod_serial = get_scrod_serial(BS)
	#info(str(scrod_serial))
	if 108==scrod_serial:
		tweak_asic_trigger_comparator_threshold(BS, 2, 3, 7, -6)
		tweak_asic_trigger_comparator_threshold(BS, 0, 2, 7, -5)
	if 4==scrod_serial:
		tweak_asic_trigger_comparator_threshold(BS, 0, 0, 0, -24)
		tweak_asic_trigger_comparator_threshold(BS, 0, 0, 1, -24)
		tweak_asic_trigger_comparator_threshold(BS, 0, 1, 0, -6)
		tweak_asic_trigger_comparator_threshold(BS, 0, 1, 1, -6)
		tweak_asic_trigger_comparator_threshold(BS, 0, 3, 0, -8)
		tweak_asic_trigger_comparator_threshold(BS, 0, 3, 1, -8)
		tweak_asic_trigger_comparator_threshold(BS, 2, 0, 0, -6)
		tweak_asic_trigger_comparator_threshold(BS, 2, 0, 1, -6)
		tweak_asic_trigger_comparator_threshold(BS, 2, 1, 0, -24)
		tweak_asic_trigger_comparator_threshold(BS, 2, 1, 1, -24)
		tweak_asic_trigger_comparator_threshold(BS, 2, 2, 0, -6)
		tweak_asic_trigger_comparator_threshold(BS, 2, 2, 1, -6)
		tweak_asic_trigger_comparator_threshold(BS, 2, 3, 0, -6)
		tweak_asic_trigger_comparator_threshold(BS, 2, 3, 1, -6)
	#show_scalers(BS)

def setup_xrm_trigger():
	manualRunReset(BS)
	#set_trig_prescale_N_log2(14)
	clear_bunch_markers()
	update_bunch_marker_from_desired_RF_bucket_with_offset(0, 0)
	if be_verbose_when_collecting_data:
		show_relevant_registers()
	cycle_calibration_channel(BS, 1)
	if not enable_cal_signal:
		disable_calibration_input(BS)
#	set_bunch_markers(1000, 2000, 3000, 4000)
#	set_quadbunch_markers(100, 102, 104, 106)
#	set_quadbunch_markers(100, 100, 100, 100)
#	set_asic_write_window_bunch_markers(1, 3, 5, 7)
#	set_asic_write_window_bunch_markers(1, 1, 1, 1)
#	set_quadbunch_markers(2,4,6,8)

def get_ready_for_data(BS):
	if be_verbose_when_collecting_data:
		info("getting ready for data")
	# CARRIER_IRSX_readoutWindows=1 SCROD_PS_maxRawWaveforms=64 total_frame_masks_active=3 (consecutive); numchunks=6
	# CARRIER_IRSX_readoutWindows=1 SCROD_PS_maxRawWaveforms=128 total_frame_masks_active=3 (consecutive); numchunks=9
	# ...phaseRead loops from prep1asic_data_trueROI or the PS code...
#	write_register_for_each_carrier(CARRIER_PS_cal7minusCh, 7, BS) # this means ch 0
#	#write_register_for_each_carrier(CARRIER_PS_cal7minusCh, 0, BS) # this means ch 7
#	write_register(CARRIER_PS_calEn, 0x0, BS, 0)
#	write_register(CARRIER_PS_calEn, 0x0, BS, 1)
#	write_register(CARRIER_PS_calEn, 0x8, BS, 2)
#	write_register(CARRIER_PS_calEn, 0x0, BS, 3)
	write_register(SCROD_PS_MAX_EVENT_QUEUE_DEPTH, 130, BS)
#	if be_verbose_when_collecting_data:
#		show_register_by_name("SCROD_PS_MAX_EVENT_QUEUE_DEPTH", BS)
	#write_register(SCROD_PS_featureExtMode, featExtractMode_normal, BS)
	write_register(SCROD_PS_featureExtMode, featExtractMode_nocuts, BS)
	#write_register(SCROD_PS_featureExtMode, featExtractMode_passthru, BS)
	if use_pedestal_subtraction_mode:
		turn_on_pedestal_subtraction_mode(BS)
	else:
		turn_off_pedestal_subtraction_mode(BS)
	if not enable_cal_signal:
		disable_calibration_input(BS)
	wait_for_all_5_PS_to_pick_up_the_changes(BS)
	#wait_for_PS_on_SCROD_to_pick_up_the_changes(BS)
	#wait_for_PS_on_each_carrier_to_pick_up_the_changes(BS)
	write_register_for_each_asic(CARRIER_IRSX_convertResetWait, 0x0f, BS)
	write_register_for_each_asic(CARRIER_IRSX_enableTestPattern, 0, BS)
	write_register(SCROD_AxiCommon_filteringTimeout, 127221875, BS)
	write_register_for_each_asic(CARRIER_IRSX_wrAddrFixed, 0x40, BS)
	#write_register_for_each_asic(CARRIER_IRSX_wrAddrMode, wrAddrMode_Calibration, BS)
	write_register_for_each_asic(CARRIER_IRSX_wrAddrMode, wrAddrMode_Cyclic, BS)
	write_register_for_each_asic(CARRIER_IRSX_readoutMode, readoutMode_Forced, BS)
	#write_register_for_each_asic(CARRIER_IRSX_readoutMode, readoutMode_Lookback, BS)
	write_register(SCROD_AxiCommon_oserdes_word_trig, (oserdes_always_value<<16) | oserdes_triggered_value, BS)
	#write_register(SCROD_AxiCommon_oserdes_word_trig, 0, BS)
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x55<<16) | 0x00, BS) # 509 MHz sine always except during trigger
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0xaa, BS) # 10101010
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0b00101000, BS)
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0b00100100, BS)
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0b01000100, BS)
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0xe7, BS) # 6 bits high
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0x3c, BS) # 4 bits high
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0x18, BS) # 2 bits high
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0x10, BS) # 1 bit high
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0xaa<<16) | 0xaa, BS) # 509 MHz sine always
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0x81, BS) # 1 bit high, then 6 bit gap, then 1 bit high
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0xc3, BS) # 2 bits high, then 4 bit gap, then 2 bits high
	#write_register(SCROD_AxiCommon_oserdes_word_trig, (0x00<<16) | 0xe7, BS) # 3 bits high, then 2 bit gap, then 3 bits high
	write_register_for_each_asic(CARRIER_IRSX_wrAddrStart, 0x00, BS)
	write_register_for_each_asic(CARRIER_IRSX_wrAddrStop,  0xe0, BS)
	#write_register_for_each_asic(CARRIER_IRSX_wrAddrStop,  0xff, BS)
	write_register_for_each_asic(CARRIER_IRSX_wrAddrJunk,  0xff, BS)
	write_register_for_each_asic(CARRIER_IRSX_writesAfterTrig, 0x00, BS)
	#write_register_for_each_asic(CARRIER_IRSX_readoutLookback, 0x000, BS) # set by set_bunch_marker()
	write_register_for_each_asic(CARRIER_IRSX_trigAdj, 0, BS)
	carrier_list = [0, 0, 0, 0]
	channel_mask = 0
	carrier_mask = 0
	for carrier in range(4):
		if carrier in carriers_to_dejuice:
			carrier_list[carrier] = 0xf
			channel_mask |= 0xf<<(4*carrier)
			carrier_mask |= 1<<carrier
	#unmask_triggers(0xa, 0x0, 0xf, 0x0, 0xf)
	unmask_triggers(carrier_mask, carrier_list[0], carrier_list[1], carrier_list[2], carrier_list[3])
	#write_register(SCROD_AxiCommon_asicMask, 0xf0f0, BS)
	write_register(SCROD_AxiCommon_asicMask, channel_mask, BS)
	if be_verbose_when_collecting_data:
		show_register_by_name("SCROD_AxiCommon_trigMask", BS)
		show_register_by_name("CARRIER_AxiCommon_trigMask", BS, 0)
		show_register_by_name("CARRIER_AxiCommon_trigMask", BS, 1)
		show_register_by_name("CARRIER_AxiCommon_trigMask", BS, 2)
		show_register_by_name("CARRIER_AxiCommon_trigMask", BS, 3)
		show_register_by_name("SCROD_AxiCommon_asicMask", BS)
	#time.sleep(4.0)

def setup_xrm_mode(BS):
	set_verbosity_of_virtual_tty(BS, 4)
	setup_xrm_trigger()
	set_nominal_asic_trigger_comparator_thresholds(BS)
	number_of_bytes_per_word = 4
	number_of_bytes_for_event_header = 5 * number_of_bytes_per_word
	number_of_enabled_channels = 0
	for carrier in range(4):
		if not carrier in carriers_to_dejuice:
			number_of_enabled_channels += 32
	if be_verbose_when_collecting_data:
		info("number_of_enabled_channels: " + str(number_of_enabled_channels))
	desired_number_of_readout_windows_per_channel = 1 # 64 samples per window
	number_of_waveforms_per_channel = 2 * desired_number_of_readout_windows_per_channel # 32 samples per waveform
	number_of_waveforms_to_expect_from_forced_mode_with_our_channel_masks = number_of_waveforms_per_channel * number_of_enabled_channels
	number_of_bytes_for_hits = number_of_waveforms_to_expect_from_forced_mode_with_our_channel_masks * 5 * number_of_bytes_per_word
	expected_number_of_bytes_for_waveforms = number_of_waveforms_to_expect_from_forced_mode_with_our_channel_masks * 18 * number_of_bytes_per_word
	global number_of_bytes_to_expect_per_event
	number_of_bytes_to_expect_per_event = number_of_bytes_for_event_header + number_of_bytes_for_hits + expected_number_of_bytes_for_waveforms
	if be_verbose_when_collecting_data:
		info("number_of_bytes_to_expect_per_event: " + str(number_of_bytes_to_expect_per_event))
	write_register_for_each_asic(CARRIER_IRSX_readoutWindows, desired_number_of_readout_windows_per_channel, BS)
	#show_readoutwindows_for_each_asic(BS)
	if be_verbose_when_collecting_data:
		info("number_of_waveforms_to_expect_from_forced_mode_with_our_channel_masks: " + str(number_of_waveforms_to_expect_from_forced_mode_with_our_channel_masks))
	write_register(SCROD_PS_maxRawWaveforms, number_of_waveforms_to_expect_from_forced_mode_with_our_channel_masks, BS)
	#sys.exit(0)
	#number_of_bytes_to_expect_per_ASDF = count_frame_masks() * number_of_bytes_to_expect_per_event
	#threshold_tweak(BS)
	#set_desired_trigger_quantities(10, 0, 0, 0)
	show_register_by_name("SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_a", BS)
	show_register_by_name("SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_b", BS)
	show_register_by_name("SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_c", BS)
	show_register_by_name("SCROD_AxiCommon_desired_trigger_quantity_for_bunch_marker_d", BS)

datestring_we_last_used_to_read_beam_conditions = "blah"
beam_conditions_need_to_be_read_again = True
def generate_beam_condition_filenames():
	global datestring
	datestring = [ "", "", "" ]
	datestring_compact = [ "", "", "" ]
	global beam_conditions_need_to_be_read_again
	#timestring = "2020-01-01.000000"
	match = re.search("([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9]).([0-9][0-9][0-9][0-9][0-9][0-9])", timestring)
	if match:
		#info(datestring[1])
		datestring_base = datetime.datetime.strptime(match.group(1) + "-" + match.group(2) + "-" + match.group(3), "%Y-%m-%d")
		#info(str(datestring[0]))
		datestring[0] = datestring_base - datetime.timedelta(days=1)
		datestring[1] = datestring_base
		datestring[2] = datestring_base + datetime.timedelta(days=1)
		#info(str(datestring[0]))
		datestring_compact[0] = datestring[0].strftime("%Y%m%d")
		datestring_compact[1] = datestring[1].strftime("%Y%m%d")
		datestring_compact[2] = datestring[2].strftime("%Y%m%d")
		datestring[0] = datestring[0].strftime("%Y-%m-%d")
		datestring[1] = datestring[1].strftime("%Y-%m-%d")
		datestring[2] = datestring[2].strftime("%Y-%m-%d")
		#info(datestring[0])
		#info(datestring[1])
		#info(datestring[2])
		#info(datestring_compact[0])
		#info(datestring_compact[1])
		#info(datestring_compact[2])
		#datestring[2] = match.group(1) + "-" + match.group(2) + "-" + match.group(3)
		#datestring_compact[1] = match.group(1) + match.group(2) + match.group(3)
		#datestring_compact_base = datetime.datetime.strptime(datestring[1].strftime(), "%Y%m%d")
	else:
		error("datestring regex")
		sys.exit(5)
	if datestring_we_last_used_to_read_beam_conditions == datestring[1]:
		beam_conditions_need_to_be_read_again = False
		return
	tarbz2_file_base = [ "", "", "" ]
	tarbz2_file = [ "", "", "" ]
	beam_condition_file_base = [ "", "", "" ]
	global beam_current_filename
	beam_current_filename = [ "", "", "" ]
	global nbunches_filename
	nbunches_filename = [ "", "", "" ]
	global bunch_current_filename
	bunch_current_filename = [ "", "", "" ]
	for i in [ 0, 1, 2 ]:
		tarbz2_file_base[i] = datestring_compact[i] + ".tar.bz2"
		mydirname = "data/" + station + "/" + datestring[i]
		tarbz2_file[i] = mydirname + "/" + tarbz2_file_base[i]
		beam_condition_file_base[i] = mydirname + "/" + datestring_compact[i] + "000000-" + datestring_compact[i] + "235959"
		beam_current_filename[i] = beam_condition_file_base[i] + ".current.HER"
		nbunches_filename[i] = beam_condition_file_base[i] + ".nbunches.HER"
		bunch_current_filename[i] = beam_condition_file_base[i] + ".bunchcurrent.HER"
		if (not os.path.exists(beam_current_filename[i]) or not os.path.exists(nbunches_filename[i]) or not os.path.exists(beam_current_filename[i])):
			if os.path.exists(tarbz2_file[i]):
				command = "cd " + mydirname + "; pwd; tar xjf " + tarbz2_file_base[i]
				info("unpacking " + tarbz2_file[i] + " ...")
				response = commands.getstatusoutput(command)
				if response[0]:
					info(response[i])
#			else:
#				warning("file " + tarbz2_file[i] + " does not exist")
	beam_conditions_need_to_be_read_again = True
	datestring = datestring[1]
	#sys.exit(17)

def get_datafilename():
	return datafilename

def get_filenames_from_basename():
	global datafilename
	datafilename = basename + ".datafile"
	global roottreefilename
	roottreefilename = basename + ".root"
	global waveformfilename
	waveformfilename = basename + ".waveforms"
	if should_plot_beam_current:
		generate_beam_condition_filenames()

def generate_new_datafilename():
	close_datafile_for_reading()
	close_waveformfile_for_reading()
	if should_write_root_tree:
		close_roottreefile_for_writing()
		#open_roottreefile_for_reading()
	global timestring
	timestring = time.strftime("%Y-%m-%d.%H%M%S")
	#timestring = "2019-11-27.012345"
	#info(timestring)
	#global datestring
	match = re.search("([0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]).([0-9][0-9][0-9][0-9][0-9][0-9])", timestring)
	if match:
		datestring = match.group(1)
	else:
		error("datestring regex")
		sys.exit(5)
	#info(datestring)
	global dirname
	dirname = "data"
	mkdir_if_necessary(dirname)
	dirname = "data/" + station
	mkdir_if_necessary(dirname)
	dirname = "data/" + station + "/" + datestring
	mkdir_if_necessary(dirname)
	global basename
	basename = dirname + "/" + timestring
	#info(basename)
	get_filenames_from_basename()
	info("")
	info("datafile name: " + datafilename)
	#sys.exit(0)
	if use_pedestal_subtraction_mode and retake_pedestals_at_every_filechange:
		take_pedestals(BS)
		manualRunReset(BS)
	get_ready_for_data(BS)
	if should_write_root_tree:
		open_roottreefile_for_writing()

def read_config_file_for_xrm_stuff():
	#global plot_continuous
	#plot_continuous = read_integer_from_config_file_or_use_default("plot_continuous", 0)
	global be_verbose_when_collecting_data
	be_verbose_when_collecting_data = read_integer_from_config_file_or_use_default("be_verbose_when_collecting_data", 0)
	global datafilesize
	datafilesize = read_integer_from_config_file_or_use_default("datafilesize", 100000000)
	global xrm_run_continuous
	xrm_run_continuous = read_integer_from_config_file_or_use_default("xrm_run_continuous", 0)
	global retake_pedestals_at_every_filechange
	retake_pedestals_at_every_filechange = read_integer_from_config_file_or_use_default("retake_pedestals_at_every_filechange", 0)
	global xrm_mode
	xrm_mode = read_string_from_config_file_or_use_default("xrm_mode", "acquire")
	global number_of_physical_windows_to_plot
	if "sweep"==xrm_mode:
		#number_of_physical_windows_to_plot = 427
		number_of_physical_windows_to_plot = 64
	else:
		number_of_physical_windows_to_plot = 1
	#info(xrm_mode)
	global show_plot
	show_plot = read_integer_from_config_file_or_use_default("show_plot", 0)
	global use_pedestal_subtraction_mode
	use_pedestal_subtraction_mode = read_integer_from_config_file_or_use_default("use_pedestal_subtraction_mode", 1)
	global desired_pause_between_acquisitions
	desired_pause_between_acquisitions = read_integer_from_config_file_or_use_default("desired_pause_between_acquisitions", 0)
	global should_cycle_slowly_through_bunch_markers
	should_cycle_slowly_through_bunch_markers = read_integer_from_config_file_or_use_default("should_cycle_slowly_through_bunch_markers", 0)
	global desired_RF_bucket
	desired_RF_bucket = read_integer_from_config_file_or_use_default("desired_RF_bucket", 1701)
	global RF_bucket_sample_offset
	RF_bucket_sample_offset = read_float_from_config_file_or_use_default("RF_bucket_sample_offset", 0)
	global multicast_cal_signal
	multicast_cal_signal = read_integer_from_config_file_or_use_default("multicast_cal_signal", 1)
	global enable_cal_signal
	enable_cal_signal = read_integer_from_config_file_or_use_default("enable_cal_signal", 1)
	global should_cycle_calibration_channel
	should_cycle_calibration_channel = read_integer_from_config_file_or_use_default("should_cycle_calibration_channel", 0)
	global sweep_start_bucket
	sweep_start_bucket = read_integer_from_config_file_or_use_default("sweep_start_bucket", 4)
	global sweep_end_bucket
	sweep_end_bucket = read_integer_from_config_file_or_use_default("sweep_end_bucket", 772)
	#sweep_end_bucket = read_integer_from_config_file_or_use_default("sweep_end_bucket", 5116)
	global oserdes_always_value
	oserdes_always_value = read_binary_value_from_config_file_or_use_default("oserdes_always_value", 0b00000000)
	global oserdes_triggered_value
	oserdes_triggered_value = read_binary_value_from_config_file_or_use_default("oserdes_triggered_value", 0b00011000)
	#info(str(oserdes_always_value))
	#info(str(oserdes_triggered_value))
	global should_plot_beam_current
	should_plot_beam_current = read_integer_from_config_file_or_use_default("should_plot_beam_current", 0)
	global plot_width
	plot_width = read_integer_from_config_file_or_use_default("plot_width", 1450)
	global plot_height
	plot_height = read_integer_from_config_file_or_use_default("plot_height", 650)
	global beam_current_plot_width
	beam_current_plot_width = float(plot_width * 0.25)
	global beam_current_plot_height
	beam_current_plot_height = float(plot_height * 0.06)
	global should_show_stacked_waveform
	should_show_stacked_waveform = read_integer_from_config_file_or_use_default("should_show_stacked_waveform", 0)
	global should_write_root_tree
	should_write_root_tree = read_integer_from_config_file_or_use_default("should_write_root_tree", 0)
	if should_write_root_tree and not should_use_ROOT:
		print_ROOT_usage()
		#should_write_root_tree = 0
	global parsedir
	parsedir = read_string_from_config_file_or_use_default("parsedir", "")
	global carriers_to_use
	carriers_to_use = read_string_from_config_file_or_use_default("carriers_to_use", "02")
	strings = re.split("([0-3])", carriers_to_use)
	#info("carriers_to_use: " + str(strings))
	values = []
	for string in strings:
		if ''==string:
			continue
		values.append(int(string))
	#info("carriers_to_use: " + str(values))
	global carriers_to_dejuice
	carriers_to_dejuice = []
	for carrier in range(4):
		if not carrier in values:
			carriers_to_dejuice.append(carrier)
	#info("carriers_to_dejuice: " + str(carriers_to_dejuice))
	#sys.exit(0)
	global station
	station = read_string_from_config_file_or_use_default("station", "TST")

#def set_desired_event_numbers(desired_event_numbers):
#	global desired_event_numbers
#	desired_event_numbers = desired_event_numbers

def set_global_trig_prescale_N_log2(desired_trig_prescale_N_log2):
	global trig_prescale_N_log2
	trig_prescale_N_log2 = desired_trig_prescale_N_log2

def xrm_run(BS):
	set_verbosity(3)
	#show_xrm_mapping()
	#sys.exit(0)
	calculate_parameters(6, 0)
	read_config_file_for_xrm_stuff()
	if "parse"==xrm_mode:
		parse_all_datafiles_and_plot_all_waveformfiles_in_this_dirtree(parsedir, 0)
		#parse_all_datafiles_and_plot_all_waveformfiles_in_this_dirtree(parsedir, 1)
	else: #if "sweep"==xrm_mode or "acquire"==xrm_mode or "pedestal"==xrm_mode:
		if "reconfig"==xrm_mode:
			clear_configuration_status(BS)
		if "coolrunning"==xrm_mode:
			carriers_to_use=""
			global carriers_to_dejuice
			carriers_to_dejuice = [ 0, 1, 2, 3 ]
			for carrier in carriers_to_dejuice:
				write_register(CARRIER_PS_ampRegEn, 0, BS, carrier)
				write_register(CARRIER_PS_ampEn, 0, BS, carrier)
				for asic in range(4):
					juice.juice_asic(BS, carrier, asic, "off")
			wait_for_PS_on_each_carrier_to_pick_up_the_changes(BS)
			return
		if not has_configuration_has_been_done_yet_on_all_carriers(BS):
			configure_boardstack(BS, 0) # trueROI but skips the setup_DLL step
			configure_boardstack(BS, 1) # fast
			take_pedestals(BS)
			#configure_boardstack_then_acquire_and_check_pedestals(BS)
			for carrier in carriers_to_dejuice:
				#info(str(carrier))
#				juice.juice_carrier(BS, carrier, juice.map_c(carrier))
				write_register(CARRIER_PS_ampRegEn, 0, BS, carrier)
				write_register(CARRIER_PS_ampEn, 0, BS, carrier)
				for asic in range(4):
					juice.juice_asic(BS, carrier, asic, "off")
			wait_for_PS_on_each_carrier_to_pick_up_the_changes(BS)
		if "pedestal"==xrm_mode:
			take_pedestals_and_read_them_out_etc(BS)
			return
		if "reconfig"==xrm_mode:
			return
		#take_pedestals(BS)
		#info(juice.verify_juice(BS))
		#config1boardstack_fast(BS)
		#prep1boardstack_data_trueROI(BS)
		#sys.exit(0)
		set_global_trig_prescale_N_log2(1)
		#global number_of_events_to_acquire_at_a_time 
		#number_of_events_to_acquire_at_a_time = N * count_frame_masks()
		setup_xrm_mode(BS)
		generate_new_datafilename()
		#generate_histogram_of_trigger_rate_versus_prescale_N_log2(0, 18)
		# 0 doesn't work reliably (gets ~56 events out of every 100 triggers)
		# 1 doesn't work reliably (gets ~98 events out of every 100 triggers)
		#number_of_events_to_acquire_at_a_time = 250
		#trig_prescale_N_log2 = 2
		# can handle 3 consecutive revolutions (in frame mask) with 256 waveforms out (1 bunch marker active only)
		if "sweep"==xrm_mode:
			sweep_bunch_marker_positions_and_take_data_at_each_position()
		else:
			N = 1
			desired_event_numbers = [ 0 ]
			get_triggered_data(N, count_frame_masks(), trig_prescale_N_log2, desired_event_numbers)
		#sweep_bunch_marker_positions()
		#show_relevant_registers()
		#setup_xrm_trigger()
		#enable_xrm_triggers()
		#show_xrm_trigger_enable_status()
		#set_desired_trigger_quantities(1, 2, 3, 4)

def main():
	parse_standard_argv_options_and_check_numcarrier_on_boardstacks()
	run_this_command_on_all_BS_and_log_results_to_file(xrm_run)

if __name__ == "__main__":
	main()