def getAvgGapPhase(self): #------------- calculate avg. RF gap phase ----------- if(self.active_cav_wrapper == null): return 0. rf_gap_arr = self.cavToGapsDict[self.active_cav_wrapper] phase_rf_gaps_avg = 0. for irfGap in rf_gap_arr: phase_rf_gaps_avg += makePhaseNear(irfGap.getPhase(),0.) phase_rf_gaps_avg /= len(rf_gap_arr) phase_rf_gaps_avg = makePhaseNear((phase_rf_gaps_avg*180./math.pi)%360.,0.) return phase_rf_gaps_avg
def getAvgGapPhase(self,cav_wrapper): #------------- calculate avg. RF gap phase ----------- if(cav_wrapper == null or not(self.cavToGapsDict.has_key(cav_wrapper))): return 0. rf_gap_arr = self.cavToGapsDict[cav_wrapper] phase_rf_gaps_avg = 0. for irfGap in rf_gap_arr: phase_rf_gaps_avg += makePhaseNear(irfGap.getPhase(),0.) #print "debug gap=",irfGap.getId()," phase=",irfGap.getPhase()*180./math.pi phase_rf_gaps_avg /= len(rf_gap_arr) phase_rf_gaps_avg = makePhaseNear((phase_rf_gaps_avg*180./math.pi)%360.,0.) return phase_rf_gaps_avg
def calculateNewLivePhases(self): self.calcForNewAmpsAndPhases() cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers for cav_wrapper in cav_wrappers: arr_time_old = cav_wrapper.rescaleBacket.arrivalTime irfGap = self.cavToGapsDict[cav_wrapper][0] cav_wrapper.rescaleBacket.designPhase = irfGap.getPhase()*180./math.pi state = self.scenario.getTrajectory().stateForElement(irfGap.getId()) arr_time_new = state.getTime() freq = 1.0e+6*cav_wrapper.cav.getCavFreq() # this sign "-" is correct. It was checked experimentally. delta_phase = - makePhaseNear(360.*freq*(arr_time_new - arr_time_old),0.) delta_phase_model = cav_wrapper.rescaleBacket.designPhase - cav_wrapper.designPhase cav_wrapper.rescaleBacket.livePhase = makePhaseNear(delta_phase + delta_phase_model + cav_wrapper.livePhase,0.)
def getTrialParams(self,trial): #------set up harmonics function parameters from Trial map var_map = trial.getTrialPoint().getValueMap() self.param_arr[0] = math.fabs(trial.getTrialPoint().getValue(self.variables.get(0))) self.param_arr[1] = math.fabs(trial.getTrialPoint().getValue(self.variables.get(1))) self.param_arr[2] = makePhaseNear(trial.getTrialPoint().getValue(self.variables.get(2)),0.) return self.param_arr
def run_measurement(self,bpm1_avg_phase_old,bpm2_avg_phase_old):
scl_long_tuneup_rescale_controller = self.scl_long_tuneup_controller.scl_long_tuneup_rescale_controller
bpms_phase_shift_panel = scl_long_tuneup_rescale_controller.bpms_phase_shift_panel
measure_stopper = bpms_phase_shift_panel.measure_stopper
measure_stopper.shouldStop = false
n_iter = int(bpms_phase_shift_panel.iter_measuremen_text.getValue())
cav_wrapper = self.scl_long_tuneup_controller.cav0_wrapper
bpm_wrapper1 = cav_wrapper.bpm_wrappers[0]
bpm_wrapper2 = cav_wrapper.bpm_wrappers[1]
ch_phase1 = ChannelFactory.defaultFactory().getChannel(bpm_wrapper1.bpm.getId()+":phaseAvg")
ch_phase2 = ChannelFactory.defaultFactory().getChannel(bpm_wrapper2.bpm.getId()+":phaseAvg")
ch_phase1.connectAndWait(0.5)
ch_phase2.connectAndWait(0.5)
phase1_arr = []
phase2_arr = []
count = 0
while(count < n_iter):
if(measure_stopper.shouldStop): break
time.sleep(1.2)
phase1_arr.append(ch_phase1.getValDbl())
phase2_arr.append(ch_phase2.getValDbl())
if(measure_stopper.shouldStop): break
count += 1
if(measure_stopper.shouldStop): break
bpms_phase_shift_panel.iter_measuremen_text.setValue(float(n_iter-count))
bpm1_avg_phase = 0.
bpm2_avg_phase = 0.
for phase in phase1_arr:
bpm1_avg_phase += phase/len(phase1_arr)
for phase in phase2_arr:
bpm2_avg_phase += phase/len(phase2_arr)
bpms_phase_shift_panel.new_phases_text.setText("%+4.1f / %+4.1f"%(bpm1_avg_phase,bpm2_avg_phase))
bpm_numb = 0
phase_diff = 0.
if(bpm_wrapper1.isGood):
phase_diff += makePhaseNear(bpm1_avg_phase - bpm1_avg_phase_old,0.)
bpm_numb += 1
if(bpm_wrapper2.isGood):
phase_diff += makePhaseNear(bpm2_avg_phase - bpm2_avg_phase_old,0.)
bpm_numb += 1
if(bpm_numb > 0):
phase_diff /= bpm_numb
bpms_phase_shift_panel.phase_shift_text.setValue(phase_diff)
bpms_phase_shift_panel.iter_measuremen_text.setValue(float(n_iter))
if(bpm_numb == 0 or count == 0): return false
return true
def makePhaseScanStep(self, cav_phase, cav_wrapper, bpm_amp_min_limit = 0.1): """ It will add one point (cav_phase,bpm_amp) or (cav_phase,bpm_phase) to the plots in the dictonary. bpm_amp_phase_dict[bpm_wrapper] = (graphDataAmp,graphDataPhase) """ scan_is_good = false count = 0 bad_count_limit = 3 while(not scan_is_good): scan_is_good = true count += 1 if(count >bad_count_limit): return false if(not self.makeMeasurement()): return false bpm_amp_phase_dict = cav_wrapper.bpm_amp_phase_dict #--------get bpm amp and phase ------------- if(bpm_amp_phase_dict.has_key(cav_wrapper.bpm_wrapper0)): (ch_ampl,ch_phase) = self.bpm_ch_amp_phase_dict[cav_wrapper.bpm_wrapper0] bpm_amp = self.batchGetRequest.getRecord(ch_ampl).doubleValue() bpm_phase = self.batchGetRequest.getRecord(ch_phase).doubleValue() if(bpm_amp < bpm_amp_min_limit): scan_is_good = false if(bpm_amp_phase_dict.has_key(cav_wrapper.bpm_wrapper1)): (ch_ampl,ch_phase) = self.bpm_ch_amp_phase_dict[cav_wrapper.bpm_wrapper1] bpm_amp = self.batchGetRequest.getRecord(ch_ampl).doubleValue() bpm_phase = self.batchGetRequest.getRecord(ch_phase).doubleValue() if(bpm_amp < bpm_amp_min_limit): scan_is_good = false if(cav_wrapper.bpm_wrapper0 == null): #that is for "All Off" cavity wrapper bpm_wrapper_first_good = null for bpm_wrapper in self.bpm_wrappers: if(bpm_wrapper.isGood and bpm_amp_phase_dict.has_key(bpm_wrapper)): bpm_wrapper_first_good = bpm_wrapper break if(bpm_wrapper_first_good != null): (ch_ampl,ch_phase) = self.bpm_ch_amp_phase_dict[bpm_wrapper_first_good] bpm_amp = self.batchGetRequest.getRecord(ch_ampl).doubleValue() if(bpm_amp < bpm_amp_min_limit): scan_is_good = false else: scan_is_good = false if(scan_is_good == false): continue for bpm_wrapper in self.bpm_wrappers: if(bpm_amp_phase_dict.has_key(bpm_wrapper) and self.bpm_ch_amp_phase_dict.has_key(bpm_wrapper)): (graphDataAmp,graphDataPhase) = bpm_amp_phase_dict[bpm_wrapper] (ch_ampl,ch_phase) = self.bpm_ch_amp_phase_dict[bpm_wrapper] #print "debug ch amp=",ch_ampl.channelName()," phase=",ch_phase.channelName() bpm_amp = self.batchGetRequest.getRecord(ch_ampl).doubleValue() bpm_phase = self.batchGetRequest.getRecord(ch_phase).doubleValue() graphDataAmp.addPoint(cav_phase,bpm_amp) old_bpm_phase = 0. if(graphDataPhase.getNumbOfPoints() > 0): old_bpm_phase = graphDataPhase.getY(graphDataPhase.getNumbOfPoints() - 1) graphDataPhase.addPoint(cav_phase,makePhaseNear(bpm_phase,old_bpm_phase)) return true
def fakeMakePhaseScanStep(self,cav_phase,cav_wrapper): cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers mass = self.scl_long_tuneup_controller.mass/1.0e+6 bpm_freq = self.scl_long_tuneup_controller.bpm_freq c = self.scl_long_tuneup_controller.c_light cav_pos0 = cav_wrappers[0].pos max_pos = cav_wrappers[len(cav_wrappers)-1].pos - cav_pos0 cav_pos = cav_wrapper.pos eKin_in = 185.6+650.0*(cav_pos-cav_pos0)/max_pos cav_phase_offset = 30. phase = makePhaseNear(cav_phase + cav_phase_offset,0.) eKin = eKin_in if(self.scl_long_tuneup_controller.cav0_wrapper != cav_wrapper): eKin += 8.0*math.cos(2.0*math.pi*phase/360.) else: eKin = 185.6 gamma = (eKin+mass)/mass beta = math.sqrt(1.0 - 1.0/gamma**2) c = 2.99792458e+8 freq = 402.5e+6 bpm_phase_coef = 360.0*freq/(c*beta) #print "debug cav_phase=",cav_phase," beta=",beta," eKin=",eKin," cav_pos=",cav_pos," coeff=",bpm_phase_coef bpm_wrappers = cav_wrapper.bpm_wrappers for bpm_wrapper in bpm_wrappers: if(cav_wrapper.bpm_amp_phase_dict.has_key(bpm_wrapper)): (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper] if(bpm_wrapper.pos < cav_pos): graphDataAmp.addPoint(cav_phase,10.0) graphDataPhase.addPoint(cav_phase,20.0) continue bpm_phase = makePhaseNear(bpm_phase_coef*(bpm_wrapper.pos - cav_pos),0.) bpm_phase += 1.0*(random.random()-0.5) bpm_amp = 25.0*1./(1.+(bpm_wrapper.pos-cav_pos)/20.) graphDataAmp.addPoint(cav_phase,bpm_amp) old_bpm_phase = 0. if(graphDataPhase.getNumbOfPoints() > 0): old_bpm_phase = graphDataPhase.getY(graphDataPhase.getNumbOfPoints() - 1) graphDataPhase.addPoint(cav_phase,makePhaseNear(bpm_phase,old_bpm_phase)) return true
def calcForNewAmpsAndPhases(self): self.setRescaledModelCavityAmplitudes() cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers for cav_wrapper in cav_wrappers: amp = cav_wrapper.rescaleBacket.designAmp phase = self.new_cav_amp_phase_dict[cav_wrapper][1] self.new_cav_amp_phase_dict[cav_wrapper] = [amp,phase] self.scenario.resync() #---set up phases : we should reproduce the rf gap avg. phases from the proxies max_limit_phase_diff = 0.01 max_phase_diff = 1.0 min_cav_amp = 0.5 max_iter = 30 it = 0 while(max_phase_diff > max_limit_phase_diff): it += 1 for cav_wrapper in cav_wrappers: irfGap = self.cavToGapsDict[cav_wrapper][0] phase = self.new_cav_amp_phase_dict[cav_wrapper][1] irfGap.setPhase(phase*math.pi/180.) part_probe = ParticleProbe(self.part_probe_init) eKin_in = self.scl_long_tuneup_controller.cav_wrappers[0].eKin_in part_probe.setKineticEnergy(eKin_in*1.0e+6) self.scenario.setProbe(part_probe) self.scenario.run() max_phase_diff = 0.0 for cav_wrapper in cav_wrappers: phase_rf_gaps_avg = self.getAvgGapPhase(cav_wrapper) phase_diff = phase_rf_gaps_avg - cav_wrapper.rescaleBacket.avg_gap_phase #print "debug cav=",cav_wrapper.alias," phase_diff=",phase_diff," phase avg =",phase_rf_gaps_avg," design avg=",cav_wrapper.avg_gap_phase #print "debug ======= amp=",cav_wrapper.cav.getDfltCavAmp()," phase=",self.cavToGapsDict[cav_wrapper][0].getPhase()*180./math.pi if(cav_wrapper.rescaleBacket.designAmp > min_cav_amp): self.new_cav_amp_phase_dict[cav_wrapper][1] -= phase_diff/1.3 phase_diff = math.fabs(phase_diff) if(max_phase_diff < phase_diff): max_phase_diff = phase_diff eKin_out = self.scenario.getTrajectory().finalState().getKineticEnergy()/1.0e+6 #print "debug eKin_out=",eKin_out if(it > max_iter): break #---- update the cavities' new model phases for cav_wrapper in cav_wrappers: phase = self.new_cav_amp_phase_dict[cav_wrapper][1] cav_wrapper.rescaleBacket.designPhase = makePhaseNear(phase,0.) #print "debug iter=",it eKin_out = self.scenario.getTrajectory().finalState().getKineticEnergy()/1.0e+6 scl_long_tuneup_rescale_controller = self.scl_long_tuneup_controller.scl_long_tuneup_rescale_controller init_amp_phases_panel = scl_long_tuneup_rescale_controller.init_amp_phases_panel init_amp_phases_panel.energy_text.setValue(eKin_out) self.restoreInitAmpPhases() return eKin_out
def allBPMs_PhaseWrapper(self,cav_wrapper): # it will wrap all BPM phases for the cvity by iteration from the BPM closest to cavity if(not cav_wrapper.isGood): return cav_pos = cav_wrapper.pos bpm_wrappers = [] for bpm_ind in range(len(cav_wrapper.bpm_wrappers)): bpm_wrapper = cav_wrapper.bpm_wrappers[bpm_ind] res_bool = cav_wrapper.bpm_amp_phase_dict.has_key(bpm_wrapper) res_bool = res_bool and bpm_wrapper.isGood res_bool = res_bool and (bpm_wrapper.pos > cav_pos) if(res_bool): bpm_wrappers.append(bpm_wrapper) for bpm_ind in range(len(bpm_wrappers)-1): (graphDataAmp0,graphDataPhase0) = cav_wrapper.bpm_amp_phase_dict[bpm_wrappers[bpm_ind]] (graphDataAmp1,graphDataPhase1) = cav_wrapper.bpm_amp_phase_dict[bpm_wrappers[bpm_ind+1]] if(graphDataPhase0.getNumbOfPoints() < 1): break if(graphDataPhase0.getNumbOfPoints() != graphDataPhase1.getNumbOfPoints()): txt = "Phase Wrapper BPM=",bpm_wrappers[bpm_ind].alias txt += " and BPM=",bpm_wrappers[bpm_ind+1].alias txt += " have different number of RF phase points n1=",graphDataPhase0.getNumbOfPoints() txt += " n2=",graphDataPhase1.getNumbOfPoints() self.scl_long_tuneup_controller.getMessageTextField().setText(txt) print "debug ===================" print txt time.sleep(10.) return false y_arr = [] for ip in range(graphDataPhase1.getNumbOfPoints()): y_arr.append(graphDataPhase1.getY(ip)) base_phase_diff = y_arr[0] - graphDataPhase0.getY(0) for ip in range(1,graphDataPhase0.getNumbOfPoints()): y0 = graphDataPhase0.getY(ip) y_arr[ip] = makePhaseNear(y_arr[ip],y0+base_phase_diff) base_phase_diff = y_arr[ip] - y0 #move all data by 360. to make the avg close to 0. y_avg = 0. for y in y_arr: y_avg += y if(len(y_arr) > 1): y_avg /= len(y_arr) y_shift = int(y_avg/360.)*360. for ip in range(len(y_arr)): y_arr[ip] -= y_shift #--- update all bpm phases graphDataPhase1.updateValuesY(y_arr) # recreate phase difference cav_wrapper.recalculatePhaseDiffData() return true
def fit(self):
if(self.active_cav_wrapper == null): return
variables = ArrayList()
delta_hint = InitialDelta()
#----- variable eKin_in
var = Variable("eKin_in",self.eKin_in, - Double.MAX_VALUE, Double.MAX_VALUE)
variables.add(var)
delta_hint.addInitialDelta(var,0.3)
#----- variable cavity amplitude
var = Variable("cav_amp",self.cav_amp, - Double.MAX_VALUE, Double.MAX_VALUE)
variables.add(var)
delta_hint.addInitialDelta(var,self.cav_amp*0.01)
#----- variable cavity phase offset
var = Variable("phase_offset",self.cav_phase_shift, - Double.MAX_VALUE, Double.MAX_VALUE)
variables.add(var)
delta_hint.addInitialDelta(var,1.0)
#-------- solve the fitting problem
scorer = CavAmpPhaseScorer(self,variables)
maxSolutionStopper = SolveStopperFactory.maxEvaluationsStopper(120)
self.solver = Solver(SimplexSearchAlgorithm(),maxSolutionStopper)
problem = ProblemFactory.getInverseSquareMinimizerProblem(variables,scorer,0.0001)
problem.addHint(delta_hint)
self.solver.solve(problem)
#------- get results
trial = self.solver.getScoreBoard().getBestSolution()
err2 = scorer.score(trial,variables)
[self.eKin_in,self.cav_amp,self.cav_phase_shift] = scorer .getTrialParams(trial)
self.active_cav_wrapper.eKin_in = self.eKin_in
self.active_cav_wrapper.designPhase = makePhaseNear(self.active_cav_wrapper.livePhase - self.cav_phase_shift,0.)
self.active_cav_wrapper.eKin_err = math.sqrt(err2)
cav_phase = self.active_cav_wrapper.livePhase
self.active_cav_wrapper.eKin_out = self.getModelEnergyOut(self.eKin_in,self.cav_amp,cav_phase,self.cav_phase_shift)
#print "debug cav=",self.active_cav_wrapper.alias," shift=",self.cav_phase_shift," amp=",self.cav_amp," err2=", math.sqrt(err2)," ekinOut=", self.active_cav_wrapper.eKin_out
#----- this defenition of the avg. gap phase will be replaced by another with self.model_eKin_in
self.active_cav_wrapper.avg_gap_phase = self.getAvgGapPhase()
self.active_cav_wrapper.designAmp = self.cav_amp
self.solver = null
#----make theory graph plot
x_arr = []
y_arr = []
for i in range(self.scan_gd.getNumbOfPoints()):
phase = self.scan_gd.getX(i)
y = self.scan_gd.getY(i)
x_arr.append(phase)
y_arr.append(y)
self.active_cav_wrapper.eKinOutPlotTh.addPoint(x_arr,y_arr)
def actionPerformed(self,actionEvent): scl_long_tuneup_phase_scan_controller = self.scl_long_tuneup_controller.scl_long_tuneup_phase_scan_controller amp_limit = scl_long_tuneup_phase_scan_controller.post_scan_panel.amp_limit_text.getValue() cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers bpms_table = scl_long_tuneup_phase_scan_controller.bpms_table for cav_wrapper in cav_wrappers: if((not cav_wrapper.isGood) or (not cav_wrapper.isMeasured)): continue self.applyBPM_AmpLimit(amp_limit,cav_wrapper) if(self.scl_long_tuneup_controller.cav0_wrapper.isMeasured): self.applyBPM_AmpLimit(amp_limit,self.scl_long_tuneup_controller.cav0_wrapper) bpms_table.getModel().fireTableDataChanged() #wrap all BPM phase scan results in the phase analysis for cav_wrapper in cav_wrappers: if((not cav_wrapper.isGood) or (not cav_wrapper.isMeasured)): continue cav_pos = cav_wrapper.pos bpm_wrappers = [] for bpm_ind in range(len(cav_wrapper.bpm_wrappers)): bpm_wrapper = cav_wrapper.bpm_wrappers[bpm_ind] res_bool = cav_wrapper.bpm_amp_phase_dict.has_key(bpm_wrapper) res_bool = res_bool and cav_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind] res_bool = res_bool and (bpm_wrapper.pos > cav_pos) if(res_bool): bpm_wrappers.append(bpm_wrapper) for bpm_ind in range(len(bpm_wrappers)-1): (graphDataAmp0,graphDataPhase0) = cav_wrapper.bpm_amp_phase_dict[bpm_wrappers[bpm_ind]] (graphDataAmp1,graphDataPhase1) = cav_wrapper.bpm_amp_phase_dict[bpm_wrappers[bpm_ind+1]] if(graphDataPhase0.getNumbOfPoints() < 1): break y_arr = [] for ip in range(graphDataPhase1.getNumbOfPoints()): y_arr.append(graphDataPhase1.getY(ip)) base_phase_diff = y_arr[0] - graphDataPhase0.getY(0) for ip in range(1,graphDataPhase0.getNumbOfPoints()): y0 = graphDataPhase0.getY(ip) y_arr[ip] = makePhaseNear(y_arr[ip],y0+base_phase_diff) base_phase_diff = y_arr[ip] - y0 #move all data by 360. to make the avg close to 0. y_avg = 0. for y in y_arr: y_avg += y if(len(y_arr) > 1): y_avg /= len(y_arr) y_shift = int(y_avg/360.)*360. for ip in range(len(y_arr)): y_arr[ip] -= y_shift #--- update all bpm phases graphDataPhase1.updateValuesY(y_arr)
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 actionPerformed(self,actionEvent):
self.scl_long_tuneup_controller.getMessageTextField().setText("This actions is not implemented yet!")
self.scl_long_tuneup_controller.getMessageTextField().setText("")
scl_long_tuneup_rescale_controller = self.scl_long_tuneup_controller.scl_long_tuneup_rescale_controller
init_amp_phases_panel = scl_long_tuneup_rescale_controller.init_amp_phases_panel
scl_tracker_model = scl_long_tuneup_rescale_controller.scl_tracker_model
if(not scl_tracker_model.isModelReady()):
txt = "The data for the SCL model is not ready! Go to Phase Analysis!"
self.scl_long_tuneup_controller.getMessageTextField().setText(txt)
return
if(not scl_tracker_model.modelArrivalTimesIsReady):
txt = "The model was not initialized! Hit the Init SCL Model button!"
self.scl_long_tuneup_controller.getMessageTextField().setText(txt)
return
bpms_phase_shift_panel = scl_long_tuneup_rescale_controller.bpms_phase_shift_panel
# the frequency of BPMs in SCL is 0.5 of the frequency of RF cavities
phase_shift_global = 2*bpms_phase_shift_panel.phase_shift_text.getValue()
cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers
for cav_wrapper in cav_wrappers:
if(cav_wrapper.isGood):
new_cav_phase = makePhaseNear(cav_wrapper.rescaleBacket.livePhase + phase_shift_global,0.)
cav_wrapper.cav.setCavPhase(new_cav_phase)
def harmonicsAnalysisStep(self): if(self.active_cav_wrapper == null): return self.eKin_in = self.active_cav_wrapper.eKin_in self.cav_amp = 14.0 self.cav_phase_shift = 0. #--------- first iteration self.getDiff2(self.eKin_in,self.cav_amp,self.cav_phase_shift) err = self.harmonicsAnalyzer.analyzeData(self.scan_gd) harm_function = self.harmonicsAnalyzer.getHrmonicsFunction() energy_amp_test = harm_function.getParamArr()[1] energy_amp_exp = self.active_cav_wrapper.energy_guess_harm_funcion.getParamArr()[1] self.cav_amp = self.cav_amp*energy_amp_exp/energy_amp_test #--------- second iteration self.getDiff2(self.eKin_in,self.cav_amp,self.cav_phase_shift) err = self.harmonicsAnalyzer.analyzeData(self.scan_gd) harm_function = self.harmonicsAnalyzer.getHrmonicsFunction() energy_amp_test = harm_function.getParamArr()[1] energy_amp_exp = self.active_cav_wrapper.energy_guess_harm_funcion.getParamArr()[1] self.cav_amp = self.cav_amp*energy_amp_exp/energy_amp_test max_model_energy_phase = self.harmonicsAnalyzer.getPositionOfMax() max_exp_energy_phase = self.active_cav_wrapper.energy_guess_harm_funcion.findMax() self.cav_phase_shift = makePhaseNear(-(max_model_energy_phase - max_exp_energy_phase),0.)
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)
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 calculateOffSets(self):
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
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_out = bpms_offsets_from_hebt1_panel.ring_energy_text.getValue()
if(eKin_out == 0.):
self.scl_long_tuneup_controller.getMessageTextField().setText("The Ring Energy is 0 GeV! Cannot calculate BPM phase offsets!")
return
gamma = (mass+eKin_out)/mass
beta = math.sqrt(1.0-1.0/(gamma*gamma))
bpm_freq = self.scl_long_tuneup_controller.bpm_freq
n_cavs = len(self.scl_long_tuneup_controller.cav_wrappers)
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[n_cavs-1]
#--- initial parameters
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
if(bpm_wrapper.pos < cav_wrapper.pos):
bpm_wrapper.right_phase_offset.phaseOffset_avg = 0.
bpm_wrapper.right_phase_offset.phaseOffset_err = 0.
bpm_wrapper.right_phase_offset.isReady = false
bpm_wrapper.right_phase_offset.phaseOffset_arr = []
cav_wrapper.eKin_out_guess = eKin_out
#------ start moving along cavities -------------------
for cav_ind in range(n_cavs-1,-1,-1):
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[cav_ind]
if(cav_wrapper.isGood and (not cav_wrapper.isMeasured)): break
if(cav_ind != n_cavs-1):
cav_wrapper.eKin_out_guess = self.scl_long_tuneup_controller.cav_wrappers[cav_ind+1].eKin_in_guess
if(not cav_wrapper.isGood):
cav_wrapper.eKin_in_guess = cav_wrapper.eKin_out_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.right_phase_offset.isReady):
bpm_wrappers_good_arr.append(bpm_wrapper)
else:
bpm_wrappers_not_done_arr.append(bpm_wrapper)
initEnergyOutGuessHarmFunc(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
calculateOffsetsForNotDoneBPMsRight(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)," eKin_in=",cav_wrapper.eKin_in_guess," eKin_out=",cav_wrapper.eKin_out_guess
#---- analysis of the "All Cavities Off" case
cav_wrapper = self.scl_long_tuneup_controller.cav_wrappers[0]
cav0_wrapper = self.scl_long_tuneup_controller.cav0_wrapper
param_arr = [cav_wrapper.eKin_in_guess,]
cav0_wrapper.energy_guess_harm_funcion.setParamArr(param_arr)
cav0_wrapper.eKin_in_guess = cav_wrapper.eKin_in_guess
cav0_wrapper.eKin_out_guess = cav_wrapper.eKin_in_guess
if(cav0_wrapper.isGood and cav0_wrapper.isMeasured):
# 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(cav0_wrapper.bpm_wrappers)):
bpm_wrapper = cav0_wrapper.bpm_wrappers[bpm_ind]
is_wanted = bpm_wrapper.isGood
is_wanted = is_wanted and cav0_wrapper.bpm_wrappers_useInPhaseAnalysis[bpm_ind]
if(is_wanted):
if(bpm_wrapper.right_phase_offset.isReady):
bpm_wrappers_good_arr.append(bpm_wrapper)
else:
bpm_wrappers_not_done_arr.append(bpm_wrapper)
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
calculateOffsetsForNotDoneBPMsRight(cav0_wrapper,self.scl_long_tuneup_controller,bpm_wrappers_good_arr,bpm_wrappers_not_done_arr)
#print "debug cav=",cav0_wrapper.alias," n_bad=",len(bpm_wrappers_not_done_arr)," eKin_in=",cav0_wrapper.eKin_in_guess," eKin_out=",cav0_wrapper.eKin_out_guess
else:
txt = "All cavities Off Case does not have the measured data!"
self.scl_long_tuneup_controller.getMessageTextField().setText(txt)
#---- set the calculated energy at CCL4 exit
bpms_offsets_from_hebt1_panel.init_energy_text.setValue(cav0_wrapper.eKin_out_guess)
#----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.right_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
#---- recalculate 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.right_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.right_phase_offset.phaseOffset_avg
for bpm_wrapper in self.scl_long_tuneup_controller.bpm_wrappers:
if(bpm_wrapper.isGood):
if(bpm_wrapper.right_phase_offset.isReady):
phase_offset = bpm_wrapper.right_phase_offset.phaseOffset_avg
phase_offset = makePhaseNear(phase_offset - base_bpm_phase_offset,0.)
bpm_wrapper.right_phase_offset.phaseOffset_avg = phase_offset
self.scl_long_tuneup_controller.updateAllTables()
def setUpCavityPhase(self,cav_wrapper): #--- wrap all BPMs phase scans at once if(self.wrapPhases): res_phase_wrap = self.allBPMs_PhaseWrapper(cav_wrapper) if(not res_phase_wrap): return false max_bad_points_count = 2 gd = cav_wrapper.phaseDiffPlot gdTh = cav_wrapper.phaseDiffPlotTh gdTh.removeAllPoints() if(gd.getNumbOfPoints() < 8): return false err = self.harmonicsAnalyzer.analyzeData(gd) harm_function = self.harmonicsAnalyzer.getHrmonicsFunction() #-----remove bad points bad_points_count = 0 bad_index = 1 while(bad_index >= 0): bad_index = -1 for i in range(gd.getNumbOfPoints()): phase = gd.getX(i) y_appr = harm_function.getValue(phase) y = gd.getY(i) if(math.fabs(y-y_appr) > 3.0*err): bad_index = i bad_points_count += 1 break if(bad_index >= 0): gd.removePoint(bad_index) bpm_wrappers = cav_wrapper.bpm_wrappers for bpm_wrapper in bpm_wrappers: if(cav_wrapper.bpm_amp_phase_dict.has_key(bpm_wrapper)): (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper] graphDataAmp.removePoint(bad_index) graphDataPhase.removePoint(bad_index) # we should stop if we have too many bad points if(bad_points_count > max_bad_points_count): return false if(bad_points_count > 0): err = self.harmonicsAnalyzer.analyzeData(gd) harm_function = self.harmonicsAnalyzer.getHrmonicsFunction() #----find a new cavity phase min_phase = self.harmonicsAnalyzer.getPositionOfMin() new_phase = cav_wrapper.initLivePhase if(self.keepCavPhases): cav_wrapper.scanPhaseShift = makePhaseNear(new_phase - min_phase,0.) else: new_phase = makePhaseNear(min_phase + cav_wrapper.scanPhaseShift,0.) # ?????? should be tested with CA cav_wrapper.livePhase = new_phase if(not self.fake_scan): cav_wrapper.cav.setCavPhase(cav_wrapper.livePhase) cav_wrapper.livePhase = new_phase cav_wrapper.phase_scan_harm_amp = harm_function.getParamArr()[1] cav_wrapper.phase_scan_harm_err = err cav_wrapper.phase_scan_harm_funcion.setParamArr(self.harmonicsAnalyzer.getHrmonicsFunction().getParamArr()) #----make theory graph plot x_arr = [] y_arr = [] for i in range(73): phase = -180.0 + 5.0*i y = harm_function.getValue(phase) x_arr.append(phase) y_arr.append(y) gdTh.addPoint(x_arr,y_arr) return true
def analyze_Data_Method(self):
scl_long_tuneup_controller = self.scl_long_tuneup_controller
max_phase_diff0 = self.max_phase_err_text.getValue()
cav_wrappers = scl_long_tuneup_controller.cav_wrappers[1:]
#----- dictionary with the bad data
self.cavs_to_bpm_dict = {}
cavs_to_bpm_dict = self.cavs_to_bpm_dict
#----- arrays with bad data for the tables
self.cavs_with_bad_data_arr = []
self.bpms_arr = []
self.points_arr = []
#---- data analysis for bad points
total_nPoints = 0
for cav_wrapper in cav_wrappers:
if (cav_wrapper.isGood and cav_wrapper.isMeasured):
bpm_wrapper0 = cav_wrapper.bpm_wrapper0
bpm_wrapper1 = cav_wrapper.bpm_wrapper1
pos0 = bpm_wrapper0.pos
pos1 = bpm_wrapper1.pos
phaseDiffPlot = cav_wrapper.phaseDiffPlot
(graphDataAmp0, graphDataPhase0
) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper0]
if (phaseDiffPlot.getNumbOfPoints() == 0): continue
for bpm_wrapper_ind in range(len(cav_wrapper.bpm_wrappers)):
bpm_wrapper = cav_wrapper.bpm_wrappers[bpm_wrapper_ind]
pos = bpm_wrapper.pos
if (pos < pos0): continue
pos_coeff = (pos - pos0) / (pos1 - pos0)
max_phase_diff = max_phase_diff0
if (pos_coeff >= 1.0):
max_phase_diff = pos_coeff * max_phase_diff0
if (cav_wrapper.
bpm_wrappers_useInPhaseAnalysis[bpm_wrapper_ind]):
(graphDataAmp, graphDataPhase
) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper]
nPoints = phaseDiffPlot.getNumbOfPoints()
bpm_phase_delta = graphDataPhase.getY(
nPoints - 1) - graphDataPhase0.getY(
nPoints - 1
) - pos_coeff * phaseDiffPlot.getY(nPoints - 1)
bad_points_arr = []
for ind in range(phaseDiffPlot.getNumbOfPoints()):
total_nPoints += 1
y = graphDataPhase.getY(
ind) - graphDataPhase0.getY(
ind) - pos_coeff * phaseDiffPlot.getY(
ind) - bpm_phase_delta
y = makePhaseNear(y, 0.)
if (abs(y) > max_phase_diff):
bad_points_arr.append(
[ind, graphDataPhase.getX(ind), y])
if (len(bad_points_arr) > 0):
if (not cavs_to_bpm_dict.has_key(cav_wrapper)):
cavs_to_bpm_dict[cav_wrapper] = [[], {}]
[bpm_wrappers, bpms_to_points_dict
] = cavs_to_bpm_dict[cav_wrapper]
bpm_wrappers.append(bpm_wrapper)
bpms_to_points_dict[bpm_wrapper] = bad_points_arr
for cav_wrapper in cav_wrappers:
if (cavs_to_bpm_dict.has_key(cav_wrapper)):
self.cavs_with_bad_data_arr.append(cav_wrapper)
#--------------------------------------------------------------------
nCavs = 0
nBPMs = 0
nPoints = 0
for cav_wrapper in self.cavs_with_bad_data_arr:
[bpm_wrappers, bpms_to_points_dict] = cavs_to_bpm_dict[cav_wrapper]
nCavs += 1
nBPMs += len(bpm_wrappers)
for bpm_wrapper in bpm_wrappers:
points_arr = bpms_to_points_dict[bpm_wrapper]
nPoints += len(points_arr)
st = "N Bad: Cavs= " + str(nCavs) + " BPMs= " + str(
nBPMs) + " Phase Points=" + str(nPoints) + "/" + str(
total_nPoints)
self.statistics_of_errors_txt.setText(st)
self.cavs_table.getModel().fireTableDataChanged()
self.bpms_table.getModel().fireTableDataChanged()
self.points_table.getModel().fireTableDataChanged()
nCavs = len(self.cavs_with_bad_data_arr)
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 run(self):
cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers
# this is a guess energy here
cav_wrappers[0].eKin_in = 185.6
n_cavs = len(cav_wrappers)
messageTextField = self.scl_long_tuneup_controller.getMessageTextField()
if(messageTextField != null):
messageTextField.setText("")
scl_long_tuneup_phase_analysis_controller = self.scl_long_tuneup_controller.scl_long_tuneup_phase_analysis_controller
scl_one_cavity_tracker_model = scl_long_tuneup_phase_analysis_controller.scl_one_cavity_tracker_model
analysis_state_controller = scl_long_tuneup_phase_analysis_controller.analysis_state_controller
analysis_state_controller.setIsRunning(true)
cavs_table = scl_long_tuneup_phase_analysis_controller.cavs_table
analysis_status_text = scl_long_tuneup_phase_analysis_controller.start_stop_analysis_panel.analysis_status_text
#---------start deal with selected cavities
cav_selected_inds = cavs_table.getSelectedRows()
if(len(cav_selected_inds) < 1 or cav_selected_inds[0] < 0):
if(messageTextField != null):
messageTextField.setText("Select one or more cavities to start Phase Analysis!")
analysis_state_controller.setIsRunning(false)
return
# these are the table model indexes
cav_wrapper = null
start_ind = cav_selected_inds[0]
last_ind = cav_selected_inds[len(cav_selected_inds)-1]
if(self.run_to_end): last_ind = n_cavs - 1
#----- set isAnalyzed=false for all downstream cavities
cav_wrapper = cav_wrappers[start_ind]
cav_wrapper.isAnalyzed = false
for cav_table_ind in range(start_ind+1,n_cavs):
cav_wrapper = cav_wrappers[cav_table_ind]
cav_wrapper.isAnalyzed = false
cav_wrapper.eKin_err = 0.
cav_wrapper.model_eKin_out = 0.
cav_wrapper.bpm_eKin_out = 0.
cav_wrapper.real_scanPhaseShift = 0.
cav_wrapper.eKinOutPlot.removeAllPoints()
cav_wrapper.eKinOutPlotTh.removeAllPoints()
cavs_table.getModel().fireTableDataChanged()
#-------start loop over cavities in the table
time_start = time.time()
n_total = last_ind - start_ind + 1
n_count = 0
for cav_table_ind in range(start_ind,last_ind+1):
#print "debug cav_table_index=",cav_table_ind
cav_wrapper = cav_wrappers[cav_table_ind]
if(cav_wrapper.eKin_in == 0.):
if(messageTextField != null):
messageTextField.setText("Cavity "+cav_wrapper.alias+" has 0. inpit energy. Fix it!")
analysis_state_controller.setIsRunning(false)
return
if(not cav_wrapper.isGood):
cav_wrapper.eKin_out = cav_wrapper.eKin_in
cav_wrapper.model_eKin_out = cav_wrapper.eKin_out
if(cav_table_ind != 0):
cav_wrapper.model_eKin_out = cav_wrappers[cav_table_ind-1].model_eKin_out
#-----set the eKin_in for the next cavity
if(cav_table_ind != len(cav_wrappers)-1):
cav_wrappers[cav_table_ind+1].eKin_in = cav_wrapper.eKin_out
continue
if(not cav_wrapper.isMeasured):
if(messageTextField != null):
messageTextField.setText("Cavity "+cav_wrapper.alias+" does not have measured data! Stop analysis.")
analysis_state_controller.setIsRunning(false)
return
cavs_table.setRowSelectionInterval(cav_table_ind,cav_table_ind)
txt = "Analysis is running! Cavity="+cav_wrapper.alias
if(start_ind != last_ind): txt = txt + " to Cavity="+cav_wrappers[last_ind-1].alias
if(n_count > 1):
run_time = time.time() - time_start
run_time_sec = int(run_time % 60)
run_time_min = int(run_time/60.)
eta_time = ((run_time/n_count)*(n_total - n_count))
eta_time_sec = int(eta_time % 60)
eta_time_min = int(eta_time/60.)
txt = txt + " ETA= %3d min %2d sec "%(eta_time_min,eta_time_sec)
txt = txt + " Elapse= %3d min %2d sec "%(run_time_min,run_time_sec)
analysis_status_text.setText(txt)
if(analysis_state_controller.getShouldStop()): break
#calculate the out energy vs. cav. phase
bpm_wrappers_good_arr = []
for bpm_ind in range(len(cav_wrapper.bpm_wrappers)):
bpm_wrapper = cav_wrapper.bpm_wrappers[bpm_ind]
# make array of BPMs already having offsets and good for phase analysis
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.final_phase_offset.isReady):
bpm_wrappers_good_arr.append(bpm_wrapper)
#print "debug start E(rf phase) calculation"
if(len(bpm_wrappers_good_arr) < 3):
if(messageTextField != null):
n_good_bpms = len(bpm_wrappers_good_arr)
messageTextField.setText("Cavity "+cav_wrapper.alias+" does not enough BPMs with offsets! Stop analysis. N BPMs="+str(n_good_bpms))
analysis_state_controller.setIsRunning(false)
return
calculateEneregyVsPhase(cav_wrapper,self.scl_long_tuneup_controller,bpm_wrappers_good_arr)
#print "debug stop E(rf phase) calculation"
if(analysis_state_controller.getShouldStop()): break
#fit the harmonics function to the energy gain
cav_wrapper.eKin_err = self.harmonicsAnalyzer.analyzeData(cav_wrapper.eKinOutPlot)
harm_function = self.harmonicsAnalyzer.getHrmonicsFunction()
#-----check fitting quality - remove bad points
bad_point_ind = 0
bad_points_count = 0
while(bad_point_ind >= 0):
bad_point_ind = -1
for ibp in range(cav_wrapper.eKinOutPlot.getNumbOfPoints()):
exp_val = cav_wrapper.eKinOutPlot.getY(ibp)
harm_val = harm_function.getValue(cav_wrapper.eKinOutPlot.getX(ibp))
diff = math.fabs(exp_val-harm_val)
if(math.fabs(exp_val-harm_val) > 2.8*cav_wrapper.eKin_err):
bad_point_ind = ibp
break
if(bad_point_ind >= 0):
bad_points_count += 1
cav_wrapper.eKinOutPlot.removePoint(bad_point_ind)
cav_wrapper.eKin_err = self.harmonicsAnalyzer.analyzeData(cav_wrapper.eKinOutPlot)
harm_function = self.harmonicsAnalyzer.getHrmonicsFunction()
if(bad_points_count > int(0.2*cav_wrapper.eKinOutPlot.getNumbOfPoints())):
analysis_status_text.setText("Analysis stopped! Bad scan! Cav="+cav_wrapper.alias)
return
cav_wrapper.bpm_eKin_out = harm_function.getValue(cav_wrapper.livePhase)
cav_wrapper.real_scanPhaseShift = makePhaseNear(cav_wrapper.livePhase - harm_function.findMax(),0.)
cav_wrapper.energy_guess_harm_funcion.setParamArr(harm_function.getParamArr())
if(analysis_state_controller.getShouldStop()): break
# put model based analysis here
scl_one_cavity_tracker_model.setActiveCavity(cav_wrapper)
scl_one_cavity_tracker_model.harmonicsAnalysisStep()
scl_one_cavity_tracker_model.fit()
model_eKin_in = cav_wrapper.eKin_in
if(cav_table_ind != 0):
model_eKin_in = cav_wrappers[cav_table_ind-1].model_eKin_out
cav_amp = scl_one_cavity_tracker_model.cav_amp
cav_phase = cav_wrapper.livePhase
cav_phase_shift = scl_one_cavity_tracker_model.cav_phase_shift
cav_wrapper.model_eKin_out = scl_one_cavity_tracker_model.getModelEnergyOut(model_eKin_in,cav_amp,cav_phase,cav_phase_shift)
cav_wrapper.avg_gap_phase = scl_one_cavity_tracker_model.getAvgGapPhase()
if(analysis_state_controller.getShouldStop()): break
cav_wrapper.isAnalyzed = true
cavs_table.getModel().fireTableDataChanged()
#-----set the eKin_in for the next cavity
if(cav_table_ind != len(cav_wrappers)-1):
cav_wrappers[cav_table_ind+1].eKin_in = cav_wrapper.eKin_out
n_count += 1
#------end of cavities loop
txt = ""
if(cav_wrapper != null):
txt = " The last cavity was "+cav_wrapper.alias+" ."
run_time = time.time() - time_start
run_time_sec = int(run_time % 60)
run_time_min = int(run_time/60.)
txt = txt + " Total time= %3d min %2d sec "%(run_time_min,run_time_sec)
if(analysis_state_controller.getShouldStop()):
analysis_status_text.setText("Analysis was interrupted!"+txt)
else:
analysis_status_text.setText("Analysis finished!"+txt)
analysis_state_controller.setIsRunning(false)
scl_one_cavity_tracker_model.restoreInitAmpPhases()
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.)
