def addPhaseDiffToOffsets(self):
for bpm_ind in range(len(self.em_bpm_wrpprs)):
bpm_wrapper = self.em_bpm_wrpprs[bpm_ind]
if (self.use_bpms[bpm_ind]):
self.bpm_phase_offsets[bpm_ind] += calculateAvgErr(
self.bpm_phase_diff_arr[bpm_ind])[0]
self.bpm_phase_offsets[bpm_ind] = makePhaseNear(
self.bpm_phase_offsets[bpm_ind], 0.)
def calculatePhaseOffsets(self,eKin_ring): mass = self.scl_long_tuneup_controller.mass/1.0e+6 c_light = self.scl_long_tuneup_controller.c_light bpm_freq = self.scl_long_tuneup_controller.bpm_freq beta = math.sqrt(eKin_ring*(eKin_ring+2*mass))/(eKin_ring+mass) slope = 360.0*bpm_freq/(c_light*beta) if(len(self.bpm_wrappers_arr) < 2): return false base_bpm_wrapper = self.bpm_wrappers_arr[0] (base_bpm_phase,base_bpm_phase_err) = calculateAvgErr(self.bpm_amp_phase_data_dict[base_bpm_wrapper][1]) for bpm_wrapper in self.bpm_wrappers_arr: pos = bpm_wrapper.pos - base_bpm_wrapper.pos (phase,phase_err) = calculateAvgErr(self.bpm_amp_phase_data_dict[bpm_wrapper][1]) phase_diff = makePhaseNear(phase - base_bpm_phase - slope*pos,0.) bpm_wrapper.right_phase_offset.phaseOffset_avg = phase_diff bpm_wrapper.right_phase_offset.phaseOffset_err = phase_err bpm_wrapper.right_phase_offset.isReady = true scl_long_tuneup_bpm_offsets_controller = self.scl_long_tuneup_controller.scl_long_tuneup_bpm_offsets_controller scl_long_tuneup_bpm_offsets_controller.bpm_offsets_table.getModel().fireTableDataChanged()
def calculatePhaseOffsets(self,eKin_ring): mass = self.scl_long_tuneup_controller.mass/1.0e+6 c_light = self.scl_long_tuneup_controller.c_light bpm_freq = self.scl_long_tuneup_controller.bpm_freq beta = math.sqrt(eKin_ring*(eKin_ring+2*mass))/(eKin_ring+mass) slope = 360.0*bpm_freq/(c_light*beta) if(len(self.bpm_wrappers_arr) < 2): return false base_bpm_wrapper = self.bpm_wrappers_arr[0] (base_bpm_phase,base_bpm_phase_err) = calculateAvgErr(self.bpm_amp_phase_data_dict[base_bpm_wrapper][1]) for bpm_wrapper in self.bpm_wrappers_arr: pos = bpm_wrapper.pos - base_bpm_wrapper.pos (phase,phase_err) = calculateAvgErr(self.bpm_amp_phase_data_dict[bpm_wrapper][1]) phase_diff = makePhaseNear(phase - base_bpm_phase - slope*pos,0.) bpm_wrapper.right_phase_offset.phaseOffset_avg = phase_diff bpm_wrapper.right_phase_offset.phaseOffset_err = phase_err bpm_wrapper.right_phase_offset.isReady = true scl_long_tuneup_bpm_offsets_controller = self.scl_long_tuneup_controller.scl_long_tuneup_bpm_offsets_controller scl_long_tuneup_bpm_offsets_controller.bpm_offsets_table.getModel().fireTableDataChanged()
def run(self):
mass = self.scl_long_tuneup_controller.mass/1.0e+6
c_light = self.scl_long_tuneup_controller.c_light
ring_length = self.scl_long_tuneup_controller.ring_length
messageTextField = self.scl_long_tuneup_controller.getMessageTextField()
if(messageTextField != null):
messageTextField.setText("")
scl_long_tuneup_bpm_offsets_controller = self.scl_long_tuneup_controller.scl_long_tuneup_bpm_offsets_controller
bpms_offsets_from_hebt1_panel = scl_long_tuneup_bpm_offsets_controller.bpms_offsets_from_hebt1_panel
n_iter = int(bpms_offsets_from_hebt1_panel.iter_text.getValue())
iter_left_text = bpms_offsets_from_hebt1_panel.iter_left_text
ring_energy_text = bpms_offsets_from_hebt1_panel.ring_energy_text
ring_energy_err_text = bpms_offsets_from_hebt1_panel.ring_energy_err_text
ca_ring_freq = ChannelFactory.defaultFactory().getChannel("Ring_Diag:BCM_D09:FFT_peak2")
scl_long_tuneup_init_controller = self.scl_long_tuneup_controller.scl_long_tuneup_init_controller
scl_long_tuneup_init_controller.connectAllBPMs()
bpmBatchReader = self.scl_long_tuneup_controller.bpmBatchReader
beamTrigger = self.scl_long_tuneup_controller.beamTrigger
statistic_state_controller = bpms_offsets_from_hebt1_panel.statistic_state_controller
beamTrigger.scan_state_controller = statistic_state_controller
statistic_state_controller.setShouldStop(false)
ring_energy_text.setValue(0.)
ring_energy_err_text.setValue(0.)
eKin_ring_arr = []
count = n_iter
while(count > 0):
iter_left_text.setValue(1.0*count)
res = bpmBatchReader.makeMeasurement()
count -= 1
if(not res):
if(messageTextField != null):
messageTextField.setText("cannot measure the BPM phases! Stop.")
if(statistic_state_controller.getShouldStop()):
messageTextField.setText("The Statistics stopped upon user's request!")
break
#print "debug count=",count
bpmBatchReader.collectStatistics(self.bpm_amp_phase_data_dict)
ring_freq = ca_ring_freq.getValDbl()
beta = ring_length*ring_freq/c_light
gamma = 1./math.sqrt(1.0-beta*beta)
eKin = mass*(gamma-1.0)
eKin_ring_arr.append(eKin)
n_iter = len(eKin_ring_arr)
iter_left_text.setValue(0.)
if(n_iter >= 1):
(eKin_ring,eKin_ring_err) = calculateAvgErr(eKin_ring_arr)
ring_energy_text.setValue(eKin_ring)
ring_energy_err_text.setValue(eKin_ring_err)
self.calculatePhaseOffsets(eKin_ring)
statistic_state_controller.setShouldStop(true)
def run(self):
mass = self.scl_long_tuneup_controller.mass/1.0e+6
c_light = self.scl_long_tuneup_controller.c_light
ring_length = self.scl_long_tuneup_controller.ring_length
messageTextField = self.scl_long_tuneup_controller.getMessageTextField()
if(messageTextField != null):
messageTextField.setText("")
scl_long_tuneup_bpm_offsets_controller = self.scl_long_tuneup_controller.scl_long_tuneup_bpm_offsets_controller
bpms_offsets_from_hebt1_panel = scl_long_tuneup_bpm_offsets_controller.bpms_offsets_from_hebt1_panel
n_iter = int(bpms_offsets_from_hebt1_panel.iter_text.getValue())
iter_left_text = bpms_offsets_from_hebt1_panel.iter_left_text
ring_energy_text = bpms_offsets_from_hebt1_panel.ring_energy_text
ring_energy_err_text = bpms_offsets_from_hebt1_panel.ring_energy_err_text
ca_ring_freq = ChannelFactory.defaultFactory().getChannel("Ring_Diag:BCM_D09:FFT_peak2")
scl_long_tuneup_init_controller = self.scl_long_tuneup_controller.scl_long_tuneup_init_controller
scl_long_tuneup_init_controller.connectAllBPMs()
bpmBatchReader = self.scl_long_tuneup_controller.bpmBatchReader
beamTrigger = self.scl_long_tuneup_controller.beamTrigger
statistic_state_controller = bpms_offsets_from_hebt1_panel.statistic_state_controller
beamTrigger.scan_state_controller = statistic_state_controller
statistic_state_controller.setShouldStop(false)
ring_energy_text.setValue(0.)
ring_energy_err_text.setValue(0.)
eKin_ring_arr = []
count = n_iter
while(count > 0):
iter_left_text.setValue(1.0*count)
res = bpmBatchReader.makeMeasurement()
count -= 1
if(not res):
if(messageTextField != null):
messageTextField.setText("cannot measure the BPM phases! Stop.")
if(statistic_state_controller.getShouldStop()):
messageTextField.setText("The Statistics stopped upon user's request!")
break
#print "debug count=",count
bpmBatchReader.collectStatistics(self.bpm_amp_phase_data_dict)
ring_freq = ca_ring_freq.getValDbl()
beta = ring_length*ring_freq/c_light
gamma = 1./math.sqrt(1.0-beta*beta)
eKin = mass*(gamma-1.0)
eKin_ring_arr.append(eKin)
n_iter = len(eKin_ring_arr)
iter_left_text.setValue(0.)
if(n_iter >= 1):
(eKin_ring,eKin_ring_err) = calculateAvgErr(eKin_ring_arr)
ring_energy_text.setValue(eKin_ring)
ring_energy_err_text.setValue(eKin_ring_err)
self.calculatePhaseOffsets(eKin_ring)
statistic_state_controller.setShouldStop(true)
def calculateOffsetsForNotDoneBPMsRight(cav_wrapper,scl_long_tuneup_controller,bpm_wrappers_good_arr,bpm_wrappers_not_done_arr): # this function will calculate offsets for "right" offsets of # "Not yet Done" BPMs by using "good" (already done) BPMs eKin_in = cav_wrapper.eKin_in_guess mass = scl_long_tuneup_controller.mass/1.0e+6 c_light = scl_long_tuneup_controller.c_light bpm_freq = scl_long_tuneup_controller.bpm_freq coeff_init = 360.0*bpm_freq/c_light for bpm_wrapper in bpm_wrappers_not_done_arr: bpm_wrapper.right_phase_offset.phaseOffset_arr = [] (graphDataAmp,phaseDiffPlot) = cav_wrapper.bpm_amp_phase_dict[bpm_wrappers_good_arr[0]] cav_wrapper.eKinOutPlot.removeAllPoints() cav_wrapper.eKinOutPlotTh.removeAllPoints() for ip in range(phaseDiffPlot.getNumbOfPoints()): cav_phase = phaseDiffPlot.getX(ip) ekin_guess = cav_wrapper.energy_guess_harm_funcion.getValue(cav_phase) beta_guess = math.sqrt(ekin_guess*(ekin_guess+2*mass))/(ekin_guess+mass) coeff = coeff_init/beta_guess # let's make bpm_phase(z) points for good BPMs gd = BasicGraphData() base_bpm_wrapper = bpm_wrappers_good_arr[0] (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[base_bpm_wrapper] base_bpm_offset = base_bpm_wrapper.right_phase_offset.phaseOffset_avg base_bpm_phase = graphDataPhase.getY(ip) - base_bpm_offset #print "debug ==== ip=",ip," cav_phase=",cav_phase," eKin_guess=",ekin_guess gd.addPoint(base_bpm_wrapper.pos,base_bpm_phase) for bpm_ind in range(1,len(bpm_wrappers_good_arr)): bpm_wrapper = bpm_wrappers_good_arr[bpm_ind] (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper] bpm_phase = graphDataPhase.getY(ip) - bpm_wrapper.right_phase_offset.phaseOffset_avg bpm_pos = bpm_wrapper.pos bpm_phase_guess = gd.getY(bpm_ind-1) + coeff*(bpm_pos-gd.getX(bpm_ind-1)) bpm_phase = makePhaseNear(bpm_phase,bpm_phase_guess) gd.addPoint(bpm_pos,bpm_phase) #print "debug bpm=",bpm_wrapper.alias," pos=",bpm_pos," phase=",bpm_phase res_arr = GraphDataOperations.polynomialFit(gd,-1.e+36,+1.e+36,1) slope = res_arr[0][1] slope_err = res_arr[1][1] init_phase = res_arr[0][0] init_phase_err = res_arr[1][0] beta = coeff_init/slope gamma = 1./math.sqrt(1.0-beta*beta) eKin = mass*(gamma-1.0) delta_eKin = mass*gamma**3*beta**3*slope_err/coeff_init cav_wrapper.eKinOutPlot.addPoint(cav_phase,eKin,delta_eKin) #print "debug cav_phase=",cav_phase,"eKin_guess=",ekin_guess," eKin=",eKin," delta_E=",delta_eKin # let's go over the bad BPMs and calculate offsets for particular cavity phase for bpm_wrapper in bpm_wrappers_not_done_arr: bpm_pos = bpm_wrapper.pos bpm_phase_th = init_phase + slope*bpm_pos (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper] bpm_phase = graphDataPhase.getY(ip) bpm_offset = makePhaseNear(bpm_phase - bpm_phase_th,0.) bpm_wrapper.right_phase_offset.phaseOffset_arr.append(bpm_offset) #----set up the output energy guess cav_wrapper.eKin_out_guess = cav_wrapper.eKinOutPlot.getValueY(cav_wrapper.livePhase) eKin_avg = 0. for i_ep in range(cav_wrapper.eKinOutPlot.getNumbOfPoints()): eKin_avg += cav_wrapper.eKinOutPlot.getY(i_ep) if(cav_wrapper.eKinOutPlot.getNumbOfPoints() != 0.): eKin_avg /= cav_wrapper.eKinOutPlot.getNumbOfPoints() cav_wrapper.eKin_in_guess = eKin_avg # let's calculate statistics for "not done" BPMs' offsets for bpm_wrapper in bpm_wrappers_not_done_arr: phase_arr = bpm_wrapper.right_phase_offset.phaseOffset_arr (phase0_avg, phase0_err) = calculateAvgErr(phase_arr) phase_arr = [] for phase in bpm_wrapper.right_phase_offset.phaseOffset_arr: phase_arr.append(makePhaseNear(phase-180.,0.)) (phase1_avg, phase1_err) = calculateAvgErr(phase_arr) phase1_avg = makePhaseNear(phase1_avg+180.,0.) if(phase1_err < phase0_err): bpm_wrapper.right_phase_offset.phaseOffset_avg = phase1_avg bpm_wrapper.right_phase_offset.phaseOffset_err = phase1_err else: bpm_wrapper.right_phase_offset.phaseOffset_avg = phase0_avg bpm_wrapper.right_phase_offset.phaseOffset_err = phase0_err bpm_wrapper.right_phase_offset.isReady = true
def calculateOffSets(self):
scl_long_tuneup_bpm_offsets_controller = self.scl_long_tuneup_controller.scl_long_tuneup_bpm_offsets_controller
bpms_offsets_from_ccl4_panel = scl_long_tuneup_bpm_offsets_controller.bpms_offsets_from_ccl4_panel
self.scl_long_tuneup_controller.getMessageTextField().setText("")
#--- transform eV to MeV
mass = self.scl_long_tuneup_controller.mass/1.0e+6
c_light = self.scl_long_tuneup_controller.c_light
eKin_in = bpms_offsets_from_ccl4_panel.ccl4_energy_text.getValue()
gamma = (mass+eKin_in)/mass
beta = math.sqrt(1.0-1.0/(gamma*gamma))
bpm_freq = self.scl_long_tuneup_controller.bpm_freq
#--- initial parameters
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
bpm_wrapper.left_phase_offset.phaseOffset_avg = 0.
bpm_wrapper.left_phase_offset.phaseOffset_err = 0.
bpm_wrapper.left_phase_offset.isReady = false
bpm_wrapper.left_phase_offset.phaseOffset_arr = []
#---- analysis of the "All Cavities Off" case
cav0_wrapper = self.scl_long_tuneup_controller.cav0_wrapper
if(cav0_wrapper.isGood and cav0_wrapper.isMeasured):
bpm_local_wrappers = []
for bpm_ind in range(len(cav0_wrapper.bpm_wrappers)):
bpm_wrapper = cav0_wrapper.bpm_wrappers[bpm_ind]
if(cav0_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind]):
bpm_local_wrappers.append(bpm_wrapper)
(graphDataAmp,graphDataPhase) = cav0_wrapper.bpm_amp_phase_dict[bpm_wrapper]
phase_offset_obj = bpm_wrapper.left_phase_offset
phase_arr= []
for ip in range(graphDataPhase.getNumbOfPoints()):
phase_arr.append(graphDataPhase.getY(ip))
(phase_avg, err) = calculateAvgErr(phase_arr)
phase_offset_obj.phase_val_tmp = phase_avg
phase_offset_obj.phase_val_err_tmp = err
if(len(bpm_local_wrappers) < 3):
txt = "Cavity "+cav0_wrapper.alias+" all data are bad! Cannot do anything!"
self.scl_long_tuneup_controller.getMessageTextField().setText(txt)
return
#---- the average BPM phases for all cavities off are ready here -------
bpm_phase_coef = 360.0*bpm_freq/(c_light*beta)
base_bpm_wrapper = bpm_local_wrappers[0]
base_pos = base_bpm_wrapper.pos
base_bpm_phase = base_bpm_wrapper.left_phase_offset.phase_val_tmp
base_bpm_phase_err = base_bpm_wrapper.left_phase_offset.phaseOffset_err
for bpm_wrapper in bpm_local_wrappers:
pos_delta = bpm_wrapper.pos - base_pos
bpm_phase_th = base_bpm_phase + bpm_phase_coef*pos_delta
phase_offset = makePhaseNear(bpm_wrapper.left_phase_offset.phase_val_tmp - bpm_phase_th,0.)
err = math.sqrt(base_bpm_phase_err**2 + bpm_wrapper.left_phase_offset.phase_val_err_tmp**2)
bpm_wrapper.left_phase_offset.phaseOffset_avg = phase_offset
bpm_wrapper.left_phase_offset.phaseOffset_err = err
bpm_wrapper.left_phase_offset.isReady = true
bpm_wrapper.left_phase_offset.phase_val_tmp = 0.
bpm_wrapper.left_phase_offset.phase_val_err_tmp = 0.
#print "debug cav=",cav0_wrapper.alias," BPM=",bpm_wrapper.alias," offset= %4.1f +- %4.1f"%(phase_offset,err)
else:
txt = "Cavity "+cav0_wrapper.alias+" - data is not ready! Cannot do anything!"
self.scl_long_tuneup_controller.getMessageTextField().setText(txt)
return
#------ start moving along cavities -------------------
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[0]
cav_wrapper.eKin_in_guess = eKin_in
n_cavs = len(self.scl_long_tuneup_controller.cav_wrappers)
for cav_ind in range(n_cavs):
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[cav_ind]
if(cav_wrapper.isGood and (not cav_wrapper.isMeasured)): break
if(cav_ind > 0):
cav_wrapper.eKin_in_guess = self.scl_long_tuneup_controller.cav_wrappers[cav_ind-1].eKin_out_guess
if(not cav_wrapper.isGood):
cav_wrapper.eKin_out_guess = cav_wrapper.eKin_in_guess
continue
# make array of BPMs already having offsets and not having ones
bpm_wrappers_good_arr = []
bpm_wrappers_not_done_arr = []
for bpm_ind in range(len(cav_wrapper.bpm_wrappers)):
bpm_wrapper = cav_wrapper.bpm_wrappers[bpm_ind]
is_wanted = bpm_wrapper.isGood and bpm_wrapper.pos > cav_wrapper.pos
is_wanted = is_wanted and cav_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind]
if(is_wanted):
if(bpm_wrapper.left_phase_offset.isReady):
bpm_wrappers_good_arr.append(bpm_wrapper)
else:
bpm_wrappers_not_done_arr.append(bpm_wrapper)
initEnergyInGuessHarmFunc(cav_wrapper,self.scl_long_tuneup_controller)
if(len(bpm_wrappers_good_arr) < 2):
txt = "Cavity "+cav_wrapper.alias+" does not have enough good BPMs! Cannot do anything!"
self.scl_long_tuneup_controller.getMessageTextField().setText(txt)
return
self.calculateOffsetsForNotDoneBPMsLeft(cav_wrapper,bpm_wrappers_good_arr,bpm_wrappers_not_done_arr)
#print "debug cav=",cav_wrapper.alias," n_bad=",len(bpm_wrappers_not_done_arr)
#----set all BPMs that do not have offsets as not good for phase analysis
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
if(bpm_wrapper.isGood):
if(not bpm_wrapper.left_phase_offset.isReady):
cav0_wrapper = self.scl_long_tuneup_controller.cav0_wrapper
bpm_ind = cav0_wrapper.bpm_wrappers.index(bpm_wrapper)
if(bpm_ind >= 0):
cav0_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind] = false
cav0_wrapper.bpm_wrappers_useInAmpBPMs[bpm_ind] = true
for cav_wrapper in self.scl_long_tuneup_controller.cav_wrappers:
bpm_ind = cav_wrapper.bpm_wrappers.index(bpm_wrapper)
if(bpm_ind >= 0):
cav_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind] = false
cav_wrapper.bpm_wrappers_useInAmpBPMs[bpm_ind] = true
#---- re-calculate phase offesets to the base BPM which is the first BPM after
#---- the last cavity
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[n_cavs-1]
base_bpm_wrapper = null
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
if(bpm_wrapper.isGood):
if(bpm_wrapper.left_phase_offset.isReady):
if(bpm_wrapper.pos > cav_wrapper.pos):
base_bpm_wrapper = bpm_wrapper
break
if(base_bpm_wrapper != null):
base_bpm_phase_offset = base_bpm_wrapper.left_phase_offset.phaseOffset_avg
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
if(bpm_wrapper.isGood):
if(bpm_wrapper.left_phase_offset.isReady):
phase_offset = bpm_wrapper.left_phase_offset.phaseOffset_avg
phase_offset = makePhaseNear(phase_offset - base_bpm_phase_offset,0.)
bpm_wrapper.left_phase_offset.phaseOffset_avg = phase_offset
#---- set the final energy after the last cavity
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[n_cavs-1]
bpms_offsets_from_hebt1_panel = scl_long_tuneup_bpm_offsets_controller.bpms_offsets_from_hebt1_panel
bpms_offsets_from_hebt1_panel.ring_energy_text.setValue(cav_wrapper.eKin_out_guess)
self.scl_long_tuneup_controller.updateAllTables()
def calculateOffsetsForNotDoneBPMsLeft(cav_wrapper,scl_long_tuneup_controller,bpm_wrappers_good_arr,bpm_wrappers_not_done_arr): # this function will calculate offsets for "left" offsets of # "Not yet Done" BPMs by using "good" (already done) BPMs eKin_in = cav_wrapper.eKin_in_guess mass = scl_long_tuneup_controller.mass/1.0e+6 c_light = scl_long_tuneup_controller.c_light bpm_freq = scl_long_tuneup_controller.bpm_freq coeff_init = 360.0*bpm_freq/c_light for bpm_wrapper in bpm_wrappers_not_done_arr: bpm_wrapper.left_phase_offset.phaseOffset_arr = [] phaseDiffPlot = cav_wrapper.phaseDiffPlot cav_wrapper.eKinOutPlot.removeAllPoints() cav_wrapper.eKinOutPlotTh.removeAllPoints() for ip in range(phaseDiffPlot.getNumbOfPoints()): cav_phase = phaseDiffPlot.getX(ip) ekin_guess = cav_wrapper.energy_guess_harm_funcion.getValue(cav_phase) beta_guess = math.sqrt(ekin_guess*(ekin_guess+2*mass))/(ekin_guess+mass) coeff = coeff_init/beta_guess # let's make bpm_phase(z) points for good BPMs gd = BasicGraphData() base_bpm_wrapper = bpm_wrappers_good_arr[0] (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[base_bpm_wrapper] base_bpm_offset = base_bpm_wrapper.left_phase_offset.phaseOffset_avg base_bpm_phase = graphDataPhase.getY(ip) - base_bpm_offset #print "debug ==== ip=",ip," cav_phase=",cav_phase," eKin_guess=",ekin_guess gd.addPoint(base_bpm_wrapper.pos,base_bpm_phase) for bpm_ind in range(1,len(bpm_wrappers_good_arr)): bpm_wrapper = bpm_wrappers_good_arr[bpm_ind] (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper] bpm_phase = graphDataPhase.getY(ip) - bpm_wrapper.left_phase_offset.phaseOffset_avg bpm_pos = bpm_wrapper.pos bpm_phase_guess = gd.getY(bpm_ind-1) + coeff*(bpm_pos-gd.getX(bpm_ind-1)) bpm_phase = makePhaseNear(bpm_phase,bpm_phase_guess) gd.addPoint(bpm_pos,bpm_phase) #print "debug bpm=",bpm_wrapper.alias," pos=",bpm_pos," phase=",bpm_phase res_arr = GraphDataOperations.polynomialFit(gd,-1.e+36,+1.e+36,1) slope = res_arr[0][1] slope_err = res_arr[1][1] init_phase = res_arr[0][0] init_phase_err = res_arr[1][0] beta = coeff_init/slope gamma = 1./math.sqrt(1.0-beta*beta) eKin = mass*(gamma-1.0) delta_eKin = mass*gamma**3*beta**3*slope_err/coeff_init cav_wrapper.eKinOutPlot.addPoint(cav_phase,eKin,delta_eKin) #print "debug cav_phase=",cav_phase,"eKin_guess=",ekin_guess," eKin=",eKin," delta_E=",delta_eKin # let's go over the bad BPMs and calculate offsets for particular cavity phase for bpm_wrapper in bpm_wrappers_not_done_arr: bpm_pos = bpm_wrapper.pos bpm_phase_th = init_phase + slope*bpm_pos (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper] bpm_phase = graphDataPhase.getY(ip) bpm_offset = makePhaseNear(bpm_phase - bpm_phase_th,0.) bpm_wrapper.left_phase_offset.phaseOffset_arr.append(bpm_offset) #----set up the output energy guess cav_wrapper.eKin_out_guess = cav_wrapper.eKinOutPlot.getValueY(cav_wrapper.livePhase) # let's calculate statistics for "not done" BPMs' offsets for bpm_wrapper in bpm_wrappers_not_done_arr: phase_arr = bpm_wrapper.left_phase_offset.phaseOffset_arr (phase0_avg, phase0_err) = calculateAvgErr(phase_arr) phase_arr = [] for phase in bpm_wrapper.left_phase_offset.phaseOffset_arr: phase_arr.append(makePhaseNear(phase-180.,0.)) (phase1_avg, phase1_err) = calculateAvgErr(phase_arr) phase1_avg = makePhaseNear(phase1_avg+180.,0.) if(phase1_err < phase0_err): bpm_wrapper.left_phase_offset.phaseOffset_avg = phase1_avg bpm_wrapper.left_phase_offset.phaseOffset_err = phase1_err else: bpm_wrapper.left_phase_offset.phaseOffset_avg = phase0_avg bpm_wrapper.left_phase_offset.phaseOffset_err = phase0_err bpm_wrapper.left_phase_offset.isReady = true
def calculateOffSets(self):
scl_long_tuneup_bpm_offsets_controller = self.scl_long_tuneup_controller.scl_long_tuneup_bpm_offsets_controller
bpms_offsets_from_ccl4_panel = scl_long_tuneup_bpm_offsets_controller.bpms_offsets_from_ccl4_panel
self.scl_long_tuneup_controller.getMessageTextField().setText("")
#--- transform eV to MeV
mass = self.scl_long_tuneup_controller.mass/1.0e+6
c_light = self.scl_long_tuneup_controller.c_light
eKin_in = bpms_offsets_from_ccl4_panel.ccl4_energy_text.getValue()
gamma = (mass+eKin_in)/mass
beta = math.sqrt(1.0-1.0/(gamma*gamma))
bpm_freq = self.scl_long_tuneup_controller.bpm_freq
#--- initial parameters
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
bpm_wrapper.left_phase_offset.phaseOffset_avg = 0.
bpm_wrapper.left_phase_offset.phaseOffset_err = 0.
bpm_wrapper.left_phase_offset.isReady = false
bpm_wrapper.left_phase_offset.phaseOffset_arr = []
#---- analysis of the "All Cavities Off" case
cav0_wrapper = self.scl_long_tuneup_controller.cav0_wrapper
if(cav0_wrapper.isGood and cav0_wrapper.isMeasured):
bpm_local_wrappers = []
for bpm_ind in range(len(cav0_wrapper.bpm_wrappers)):
bpm_wrapper = cav0_wrapper.bpm_wrappers[bpm_ind]
if(cav0_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind]):
bpm_local_wrappers.append(bpm_wrapper)
(graphDataAmp,graphDataPhase) = cav0_wrapper.bpm_amp_phase_dict[bpm_wrapper]
phase_offset_obj = bpm_wrapper.left_phase_offset
phase_arr= []
for ip in range(graphDataPhase.getNumbOfPoints()):
phase_arr.append(graphDataPhase.getY(ip))
(phase_avg, err) = calculateAvgErr(phase_arr)
phase_offset_obj.phase_val_tmp = phase_avg
phase_offset_obj.phase_val_err_tmp = err
if(len(bpm_local_wrappers) == 0):
txt = "Cavity "+cav0_wrapper.alias+" all data are bad! Cannot do anything!"
self.scl_long_tuneup_controller.getMessageTextField().setText(txt)
return
#---- the average BPM phases for all cavities off are ready here -------
bpm_phase_coef = 360.0*bpm_freq/(c_light*beta)
base_bpm_wrapper = bpm_local_wrappers[0]
base_pos = base_bpm_wrapper.pos
base_bpm_phase = base_bpm_wrapper.left_phase_offset.phase_val_tmp
base_bpm_phase_err = base_bpm_wrapper.left_phase_offset.phaseOffset_err
for bpm_wrapper in bpm_local_wrappers:
pos_delta = bpm_wrapper.pos - base_pos
bpm_phase_th = base_bpm_phase + bpm_phase_coef*pos_delta
phase_offset = makePhaseNear(bpm_wrapper.left_phase_offset.phase_val_tmp - bpm_phase_th,0.)
err = math.sqrt(base_bpm_phase_err**2 + bpm_wrapper.left_phase_offset.phase_val_err_tmp**2)
bpm_wrapper.left_phase_offset.phaseOffset_avg = phase_offset
bpm_wrapper.left_phase_offset.phaseOffset_err = err
bpm_wrapper.left_phase_offset.isReady = true
bpm_wrapper.left_phase_offset.phase_val_tmp = 0.
bpm_wrapper.left_phase_offset.phase_val_err_tmp = 0.
#print "debug cav=",cav0_wrapper.alias," BPM=",bpm_wrapper.alias," offset= %4.1f +- %4.1f"%(phase_offset,err)
#------ start moving along cavities -------------------
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[0]
cav_wrapper.eKin_in_guess = eKin_in
n_cavs = len(self.scl_long_tuneup_controller.cav_wrappers)
for cav_ind in range(n_cavs):
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[cav_ind]
if(cav_wrapper.isGood and (not cav_wrapper.isMeasured)): break
if(cav_ind > 0):
cav_wrapper.eKin_in_guess = self.scl_long_tuneup_controller.cav_wrappers[cav_ind-1].eKin_out_guess
if(not cav_wrapper.isGood):
cav_wrapper.eKin_out_guess = cav_wrapper.eKin_in_guess
continue
# make array of BPMs already having offsets and not having ones
bpm_wrappers_good_arr = []
bpm_wrappers_not_done_arr = []
for bpm_ind in range(len(cav_wrapper.bpm_wrappers)):
bpm_wrapper = cav_wrapper.bpm_wrappers[bpm_ind]
is_wanted = bpm_wrapper.isGood and bpm_wrapper.pos > cav_wrapper.pos
is_wanted = is_wanted and cav_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind]
if(is_wanted):
if(bpm_wrapper.left_phase_offset.isReady):
bpm_wrappers_good_arr.append(bpm_wrapper)
else:
bpm_wrappers_not_done_arr.append(bpm_wrapper)
initEnergyInGuessHarmFunc(cav_wrapper,self.scl_long_tuneup_controller)
if(len(bpm_wrappers_good_arr) < 2):
txt = "Cavity "+cav_wrapper.alias+" does not have enough good BPMs! Cannot do anything!"
self.scl_long_tuneup_controller.getMessageTextField().setText(txt)
return
calculateOffsetsForNotDoneBPMsLeft(cav_wrapper,self.scl_long_tuneup_controller,bpm_wrappers_good_arr,bpm_wrappers_not_done_arr)
#print "debug cav=",cav_wrapper.alias," n_bad=",len(bpm_wrappers_not_done_arr)
#----set all BPMs that do not have offsets as not good for phase analysis
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
if(bpm_wrapper.isGood):
if(not bpm_wrapper.left_phase_offset.isReady):
cav0_wrapper = self.scl_long_tuneup_controller.cav0_wrapper
bpm_ind = cav0_wrapper.bpm_wrappers.index(bpm_wrapper)
if(bpm_ind >= 0):
cav0_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind] = false
cav0_wrapper.bpm_wrappers_useInAmpBPMs[bpm_ind] = true
for cav_wrapper in self.scl_long_tuneup_controller.cav_wrappers:
bpm_ind = cav_wrapper.bpm_wrappers.index(bpm_wrapper)
if(bpm_ind >= 0):
cav_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind] = false
cav_wrapper.bpm_wrappers_useInAmpBPMs[bpm_ind] = true
#---- re-calculate phase offesets to the base BPM which is the first BPM after
#---- the last cavity
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[n_cavs-1]
base_bpm_wrapper = null
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
if(bpm_wrapper.isGood):
if(bpm_wrapper.left_phase_offset.isReady):
if(bpm_wrapper.pos > cav_wrapper.pos):
base_bpm_wrapper = bpm_wrapper
break
if(base_bpm_wrapper != null):
base_bpm_phase_offset = base_bpm_wrapper.left_phase_offset.phaseOffset_avg
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
if(bpm_wrapper.isGood):
if(bpm_wrapper.left_phase_offset.isReady):
phase_offset = bpm_wrapper.left_phase_offset.phaseOffset_avg
phase_offset = makePhaseNear(phase_offset - base_bpm_phase_offset,0.)
bpm_wrapper.left_phase_offset.phaseOffset_avg = phase_offset
#---- set the final energy after the last cavity
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[n_cavs-1]
bpms_offsets_from_hebt1_panel = scl_long_tuneup_bpm_offsets_controller.bpms_offsets_from_hebt1_panel
bpms_offsets_from_hebt1_panel.ring_energy_text.setValue(cav_wrapper.eKin_out_guess)
self.scl_long_tuneup_controller.updateAllTables()
def calculateEnergy(self, eKin_in):
mass = self.scl_long_tuneup_controller.mass / 1.0e+6
c_light = self.scl_long_tuneup_controller.c_light
bpm_freq = self.scl_long_tuneup_controller.bpm_freq
coeff_init = 360.0 * bpm_freq / c_light
beta = math.sqrt(eKin_in * (eKin_in + 2 * mass)) / (eKin_in + mass)
coeff = coeff_init / beta
#------ calculate avg bpm phases
res_arr = []
for bpm_ind in range(len(self.em_bpm_wrpprs)):
bpm_wrapper = self.em_bpm_wrpprs[bpm_ind]
if (not self.use_bpms[bpm_ind]): continue
if (not self.bpm_amp_phase_data_dict.has_key(bpm_wrapper)):
continue
(amp_arr, phase_arr) = self.bpm_amp_phase_data_dict[bpm_wrapper]
(phase_avg, phase_err) = calculateAvgErr(phase_arr)
#print "debug bpm=",bpm_wrapper.alias," (phase_avg,phase_err) =",(phase_avg,phase_err)
res_arr.append([bpm_ind, bpm_wrapper, phase_avg, phase_err])
n_res = len(res_arr)
scl_long_tuneup_energy_meter_controller = self.scl_long_tuneup_controller.scl_long_tuneup_energy_meter_controller
table_and_plots_panel = scl_long_tuneup_energy_meter_controller.table_and_plots_panel
init_start_stop_panel = scl_long_tuneup_energy_meter_controller.init_start_stop_panel
fixInitEenergy_RadioButton = init_start_stop_panel.fixInitEenergy_RadioButton
buffer_size = int(init_start_stop_panel.buffer_size_text.getValue())
if (n_res < 2): return eKin_in
[bpm_ind0, bpm_wrapper0, phase_avg0, phase_err0] = res_arr[0]
phase_avg0 = phase_avg0 - self.bpm_phase_offsets[0]
res_arr[0][2] = phase_avg0
base_pos = bpm_wrapper0.pos
#"""
for ind in range(n_res - 1):
[bpm_ind0, bpm_wrapper0, phase_avg0, phase_err0] = res_arr[ind]
[bpm_ind1, bpm_wrapper1, phase_avg1, phase_err1] = res_arr[ind + 1]
bpm1_phase = phase_avg1 - self.bpm_phase_offsets[bpm_ind1]
bpm1_phase_guess = phase_avg0 + coeff * (bpm_wrapper1.pos -
bpm_wrapper0.pos)
bpm1_phase = makePhaseNear(bpm1_phase, bpm1_phase_guess)
res_arr[ind + 1][2] = bpm1_phase
"""
for ind in range(1,n_res):
[bpm_ind,bpm_wrapper,phase_avg,phase_err] = res_arr[ind]
bpm_phase = phase_avg - self.bpm_phase_offsets[bpm_ind]
delta_pos = bpm_wrapper.pos - base_pos
bpm_phase_guess = phase_avg0 + coeff*delta_pos
bpm_phase = makePhaseNear(bpm_phase,bpm_phase_guess)
res_arr[ind][2] = bpm_phase
"""
#----- make phase plot
gd = BasicGraphData()
for ind in range(n_res):
[bpm_ind, bpm_wrapper, phase_avg, phase_err] = res_arr[ind]
gd.addPoint(bpm_wrapper.pos - base_pos, phase_avg, phase_err)
res_poly_arr = GraphDataOperations.polynomialFit(
gd, -1.e+36, +1.e+36, 1)
if (res_poly_arr == null): return eKin_in
slope = res_poly_arr[0][1]
init_phase = res_poly_arr[0][0]
if (fixInitEenergy_RadioButton.isSelected()):
slope = coeff
init_phase = phase_avg0
beta = coeff_init / slope
gamma = 1. / math.sqrt(1.0 - beta * beta)
eKin = mass * (gamma - 1.0)
slope_err = res_poly_arr[1][1]
delta_eKin = mass * gamma**3 * beta**3 * slope_err / coeff_init
#make phase error plot
x_arr = []
y_arr = []
err_arr = []
for ind in range(n_res):
[bpm_ind, bpm_wrapper, phase_avg, phase_err] = res_arr[ind]
x_arr.append(bpm_wrapper.pos)
phase_diff = makePhaseNear(
phase_avg - (init_phase + slope *
(bpm_wrapper.pos - base_pos)), 0.)
self.bpm_phase_diff_arr[bpm_ind].append(phase_diff)
if (len(self.bpm_phase_diff_arr[bpm_ind]) > buffer_size):
self.bpm_phase_diff_arr[bpm_ind] = self.bpm_phase_diff_arr[
bpm_ind][1:]
(phase_diff,
phase_err) = calculateAvgErr(self.bpm_phase_diff_arr[bpm_ind])
y_arr.append(phase_diff)
err_arr.append(phase_err)
table_and_plots_panel.bpm_phase_err_gd.removeAllPoints()
table_and_plots_panel.bpm_phase_err_gd.addPoint(x_arr, y_arr, err_arr)
return (eKin, delta_eKin)
