def __init__(self, parent, gateName, tofs, tofl, tofs_dict, tofl_dict):
self.parent = parent
self.gateName = gateName
self.tofs = tofs
self.tofl = tofl
self.tofs_dict = tofs_dict
self.tofl_dict = tofl_dict
self.tofbin = self.parent.monitor_params['t']['bin']
print self.tofs_dict, self.tofl_dict
self.tof_ind = (self.parent.TaxisM > self.tofs) & (self.parent.TaxisM <
self.tofl)
self.particle = self.gateName
self.extractE = extractE
self.alg = PyAlgos()
self.alg.set_peak_selection_pars(npix_min=self.parent.npix_min,
npix_max=self.parent.npix_max,
amax_thr=self.parent.amax_thr,
atot_thr=self.parent.atot_thr,
son_min=self.parent.son_min)
self.init_vars()
def __init__(self, source, monitor_params):
super(Coin, self).__init__(map_func=self.process_data,
reduce_func=self.reduce,save_func=self.save_data,
source=source, monitor_params=monitor_params)
import psana
self.monitor_params = monitor_params
self.init_params(monitor_params)
self.e_cols = self.eimg_center_y - self.e_radius
self.e_coll = self.eimg_center_y + self.e_radius+1
self.e_rows = self.eimg_center_x - self.e_radius
self.e_rowl = self.eimg_center_x + self.e_radius+1
self.e_center_y = self.eimg_center_y
self.e_center_x = self.eimg_center_x
self.mask = np.ones([1024,1024])
self.mask[350:650, 350:650] = 0
self.mask[:, :350] = 0
#self.alg = PyAlgos(mask = self.mask)
self.alg = PyAlgos()
self.alg.set_peak_selection_pars(npix_min=self.npix_min, npix_max=self.npix_max, amax_thr=self.amax_thr, atot_thr=self.atot_thr, son_min=self.son_min)
self.speed_rep_int = self.params_gen['speed_report_interval']
self.old_time = time.time()
self.time = None
print('Starting worker: {0}.'.format(self.mpi_rank))
sys.stdout.flush()
return
def __init__(self, parent, gateName, tof1s, tof1l, tof2s, tof2l, tof3s,
tof3l, thresh1_n3n1, thresh2_n3n1, thresh1_n3n2, thresh2_n3n2,
ang_f):
self.parent = parent
self.gateName = gateName
self.tof1s = tof1s
self.tof1l = tof1l
self.tof2s = tof2s
self.tof2l = tof2l
self.tof3s = tof3s
self.tof3l = tof3l
self.extractE = extractE
self.PiPiCo_ind1 = (self.parent.TaxisM >
self.tof1s) & (self.parent.TaxisM < self.tof1l)
self.PiPiCo_ind2 = (self.parent.TaxisM >
self.tof2s) & (self.parent.TaxisM < self.tof2l)
self.PiPiCo_ind3 = (self.parent.TaxisM >
self.tof3s) & (self.parent.TaxisM < self.tof3l)
self.thresh1 = {}
self.thresh2 = {}
self.thresh1['n3n1'] = thresh1_n3n1
self.thresh1['n3n2'] = thresh1_n3n2
self.thresh2['n3n1'] = thresh2_n3n1
self.thresh2['n3n2'] = thresh2_n3n2
self.ang_f = ang_f
self.cos_theta_f1 = np.cos(0.5 * self.ang_f * np.pi / 180)
self.cos_theta_f2 = np.cos((90 - 0.5 * self.ang_f) * np.pi / 180)
self.cos_theta_f3 = -np.cos((90 - 0.5 * self.ang_f) * np.pi / 180)
self.cos_theta_f4 = -np.cos(0.5 * self.ang_f * np.pi / 180)
self.particle1 = self.gateName[:2]
self.particle2 = self.gateName[2:4]
self.particle3 = self.gateName[4:6]
self.alg = PyAlgos()
self.alg.set_peak_selection_pars(npix_min=self.parent.npix_min,
npix_max=self.parent.npix_max,
amax_thr=self.parent.amax_thr,
atot_thr=self.parent.atot_thr,
son_min=self.parent.son_min)
self.init_vars()
def __init__(self,
exp,
run,
detname,
evt,
detector,
algorithm,
hitParam_alg_npix_min,
hitParam_alg_npix_max,
hitParam_alg_amax_thr,
hitParam_alg_atot_thr,
hitParam_alg_son_min,
streakMask_on,
streakMask_sigma,
streakMask_width,
userMask_path,
psanaMask_on,
psanaMask_calib,
psanaMask_status,
psanaMask_edges,
psanaMask_central,
psanaMask_unbond,
psanaMask_unbondnrs,
medianFilterOn=0,
medianRank=5,
radialFilterOn=0,
distance=0.0,
windows=None,
**kwargs):
self.exp = exp
self.run = run
self.detname = detname
self.det = detector
self.algorithm = algorithm
self.maxRes = 0
self.npix_min = hitParam_alg_npix_min
self.npix_max = hitParam_alg_npix_max
self.amax_thr = hitParam_alg_amax_thr
self.atot_thr = hitParam_alg_atot_thr
self.son_min = hitParam_alg_son_min
self.streakMask_on = str2bool(streakMask_on)
self.streakMask_sigma = streakMask_sigma
self.streakMask_width = streakMask_width
self.userMask_path = userMask_path
self.psanaMask_on = str2bool(psanaMask_on)
self.psanaMask_calib = str2bool(psanaMask_calib)
self.psanaMask_status = str2bool(psanaMask_status)
self.psanaMask_edges = str2bool(psanaMask_edges)
self.psanaMask_central = str2bool(psanaMask_central)
self.psanaMask_unbond = str2bool(psanaMask_unbond)
self.psanaMask_unbondnrs = str2bool(psanaMask_unbondnrs)
self.medianFilterOn = medianFilterOn
self.medianRank = medianRank
self.radialFilterOn = radialFilterOn
self.distance = distance
self.windows = windows
self.userMask = None
self.psanaMask = None
self.streakMask = None
self.userPsanaMask = None
self.combinedMask = None
# Make user mask
if self.userMask_path is not None:
self.userMask = np.load(self.userMask_path)
# Make psana mask
if self.psanaMask_on:
self.psanaMask = detector.mask(evt,
calib=self.psanaMask_calib,
status=self.psanaMask_status,
edges=self.psanaMask_edges,
central=self.psanaMask_central,
unbond=self.psanaMask_unbond,
unbondnbrs=self.psanaMask_unbondnrs)
# Combine userMask and psanaMask
self.userPsanaMask = np.ones_like(self.det.calib(evt))
if self.userMask is not None:
self.userPsanaMask *= self.userMask
if self.psanaMask is not None:
self.userPsanaMask *= self.psanaMask
# Powder of hits and misses
self.powderHits = np.zeros_like(self.userPsanaMask)
self.powderMisses = np.zeros_like(self.userPsanaMask)
self.alg = PyAlgos(windows=self.windows,
mask=self.userPsanaMask,
pbits=0)
# set peak-selector parameters:
self.alg.set_peak_selection_pars(npix_min=self.npix_min, npix_max=self.npix_max, \
amax_thr=self.amax_thr, atot_thr=self.atot_thr, \
son_min=self.son_min)
# set algorithm specific parameters
if algorithm == 1:
self.hitParam_alg1_thr_low = kwargs["alg1_thr_low"]
self.hitParam_alg1_thr_high = kwargs["alg1_thr_high"]
self.hitParam_alg1_rank = int(kwargs["alg1_rank"])
self.hitParam_alg1_radius = int(kwargs["alg1_radius"])
self.hitParam_alg1_dr = kwargs["alg1_dr"]
elif algorithm == 3:
self.hitParam_alg3_rank = kwargs["alg3_rank"]
self.hitParam_alg3_r0 = int(kwargs["alg3_r0"])
self.hitParam_alg3_dr = kwargs["alg3_dr"]
elif algorithm == 4:
self.hitParam_alg4_thr_low = kwargs["alg4_thr_low"]
self.hitParam_alg4_thr_high = kwargs["alg4_thr_high"]
self.hitParam_alg4_rank = int(kwargs["alg4_rank"])
self.hitParam_alg4_r0 = int(kwargs["alg4_r0"])
self.hitParam_alg4_dr = kwargs["alg4_dr"]
self.maxNumPeaks = 2048
self.StreakMask = myskbeam.StreakMask(self.det,
evt,
width=self.streakMask_width,
sigma=self.streakMask_sigma)
self.cx, self.cy = self.det.point_indexes(evt, pxy_um=(0, 0))
self.iX = np.array(self.det.indexes_x(evt), dtype=np.int64)
self.iY = np.array(self.det.indexes_y(evt), dtype=np.int64)
if len(self.iX.shape) == 2:
self.iX = np.expand_dims(self.iX, axis=0)
self.iY = np.expand_dims(self.iY, axis=0)
# Initialize radial background subtraction
self.setupExperiment()
if self.radialFilterOn:
self.setupRadialBackground()
self.updatePolarizationFactor()
def updateClassification(self):
if self.parent.calib is not None:
if self.parent.mk.streakMaskOn:
self.parent.mk.initMask()
self.parent.mk.streakMask = self.parent.mk.StreakMask.getStreakMaskCalib(self.parent.evt)
if self.parent.mk.streakMask is None:
self.parent.mk.streakMaskAssem = None
else:
self.parent.mk.streakMaskAssem = self.parent.det.image(self.parent.evt, self.parent.mk.streakMask)
self.algInitDone = False
self.parent.mk.displayMask()
# update combined mask
self.parent.mk.combinedMask = np.ones_like(self.parent.calib)
if self.parent.mk.streakMask is not None and self.parent.mk.streakMaskOn is True:
self.parent.mk.combinedMask *= self.parent.mk.streakMask
if self.parent.mk.userMask is not None and self.parent.mk.userMaskOn is True:
self.parent.mk.combinedMask *= self.parent.mk.userMask
if self.parent.mk.psanaMask is not None and self.parent.mk.psanaMaskOn is True:
self.parent.mk.combinedMask *= self.parent.mk.psanaMask
# Peak output (0-16):
# 0 seg
# 1 row
# 2 col
# 3 npix: no. of pixels in the ROI intensities above threshold
# 4 amp_max: max intensity
# 5 amp_tot: sum of intensities
# 6,7: row_cgrav: center of mass
# 8,9: row_sigma
# 10,11,12,13: minimum bounding box
# 14: background
# 15: noise
# 16: signal over noise
if self.algorithm == 0: # No peak algorithm
self.peaks = None
self.drawPeaks()
else:
# Only initialize the hit finder algorithm once
if self.algInitDone is False:
self.windows = None
self.alg = []
self.alg = PyAlgos(windows=self.windows, mask=self.parent.mk.combinedMask, pbits=0)
# set peak-selector parameters:
if self.algorithm == 1:
self.alg.set_peak_selection_pars(npix_min=self.hitParam_alg1_npix_min, npix_max=self.hitParam_alg1_npix_max, \
amax_thr=self.hitParam_alg1_amax_thr, atot_thr=self.hitParam_alg1_atot_thr, \
son_min=self.hitParam_alg1_son_min)
elif self.algorithm == 2:
self.alg.set_peak_selection_pars(npix_min=self.hitParam_alg2_npix_min, npix_max=self.hitParam_alg2_npix_max, \
amax_thr=self.hitParam_alg2_amax_thr, atot_thr=self.hitParam_alg2_atot_thr, \
son_min=self.hitParam_alg2_son_min)
elif self.algorithm == 3:
self.alg.set_peak_selection_pars(npix_min=self.hitParam_alg3_npix_min, npix_max=self.hitParam_alg3_npix_max, \
amax_thr=self.hitParam_alg3_amax_thr, atot_thr=self.hitParam_alg3_atot_thr, \
son_min=self.hitParam_alg3_son_min)
elif self.algorithm == 4:
self.alg.set_peak_selection_pars(npix_min=self.hitParam_alg4_npix_min, npix_max=self.hitParam_alg4_npix_max, \
amax_thr=self.hitParam_alg4_amax_thr, atot_thr=self.hitParam_alg4_atot_thr, \
son_min=self.hitParam_alg4_son_min)
self.algInitDone = True
self.parent.calib = self.parent.calib * 1.0 # Neccessary when int is returned
if self.algorithm == 1:
# v1 - aka Droplet Finder - two-threshold peak-finding algorithm in restricted region
# around pixel with maximal intensity.
self.peakRadius = int(self.hitParam_alg1_radius)
self.peaks = self.alg.peak_finder_v4r2(self.parent.calib,
thr_low=self.hitParam_alg1_thr_low,
thr_high=self.hitParam_alg1_thr_high,
rank=int(self.hitParam_alg1_rank),
r0=self.peakRadius,
dr=self.hitParam_alg1_dr)
elif self.algorithm == 2:
# v2 - define peaks for regions of connected pixels above threshold
self.peakRadius = int(self.hitParam_alg2_r0)
self.peaks = self.alg.peak_finder_v2(self.parent.calib, thr=self.hitParam_alg2_thr, r0=self.peakRadius, dr=self.hitParam_alg2_dr)
elif self.algorithm == 3:
self.peakRadius = int(self.hitParam_alg3_r0)
self.peaks = self.alg.peak_finder_v3(self.parent.calib, rank=self.hitParam_alg3_rank, r0=self.peakRadius, dr=self.hitParam_alg3_dr)
elif self.algorithm == 4:
# v4 - aka Droplet Finder - the same as v1, but uses rank and r0 parameters in stead of common radius.
self.peakRadius = int(self.hitParam_alg4_r0)
self.peaks = self.alg.peak_finder_v4(self.parent.calib, thr_low=self.hitParam_alg4_thr_low, thr_high=self.hitParam_alg4_thr_high,
rank=self.hitParam_alg4_rank, r0=self.peakRadius, dr=self.hitParam_alg4_dr)
self.numPeaksFound = self.peaks.shape[0]
if self.parent.args.v >= 1: print "Num peaks found: ", self.numPeaksFound, self.peaks.shape
# update clen
self.parent.geom.updateClen('lcls')
self.parent.index.clearIndexedPeaks()
# Save image and peaks in cheetah cxi file
self.saveCheetahFormat('lcls')
if self.parent.index.showIndexedPeaks: self.parent.index.updateIndex()
self.drawPeaks()
if self.parent.args.v >= 1: print "Done updateClassification"
import psana
ds = psana.DataSource('exp=xpptut15:run=54:smd')
det = psana.Detector('cspad')
from ImgAlgos.PyAlgos import PyAlgos
alg = PyAlgos()
for nevent, evt in enumerate(ds.events()):
if nevent >= 2: break
nda = det.calib(evt)
if nda is None: continue
thr = 20
numpix = alg.number_of_pix_above_thr(nda, thr)
totint = alg.intensity_of_pix_above_thr(nda, thr)
print '%d pixels have total intensity %5.1f above threshold %5.1f' % (
numpix, totint, thr)
winds_bkgd = [(s, 10, 100, 270, 370) for s in (4,12,20,28)] # use part of segments 4 and 20 to subtr bkgd winds_arc = [(s, 0, 185, 0, 388) for s in (0,7,8,15)] winds_equ = [(s, 0, 185, 0, 388) for s in (0,1,9,15,16,17,25,31)] winds_tot = [(s, 0, 185, 0, 388) for s in (0,1,7,8,9,15,16,17,23,24,25,31)] mask_winds_tot = np.zeros(shape_cspad, dtype=np.int16) mask_winds_tot[(0,1,7,8,9,15,16,17,23,24,25,31),:,:] = seg1 #mask_winds_equ[(0,1,9,15,16,17,25,31),:,:] = seg1 #mask_winds_arc[(0,7,8,15),:,:] = seg1 print_arr(winds_arc, 'winds_arc') print_arr_attr(winds_arc, 'winds_arc') alg_arc = PyAlgos(windows=winds_arc, mask=mask_arc, pbits=2) alg_arc.set_peak_selection_pars(npix_min=0, npix_max=1e6, amax_thr=0, atot_thr=0, son_min=10) #alg_arc.set_peak_selection_pars(npix_min=0, npix_max=1e6, amax_thr=0, atot_thr=500, son_min=6) # for v2r1 alg_equ = PyAlgos(windows=winds_equ, mask=mask_equ, pbits=0) alg_equ.set_peak_selection_pars(npix_min=0, npix_max=1e6, amax_thr=0, atot_thr=0, son_min=10) #alg_equ.set_peak_selection_pars(npix_min=0, npix_max=1e6, amax_thr=0, atot_thr=500, son_min=6) # for v2r1 #alg_equ.print_attributes() #alg_equ.print_input_pars() ##----------------------------- xoffset, yoffset = 300, 300 xsize, ysize = 1150, 1150
def __init__(self, source, monitor_params):
super(Onda, self).__init__(map_func=self.process_data,
reduce_func=self.collect_data,
source=source, monitor_params=monitor_params)
import psana
self.npix_min, self.npix_max= monitor_params['Opal']['npix_min'],monitor_params['Opal']['npix_max']
self.amax_thr, self.atot_thr, self.son_min = monitor_params['Opal']['amax_thr'], monitor_params['Opal']['atot_thr'], monitor_params['Opal']['son_min']
self.thr_low, self.thr_high = monitor_params['Opal']['thr_low'], monitor_params['Opal']['thr_high']
self.rank, self.r0, self.dr = monitor_params['Opal']['rank'], monitor_params['Opal']['r0'], monitor_params['Opal']['dr']
self.e_center_x, self.e_center_y = monitor_params['Opal']['e_center_x'],monitor_params['Opal']['e_center_y']
print 'coin_point1'
self.params_gen = monitor_params['General']
self.params_peakfinder_t, self.params_peakfinder_x, self.params_peakfinder_y = monitor_params['PeakFinderMcp'], monitor_params['PeakFinderX'], monitor_params['PeakFinderY']
self.params_hitfinder = monitor_params['HitFinder']
self.output_params = monitor_params['OutputLayer']
self.offset_acq = [0.01310443,0.02252858,0.02097541,0.01934959,-0.0001188]
self.t_channel = monitor_params['DetectorLayer']['mcp_channel']
self.x1_channel = monitor_params['DetectorLayer']['x1_channel']
self.x2_channel = monitor_params['DetectorLayer']['x2_channel']
self.y1_channel = monitor_params['DetectorLayer']['y1_channel']
self.y2_channel = monitor_params['DetectorLayer']['y2_channel']
#################################################################
self.Xmin, self.Ymin, self.Tmin = monitor_params['OutputLayer']['xmin'],monitor_params['OutputLayer']['ymin'],monitor_params['OutputLayer']['tmin']
self.Xmax, self.Ymax, self.Tmax = monitor_params['OutputLayer']['xmax'],monitor_params['OutputLayer']['ymax'],monitor_params['OutputLayer']['tmax']
self.Xbin, self.Ybin, self.Tbin = monitor_params['OutputLayer']['xbin'],monitor_params['OutputLayer']['ybin'],monitor_params['OutputLayer']['tbin']
self.Xbinnum = int((self.Xmax - self.Xmin)/self.Xbin)
self.Ybinnum = int((self.Ymax - self.Ymin)/self.Ybin)
self.Tbinnum = int((self.Tmax - self.Tmin)/self.Tbin)
self.Xaxis = np.linspace(self.Xmin, self.Xmax, self.Xbinnum)
self.Yaxis = np.linspace(self.Ymin, self.Ymax, self.Ybinnum)
self.Taxis = np.linspace(self.Tmin, self.Tmax, self.Tbinnum)
self.Xaxis_r = self.Xaxis[::-1]
self.Yaxis_r = self.Yaxis[::-1]
self.Taxis_r = self.Taxis[::-1]
self.XaxisM = (self.Xaxis[:-1] + self.Xaxis[1:])/2
self.YaxisM = (self.Yaxis[:-1] + self.Yaxis[1:])/2
self.TaxisM = (self.Taxis[:-1] + self.Taxis[1:])/2
self.eXmin, self.eYmin, self.eRmin, self.eAmin = monitor_params['OutputLayer']['exmin'],monitor_params['OutputLayer']['eymin'],monitor_params['OutputLayer']['ermin'],monitor_params['OutputLayer']['eamin']
self.eXmax, self.eYmax, self.eRmax, self.eAmax = monitor_params['OutputLayer']['exmax'],monitor_params['OutputLayer']['eymax'],monitor_params['OutputLayer']['ermax'],monitor_params['OutputLayer']['eamax']
self.eXbin, self.eYbin, self.eRbin, self.eAbin = monitor_params['OutputLayer']['exbin'],monitor_params['OutputLayer']['eybin'],monitor_params['OutputLayer']['erbin'],monitor_params['OutputLayer']['eabin']
self.photon_eng_bin, self.pulse_eng_bin = monitor_params['OutputLayer']['photon_eng_bin'],monitor_params['OutputLayer']['pulse_eng_bin']
self.photon_eng_min, self.pulse_eng_min = monitor_params['OutputLayer']['photon_eng_min'],monitor_params['OutputLayer']['pulse_eng_min']
self.photon_eng_max, self.pulse_eng_max = monitor_params['OutputLayer']['photon_eng_max'],monitor_params['OutputLayer']['pulse_eng_max']
self.photon_eng_binnum = int((self.photon_eng_max - self.photon_eng_min)/self.photon_eng_bin)
self.pulse_eng_binnum = int((self.pulse_eng_max - self.pulse_eng_min)/self.pulse_eng_bin)
self.photon_eng_axis = np.linspace(self.photon_eng_min, self.photon_eng_max, self.photon_eng_binnum)
self.pulse_eng_axis = np.linspace(self.pulse_eng_min, self.pulse_eng_max, self.pulse_eng_binnum)
self.eXbinnum = int((self.eXmax - self.eXmin)/self.eXbin)
self.eYbinnum = int((self.eYmax - self.eYmin)/self.eYbin)
self.eAbinnum = int((self.eAmax - self.eAmin)/self.eAbin)
self.eRbinnum = int((self.eRmax - self.eRmin)/self.eRbin)
print 'binnum:', self.eXbinnum, self.eYbinnum
self.eXaxis = np.linspace(self.eXmin, self.eXmax, self.eXbinnum)
self.eYaxis = np.linspace(self.eYmin, self.eYmax, self.eYbinnum)
self.eAaxis = np.linspace(self.eAmin, self.eAmax, self.eAbinnum)
self.eRaxis = np.linspace(self.eRmin, self.eRmax, self.eRbinnum)
self.eXaxis_r = self.eXaxis[::-1]
self.eYaxis_r = self.eYaxis[::-1]
self.eAaxis_r = self.eAaxis[::-1]
self.eRaxis_r = self.eRaxis[::-1]
self.eXaxisM = (self.eXaxis[:-1] + self.eXaxis[1:])/2
self.eYaxisM = (self.eYaxis[:-1] + self.eYaxis[1:])/2
self.eAaxisM = (self.eAaxis[:-1] + self.eAaxis[1:])/2
self.eRaxisM = (self.eRaxis[:-1] + self.eRaxis[1:])/2
self.pho_pls_eng = np.zeros([self.photon_eng_binnum-1 , self.pulse_eng_binnum-1])
self.eXY = np.zeros([self.photon_eng_binnum-1 , self.pulse_eng_binnum-1, self.eXbinnum-1, self.eYbinnum-1])
self.eAR = np.zeros([self.photon_eng_binnum-1 , self.pulse_eng_binnum-1, self.eAbinnum-1, self.eRbinnum-1])
self.eA = np.zeros([self.photon_eng_binnum-1 , self.pulse_eng_binnum-1, self.eAbinnum-1])
self.eR = np.zeros([self.photon_eng_binnum-1 , self.pulse_eng_binnum-1, self.eRbinnum-1])
self.PeakFinderT = AcqirisPeakFinder(self.params_peakfinder_t)
self.PeakFinderX = AcqirisPeakFinder(self.params_peakfinder_x)
self.PeakFinderY = AcqirisPeakFinder(self.params_peakfinder_y)
self.hit_list = []
self.HitFinder = BasicHitFinder(self.params_hitfinder)
self.num_events_all = 0
self.mask = np.ones([1024,1024])
self.mask[350:650, 350:650] = 0
self.mask[:, :350] = 0
self.alg = PyAlgos()
self.alg.set_peak_selection_pars(npix_min=self.npix_min, npix_max=self.npix_max, amax_thr=self.amax_thr, atot_thr=self.atot_thr, son_min=self.son_min)
if self.role == 'master':
self.collected_data = {}
self.publish_ip = self.params_gen['publish_ip']
self.publish_port = self.params_gen['publish_port']
self.speed_rep_int = self.params_gen['speed_report_interval']
self.accumulated_shots = self.params_gen['accumulated_shots']
self.peaks_to_send_string = self.params_gen['peaks_to_send'].split(',')
self.peaks_to_send = (int(self.peaks_to_send_string[0]),
int(self.peaks_to_send_string[1]))
print('Starting the monitor...')
sys.stdout.flush()
zmq_mon.init_zmq_to_gui(self, self.publish_ip, self.publish_port)
self.num_events = 0
self.old_time = time.time()
self.time = None
self.data_accumulator = []
if self.role == 'worker':
self.XYw = np.zeros([self.Xbinnum-1, self.Ybinnum-1])
self.eXYw = np.zeros([self.eXbinnum-1, self.eYbinnum-1])
self.eARw = np.zeros([self.eAbinnum-1, self.eRbinnum-1])
self.eRw = np.zeros([1, self.eRbinnum-1])
self.eAw = np.zeros([1, self.eAbinnum-1])
self.Tofw = np.zeros([1, self.Tbinnum-1])
self.XTw = np.zeros([self.Tbinnum-1, self.Xbinnum-1])
self.YTw = np.zeros([self.Tbinnum-1, self.Ybinnum-1])
self.TSumXw = np.zeros([self.Tbinnum-1,1])
self.TSumYw = np.zeros([self.Tbinnum-1,1])
self.PiPiCow = np.zeros([self.Tbinnum-2,self.Tbinnum-2])
self.results_dict = {}
print('Starting worker: {0}.'.format(self.mpi_rank))
sys.stdout.flush()
return
