def addGraph(self,pv_name,time_arr,val_arr): ind = len(self.gd_arr)%len(self.color_arr) gd = BasicGraphData() gd.setGraphProperty("Legend",pv_name) gd.addPoint(time_arr,val_arr) gd.setGraphColor(self.color_arr[ind]) self.gpF.addGraphData(gd) self.gd_arr.append(gd)
def addGraph(self, pv_name, time_arr, val_arr): ind = len(self.gd_arr) % len(self.color_arr) gd = BasicGraphData() gd.setGraphProperty("Legend", pv_name) gd.addPoint(time_arr, val_arr) gd.setGraphColor(self.color_arr[ind]) self.gpF.addGraphData(gd) self.gd_arr.append(gd)
class WS_Scan_and_Fit_Record: def __init__(self,ws_scan_Record): self.isOn = true self.index = -1 self.pos = 0. self.fit_is_good = false self.gauss_sigma = ws_scan_Record.gauss_sigma self.ws_node = ws_scan_Record.ws_node self.ws_direction = ws_scan_Record.ws_direction self.custom_gauss_sigma = 0. self.custom_rms_sigma = 0. self.gd_wf = BasicGraphData() self.gd_fit_wf = BasicGraphData() self.gd_log_wf = BasicGraphData() self.gd_log_fit_wf = BasicGraphData() self.gd_wf.setDrawLinesOn(false) self.gd_log_wf.setDrawLinesOn(false) self.gd_fit_wf.setDrawPointsOn(false) self.gd_log_fit_wf.setDrawPointsOn(false) self.gd_wf.setGraphPointSize(5) self.gd_log_wf.setGraphPointSize(5) self.gd_fit_wf.setLineThick(3) self.gd_log_fit_wf.setLineThick(3) self.gd_wf.setGraphColor(Color.BLUE) self.gd_log_wf.setGraphColor(Color.BLUE) self.gd_fit_wf.setGraphColor(Color.RED) self.gd_log_fit_wf.setGraphColor(Color.RED) legendKey = GRAPH_LEGEND_KEY legendName = self.ws_node.getId() if(self.ws_direction == WS_DIRECTION_HOR): legendName += " Hor. " if(self.ws_direction == WS_DIRECTION_VER): legendName += " Ver. " self.gd_wf.setGraphProperty(legendKey,legendName+" Data") self.gd_log_wf.setGraphProperty(legendKey,"Log "+legendName+" Data ") self.gd_fit_wf.setGraphProperty(legendKey,"Log "+legendName+" Fit ") self.gd_log_fit_wf.setGraphProperty(legendKey,"Log "+legendName+" Fit ") #----------- copy Graph data ------------- for i in range(ws_scan_Record.gd_wf.getNumbOfPoints()): self.gd_wf.addPoint(ws_scan_Record.gd_wf.getX(i),ws_scan_Record.gd_wf.getY(i)) for i in range(ws_scan_Record.gd_log_wf.getNumbOfPoints()): self.gd_log_wf.addPoint(ws_scan_Record.gd_log_wf.getX(i),ws_scan_Record.gd_log_wf.getY(i)) self.n_fit_points = 150 self.quad_dict = {} self.cav_amp_phase_dict = {} self.param_dict = [self.quad_dict,self.cav_amp_phase_dict] #-----Gauss Fitting params---------------- self.CONST = DoubleInputTextField(0.,ScientificNumberFormat(5),10) self.A0 = DoubleInputTextField(0.,ScientificNumberFormat(5),10) self.X_CENTER = DoubleInputTextField(0.,ScientificNumberFormat(5),10) self.SIGMA = DoubleInputTextField(self.gauss_sigma,ScientificNumberFormat(5),10) self.X_MIN = DoubleInputTextField(ws_scan_Record.left_limit,ScientificNumberFormat(5),10) self.X_MAX = DoubleInputTextField(ws_scan_Record.right_limit,ScientificNumberFormat(5),10) def plotFitData(self): x_min = self.X_MIN.getValue() x_max = self.X_MAX.getValue() step = (x_max - x_min)/(self.n_fit_points - 1) base = self.CONST.getValue() a0 = self.A0.getValue() x0 = self.X_CENTER.getValue() sigma2 = (self.SIGMA.getValue())**2 self.gd_fit_wf.removeAllPoints() self.gd_log_fit_wf.removeAllPoints() for i in range(self.n_fit_points): x = x_min + i*step y = base + a0*math.exp(-(x-x0)**2/(2*sigma2)) self.gd_fit_wf.addPoint(x,y) if(y > 0.): self.gd_log_fit_wf.addPoint(x,math.log(y)) def setParamDict(self,param_dict): self.param_dict = param_dict [self.quad_dict,self.cav_amp_phase_dict] = self.param_dict def getName(self): return self.ws_node.getId() def getAccNode(self): return self.ws_node def updateGaussParams(self): self.custom_gauss_sigma = self.SIGMA.getValue()
class WS_Scan_Record: """ This class keeps the results of the scan in one directions for one LW or WS """ def __init__(self, ws_node, ws_direction = WS_DIRECTION_NULL): self.ws_node = ws_node self.gauss_sigma = 0. self.gd_wf = BasicGraphData() self.gd_log_wf = BasicGraphData() self.gd_wf.setDrawLinesOn(false) self.gd_log_wf.setDrawLinesOn(false) self.gd_wf.setGraphPointSize(5) self.gd_log_wf.setGraphPointSize(5) self.gd_wf.setGraphColor(Color.BLUE) self.gd_log_wf.setGraphColor(Color.BLUE) self.setDirection(ws_direction) self.left_limit = 0. self.right_limit = 0. def setWF(self,wf_x_arr,wf_y_arr): #set waive form self.gd_wf.removeAllPoints() self.gd_log_wf.removeAllPoints() if(len(wf_x_arr) == len(wf_y_arr) and len(wf_y_arr) > 0): self.left_limit = wf_x_arr[0] self.right_limit = wf_x_arr[len(wf_x_arr)-1] y_max = 0. for y in wf_y_arr: if(math.fabs(y_max) < math.fabs(y)): y_max = y if(y_max < 0): for i in range(len(wf_y_arr)): wf_y_arr[i] = - wf_y_arr[i] y_max = - y_max self.gd_wf.addPoint(wf_x_arr,wf_y_arr) for i in range(len(wf_y_arr)): if(wf_y_arr[i] > 0.): self.gd_log_wf.addPoint(wf_x_arr[i],math.log(wf_y_arr[i])) def setDirection( self,ws_direction): self.ws_direction = ws_direction legendKey = GRAPH_LEGEND_KEY legendName = self.ws_node.getId() if(self.ws_direction == WS_DIRECTION_HOR): legendName += " Hor. " if(self.ws_direction == WS_DIRECTION_VER): legendName += " Ver. " self.gd_wf.setGraphProperty(legendKey,legendName+" Data") self.gd_log_wf.setGraphProperty(legendKey,"Log "+legendName+" Data ") def getName(self): return self.ws_node.getId() def getAccNode(self): return self.ws_node def getCopy(self): """ This method will return the partial copy of the record """ cp_record = WS_Scan_Record(self.ws_node,self.ws_direction) cp_record.left_limit = self.left_limit cp_record.right_limit = self.right_limit cp_record.gauss_sigma = self.gauss_sigma #copy Graph data for i in range(self.gd_wf.getNumbOfPoints()): cp_record.gd_wf.addPoint(self.gd_wf.getX(i),self.gd_wf.getY(i)) cp_record.gd_log_wf.addPoint(self.gd_log_wf.getX(i),self.gd_log_wf.getY(i)) return cp_record
class SCL_Cavity_Wrapper: def __init__(self, cav): #self.bpm_ch_amp_phase_dic[BPM_Wrapper] = (graphDataAmp,graphDataPhase) self.cav = cav self.alias = cav.getId().split(":")[1] self.isGood = true self.isMeasured = false self.isAnalyzed = false self.pos = 0. self.bpm_amp_phase_dict = {} self.bpm_wrappers = [] #--- use or not in phase scan analysis self.bpm_wrappers_useInPhaseAnalysis = [] #--- use or not in BPMs' amplitudes analysis self.bpm_wrappers_useInAmpBPMs = [] #--- BPM wrappers for BPM0 and BPM1 during cavity phase setup after the phase scan self.bpm_wrapper0 = null self.bpm_wrapper1 = null self.phaseDiffPlot = BasicGraphData() self.phaseDiffPlot.setGraphPointSize(7) self.phaseDiffPlot.setGraphColor(Color.BLUE) self.phaseDiffPlotTh = BasicGraphData() self.phaseDiffPlotTh.setDrawPointsOn(false) self.phaseDiffPlotTh.setGraphColor(Color.RED) self.phaseDiffPlotTh.setLineThick(3) #----cavity's parameters self.initDesignAmp = 0. self.initDesignPhase = 0. #-- design parameters will be defined after analysis of the phase scan data self.designAmp = 0. self.designPhase = 0. self.avg_gap_phase = 0. # this is a model parameter that will be used in rescaling #--- initial live parameters are measured after initialization self.initLiveAmp = 0. self.initLivePhase = 0. #live phase will be defined after scan self.livePhase = 0. self.scanPhaseShift = -18.0 self.real_scanPhaseShift = 0. #--- avg. phase error and harmonic amp after harmonics fitting during phase scan self.phase_scan_harm_err = 0. self.phase_scan_harm_amp = 0. self.phase_scan_harm_funcion = HramonicsFunc([ 0., ]) self.energy_guess_harm_funcion = HramonicsFunc([ 0., ]) self.eKinOutPlot = BasicGraphData() self.eKinOutPlot.setGraphPointSize(7) self.eKinOutPlot.setGraphColor(Color.BLUE) self.eKinOutPlotTh = BasicGraphData() self.eKinOutPlotTh.setDrawPointsOn(false) self.eKinOutPlotTh.setGraphColor(Color.RED) self.eKinOutPlotTh.setLineThick(3) self.eKinOutPlot.setGraphProperty(GRAPH_LEGEND_KEY, " Ekin Out " + self.alias) self.eKinOutPlotTh.setGraphProperty(GRAPH_LEGEND_KEY, " Ekin Out Fit " + self.alias) #--- energy params self.eKin_in_guess = 0. # is used for CCL4 forward analysis self.eKin_out_guess = 0. # is used for CCL4 forward analysis self.eKin_in = 0. self.eKin_out = 0. self.eKin_err = 0. self.bpm_eKin_out = 0. self.model_eKin_out = 0. #------- the rescale data bucket self.rescaleBacket = CavityRescaleBucket(self) #------- the longitudinal Twiss parameters bucket self.longTwissBucket = Long_Twiss_Bucket(self) #------- LLRF Buffer resettings PVs self.ch_aff_mode = ChannelFactory.defaultFactory().getChannel( "SCL_LLRF:FCM" + self.alias.replace("Cav", "") + ":AFF_Mode") self.ch_aff_reset = ChannelFactory.defaultFactory().getChannel( "SCL_LLRF:FCM" + self.alias.replace("Cav", "") + ":AFF_Reset") #------- Amplitude set goal value PV self.ampl_goal_pv = ChannelFactory.defaultFactory().getChannel( "SCL_LLRF:FCM" + self.alias.replace("Cav", "") + ":cavAmpGoal") #print "debug conncted cav=",self.alias def getLiveAmlitudeSetGoal(self): if (self.ampl_goal_pv.connectAndWait(3.0)): return self.ampl_goal_pv.getValDbl() return 0. def setAFF_Off(self): if (self.ch_aff_mode.connectAndWait(0.1)): self.ch_aff_mode.putVal(0) def setAFF_On(self): if (self.ch_aff_mode.connectAndWait(0.1)): self.ch_aff_mode.putVal(2) def resetAFF(self): if (self.ch_aff_reset.connectAndWait(0.1)): self.ch_aff_reset.putVal(1) def setBlankBeam(self, bool_val): self.cav.setBlankBeam(bool_val) def setUpBPM_Wrappers(self, bpm_wrappers, scl_long_tuneup_controller): self.bpm_amp_phase_dict = {} self.bpm_wrappers = [] self.bpm_wrappers_useInPhaseAnalysis = [] self.bpm_wrappers_useInAmpBPMs = [] for bpm_wrapper in bpm_wrappers: #we will use all bpm_wrappers even if they are before the cavity #if(bpm_wrapper.getPosition() > self.getPosition() and bpm_wrapper.isGood): if (bpm_wrapper.isGood): self.bpm_wrappers.append(bpm_wrapper) self.bpm_wrappers_useInPhaseAnalysis.append(true) self.bpm_wrappers_useInAmpBPMs.append(true) (graphDataAmp, graphDataPhase) = (BasicGraphData(), BasicGraphData()) graphDataAmp.setGraphPointSize(5) graphDataPhase.setGraphPointSize(5) graphDataAmp.setGraphColor(Color.BLUE) graphDataPhase.setGraphColor(Color.BLUE) graphDataPhase.setGraphProperty(GRAPH_LEGEND_KEY, " Phase " + bpm_wrapper.alias) graphDataAmp.setGraphProperty(GRAPH_LEGEND_KEY, " Amp " + bpm_wrapper.alias) self.bpm_amp_phase_dict[bpm_wrapper] = (graphDataAmp, graphDataPhase) # HEBT2 BPMs should not be used in the phase and amp analysis (pending the XAL Online Model fix) for ind in range(len(self.bpm_wrappers)): bpm_wrapper = self.bpm_wrappers[ind] #---- HEBT2 should be excluded - usually energy is wrong for beam transport to HEBT2 if (bpm_wrapper.pos > 280.): self.bpm_wrappers_useInPhaseAnalysis[ind] = false self.bpm_wrappers_useInAmpBPMs[ind] = false # longitudinal twiss bucket update self.longTwissBucket.update() def setBPM_0_1_Wrappers(self, bpm_wrapper0, bpm_wrapper1): self.phaseDiffPlot.removeAllPoints() self.phaseDiffPlotTh.removeAllPoints() self.bpm_wrapper0 = null self.bpm_wrapper1 = null if (self.bpm_amp_phase_dict.has_key(bpm_wrapper0)): self.bpm_wrapper0 = bpm_wrapper0 if (self.bpm_amp_phase_dict.has_key(bpm_wrapper1)): self.bpm_wrapper1 = bpm_wrapper1 self.phaseDiffPlot.removeAllPoints() legendKey = GRAPH_LEGEND_KEY txt = self.alias + " Phase diff " self.phaseDiffPlotTh.setGraphProperty(legendKey, txt + "Fit") if (self.bpm_wrapper0 != null and self.bpm_wrapper1 != null): self.phaseDiffPlot.setGraphProperty( legendKey, txt + self.bpm_wrapper0.alias + " " + self.bpm_wrapper1.alias) else: self.phaseDiffPlot.setGraphProperty(legendKey, txt) def clean(self): for bpm_wrapper in self.bpm_wrappers: (graphDataAmp, graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper] graphDataAmp.removeAllPoints() graphDataPhase.removeAllPoints() self.livePhase = 0. self.isMeasured = false self.isAnalyzed = false self.phase_scan_harm_err = 0. self.phase_scan_harm_amp = 0. self.avg_gap_phase = 0. self.eKin_err = 0. self.model_eKin_out = 0. self.bpm_eKin_out = 0. self.real_scanPhaseShift = 0. self.phase_scan_harm_funcion.setParamArr([ 0., ]) self.phaseDiffPlot.removeAllPoints() self.phaseDiffPlotTh.removeAllPoints() self.eKinOutPlot.removeAllPoints() self.eKinOutPlotTh.removeAllPoints() #---clean the rescale data self.rescaleBacket.clean() #---clean longitudinal Twiss data self.longTwissBucket.clean() def addScanPointToPhaseDiffData(self): if (self.bpm_wrapper0 == null or self.bpm_wrapper1 == null): return (graphDataAmp0, graphDataPhase0) = self.bpm_amp_phase_dict[self.bpm_wrapper0] (graphDataAmp1, graphDataPhase1) = self.bpm_amp_phase_dict[self.bpm_wrapper1] if (graphDataPhase0.getNumbOfPoints() != graphDataPhase1.getNumbOfPoints()): return n_points = graphDataPhase0.getNumbOfPoints() ind = n_points - 1 x = graphDataPhase0.getX(ind) y = graphDataPhase1.getY(ind) - graphDataPhase0.getY(ind) self.phaseDiffPlot.addPoint(x, y) def recalculatePhaseDiffData(self): if (self.bpm_wrapper0 == null or self.bpm_wrapper1 == null): return (graphDataAmp0, graphDataPhase0) = self.bpm_amp_phase_dict[self.bpm_wrapper0] (graphDataAmp1, graphDataPhase1) = self.bpm_amp_phase_dict[self.bpm_wrapper1] if (graphDataPhase0.getNumbOfPoints() != graphDataPhase1.getNumbOfPoints()): return x_arr = [] y_arr = [] for ind in range(graphDataPhase0.getNumbOfPoints()): x_arr.append(graphDataPhase0.getX(ind)) y_arr.append(graphDataPhase1.getY(ind) - graphDataPhase0.getY(ind)) self.phaseDiffPlot.removeAllPoints() self.phaseDiffPlot.addPoint(x_arr, y_arr) def getAmpPhaseGraphs(self, bpm_wrapper): if (self.bpm_amp_phase_dict.has_key(bpm_wrapper)): (graphDataAmp, graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper] return (graphDataAmp, graphDataPhase) return (null, null) def setPosition(self, accSeq): self.pos = accSeq.getPosition(self.cav) def getPosition(self): return self.pos def writeDataToXML(self, root_da): cav_wrapper_da = root_da.createChild(self.alias) cav_wrapper_da.setValue("cav", self.cav.getId()) bpm0_name = "null" bpm1_name = "null" if (self.bpm_wrapper0 != null): bpm0_name = self.bpm_wrapper0.alias if (self.bpm_wrapper1 != null): bpm1_name = self.bpm_wrapper1.alias cav_wrapper_da.setValue("bpm0", bpm0_name) cav_wrapper_da.setValue("bpm1", bpm1_name) cav_wrapper_da.setValue("isGood", self.isGood) cav_wrapper_da.setValue("isMeasured", self.isMeasured) cav_wrapper_da.setValue("isAnalyzed", self.isAnalyzed) #-------------------------------- cav_wrapper_params_da = cav_wrapper_da.createChild("Params") cav_wrapper_params_da.setValue("initDesignAmp", self.initDesignAmp) cav_wrapper_params_da.setValue("initDesignPhase", self.initDesignPhase) cav_wrapper_params_da.setValue("designAmp", self.designAmp) cav_wrapper_params_da.setValue("designPhase", self.designPhase) cav_wrapper_params_da.setValue("avg_gap_phase", self.avg_gap_phase) cav_wrapper_params_da.setValue("initLiveAmp", self.initLiveAmp) cav_wrapper_params_da.setValue("initLivePhase", self.initLivePhase) cav_wrapper_params_da.setValue("livePhase", self.livePhase) cav_wrapper_params_da.setValue("scanPhaseShift", self.scanPhaseShift) cav_wrapper_params_da.setValue("phase_scan_harm_err", self.phase_scan_harm_err) cav_wrapper_params_da.setValue("phase_scan_harm_amp", self.phase_scan_harm_amp) cav_wrapper_params_da.setValue("eKin_in_guess", self.eKin_in_guess) cav_wrapper_params_da.setValue("eKin_out_guess", self.eKin_out_guess) cav_wrapper_params_da.setValue("eKin_in", self.eKin_in) cav_wrapper_params_da.setValue("eKin_out", self.eKin_out) cav_wrapper_params_da.setValue("eKin_err", self.eKin_err) cav_wrapper_params_da.setValue("bpm_eKin_out", self.bpm_eKin_out) cav_wrapper_params_da.setValue("model_eKin_out", self.model_eKin_out) cav_wrapper_params_da.setValue("real_scanPhaseShift", self.real_scanPhaseShift) #--------- write the cavity rescale data self.rescaleBacket.writeDataToXML(cav_wrapper_da) #--------------------------------- cav_wrapper_phase_harm_da = cav_wrapper_da.createChild( "Phase_Harm_Func") cav_wrapper_phase_harm_da.setValue( "params_arr", self.phase_scan_harm_funcion.getTxtParamArr()) cav_wrapper_energy_harm_da = cav_wrapper_da.createChild( "Eenergy_guess_Harm_Func") cav_wrapper_energy_harm_da.setValue( "params_arr", self.energy_guess_harm_funcion.getTxtParamArr()) #---------------------------------- dumpGraphDataToDA(self.phaseDiffPlot, cav_wrapper_da, "Phase_Diff_GD", "%8.3f", "%8.3f") dumpGraphDataToDA(self.phaseDiffPlotTh, cav_wrapper_da, "Phase_Diff_Fit_GD", "%8.3f", "%8.3f") dumpGraphDataToDA(self.eKinOutPlot, cav_wrapper_da, "Ekin_Out_GD", "%8.3f", "%10.4f") dumpGraphDataToDA(self.eKinOutPlotTh, cav_wrapper_da, "Ekin_Out_Fit_GD", "%8.3f", "%10.4f") #------------------------------------ cav_wrapper_bpm_list_da = cav_wrapper_da.createChild("bpm_arr") txt = "" for bpm_wrapper in self.bpm_wrappers: txt = txt + " " + bpm_wrapper.alias cav_wrapper_bpm_list_da.setValue("bpm_wrappers", txt) cav_wrapper_bpm_list_da = cav_wrapper_da.createChild( "bpm_use_in_phase_analysis_arr") txt = "" for bool_val in self.bpm_wrappers_useInPhaseAnalysis: val = "0" if (bool_val): val = "1" txt = txt + " " + val cav_wrapper_bpm_list_da.setValue("use_arr", txt) cav_wrapper_bpm_list_da = cav_wrapper_da.createChild( "bpm_use_in_amp_analysis_arr") txt = "" for bool_val in self.bpm_wrappers_useInAmpBPMs: val = "0" if (bool_val): val = "1" txt = txt + " " + val cav_wrapper_bpm_list_da.setValue("use_arr", txt) #--------------------------------------------- cav_wrapper_scan_data_da = cav_wrapper_da.createChild("scan_data") for bpm_wrapper in self.bpm_wrappers: if (self.bpm_amp_phase_dict.has_key(bpm_wrapper)): (graphDataAmp, graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper] cav_wrapper_scan_data_bpm_da = cav_wrapper_scan_data_da.createChild( bpm_wrapper.alias) dumpGraphDataToDA(graphDataPhase, cav_wrapper_scan_data_bpm_da, "phase", "%8.3f", "%8.3f") dumpGraphDataToDA(graphDataAmp, cav_wrapper_scan_data_bpm_da, "amplitude", "%8.3f", "%10.3g") def readDataFromXML(self, cav_wrapper_da, scl_long_tuneup_controller): #print "debug ============= cav_wrapper_da=",cav_wrapper_da.name() self.bpm_wrapper0 = scl_long_tuneup_controller.getBPM_Wrapper( cav_wrapper_da.stringValue("bpm0")) self.bpm_wrapper1 = scl_long_tuneup_controller.getBPM_Wrapper( cav_wrapper_da.stringValue("bpm1")) self.isGood = Boolean(cav_wrapper_da.intValue("isGood")).booleanValue() self.isMeasured = Boolean( cav_wrapper_da.intValue("isMeasured")).booleanValue() self.isAnalyzed = Boolean( cav_wrapper_da.intValue("isAnalyzed")).booleanValue() #--------- read parameters------------------------- cav_wrapper_params_da = cav_wrapper_da.childAdaptor("Params") self.initDesignAmp = cav_wrapper_params_da.doubleValue("initDesignAmp") self.initDesignPhase = cav_wrapper_params_da.doubleValue( "initDesignPhase") self.designAmp = cav_wrapper_params_da.doubleValue("designAmp") self.designPhase = cav_wrapper_params_da.doubleValue("designPhase") self.avg_gap_phase = cav_wrapper_params_da.doubleValue("avg_gap_phase") self.initLiveAmp = cav_wrapper_params_da.doubleValue("initLiveAmp") self.initLivePhase = cav_wrapper_params_da.doubleValue("initLivePhase") self.livePhase = cav_wrapper_params_da.doubleValue("livePhase") self.scanPhaseShift = cav_wrapper_params_da.doubleValue( "scanPhaseShift") self.phase_scan_harm_err = cav_wrapper_params_da.doubleValue( "phase_scan_harm_err") self.phase_scan_harm_amp = cav_wrapper_params_da.doubleValue( "phase_scan_harm_amp") self.eKin_in_guess = cav_wrapper_params_da.doubleValue("eKin_in_guess") self.eKin_out_guess = cav_wrapper_params_da.doubleValue( "eKin_out_guess") self.eKin_in = cav_wrapper_params_da.doubleValue("eKin_in") self.eKin_out = cav_wrapper_params_da.doubleValue("eKin_out") self.eKin_err = cav_wrapper_params_da.doubleValue("eKin_err") self.bpm_eKin_out = cav_wrapper_params_da.doubleValue("bpm_eKin_out") self.model_eKin_out = cav_wrapper_params_da.doubleValue( "model_eKin_out") self.real_scanPhaseShift = cav_wrapper_params_da.doubleValue( "real_scanPhaseShift") #--------- read the cavity rescale data self.rescaleBacket.readDataFromXML(cav_wrapper_da) #--------- read harm. functions------------------------- cav_wrapper_phase_harm_da = cav_wrapper_da.childAdaptor( "Phase_Harm_Func") self.phase_scan_harm_funcion.parsePramArr( cav_wrapper_phase_harm_da.stringValue("params_arr")) cav_wrapper_energy_harm_da = cav_wrapper_da.childAdaptor( "Eenergy_guess_Harm_Func") self.energy_guess_harm_funcion.parsePramArr( cav_wrapper_energy_harm_da.stringValue("params_arr")) #--------- read phase Diff. graph data readGraphDataFromDA(self.phaseDiffPlot, cav_wrapper_da, "Phase_Diff_GD") readGraphDataFromDA(self.phaseDiffPlotTh, cav_wrapper_da, "Phase_Diff_Fit_GD") readGraphDataFromDA(self.eKinOutPlot, cav_wrapper_da, "Ekin_Out_GD") readGraphDataFromDA(self.eKinOutPlotTh, cav_wrapper_da, "Ekin_Out_Fit_GD") #--------- loop over bpm wrappers for this cavity cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor("bpm_arr") bpm_wrapper_alias_arr = cav_wrapper_bpm_list_da.stringValue( "bpm_wrappers").split() cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor( "bpm_use_in_phase_analysis_arr") use_in_phase_analysis_arr = cav_wrapper_bpm_list_da.stringValue( "use_arr").split() cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor( "bpm_use_in_amp_analysis_arr") use_in_amp_analysis_arr = cav_wrapper_bpm_list_da.stringValue( "use_arr").split() bpm_wrapper_arr = [] for bpm_wrapper_alias in bpm_wrapper_alias_arr: bpm_wrapper = scl_long_tuneup_controller.getBPM_Wrapper( bpm_wrapper_alias) bpm_wrapper_arr.append(bpm_wrapper) bpm_wrappers = [] use_in_phase_arr = [] use_in_amp_arr = [] for ind in range(len(bpm_wrapper_arr)): bpm_wrapper = bpm_wrapper_arr[ind] if (bpm_wrapper != null): bpm_wrappers.append(bpm_wrapper) use_in_phase_arr.append(use_in_phase_analysis_arr[ind]) use_in_amp_arr.append(use_in_amp_analysis_arr[ind]) use_in_phase_analysis_arr = use_in_phase_arr use_in_amp_analysis_arr = use_in_amp_arr self.setUpBPM_Wrappers(bpm_wrappers, scl_long_tuneup_controller) for ind in range(len(self.bpm_wrappers)): bpm_wrapper = self.bpm_wrappers[ind] self.bpm_wrappers_useInPhaseAnalysis[ind] = Boolean( int(use_in_phase_analysis_arr[ind])).booleanValue() self.bpm_wrappers_useInAmpBPMs[ind] = Boolean( int(use_in_amp_analysis_arr[ind])).booleanValue() #-------- read the phase scan data # we have to keep in mind that in self.bpm_wrappers we have only bpm wrappers that exist in the # scl_long_tuneup_controller.bpm_wrappers and therefore exist in the self.bpm_amp_phase_dict as keys # Threfore they have (graphDataAmp,graphDataPhase) and we just have to fill them out. cav_wrapper_scan_data_da = cav_wrapper_da.childAdaptor("scan_data") for bpm_wrapper in self.bpm_wrappers: if (not self.bpm_amp_phase_dict.has_key(bpm_wrapper)): continue (graphDataAmp, graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper] cav_wrapper_scan_data_bpm_da = cav_wrapper_scan_data_da.childAdaptor( bpm_wrapper.alias) if (cav_wrapper_scan_data_bpm_da != null): readGraphDataFromDA(graphDataPhase, cav_wrapper_scan_data_bpm_da, "phase") readGraphDataFromDA(graphDataAmp, cav_wrapper_scan_data_bpm_da, "amplitude")
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
class BPM_Scan_Data: def __init__(self,main_loop_controller,cav_controller,bpm_wrapper): self.main_loop_controller = main_loop_controller self.cav_controller = cav_controller self.bpm_wrapper = bpm_wrapper self.cav_amp = 0. self.derivative = 0. self.zero_accel_phase = 0. self.max_accel_phase = 0. self.min_accel_phase = 0. #------ for MEBT measurements for Iteration process only self.cav_off_bpm_phase = 0. self.cav_off_bpm_phase_err = 0. self.cav_on_bpm_phase = 0. self.cav_on_bpm_phase_err = 0. self.cav_off_bpm_amp = 0. self.cav_off_bpm_amp_err = 0. self.cav_on_bpm_amp = 0. self.cav_on_bpm_amp_err = 0. #----------------------------------------------------- self.harmonicsAnalyzer = HarmonicsAnalyzer(2) self.phase_gd = BasicGraphData() self.phase_gd.setLineThick(3) self.phase_gd.setGraphPointSize(7) self.phase_gd.setGraphColor(Color.BLUE) self.phase_gd.setGraphProperty(GRAPH_LEGEND_KEY,self.bpm_wrapper.alias) self.phase_gd.setDrawLinesOn(true) self.phase_gd.setDrawPointsOn(true) #------------------------------ self.amp_gd = BasicGraphData() self.amp_gd.setLineThick(3) self.amp_gd.setGraphPointSize(7) self.amp_gd.setGraphColor(Color.BLUE) self.amp_gd.setGraphProperty(GRAPH_LEGEND_KEY,self.bpm_wrapper.alias) self.amp_gd.setDrawLinesOn(true) self.amp_gd.setDrawPointsOn(true) #------------------------------------ self.phase_fit_gd = BasicGraphData() self.phase_fit_gd.setLineThick(3) self.phase_fit_gd.setGraphPointSize(3) self.phase_fit_gd.setGraphColor(Color.RED) self.phase_fit_gd.setGraphProperty(GRAPH_LEGEND_KEY,"Fit "+self.bpm_wrapper.alias) self.phase_fit_gd.setDrawLinesOn(true) self.phase_fit_gd.setDrawPointsOn(false) def clean(self): self.phase_gd.removeAllPoints() self.amp_gd.removeAllPoints() self.phase_fit_gd.removeAllPoints() self.derivative = 0. self.zero_accel_phase = 0. self.max_accel_phase = 0. self.min_accel_phase = 0. #------ for MEBT measurements for Iteration process only self.cav_off_bpm_phase = 0. self.cav_off_bpm_phase_err = 0. self.cav_on_bpm_phase = 0. self.cav_on_bpm_phase_err = 0. self.cav_off_bpm_amp = 0. self.cav_off_bpm_amp_err = 0. self.cav_on_bpm_amp = 0. self.cav_on_bpm_amp_err = 0. def addPoint(self,cav_phase): if(not self.bpm_wrapper.isOn): return bpm_amp = self.bpm_wrapper.bpm.getAmpAvg() bpm_phase = self.bpm_wrapper.bpm.getPhaseAvg() self.addExternalPoint(cav_phase,bpm_amp,bpm_phase) def getAmpAndPhase(self): if(not self.bpm_wrapper.isOn): return (0.,0.) bpm_amp = self.bpm_wrapper.bpm.getAmpAvg() bpm_phase = self.bpm_wrapper.bpm.getPhaseAvg() return (bpm_amp,bpm_phase) def addExternalPoint(self,cav_phase,bpm_amp,bpm_phase): if(self.phase_gd.getNumbOfPoints() != 0): cav_phase_old = self.phase_gd.getX(self.phase_gd.getNumbOfPoints()-1) bpm_phase_old = self.phase_gd.getY(self.phase_gd.getNumbOfPoints()-1) cav_phase = makePhaseNear(cav_phase,cav_phase_old) bpm_phase = makePhaseNear(bpm_phase,bpm_phase_old) self.phase_gd.addPoint(cav_phase,bpm_phase) self.amp_gd.addPoint(cav_phase,bpm_amp) def shiftToPhase(self,gd,bpm_phase_init): nP = gd.getNumbOfPoints() if(nP == 0): return x_arr = [] y_arr = [] err_arr = [] for ip in range(nP): x_arr.append(gd.getX(ip)) y_arr.append(gd.getY(ip)) err_arr.append(gd.getErr(ip)) gd.removeAllPoints() y_arr[0] = makePhaseNear(y_arr[0],bpm_phase_init) for ip in range(1,nP): y_arr[ip] = makePhaseNear(y_arr[ip],y_arr[ip-1]) gd.addPoint(x_arr,y_arr,err_arr) def makeLinearFit(self): self.phase_fit_gd.removeAllPoints() self.derivative = 0. if(self.phase_gd.getNumbOfPoints() > 1): GraphDataOperations.polynomialFit(self.phase_gd,self.phase_fit_gd,1) self.phase_fit_gd.setGraphColor(Color.RED) nP = self.phase_fit_gd.getNumbOfPoints() self.derivative = 0. if(nP > 1): X0 = self.phase_fit_gd.getX(0) X1 = self.phase_fit_gd.getX(nP-1) self.derivative = self.phase_fit_gd.getValueDerivativeY((X0+X1)/2.0) return true return false def makeHarmonicFit(self): self.phase_fit_gd.removeAllPoints() if(self.phase_gd.getNumbOfPoints() < 8): return false err = self.harmonicsAnalyzer.analyzeData(self.phase_gd) harm_function = self.harmonicsAnalyzer.getHrmonicsFunction() #-----remove bad points gd = self.phase_gd max_bad_points_count = 3 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) self.amp_gd.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 = makePhaseNear(self.harmonicsAnalyzer.getPositionOfMin(),0.) max_phase = makePhaseNear(self.harmonicsAnalyzer.getPositionOfMax(),0.) # guess phase is -90 deg if max acceleratiom phase is 0. self.zero_accel_phase = makePhaseNear(min_phase - 90.,0.) self.max_accel_phase = min_phase self.min_accel_phase = max_phase #print "debug min_phase=",min_phase #print "debug max_phase=",max_phase #print "debug zero_accel_phase =",self.zero_accel_phase #----make theory graph plot harm_function = self.harmonicsAnalyzer.getHrmonicsFunction() 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) self.phase_fit_gd.addPoint(x_arr,y_arr) #-------------------- return true def setCavAmplitudeParam(self,cav_amp): self.cav_amp = cav_amp self.phase_fit_gd.setGraphProperty(GRAPH_LEGEND_KEY,"Fit "+self.bpm_wrapper.alias+" CavAmp= %6.4f "%self.cav_amp) self.phase_gd.setGraphProperty(GRAPH_LEGEND_KEY,self.bpm_wrapper.alias+" CavAmp= %6.4f "%self.cav_amp) self.amp_gd.setGraphProperty(GRAPH_LEGEND_KEY,self.bpm_wrapper.alias+" CavAmp= %6.4f "%self.cav_amp) def checkLastDataPoint(self,min_bpm_amp): if(not self.bpm_wrapper.isOn): return false res = true nP = self.phase_gd.getNumbOfPoints() if(nP > 1): if(math.fabs(self.phase_gd.getY(nP-2) - self.phase_gd.getY(nP-1)) < 0.000000001): return false if(nP > 0): if(self.amp_gd.getY(nP-1) < min_bpm_amp): return false return res def removeLastPoint(self): if(not self.bpm_wrapper.isOn): return nP = self.phase_gd.getNumbOfPoints() if(nP < 1): return self.phase_gd.removePoint(nP-1) self.amp_gd.removePoint(nP-1) def getAvgPhaseAndErr(self): nP = self.phase_gd.getNumbOfPoints() if(nP < 1): return (0.,0.) phase_arr = [] for ind in range(nP): phase_arr.append(self.phase_gd.getY(ind)) (avg_phase,avg_phase_err) = calculateAvgErr(phase_arr) return (avg_phase,avg_phase_err) def writeDataToXML(self,root_da): bpm_scan_data_da = root_da.createChild("bpm_scan_data") bpm_scan_data_da.setValue("cav",self.cav_controller.cav_wrapper.alias) bpm_scan_data_da.setValue("bpm",self.bpm_wrapper.alias) bpm_scan_data_da.setValue("cav_amp",self.cav_amp) bpm_scan_data_da.setValue("derivative","%7.5f"%self.derivative) bpm_scan_data_da.setValue("zero_accel_phase","%7.3f"%self.zero_accel_phase) bpm_scan_data_da.setValue("max_accel_phase", "%7.3f"%self.max_accel_phase) if(self.cav_controller.cav_wrapper.alias.find("MEBT") >= 0): mebt_cav_off_on_da = bpm_scan_data_da.createChild("cav_off_on_data") mebt_cav_off_on_da.setValue("cav_off_bpm_phase",self.cav_off_bpm_phase) mebt_cav_off_on_da.setValue("cav_off_bpm_phase_err",self.cav_off_bpm_phase_err) mebt_cav_off_on_da.setValue("cav_on_bpm_phase",self.cav_on_bpm_phase) mebt_cav_off_on_da.setValue("cav_on_bpm_phase_err",self.cav_on_bpm_phase_err) mebt_cav_off_on_da.setValue("cav_off_bpm_amp",self.cav_off_bpm_amp) mebt_cav_off_on_da.setValue("cav_off_bpm_amp_err",self.cav_off_bpm_amp_err) mebt_cav_off_on_da.setValue("cav_on_bpm_amp",self.cav_on_bpm_amp) mebt_cav_off_on_da.setValue("cav_on_bpm_amp_err",self.cav_on_bpm_amp_err) dumpGraphDataToDA(self.phase_gd,bpm_scan_data_da,"phase_scan_gd") dumpGraphDataToDA(self.amp_gd,bpm_scan_data_da,"amp_scan_gd") dumpGraphDataToDA(self.phase_fit_gd,bpm_scan_data_da,"phase_scan_fit_gd") def readDataFromXML(self,bpm_scan_data_da): self.cav_amp = bpm_scan_data_da.doubleValue("cav_amp") self.derivative = bpm_scan_data_da.doubleValue("derivative") self.zero_accel_phase = bpm_scan_data_da.doubleValue("zero_accel_phase") self.max_accel_phase = bpm_scan_data_da.doubleValue("max_accel_phase") mebt_cav_off_on_da = bpm_scan_data_da.childAdaptor("cav_off_on_data") if(mebt_cav_off_on_da != null): self.cav_off_bpm_phase = mebt_cav_off_on_da.doubleValue("cav_off_bpm_phase") self.cav_off_bpm_phase_err = mebt_cav_off_on_da.doubleValue("cav_off_bpm_phase_err") self.cav_on_bpm_phase = mebt_cav_off_on_da.doubleValue("cav_on_bpm_phase") self.cav_on_bpm_phase_err = mebt_cav_off_on_da.doubleValue("cav_on_bpm_phase_err") self.cav_off_bpm_amp = mebt_cav_off_on_da.doubleValue("cav_off_bpm_amp") self.cav_off_bpm_amp_err = mebt_cav_off_on_da.doubleValue("cav_off_bpm_amp_err") self.cav_on_bpm_amp = mebt_cav_off_on_da.doubleValue("cav_on_bpm_amp") self.cav_on_bpm_amp_err = mebt_cav_off_on_da.doubleValue("cav_on_bpm_amp_err") readGraphDataFromDA(self.phase_gd,bpm_scan_data_da,"phase_scan_gd") readGraphDataFromDA(self.amp_gd,bpm_scan_data_da,"amp_scan_gd") readGraphDataFromDA(self.phase_fit_gd,bpm_scan_data_da,"phase_scan_fit_gd")
def calculateEneregyVsPhase(cav_wrapper,scl_long_tuneup_controller,bpm_wrappers_good_arr): # This function will calculate output energy vs. cav. phase by using known BPM offsets # It will return false if the cavity cannot be analysed eKin_in = cav_wrapper.eKin_in # make cav_wrapper.energy_guess_harm_funcion harmonic function res = makeEnergyGuessHarmFunc(eKin_in,cav_wrapper,scl_long_tuneup_controller) if(not res): return false 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 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.final_phase_offset.phaseOffset_avg base_bpm_phase = makePhaseNear180(graphDataPhase.getY(ip) - base_bpm_offset,0.) gd.addPoint(base_bpm_wrapper.pos,base_bpm_phase) #print "debug ==== ip=",ip," cav_phase=",cav_phase," eKin_guess=",ekin_guess 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.final_phase_offset.phaseOffset_avg delta_pos = bpm_wrapper.pos - gd.getX(bpm_ind-1) bpm_phase_guess = gd.getY(bpm_ind-1) + coeff*delta_pos bpm_phase = makePhaseNear180(bpm_phase,bpm_phase_guess) gd.addPoint(bpm_wrapper.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) if(res_arr == null): return false slope = res_arr[0][1] init_phase = res_arr[0][0] bad_point_ind = 1 bad_points_count = 0 while(bad_point_ind >= 0): bad_point_ind = -1 avg_err2 = 0. for index in range(gd.getNumbOfPoints()): avg_err2 += (gd.getY(index) - (init_phase + slope*gd.getX(index)))**2 if(gd.getNumbOfPoints() > 1): avg_err2 /= gd.getNumbOfPoints() avg_err = math.sqrt(avg_err2) for index in range(gd.getNumbOfPoints()): diff = gd.getY(index) - (init_phase + slope*gd.getX(index)) if(math.fabs(diff) > 3.0*avg_err): bad_point_ind = index break if(bad_point_ind >= 0): bad_points_count += 1 gd.removePoint(bad_point_ind) res_arr = GraphDataOperations.polynomialFit(gd,-1.e+36,+1.e+36,1) if(res_arr == null): return false slope = res_arr[0][1] init_phase = res_arr[0][0] if(bad_points_count > 4): return false slope_err = res_arr[1][1] 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_out=",eKin," dE=",delta_eKin," ekin_guess=",ekin_guess for ip0 in range(gd.getNumbOfPoints()): print "debug bpm_ind=",ip0," pos=",gd.getX(ip0)," Y=",gd.getY(ip0)," delta=",(gd.getY(ip0)-(res_arr[0][1]*gd.getX(ip0)+init_phase)) """ return true
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)
#--------------------------------------------------- # TEST SCRIPT #--------------------------------------------------- if __name__=="__main__": gd = BasicGraphData() n_points = 36 step = 360./(n_points + 1) param_arr = [12.0,2.0,-25.0,0.2,+30.] #param_arr = [12.0,2.0,-25.0] print "initial params=",param_arr x = -180. for i in range(n_points): x += step y = TestHarmFunc(param_arr,x)+0.001*2*(random.random()-0.5) gd.addPoint(x,y) print "init x=",x," y=",y harmonicsAnalyzer = HarmonicsAnalyzer(2) err = harmonicsAnalyzer.analyzeData(gd) print "=================res================" print "res_arr=",harmonicsAnalyzer.getParamsArr() print "min pos =",harmonicsAnalyzer.getPositionOfMin() print "avg. error = ",err #if you want to measure the speed, please comment out sys.exit(1) sys.exit(1) count = 0 while(1 < 2):
class Orbit_Diff_Graphs_Panel(JPanel): def __init__(self,mebt_main_orbit_diff_cntrl): self.mebt_main_orbit_diff_cntrl = mebt_main_orbit_diff_cntrl self.setLayout(BorderLayout()) tabbedPane = JTabbedPane() #----etched border etched_border = BorderFactory.createEtchedBorder() #---- plots for Hor-Ver and Longitudinal self.hor_plot = FunctionGraphsJPanel() self.hor_plot.setLegendButtonVisible(true) self.hor_plot.setChooseModeButtonVisible(true) self.hor_plot.setName("Horizontal Plane (Vert.Lns.: Black:quads Blue:DC Red:Cavs)") self.hor_plot.setAxisNames("Position, m","X[mm]") self.hor_plot.setBorder(etched_border) self.ver_plot = FunctionGraphsJPanel() self.ver_plot.setLegendButtonVisible(true) self.ver_plot.setChooseModeButtonVisible(true) self.ver_plot.setName("Vertical Plane (Vert.Lns.: Black:quads Blue:DC Red:Cavs)") self.ver_plot.setAxisNames("Position, m","Y[mm]") self.ver_plot.setBorder(etched_border) #------------------------------------------------ self.hor_diff_plot = FunctionGraphsJPanel() self.hor_diff_plot.setLegendButtonVisible(true) self.hor_diff_plot.setChooseModeButtonVisible(true) self.hor_diff_plot.setName("Horizontal Plane (Vert.Lns.: Black:quads Blue:DC Red:Cavs)") self.hor_diff_plot.setAxisNames("Position, m","Diff X[mm]") self.hor_diff_plot.setBorder(etched_border) self.ver_diff_plot = FunctionGraphsJPanel() self.ver_diff_plot.setLegendButtonVisible(true) self.ver_diff_plot.setChooseModeButtonVisible(true) self.ver_diff_plot.setName("Vertical Plane (Vert.Lns.: Black:quads Blue:DC Red:Cavs)") self.ver_diff_plot.setAxisNames("Position, m","Diff Y[mm]") self.ver_diff_plot.setBorder(etched_border) #-------------------------------------------------------------------- quad_wrappers = self.mebt_main_orbit_diff_cntrl.quad_wrappers dc_wrappers = self.mebt_main_orbit_diff_cntrl.dc_wrappers mebt_cav_wrappers = self.mebt_main_orbit_diff_cntrl.mebt_cav_wrappers for wrapper in quad_wrappers: self.hor_plot.addVerticalLine(wrapper.pos,Color.BLACK) self.ver_plot.addVerticalLine(wrapper.pos,Color.BLACK) self.hor_diff_plot.addVerticalLine(wrapper.pos,Color.BLACK) self.ver_diff_plot.addVerticalLine(wrapper.pos,Color.BLACK) for wrapper in dc_wrappers: self.hor_plot.addVerticalLine(wrapper.pos,Color.BLUE) self.ver_plot.addVerticalLine(wrapper.pos,Color.BLUE) self.hor_diff_plot.addVerticalLine(wrapper.pos,Color.BLUE) self.ver_diff_plot.addVerticalLine(wrapper.pos,Color.BLUE) for wrapper in mebt_cav_wrappers: self.hor_plot.addVerticalLine(wrapper.pos,Color.RED) self.ver_plot.addVerticalLine(wrapper.pos,Color.RED) self.hor_diff_plot.addVerticalLine(wrapper.pos,Color.RED) self.ver_diff_plot.addVerticalLine(wrapper.pos,Color.RED) #--------------------------------------------------------------------- #-------------------------------------------------- #---- panels graph_diff_panel = JPanel(GridLayout(2,1)) graph_diff_panel.add(self.hor_diff_plot) graph_diff_panel.add(self.ver_diff_plot) #---------------------------------- graph_panel = JPanel(GridLayout(2,1)) graph_panel.add(self.hor_plot) graph_panel.add(self.ver_plot) #---------------------------------- tabbedPane.add("Orbit Difference",graph_diff_panel) tabbedPane.add("Orbit",graph_panel) #------------------------------------- self.x_model_gd = BasicGraphData() self.x_model_gd.setLineThick(3) self.x_model_gd.setGraphPointSize(7) self.x_model_gd.setGraphColor(Color.BLUE) self.x_model_gd.setGraphProperty(GRAPH_LEGEND_KEY,"X Model [mm]") self.x_model_gd.setDrawLinesOn(true) self.x_model_gd.setDrawPointsOn(false) #------------------------------------- self.y_model_gd = BasicGraphData() self.y_model_gd.setLineThick(3) self.y_model_gd.setGraphPointSize(7) self.y_model_gd.setGraphColor(Color.RED) self.y_model_gd.setGraphProperty(GRAPH_LEGEND_KEY,"Y Model [mm]") self.y_model_gd.setDrawLinesOn(true) self.y_model_gd.setDrawPointsOn(false) #------------------------------------- self.x_model_diff_gd = BasicGraphData() self.x_model_diff_gd.setLineThick(3) self.x_model_diff_gd.setGraphPointSize(7) self.x_model_diff_gd.setGraphColor(Color.BLUE) self.x_model_diff_gd.setGraphProperty(GRAPH_LEGEND_KEY,"X Diff Model [mm]") self.x_model_diff_gd.setDrawLinesOn(true) self.x_model_diff_gd.setDrawPointsOn(false) #------------------------------------- self.y_model_diff_gd = BasicGraphData() self.y_model_diff_gd.setLineThick(3) self.y_model_diff_gd.setGraphPointSize(7) self.y_model_diff_gd.setGraphColor(Color.RED) self.y_model_diff_gd.setGraphProperty(GRAPH_LEGEND_KEY,"Y Diff Model [mm]") self.y_model_diff_gd.setDrawLinesOn(true) self.y_model_diff_gd.setDrawPointsOn(false) #------------------------------------- #------------------------------------- self.x_bpm_gd = BasicGraphData() self.x_bpm_gd.setLineThick(3) self.x_bpm_gd.setGraphPointSize(7) self.x_bpm_gd.setGraphColor(Color.BLUE) self.x_bpm_gd.setGraphProperty(GRAPH_LEGEND_KEY,"X BPM [mm]") self.x_bpm_gd.setDrawLinesOn(false) self.x_bpm_gd.setDrawPointsOn(true) #------------------------------------- self.y_bpm_gd = BasicGraphData() self.y_bpm_gd.setLineThick(3) self.y_bpm_gd.setGraphPointSize(7) self.y_bpm_gd.setGraphColor(Color.RED) self.y_bpm_gd.setGraphProperty(GRAPH_LEGEND_KEY,"Y BPM [mm]") self.y_bpm_gd.setDrawLinesOn(false) self.y_bpm_gd.setDrawPointsOn(true) #------------------------------------- self.x_bpm_diff_gd = BasicGraphData() self.x_bpm_diff_gd.setLineThick(3) self.x_bpm_diff_gd.setGraphPointSize(7) self.x_bpm_diff_gd.setGraphColor(Color.BLUE) self.x_bpm_diff_gd.setGraphProperty(GRAPH_LEGEND_KEY,"X Diff BPM [mm]") self.x_bpm_diff_gd.setDrawLinesOn(false) self.x_bpm_diff_gd.setDrawPointsOn(true) #------------------------------------- self.y_bpm_diff_gd = BasicGraphData() self.y_bpm_diff_gd.setLineThick(3) self.y_bpm_diff_gd.setGraphPointSize(7) self.y_bpm_diff_gd.setGraphColor(Color.RED) self.y_bpm_diff_gd.setGraphProperty(GRAPH_LEGEND_KEY,"Y Diff BPM [mm]") self.y_bpm_diff_gd.setDrawLinesOn(false) self.y_bpm_diff_gd.setDrawPointsOn(true) #------------------------------------- self.index0_button = JRadioButton("Orbit #0") self.index1_button = JRadioButton("Orbit #1") self.button_group = ButtonGroup() self.button_group.add(self.index0_button) self.button_group.add(self.index1_button) self.index0_button.setSelected(true) replot_button = JButton("Replot Graphs") replot_button.addActionListener(Replot_Button_Listener(self.mebt_main_orbit_diff_cntrl)) button_panel = JPanel(FlowLayout(FlowLayout.LEFT,3,3)) button_panel.add(self.index0_button) button_panel.add(self.index1_button) button_panel.add(replot_button) #----------------------------------------------- self.add(tabbedPane,BorderLayout.CENTER) self.add(button_panel,BorderLayout.SOUTH) def removeAllGraphData(self): self.hor_plot.removeAllGraphData() self.ver_plot.removeAllGraphData() self.hor_diff_plot.removeAllGraphData() self.ver_diff_plot.removeAllGraphData() #-------------------------------------- self.x_model_gd.removeAllPoints() self.y_model_gd.removeAllPoints() self.x_model_diff_gd.removeAllPoints() self.y_model_diff_gd.removeAllPoints() #-------------------------------------- self.x_bpm_gd.removeAllPoints() self.y_bpm_gd.removeAllPoints() self.x_bpm_diff_gd.removeAllPoints() self.y_bpm_diff_gd.removeAllPoints() def updateGraphData(self): self.removeAllGraphData() orb_index = 0 if(self.index1_button.isSelected()): orb_index = 1 #print "debug orb_index=",orb_index #==== update graph data from calculator and measurer orbit_measurer = self.mebt_main_orbit_diff_cntrl.orbit_measurer mebt_orbit_holder_0 = orbit_measurer.mebt_orbit_holder_0 mebt_orbit_holder_1 = orbit_measurer.mebt_orbit_holder_1 bpm_orbit_holder_0 = orbit_measurer.bpm_orbit_holder_0 bpm_orbit_holder_1 = orbit_measurer.bpm_orbit_holder_1 bpm_wrappers = self.mebt_main_orbit_diff_cntrl.bpm_wrappers max_pos = 0. for bpm_wrapper in bpm_wrappers: if(bpm_wrapper.use): if(max_pos < bpm_wrapper.pos): max_pos = bpm_wrapper.pos #---------------------------------------- pos_step = 0.1 pos_old = -1. traj0 = mebt_orbit_holder_0.getTrajectory() traj1 = mebt_orbit_holder_1.getTrajectory() for ind in range(traj0.numStates()): state0 = traj0.stateWithIndex(ind) pos = state0.getPosition() state1 = traj1.stateNearestPosition(pos) if(pos > (pos_old + pos_step) and pos_old < max_pos): x0 = state0.getPhaseCoordinates().getx()*1000. y0 = state0.getPhaseCoordinates().gety()*1000. x1 = state1.getPhaseCoordinates().getx()*1000. y1 = state1.getPhaseCoordinates().gety()*1000. pos_old = pos if(orb_index == 0): self.x_model_gd.addPoint(pos,x0) self.y_model_gd.addPoint(pos,y0) else: self.x_model_gd.addPoint(pos,x1) self.y_model_gd.addPoint(pos,y1) self.x_model_diff_gd.addPoint(pos,x1-x0) self.y_model_diff_gd.addPoint(pos,y1-y0) #---------------------------------------------- #bpm_orbit_holder_0.calcStatistics() #bpm_orbit_holder_1.calcStatistics() for bpm_wrapper in bpm_wrappers: if(bpm_wrapper.use): (x0,x0_err,y0,y0_err) = bpm_orbit_holder_0.getXY_and_Err(bpm_wrapper) (x1,x1_err,y1,y1_err) = bpm_orbit_holder_1.getXY_and_Err(bpm_wrapper) if(orb_index == 0): self.x_bpm_gd.addPoint(bpm_wrapper.pos,x0,x0_err) self.y_bpm_gd.addPoint(bpm_wrapper.pos,y0,y0_err) else: self.x_bpm_gd.addPoint(bpm_wrapper.pos,x1,x1_err) self.y_bpm_gd.addPoint(bpm_wrapper.pos,y1,y1_err) self.x_bpm_diff_gd.addPoint(bpm_wrapper.pos,x1-x0,math.sqrt(x0_err**2+x1_err**2)) self.y_bpm_diff_gd.addPoint(bpm_wrapper.pos,y1-y0,math.sqrt(y0_err**2+y1_err**2)) #------------------------------------- self.hor_plot.addGraphData(self.x_model_gd) self.hor_plot.addGraphData(self.x_bpm_gd) self.ver_plot.addGraphData(self.y_model_gd) self.ver_plot.addGraphData(self.y_bpm_gd) #------------------------------------- self.hor_diff_plot.addGraphData(self.x_model_diff_gd) self.hor_diff_plot.addGraphData(self.x_bpm_diff_gd) self.ver_diff_plot.addGraphData(self.y_model_diff_gd) self.ver_diff_plot.addGraphData(self.y_bpm_diff_gd)
#--------------------------------------------------- # TEST SCRIPT #--------------------------------------------------- if __name__ == "__main__": gd = BasicGraphData() n_points = 36 step = 360. / (n_points + 1) param_arr = [12.0, 2.0, -25.0, 0.2, +30.] #param_arr = [12.0,2.0,-25.0] print "initial params=", param_arr x = -180. for i in range(n_points): x += step y = TestHarmFunc(param_arr, x) + 0.001 * 2 * (random.random() - 0.5) gd.addPoint(x, y) print "init x=", x, " y=", y harmonicsAnalyzer = HarmonicsAnalyzer(2) err = harmonicsAnalyzer.analyzeData(gd) print "=================res================" print "res_arr=", harmonicsAnalyzer.getParamsArr() print "min pos =", harmonicsAnalyzer.getPositionOfMin() print "avg. error = ", err #if you want to measure the speed, please comment out sys.exit(1) sys.exit(1) count = 0 while (1 < 2):
class SCL_Cavity_Wrapper: def __init__(self,cav): #self.bpm_ch_amp_phase_dic[BPM_Wrapper] = (graphDataAmp,graphDataPhase) self.cav = cav self.alias = cav.getId().split(":")[1] self.isGood = true self.isMeasured = false self.isAnalyzed = false self.pos = 0. self.bpm_amp_phase_dict = {} self.bpm_wrappers = [] #--- use or not in phase scan analysis self.bpm_wrappers_useInPhaseAnalysis = [] #--- use or not in BPMs' amplitudes analysis self.bpm_wrappers_useInAmpBPMs = [] #--- BPM wrappers for BPM0 and BPM1 during cavity phase setup after the phase scan self.bpm_wrapper0 = null self.bpm_wrapper1 = null self.phaseDiffPlot = BasicGraphData() self.phaseDiffPlot.setGraphPointSize(7) self.phaseDiffPlot.setGraphColor(Color.BLUE) self.phaseDiffPlotTh = BasicGraphData() self.phaseDiffPlotTh.setDrawPointsOn(false) self.phaseDiffPlotTh.setGraphColor(Color.RED) self.phaseDiffPlotTh.setLineThick(3) #----cavity's parameters self.initDesignAmp = 0. self.initDesignPhase = 0. #-- design parameters will be defined after analysis of the phase scan data self.designAmp = 0. self.designPhase = 0. self.avg_gap_phase = 0. # this is a model parameter that will be used in rescaling #--- initial live parameters are measured after initialization self.initLiveAmp = 0. self.initLivePhase = 0. #live phase will be defined after scan self.livePhase = 0. self.scanPhaseShift = -18.0 self.real_scanPhaseShift = 0. #--- avg. phase error and harmonic amp after harmonics fitting during phase scan self.phase_scan_harm_err = 0. self.phase_scan_harm_amp = 0. self.phase_scan_harm_funcion = HramonicsFunc([0.,]) self.energy_guess_harm_funcion = HramonicsFunc([0.,]) self.eKinOutPlot = BasicGraphData() self.eKinOutPlot.setGraphPointSize(7) self.eKinOutPlot.setGraphColor(Color.BLUE) self.eKinOutPlotTh = BasicGraphData() self.eKinOutPlotTh.setDrawPointsOn(false) self.eKinOutPlotTh.setGraphColor(Color.RED) self.eKinOutPlotTh.setLineThick(3) self.eKinOutPlot.setGraphProperty(GRAPH_LEGEND_KEY," Ekin Out "+self.alias) self.eKinOutPlotTh.setGraphProperty(GRAPH_LEGEND_KEY," Ekin Out Fit "+self.alias) #--- energy params self.eKin_in_guess = 0. # is used for CCL4 forward analysis self.eKin_out_guess = 0. # is used for CCL4 forward analysis self.eKin_in = 0. self.eKin_out = 0. self.eKin_err = 0. self.bpm_eKin_out = 0. self.model_eKin_out = 0. #------- the rescale data bucket self.rescaleBacket = CavityRescaleBucket(self) #------- the longitudinal Twiss parameters bucket self.longTwissBucket = Long_Twiss_Bucket(self) def setBlankBeam(self,bool_val): self.cav.setBlankBeam(bool_val) def setUpBPM_Wrappers(self,bpm_wrappers,scl_long_tuneup_controller): self.bpm_amp_phase_dict = {} self.bpm_wrappers = [] self.bpm_wrappers_useInPhaseAnalysis = [] self.bpm_wrappers_useInAmpBPMs = [] for bpm_wrapper in bpm_wrappers: #we will use all bpm_wrappers even if they are before the cavity #if(bpm_wrapper.getPosition() > self.getPosition() and bpm_wrapper.isGood): if(bpm_wrapper.isGood): self.bpm_wrappers.append(bpm_wrapper) self.bpm_wrappers_useInPhaseAnalysis.append(true) self.bpm_wrappers_useInAmpBPMs.append(true) (graphDataAmp,graphDataPhase) = (BasicGraphData(),BasicGraphData()) graphDataAmp.setGraphPointSize(5) graphDataPhase.setGraphPointSize(5) graphDataAmp.setGraphColor(Color.BLUE) graphDataPhase.setGraphColor(Color.BLUE) graphDataPhase.setGraphProperty(GRAPH_LEGEND_KEY," Phase "+bpm_wrapper.alias) graphDataAmp.setGraphProperty(GRAPH_LEGEND_KEY," Amp "+bpm_wrapper.alias) self.bpm_amp_phase_dict[bpm_wrapper] = (graphDataAmp,graphDataPhase) # HEBT2 BPMs should not be used in the phase and amp analysis (pending the XAL Online Model fix) for ind in range(len(self.bpm_wrappers)): bpm_wrapper = self.bpm_wrappers[ind] #---- HEBT2 should be excluded - usually energy is wrong for beam transport to HEBT2 if(bpm_wrapper.pos > 280.): self.bpm_wrappers_useInPhaseAnalysis[ind] = false self.bpm_wrappers_useInAmpBPMs[ind] = false # longitudinal twiss bucket update self.longTwissBucket.update() def setBPM_0_1_Wrappers(self,bpm_wrapper0,bpm_wrapper1): self.phaseDiffPlot.removeAllPoints() self.phaseDiffPlotTh.removeAllPoints() self.bpm_wrapper0 = null self.bpm_wrapper1 = null if(self.bpm_amp_phase_dict.has_key(bpm_wrapper0)): self.bpm_wrapper0 = bpm_wrapper0 if(self.bpm_amp_phase_dict.has_key(bpm_wrapper1)): self.bpm_wrapper1 = bpm_wrapper1 self.phaseDiffPlot.removeAllPoints() legendKey = GRAPH_LEGEND_KEY txt = self.alias + " Phase diff " self.phaseDiffPlotTh.setGraphProperty(legendKey,txt + "Fit") if(self.bpm_wrapper0 != null and self.bpm_wrapper1 != null): self.phaseDiffPlot.setGraphProperty(legendKey,txt+self.bpm_wrapper0.alias+" "+self.bpm_wrapper1.alias) else: self.phaseDiffPlot.setGraphProperty(legendKey,txt) def clean(self): for bpm_wrapper in self.bpm_wrappers: (graphDataAmp,graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper] graphDataAmp.removeAllPoints() graphDataPhase.removeAllPoints() self.livePhase = 0. self.isMeasured = false self.isAnalyzed = false self.phase_scan_harm_err = 0. self.phase_scan_harm_amp = 0. self.avg_gap_phase = 0. self.eKin_err = 0. self.model_eKin_out = 0. self.bpm_eKin_out = 0. self.real_scanPhaseShift = 0. self.phase_scan_harm_funcion.setParamArr([0.,]) self.phaseDiffPlot.removeAllPoints() self.phaseDiffPlotTh.removeAllPoints() self.eKinOutPlot.removeAllPoints() self.eKinOutPlotTh.removeAllPoints() #---clean the rescale data self.rescaleBacket.clean() #---clean longitudinal Twiss data self.longTwissBucket.clean() def addScanPointToPhaseDiffData(self): if(self.bpm_wrapper0 == null or self.bpm_wrapper1 == null): return (graphDataAmp0,graphDataPhase0) = self.bpm_amp_phase_dict[self.bpm_wrapper0] (graphDataAmp1,graphDataPhase1) = self.bpm_amp_phase_dict[self.bpm_wrapper1] if(graphDataPhase0.getNumbOfPoints() != graphDataPhase1.getNumbOfPoints()): return n_points = graphDataPhase0.getNumbOfPoints() ind = n_points-1 x = graphDataPhase0.getX(ind) y = graphDataPhase1.getY(ind) - graphDataPhase0.getY(ind) self.phaseDiffPlot.addPoint(x,y) def recalculatePhaseDiffData(self): if(self.bpm_wrapper0 == null or self.bpm_wrapper1 == null): return (graphDataAmp0,graphDataPhase0) = self.bpm_amp_phase_dict[self.bpm_wrapper0] (graphDataAmp1,graphDataPhase1) = self.bpm_amp_phase_dict[self.bpm_wrapper1] if(graphDataPhase0.getNumbOfPoints() != graphDataPhase1.getNumbOfPoints()): return x_arr = [] y_arr = [] for ind in range(graphDataPhase0.getNumbOfPoints()): x_arr.append(graphDataPhase0.getX(ind)) y_arr.append(graphDataPhase1.getY(ind) - graphDataPhase0.getY(ind)) self.phaseDiffPlot.removeAllPoints() self.phaseDiffPlot.addPoint(x_arr,y_arr) def getAmpPhaseGraphs(self,bpm_wrapper): if(self.bpm_amp_phase_dict.has_key(bpm_wrapper)): (graphDataAmp,graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper] return (graphDataAmp,graphDataPhase) return (null,null) def setPosition(self,accSeq): self.pos = accSeq.getPosition(self.cav) def getPosition(self): return self.pos def writeDataToXML(self,root_da): cav_wrapper_da = root_da.createChild(self.alias) cav_wrapper_da.setValue("cav",self.cav.getId()) bpm0_name = "null" bpm1_name = "null" if(self.bpm_wrapper0 != null): bpm0_name = self.bpm_wrapper0.alias if(self.bpm_wrapper1 != null): bpm1_name = self.bpm_wrapper1.alias cav_wrapper_da.setValue("bpm0",bpm0_name) cav_wrapper_da.setValue("bpm1",bpm1_name) cav_wrapper_da.setValue("isGood",self.isGood ) cav_wrapper_da.setValue("isMeasured",self.isMeasured) cav_wrapper_da.setValue("isAnalyzed",self.isAnalyzed) #-------------------------------- cav_wrapper_params_da = cav_wrapper_da.createChild("Params") cav_wrapper_params_da.setValue("initDesignAmp",self.initDesignAmp) cav_wrapper_params_da.setValue("initDesignPhase",self.initDesignPhase) cav_wrapper_params_da.setValue("designAmp",self.designAmp) cav_wrapper_params_da.setValue("designPhase",self.designPhase) cav_wrapper_params_da.setValue("avg_gap_phase",self.avg_gap_phase) cav_wrapper_params_da.setValue("initLiveAmp",self.initLiveAmp) cav_wrapper_params_da.setValue("initLivePhase",self.initLivePhase) cav_wrapper_params_da.setValue("livePhase",self.livePhase) cav_wrapper_params_da.setValue("scanPhaseShift",self.scanPhaseShift) cav_wrapper_params_da.setValue("phase_scan_harm_err",self.phase_scan_harm_err) cav_wrapper_params_da.setValue("phase_scan_harm_amp",self.phase_scan_harm_amp) cav_wrapper_params_da.setValue("eKin_in_guess",self.eKin_in_guess) cav_wrapper_params_da.setValue("eKin_out_guess",self.eKin_out_guess) cav_wrapper_params_da.setValue("eKin_in",self.eKin_in) cav_wrapper_params_da.setValue("eKin_out",self.eKin_out) cav_wrapper_params_da.setValue("eKin_err",self.eKin_err) cav_wrapper_params_da.setValue("bpm_eKin_out",self.bpm_eKin_out) cav_wrapper_params_da.setValue("model_eKin_out",self.model_eKin_out) cav_wrapper_params_da.setValue("real_scanPhaseShift",self.real_scanPhaseShift) #--------- write the cavity rescale data self.rescaleBacket.writeDataToXML(cav_wrapper_da) #--------------------------------- cav_wrapper_phase_harm_da = cav_wrapper_da.createChild("Phase_Harm_Func") cav_wrapper_phase_harm_da.setValue("params_arr",self.phase_scan_harm_funcion.getTxtParamArr()) cav_wrapper_energy_harm_da = cav_wrapper_da.createChild("Eenergy_guess_Harm_Func") cav_wrapper_energy_harm_da.setValue("params_arr",self.energy_guess_harm_funcion.getTxtParamArr()) #---------------------------------- dumpGraphDataToDA(self.phaseDiffPlot,cav_wrapper_da,"Phase_Diff_GD","%8.3f","%8.3f") dumpGraphDataToDA(self.phaseDiffPlotTh,cav_wrapper_da,"Phase_Diff_Fit_GD","%8.3f","%8.3f") dumpGraphDataToDA(self.eKinOutPlot,cav_wrapper_da,"Ekin_Out_GD","%8.3f","%10.4f") dumpGraphDataToDA(self.eKinOutPlotTh,cav_wrapper_da,"Ekin_Out_Fit_GD","%8.3f","%10.4f") #------------------------------------ cav_wrapper_bpm_list_da = cav_wrapper_da.createChild("bpm_arr") txt = "" for bpm_wrapper in self.bpm_wrappers: txt = txt +" "+ bpm_wrapper.alias cav_wrapper_bpm_list_da.setValue("bpm_wrappers",txt) cav_wrapper_bpm_list_da = cav_wrapper_da.createChild("bpm_use_in_phase_analysis_arr") txt = "" for bool_val in self.bpm_wrappers_useInPhaseAnalysis: val = "0" if(bool_val): val = "1" txt = txt +" "+ val cav_wrapper_bpm_list_da.setValue("use_arr",txt) cav_wrapper_bpm_list_da = cav_wrapper_da.createChild("bpm_use_in_amp_analysis_arr") txt = "" for bool_val in self.bpm_wrappers_useInAmpBPMs: val = "0" if(bool_val): val = "1" txt = txt +" "+ val cav_wrapper_bpm_list_da.setValue("use_arr",txt) #--------------------------------------------- cav_wrapper_scan_data_da = cav_wrapper_da.createChild("scan_data") for bpm_wrapper in self.bpm_wrappers: if(self.bpm_amp_phase_dict.has_key(bpm_wrapper)): (graphDataAmp,graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper] cav_wrapper_scan_data_bpm_da = cav_wrapper_scan_data_da.createChild(bpm_wrapper.alias) dumpGraphDataToDA(graphDataPhase,cav_wrapper_scan_data_bpm_da,"phase","%8.3f","%8.3f") dumpGraphDataToDA(graphDataAmp,cav_wrapper_scan_data_bpm_da,"amplitude","%8.3f","%10.3g") def readDataFromXML(self,cav_wrapper_da,scl_long_tuneup_controller): #print "debug ============= cav_wrapper_da=",cav_wrapper_da.name() self.bpm_wrapper0 = scl_long_tuneup_controller.getBPM_Wrapper(cav_wrapper_da.stringValue("bpm0")) self.bpm_wrapper1 = scl_long_tuneup_controller.getBPM_Wrapper(cav_wrapper_da.stringValue("bpm1")) self.isGood = Boolean(cav_wrapper_da.intValue("isGood")).booleanValue() self.isMeasured = Boolean(cav_wrapper_da.intValue("isMeasured")).booleanValue() self.isAnalyzed = Boolean(cav_wrapper_da.intValue("isAnalyzed")).booleanValue() #--------- read parameters------------------------- cav_wrapper_params_da = cav_wrapper_da.childAdaptor("Params") self.initDesignAmp = cav_wrapper_params_da.doubleValue("initDesignAmp") self.initDesignPhase = cav_wrapper_params_da.doubleValue("initDesignPhase") self.designAmp = cav_wrapper_params_da.doubleValue("designAmp") self.designPhase = cav_wrapper_params_da.doubleValue("designPhase") self.avg_gap_phase = cav_wrapper_params_da.doubleValue("avg_gap_phase") self.initLiveAmp = cav_wrapper_params_da.doubleValue("initLiveAmp") self.initLivePhase = cav_wrapper_params_da.doubleValue("initLivePhase") self.livePhase = cav_wrapper_params_da.doubleValue("livePhase") self.scanPhaseShift = cav_wrapper_params_da.doubleValue("scanPhaseShift") self.phase_scan_harm_err = cav_wrapper_params_da.doubleValue("phase_scan_harm_err") self.phase_scan_harm_amp = cav_wrapper_params_da.doubleValue("phase_scan_harm_amp") self.eKin_in_guess = cav_wrapper_params_da.doubleValue("eKin_in_guess") self.eKin_out_guess = cav_wrapper_params_da.doubleValue("eKin_out_guess") self.eKin_in = cav_wrapper_params_da.doubleValue("eKin_in") self.eKin_out = cav_wrapper_params_da.doubleValue("eKin_out") self.eKin_err = cav_wrapper_params_da.doubleValue("eKin_err") self.bpm_eKin_out = cav_wrapper_params_da.doubleValue("bpm_eKin_out") self.model_eKin_out = cav_wrapper_params_da.doubleValue("model_eKin_out") self.real_scanPhaseShift = cav_wrapper_params_da.doubleValue("real_scanPhaseShift") #--------- read the cavity rescale data self.rescaleBacket. readDataFromXML(cav_wrapper_da) #--------- read harm. functions------------------------- cav_wrapper_phase_harm_da = cav_wrapper_da.childAdaptor("Phase_Harm_Func") self.phase_scan_harm_funcion.parsePramArr(cav_wrapper_phase_harm_da.stringValue("params_arr")) cav_wrapper_energy_harm_da = cav_wrapper_da.childAdaptor("Eenergy_guess_Harm_Func") self.energy_guess_harm_funcion.parsePramArr(cav_wrapper_energy_harm_da.stringValue("params_arr")) #--------- read phase Diff. graph data readGraphDataFromDA(self.phaseDiffPlot,cav_wrapper_da,"Phase_Diff_GD") readGraphDataFromDA(self.phaseDiffPlotTh,cav_wrapper_da,"Phase_Diff_Fit_GD") readGraphDataFromDA(self.eKinOutPlot,cav_wrapper_da,"Ekin_Out_GD") readGraphDataFromDA(self.eKinOutPlotTh,cav_wrapper_da,"Ekin_Out_Fit_GD") #--------- loop over bpm wrappers for this cavity cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor("bpm_arr") bpm_wrapper_alias_arr = cav_wrapper_bpm_list_da.stringValue("bpm_wrappers").split() cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor("bpm_use_in_phase_analysis_arr") use_in_phase_analysis_arr = cav_wrapper_bpm_list_da.stringValue("use_arr").split() cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor("bpm_use_in_amp_analysis_arr") use_in_amp_analysis_arr = cav_wrapper_bpm_list_da.stringValue("use_arr").split() bpm_wrapper_arr = [] for bpm_wrapper_alias in bpm_wrapper_alias_arr: bpm_wrapper = scl_long_tuneup_controller.getBPM_Wrapper(bpm_wrapper_alias) bpm_wrapper_arr.append(bpm_wrapper) bpm_wrappers = [] use_in_phase_arr = [] use_in_amp_arr = [] for ind in range(len(bpm_wrapper_arr)): bpm_wrapper = bpm_wrapper_arr[ind] if(bpm_wrapper != null): bpm_wrappers.append(bpm_wrapper) use_in_phase_arr.append(use_in_phase_analysis_arr[ind]) use_in_amp_arr.append(use_in_amp_analysis_arr[ind]) use_in_phase_analysis_arr = use_in_phase_arr use_in_amp_analysis_arr = use_in_amp_arr self.setUpBPM_Wrappers(bpm_wrappers,scl_long_tuneup_controller) for ind in range(len(self.bpm_wrappers)): bpm_wrapper = self.bpm_wrappers[ind] self.bpm_wrappers_useInPhaseAnalysis[ind] = Boolean(int(use_in_phase_analysis_arr[ind])).booleanValue() self.bpm_wrappers_useInAmpBPMs[ind] = Boolean(int(use_in_amp_analysis_arr[ind])).booleanValue() #-------- read the phase scan data # we have to keep in mind that in self.bpm_wrappers we have only bpm wrappers that exist in the # scl_long_tuneup_controller.bpm_wrappers and therefore exist in the self.bpm_amp_phase_dict as keys # Threfore they have (graphDataAmp,graphDataPhase) and we just have to fill them out. cav_wrapper_scan_data_da = cav_wrapper_da.childAdaptor("scan_data") for bpm_wrapper in self.bpm_wrappers: if(not self.bpm_amp_phase_dict.has_key(bpm_wrapper)): continue (graphDataAmp,graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper] cav_wrapper_scan_data_bpm_da = cav_wrapper_scan_data_da.childAdaptor(bpm_wrapper.alias) if(cav_wrapper_scan_data_bpm_da != null): readGraphDataFromDA(graphDataPhase,cav_wrapper_scan_data_bpm_da,"phase") readGraphDataFromDA(graphDataAmp,cav_wrapper_scan_data_bpm_da,"amplitude")
class AccState: """ AccState keeps the dictionary with quad fields, cavity amp. and phases, the graph plot with WS/LW sizes, the calculated beam sizes, and the scenario for this quad/cavities parameters. """ def __init__(self,quad_cav_dict,linac_wizard_document): self.quad_cav_dict = quad_cav_dict self.linac_wizard_document = linac_wizard_document self.isOn = true self.size_hor_record_arr = [] self.size_ver_record_arr = [] self.isSelected_ = false #----------- graph data self.gd_exp_hor = BasicGraphData() self.gd_exp_ver = BasicGraphData() self.gd_exp_hor.setDrawLinesOn(false) self.gd_exp_ver.setDrawLinesOn(false) self.gd_exp_hor.setGraphPointSize(11) self.gd_exp_ver.setGraphPointSize(11) self.gd_exp_hor.setGraphColor(Color.BLUE) self.gd_exp_ver.setGraphColor(Color.BLUE) self.gd_model_hor = BasicGraphData() self.gd_model_ver = BasicGraphData() self.gd_model_lon = BasicGraphData() self.gd_model_hor.setGraphColor(Color.RED) self.gd_model_ver.setGraphColor(Color.RED) self.gd_model_lon.setGraphColor(Color.RED) self.gd_model_hor.setLineThick(3) self.gd_model_ver.setLineThick(3) self.gd_model_lon.setLineThick(4) self.gd_model_hor.setDrawPointsOn(false) self.gd_model_ver.setDrawPointsOn(false) self.gd_exp_hor.setGraphProperty(GRAPH_LEGEND_KEY,"LW/WS sizes") self.gd_exp_ver.setGraphProperty(GRAPH_LEGEND_KEY,"LW/WS sizes") self.gd_model_hor.setGraphProperty(GRAPH_LEGEND_KEY,"Model Hor. Size") self.gd_model_ver.setGraphProperty(GRAPH_LEGEND_KEY,"Model Ver. Size") self.gd_model_lon.setGraphProperty(GRAPH_LEGEND_KEY,"Model Longitudinal Size") #------ accelerator model set up accSeq = self.linac_wizard_document.getAccSeq() quads = self.linac_wizard_document.ws_lw_controller.quads cavs = self.linac_wizard_document.ws_lw_controller.cavs #--memorize the initial values self.quad_field_arr = [] for quad in quads: self.quad_field_arr.append([quad,quad.getDfltField()]) self.cav_amp_phase_arr = [] for cav in cavs: self.cav_amp_phase_arr.append([cav,cav.getDfltCavAmp(),cav.getDfltCavPhase()]) #-- set up values from dictionaries [quad_dict,cav_amp_phase_dict] = self.quad_cav_dict for quad in quads: if(quad_dict.has_key(quad)): quad.setDfltField(quad_dict[quad]) for cav in cavs: if(cav_amp_phase_dict.has_key(cav)): cav.updateDesignAmp(cav_amp_phase_dict[cav][0]) cav.updateDesignPhase(cav_amp_phase_dict[cav][1]) self.env_tracker = AlgorithmFactory.createEnvTrackerAdapt(accSeq) self.env_tracker.setRfGapPhaseCalculation(true) self.env_tracker.setUseSpacecharge(true) self.design_probe = ProbeFactory.getEnvelopeProbe(accSeq,self.env_tracker) probe = EnvelopeProbe(self.design_probe) self.scenario = Scenario.newScenarioFor(accSeq) self.scenario.setProbe(probe) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.resync() self.scenario.run() self.traj = self.scenario.getTrajectory() #---restore the quads and cav parameters for [quad,field] in self.quad_field_arr: quad.setDfltField(field) for [cav,amp,phase] in self.cav_amp_phase_arr: cav.updateDesignAmp(amp) cav.updateDesignPhase(phase) def resyncScenario(self): #-- set up values from dictionaries [quad_dict,cav_amp_phase_dict] = self.quad_cav_dict for [quad,field] in self.quad_field_arr: if(quad_dict.has_key(quad)): quad.setDfltField(quad_dict[quad]) for [cav,amp,phase] in self.cav_amp_phase_arr: if(cav_amp_phase_dict.has_key(cav)): cav.updateDesignAmp(cav_amp_phase_dict[cav][0]) cav.updateDesignPhase(cav_amp_phase_dict[cav][1]) self.scenario.resync() #---restore the quads and cav parameters for [quad,field] in self.quad_field_arr: quad.setDfltField(field) for [cav,amp,phase] in self.cav_amp_phase_arr: cav.updateDesignAmp(amp) cav.updateDesignPhase(phase) def updateGraphData(self): tr_twiss_analysis_controller = self.linac_wizard_document.tr_twiss_analysis_controller fit_param_index = tr_twiss_analysis_controller.fit_param_index self.gd_exp_hor.removeAllPoints() self.gd_exp_ver.removeAllPoints() for size_record in self.size_hor_record_arr: if(not size_record.isOn): continue size = size_record.gauss_sigma if(fit_param_index == 1): size = size_record.custom_gauss_sigma if(fit_param_index == 2): size = size_record.custom_rms_sigma pos = size_record.pos self.gd_exp_hor.addPoint(pos,size) for size_record in self.size_ver_record_arr: if(not size_record.isOn): continue size = size_record.gauss_sigma if(fit_param_index == 1): size = size_record.custom_gauss_sigma if(fit_param_index == 2): size = size_record.custom_rms_sigma pos = size_record.pos self.gd_exp_ver.addPoint(pos,size) def addSizeRecord(self,size_record): if(size_record.ws_direction == WS_DIRECTION_HOR): self.size_hor_record_arr.append(size_record) if(size_record.ws_direction == WS_DIRECTION_VER): self.size_ver_record_arr.append(size_record) def getQuadCavDict(self): return self.quad_cav_dict def setSelection(self,selection = false): self.isSelected_ = selection def isSelected(self): return self.isSelected_
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
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()
class FaradayCup_Scan_Data: def __init__(self, dtl_acceptance_scans_controller, dtl_acc_scan_cavity_controller): self.dtl_acceptance_scans_controller = dtl_acceptance_scans_controller self.main_loop_controller = self.dtl_acceptance_scans_controller.main_loop_controller self.dtl_acc_scan_cavity_controller = dtl_acc_scan_cavity_controller self.cav_wrapper = self.dtl_acc_scan_cavity_controller.cav_wrapper self.cav_amp = 0. self.cav_init_phase = 0. self.cav_phase_shift = 0. #----------------------------------------------------- self.fc_scan_gd = BasicGraphData() self.fc_scan_gd.setLineThick(3) self.fc_scan_gd.setGraphPointSize(7) self.fc_scan_gd.setGraphColor(Color.BLUE) self.fc_scan_gd.setGraphProperty(GRAPH_LEGEND_KEY, self.cav_wrapper.alias) self.fc_scan_gd.setDrawLinesOn(true) self.fc_scan_gd.setDrawPointsOn(true) def clean(self): self.fc_scan_gd.removeAllPoints() #------ for MEBT measurements for Iteration process only self.cav_amp = 0. self.cav_init_phase = 0. self.cav_phase_shift = 0. def addPoint(self): cav_phase = self.dtl_acc_scan_cavity_controller.getCavPhase() fc_charge = self.dtl_acc_scan_cavity_controller.getFC_Charge() self.addExternalPoint(cav_phase, fc_charge) def addExternalPoint(self, cav_phase, fc_charge): if (self.fc_scan_gd.getNumbOfPoints() != 0): cav_phase_old = self.fc_scan_gd.getX( self.fc_scan_gd.getNumbOfPoints() - 1) cav_phase = makePhaseNear(cav_phase, cav_phase_old) self.fc_scan_gd.addPoint(cav_phase, fc_charge) def shiftCavPhase(self, gd, phase_shift): self.cav_phase_shift += phase_shift self.cav_init_phase += phase_shift self.cav_phase_shift = makePhaseNear(self.cav_phase_shift, 0.) self.cav_init_phase = makePhaseNear(self.cav_init_phase, 0.) nP = gd.getNumbOfPoints() if (nP == 0): return x_arr = [] y_arr = [] err_arr = [] for ip in range(nP): x_arr.append(gd.getX(ip) + phase_shift) y_arr.append(gd.getY(ip)) err_arr.append(gd.getErr(ip)) gd.removeAllPoints() for ip in range(nP): x_arr[ip] = makePhaseNear(x_arr[ip], 0.) gd.addPoint(x_arr, y_arr, err_arr) def setCavAmplitudeParam(self, cav_amp): self.cav_amp = cav_amp self.fc_scan_gd.setGraphProperty( GRAPH_LEGEND_KEY, self.cav_wrapper.alias + " CavAmp= %6.4f " % self.cav_amp) def checkLastDataPoint(self, min_charge): res = true nP = self.fc_scan_gd.getNumbOfPoints() if (nP > 1): if (math.fabs(self.amp_gd.getY(nP - 1)) > min_charge): if (math.fabs( self.fc_scan_gd.getY(nP - 2) - self.fc_scan_gd.getY(nP - 1)) < 0.000000001): return false return res def removeLastPoint(self): nP = self.fc_scan_gd.getNumbOfPoints() if (nP < 1): return self.fc_scan_gd.removePoint(nP - 1) def writeDataToXML(self, root_da): fc_scan_data_da = root_da.createChild("fc_scan_data") fc_scan_data_da.setValue("cav_amp", self.cav_amp) fc_scan_data_da.setValue("cav_phase", self.cav_init_phase) fc_scan_data_da.setValue("phase_shift", self.cav_phase_shift) dumpGraphDataToDA(self.fc_scan_gd, fc_scan_data_da, "fc_acceptance_scan_gd") def readDataFromXML(self, fc_scan_data_da): self.cav_amp = fc_scan_data_da.doubleValue("cav_amp") self.cav_init_phase = fc_scan_data_da.doubleValue("cav_phase") self.cav_phase_shift = fc_scan_data_da.doubleValue("phase_shift") readGraphDataFromDA(self.fc_scan_gd, fc_scan_data_da, "fc_acceptance_scan_gd")