def __init__(self,scl_long_tuneup_controller): self.scl_long_tuneup_controller = scl_long_tuneup_controller self.scl_accSeq = self.scl_long_tuneup_controller.scl_accSeq self.part_tracker = AlgorithmFactory.createParticleTracker(self.scl_accSeq) self.part_tracker.setRfGapPhaseCalculation(true) self.part_probe_init = ProbeFactory.createParticleProbe(self.scl_accSeq,self.part_tracker) self.scenario = Scenario.newScenarioFor(self.scl_accSeq) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.resync() # in the dictionary we will have # cav_wrappers_param_dict[cav_wrapper] = [cavAmp,phase,[[gapLattElem,E0,ETL],...]] # E0 and ETL are parameters for all RF gaps self.cav_wrappers_param_dict = {} cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers self.cav_amp_phase_dict = {} for cav_wrapper in cav_wrappers: amp = cav_wrapper.cav.getDfltCavAmp() phase = cav_wrapper.cav.getDfltCavPhase() self.cav_amp_phase_dict[cav_wrapper] = (amp,phase) #------ Make rf gap arrays for each cavity. #------ The elements are IdealRfGap instances not AcceleratorNode. #------ self.cavToGapsDict has {cav_name:[irfGaps]} rfGaps = self.scl_accSeq.getAllNodesWithQualifier(AndTypeQualifier().and((OrTypeQualifier()).or(RfGap.s_strType))) self.cavToGapsDict = {} for cav_wrapper in cav_wrappers: self.cavToGapsDict[cav_wrapper] = [] for rfGap in rfGaps: if(rfGap.getId().find(cav_wrapper.cav.getId()) >= 0): irfGaps = self.scenario.elementsMappedTo(rfGap) self.cavToGapsDict[cav_wrapper].append(irfGaps[0]) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_PHASE,phase) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_ETL,val) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_E0,val) #self.scenario.setModelInput(quad,ElectromagnetPropertyAccessor,PROPERTY_FIELD,val) #---------------------------------------------------------------- self.scan_gd = BasicGraphData() self.harmonicsAnalyzer = HarmonicsAnalyzer(2) self.eKin_in = 185.6 self.cav_amp = 14.0 self.cav_phase_shift = 0. #------------------------ self.active_cav_wrapper = null self.solver = null
def __init__(self,scl_long_tuneup_controller, run_to_end = true): self.scl_long_tuneup_controller = scl_long_tuneup_controller self.run_to_end = run_to_end self.harmonicsAnalyzer = HarmonicsAnalyzer(2) #--- fake scan boolean variable scl_long_tuneup_phase_scan_controller = self.scl_long_tuneup_controller.scl_long_tuneup_phase_scan_controller set_phase_shift_panel = scl_long_tuneup_phase_scan_controller.set_phase_shift_panel self.fake_scan = set_phase_shift_panel.scanSim_RadioButton.isSelected() self.useTrigger = set_phase_shift_panel.beamTrigger_RadioButton.isSelected() self.keepCavPhases = set_phase_shift_panel.keepLiveCavPhases_RadioButton.isSelected() self.wrapPhases = set_phase_shift_panel.wrapPhases_RadioButton.isSelected()
class SCL_One_Cavity_Tracker_Model: def __init__(self,scl_long_tuneup_controller): self.scl_long_tuneup_controller = scl_long_tuneup_controller self.scl_accSeq = self.scl_long_tuneup_controller.scl_accSeq self.part_tracker = AlgorithmFactory.createParticleTracker(self.scl_accSeq) self.part_tracker.setRfGapPhaseCalculation(true) self.part_probe_init = ProbeFactory.createParticleProbe(self.scl_accSeq,self.part_tracker) self.scenario = Scenario.newScenarioFor(self.scl_accSeq) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.resync() # in the dictionary we will have # cav_wrappers_param_dict[cav_wrapper] = [cavAmp,phase,[[gapLattElem,E0,ETL],...]] # E0 and ETL are parameters for all RF gaps self.cav_wrappers_param_dict = {} cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers self.cav_amp_phase_dict = {} for cav_wrapper in cav_wrappers: amp = cav_wrapper.cav.getDfltCavAmp() phase = cav_wrapper.cav.getDfltCavPhase() self.cav_amp_phase_dict[cav_wrapper] = (amp,phase) #------ Make rf gap arrays for each cavity. #------ The elements are IdealRfGap instances not AcceleratorNode. #------ self.cavToGapsDict has {cav_name:[irfGaps]} rfGaps = self.scl_accSeq.getAllNodesWithQualifier(AndTypeQualifier().and((OrTypeQualifier()).or(RfGap.s_strType))) self.cavToGapsDict = {} for cav_wrapper in cav_wrappers: self.cavToGapsDict[cav_wrapper] = [] for rfGap in rfGaps: if(rfGap.getId().find(cav_wrapper.cav.getId()) >= 0): irfGaps = self.scenario.elementsMappedTo(rfGap) self.cavToGapsDict[cav_wrapper].append(irfGaps[0]) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_PHASE,phase) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_ETL,val) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_E0,val) #self.scenario.setModelInput(quad,ElectromagnetPropertyAccessor,PROPERTY_FIELD,val) #---------------------------------------------------------------- self.scan_gd = BasicGraphData() self.harmonicsAnalyzer = HarmonicsAnalyzer(2) self.eKin_in = 185.6 self.cav_amp = 14.0 self.cav_phase_shift = 0. #------------------------ self.active_cav_wrapper = null self.solver = null def restoreInitAmpPhases(self): cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers for cav_wrapper in cav_wrappers: (amp,phase) = self.cav_amp_phase_dict[cav_wrapper] self.active_cav_wrapper.cav.updateDesignAmp(amp) self.active_cav_wrapper.cav.updateDesignPhase(phase) self.setActiveCavity(null) def getEkinAmpPhaseShift(self): return (self.eKin_in,self.cav_amp,self.cav_phase_shift) def setModelAmpPhaseToActiveCav(self,amp,phase,phase_shift): if(self.active_cav_wrapper != null): self.active_cav_wrapper.cav.updateDesignAmp(amp) self.active_cav_wrapper.cav.updateDesignPhase(phase-phase_shift) 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 getModelEnergyOut(self,eKin_in,amp,phase,phase_shift): if(self.active_cav_wrapper == null): return 0. self.setModelAmpPhaseToActiveCav(amp,phase,phase_shift) part_probe = ParticleProbe(self.part_probe_init) part_probe.setKineticEnergy(eKin_in*1.0e+6) self.scenario.setProbe(part_probe) self.scenario.resync() self.scenario.run() return self.scenario.getTrajectory().finalState().getKineticEnergy()/1.0e+6 def fillOutEneregyVsPhase(self,eKin_in,amp,phase_shift,phase_arr): self.scan_gd.removeAllPoints() if(self.active_cav_wrapper == null): return self.active_cav_wrapper.cav.updateDesignAmp(amp) self.scenario.resync() irfGap = self.cavToGapsDict[self.active_cav_wrapper][0] for phase in phase_arr: part_probe = ParticleProbe(self.part_probe_init) part_probe.setKineticEnergy(eKin_in*1.0e+6) self.scenario.setProbe(part_probe) #self.active_cav_wrapper.cav.updateDesignPhase(phase-phase_shift) #self.scenario.resync() irfGap.setPhase((phase-phase_shift)*math.pi/180.) self.scenario.run() eKin_out = self.scenario.getTrajectory().finalState().getKineticEnergy()/1.0e+6 self.scan_gd.addPoint(phase,eKin_out) return self.scan_gd def getDiff2(self,eKin_in,amp,phase_shift): if(self.active_cav_wrapper == null): return 0. scan_gdExp = self.active_cav_wrapper.eKinOutPlot n_points = scan_gdExp.getNumbOfPoints() if(n_points <= 0): return 0. phase_arr = [] for ip in range(n_points): phase_arr.append(scan_gdExp.getX(ip)) scan_gd = self.fillOutEneregyVsPhase(eKin_in,amp,phase_shift,phase_arr) diff2 = 0. for ip in range(n_points): diff2 += (scan_gd.getY(ip) - scan_gdExp.getY(ip))**2 diff2 /= n_points return diff2 def setActiveCavity(self,cav_wrapper): self.active_cav_wrapper = cav_wrapper if(cav_wrapper != null): self.gap_list = cav_wrapper.cav.getGapsAsList() self.gap_first = self.gap_list.get(0) self.gap_last = self.gap_list.get(self.gap_list.size()-1) self.scenario.setStartNode(self.gap_first.getId()) self.scenario.setStopNode(self.gap_last.getId()) else: self.scenario.unsetStartNode() self.scenario.unsetStopNode() self.gap_first = null self.gap_last = null self.gap_list = null 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.) #print "debug model max=",max_model_energy_phase," exp=",max_exp_energy_phase," shift=",self.cav_phase_shift," amp=",self.cav_amp 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 stopFitting(self): if(self.solver != null): self.solver.stopSolving()
def __init__(self,scl_long_tuneup_controller, run_to_end = true): self.scl_long_tuneup_controller = scl_long_tuneup_controller self.run_to_end = run_to_end self.harmonicsAnalyzer = HarmonicsAnalyzer(2)
class PhaseAnalysis_Runner(Runnable): # main thread runner for the anlysis def __init__(self,scl_long_tuneup_controller, run_to_end = true): self.scl_long_tuneup_controller = scl_long_tuneup_controller self.run_to_end = run_to_end self.harmonicsAnalyzer = HarmonicsAnalyzer(2) 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()
class PhaseScan_Runner(Runnable): def __init__(self,scl_long_tuneup_controller, run_to_end = true): self.scl_long_tuneup_controller = scl_long_tuneup_controller self.run_to_end = run_to_end self.harmonicsAnalyzer = HarmonicsAnalyzer(2) #--- fake scan boolean variable scl_long_tuneup_phase_scan_controller = self.scl_long_tuneup_controller.scl_long_tuneup_phase_scan_controller set_phase_shift_panel = scl_long_tuneup_phase_scan_controller.set_phase_shift_panel self.fake_scan = set_phase_shift_panel.scanSim_RadioButton.isSelected() self.useTrigger = set_phase_shift_panel.beamTrigger_RadioButton.isSelected() self.keepCavPhases = set_phase_shift_panel.keepLiveCavPhases_RadioButton.isSelected() self.wrapPhases = set_phase_shift_panel.wrapPhases_RadioButton.isSelected() def run(self): messageTextField = self.scl_long_tuneup_controller.getMessageTextField() if(messageTextField != null): messageTextField.setText("") scl_long_tuneup_phase_scan_controller = self.scl_long_tuneup_controller.scl_long_tuneup_phase_scan_controller scan_state_controller = scl_long_tuneup_phase_scan_controller.scan_state_controller cavs_table = scl_long_tuneup_phase_scan_controller.cavs_table cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers n_cavs = len(cav_wrappers) phase_step = scl_long_tuneup_phase_scan_controller.start_stop_scan_panel.phase_step_text.getValue() time_wait = scl_long_tuneup_phase_scan_controller.set_phase_shift_panel.time_wait_text.getValue() scan_status_text = scl_long_tuneup_phase_scan_controller.start_stop_scan_panel.scan_status_text scl_long_tuneup_init_controller = self.scl_long_tuneup_controller.scl_long_tuneup_init_controller if(not scl_long_tuneup_init_controller.allPairsSet()): if(messageTextField != null): messageTextField.setText("You should Initialize the scan first! Go to the Init tab!") return scl_long_tuneup_init_controller.connectAllBPMs() beamTrigger = self.scl_long_tuneup_controller.beamTrigger bpmBatchReader = self.scl_long_tuneup_controller.bpmBatchReader bpm_amp_min_limit = scl_long_tuneup_phase_scan_controller.post_scan_panel.amp_limit_text.getValue() #------------------------------- CA START # ?????? For live CA if(beamTrigger == null): if(messageTextField != null): messageTextField.setText("You should Initialize the scan first! Go to the Init tab!") return else: beamTrigger.setFakeScan(self.fake_scan) beamTrigger.setUseTrigger(self.useTrigger) beamTrigger.setSleepTime(time_wait) beamTrigger.scan_state_controller = scan_state_controller bpmBatchReader.setBeamTrigger(beamTrigger) #------------------------------- CA END #---------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 Scan!") beamTrigger.setFakeScan(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 #----- blank and clean scan data for all downstream cavities cav_wrapper = self.scl_long_tuneup_controller.cav0_wrapper if(start_ind != 0): cav_wrapper = cav_wrappers[start_ind-1] cav_wrapper.clean() for cav_table_ind in range(start_ind+1,n_cavs+1): cav_wrapper = cav_wrappers[cav_table_ind-1] if(cav_wrapper.isGood): # ?????? should be tested with CA if(not self.fake_scan): cav_wrapper.setBlankBeam(true) cav_wrapper.clean() cavs_table.getModel().fireTableDataChanged() #-------start loop over cavities in the table result = true 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): cavs_table.setRowSelectionInterval(cav_table_ind,cav_table_ind) cav_wrapper = self.scl_long_tuneup_controller.cav0_wrapper if(cav_table_ind != 0): cav_wrapper = cav_wrappers[cav_table_ind-1] if(not cav_wrapper.isGood): continue if(cav_table_ind != 0): # ?????? should be tested with CA if(not self.fake_scan): cav_wrapper.setBlankBeam(false) txt = "Scan 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.) eat_time = ((run_time/n_count)*(n_total - n_count)) eat_time_sec = int(eat_time % 60) eat_time_min = int(eat_time/60.) txt = txt + " ETA= %3d min %2d sec "%(eat_time_min,eat_time_sec) txt = txt + " Elapse= %3d min %2d sec "%(run_time_min,run_time_sec) scan_status_text.setText(txt) if(scan_state_controller.getShouldStop()): break cav_phase = -180. while(cav_phase <= 180.): #debug #print "debug cav=",cav_wrapper.alias," phase=",cav_phase #--------set cavity phase if(cav_table_ind != 0): # ?????? should be tested with CA if(not self.fake_scan): cav_wrapper.cav.setCavPhase(cav_phase) if(cav_wrapper == self.scl_long_tuneup_controller.cav0_wrapper): scan_status_text.setText("Scan running cavity= "+cav_wrapper.alias+" phase="+str(cav_phase)) if(scan_state_controller.getShouldStop()): break time.sleep(time_wait) if(scan_state_controller.getShouldStop()): break # ?????? For live CA result = false if(not self.fake_scan): result = bpmBatchReader.makePhaseScanStep(cav_phase,cav_wrapper,bpm_amp_min_limit) else: result = self.fakeMakePhaseScanStep(cav_phase,cav_wrapper) if(scan_state_controller.getShouldStop()): break if(result == false): scan_status_text.setText("Scan stopped. Could not get BPM data. Please check!") if(messageTextField != null): messageTextField.setText("") beamTrigger.setFakeScan(false) return if(cav_table_ind != 0): cav_wrapper.addScanPointToPhaseDiffData() cav_phase += phase_step #----end of phase loop if(scan_state_controller.getShouldStop()): break #set up the Cavity phase according to scan if(cav_table_ind != 0): res_phase_set = self.setUpCavityPhase(cav_wrapper) time.sleep(time_wait) if(not res_phase_set): scan_status_text.setText("Scan stopped! Bad scan! Cannot set up phase for cavity="+cav_wrapper.alias) beamTrigger.setFakeScan(false) return cav_wrapper.isMeasured = true cavs_table.getModel().fireTableDataChanged() 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(scan_state_controller.getShouldStop()): scan_status_text.setText("Scan was interrupted!"+txt) else: scan_status_text.setText("Scan finished!"+txt) #restore the beam trigger fake scan state beamTrigger.setFakeScan(false) 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 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 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