class Table_and_Plots_Panel(JPanel):
def __init__(self,scl_long_tuneup_controller):
self.scl_long_tuneup_controller = scl_long_tuneup_controller
self.setLayout(BorderLayout())
#----etched border
etched_border = BorderFactory.createEtchedBorder()
titled_border = BorderFactory.createTitledBorder(etched_border,"BPM Table and Plots")
self.setBorder(titled_border)
#----------------------------------------
self.bpm_table = JTable(Energy_Meter_BPMs_Table_Model(self.scl_long_tuneup_controller))
self.bpm_table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
self.bpm_table.setFillsViewportHeight(true)
self.bpm_table.setPreferredScrollableViewportSize(Dimension(400,300))
scrl_panel = JScrollPane(self.bpm_table)
scrl_panel.setBorder(etched_border)
bpm_table_panel = JPanel(BorderLayout())
bpm_table_panel.add(scrl_panel,BorderLayout.WEST)
#-----------------------------------------
self.gp_bpm_phase_err = FunctionGraphsJPanel()
self.gp_bpm_phase_err.setLegendButtonVisible(true)
self.gp_bpm_phase_err.setChooseModeButtonVisible(true)
self.gp_bpm_phase_err.setName("BPM Phase Errors")
self.gp_bpm_phase_err.setAxisNames("position, [m]","BPM Phase Error, [deg]")
self.gp_bpm_phase_err.setBorder(etched_border)
bpm_graph_panel = JPanel(BorderLayout())
bpm_graph_panel.add(self.gp_bpm_phase_err)
#------graph data
self.bpm_phase_err_gd = BasicGraphData()
self.bpm_phase_err_gd.setGraphPointSize(8)
self.bpm_phase_err_gd.setDrawLinesOn(false)
self.bpm_phase_err_gd.setGraphColor(Color.BLUE)
self.gp_bpm_phase_err.addGraphData(self.bpm_phase_err_gd)
#-----------------------------------------
self.add(bpm_table_panel,BorderLayout.WEST)
self.add(bpm_graph_panel,BorderLayout.CENTER)
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_
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 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 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 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")
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 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)
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")
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")
