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 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)