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 __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 __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 __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)
#-------------------------------------
self.xAvg_gd = BasicGraphData()
self.yAvg_gd = BasicGraphData()
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)
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 update(self): self.bpm_amp_plotTh_arr = [] for bpm_wrapper in self.cav_wrapper.bpm_wrappers: amp_plotTh = BasicGraphData() amp_plotTh.setDrawPointsOn(false) amp_plotTh.setGraphColor(Color.RED) amp_plotTh.setLineThick(3) amp_plotTh.setGraphProperty(GRAPH_LEGEND_KEY,"Cav: "+self.cav_wrapper.alias+" BPM: "+bpm_wrapper.alias) self.bpm_amp_plotTh_arr.append([bpm_wrapper,amp_plotTh])
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 __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 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 __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 __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")
def calculateOffsetsForNotDoneBPMsRight(cav_wrapper,scl_long_tuneup_controller,bpm_wrappers_good_arr,bpm_wrappers_not_done_arr): # this function will calculate offsets for "right" offsets of # "Not yet Done" BPMs by using "good" (already done) BPMs eKin_in = cav_wrapper.eKin_in_guess mass = scl_long_tuneup_controller.mass/1.0e+6 c_light = scl_long_tuneup_controller.c_light bpm_freq = scl_long_tuneup_controller.bpm_freq coeff_init = 360.0*bpm_freq/c_light for bpm_wrapper in bpm_wrappers_not_done_arr: bpm_wrapper.right_phase_offset.phaseOffset_arr = [] (graphDataAmp,phaseDiffPlot) = cav_wrapper.bpm_amp_phase_dict[bpm_wrappers_good_arr[0]] cav_wrapper.eKinOutPlot.removeAllPoints() cav_wrapper.eKinOutPlotTh.removeAllPoints() for ip in range(phaseDiffPlot.getNumbOfPoints()): cav_phase = phaseDiffPlot.getX(ip) ekin_guess = cav_wrapper.energy_guess_harm_funcion.getValue(cav_phase) beta_guess = math.sqrt(ekin_guess*(ekin_guess+2*mass))/(ekin_guess+mass) coeff = coeff_init/beta_guess # let's make bpm_phase(z) points for good BPMs gd = BasicGraphData() base_bpm_wrapper = bpm_wrappers_good_arr[0] (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[base_bpm_wrapper] base_bpm_offset = base_bpm_wrapper.right_phase_offset.phaseOffset_avg base_bpm_phase = graphDataPhase.getY(ip) - base_bpm_offset #print "debug ==== ip=",ip," cav_phase=",cav_phase," eKin_guess=",ekin_guess gd.addPoint(base_bpm_wrapper.pos,base_bpm_phase) for bpm_ind in range(1,len(bpm_wrappers_good_arr)): bpm_wrapper = bpm_wrappers_good_arr[bpm_ind] (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper] bpm_phase = graphDataPhase.getY(ip) - bpm_wrapper.right_phase_offset.phaseOffset_avg bpm_pos = bpm_wrapper.pos bpm_phase_guess = gd.getY(bpm_ind-1) + coeff*(bpm_pos-gd.getX(bpm_ind-1)) bpm_phase = makePhaseNear(bpm_phase,bpm_phase_guess) gd.addPoint(bpm_pos,bpm_phase) #print "debug bpm=",bpm_wrapper.alias," pos=",bpm_pos," phase=",bpm_phase res_arr = GraphDataOperations.polynomialFit(gd,-1.e+36,+1.e+36,1) slope = res_arr[0][1] slope_err = res_arr[1][1] init_phase = res_arr[0][0] init_phase_err = res_arr[1][0] beta = coeff_init/slope gamma = 1./math.sqrt(1.0-beta*beta) eKin = mass*(gamma-1.0) delta_eKin = mass*gamma**3*beta**3*slope_err/coeff_init cav_wrapper.eKinOutPlot.addPoint(cav_phase,eKin,delta_eKin) #print "debug cav_phase=",cav_phase,"eKin_guess=",ekin_guess," eKin=",eKin," delta_E=",delta_eKin # let's go over the bad BPMs and calculate offsets for particular cavity phase for bpm_wrapper in bpm_wrappers_not_done_arr: bpm_pos = bpm_wrapper.pos bpm_phase_th = init_phase + slope*bpm_pos (graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper] bpm_phase = graphDataPhase.getY(ip) bpm_offset = makePhaseNear(bpm_phase - bpm_phase_th,0.) bpm_wrapper.right_phase_offset.phaseOffset_arr.append(bpm_offset) #----set up the output energy guess cav_wrapper.eKin_out_guess = cav_wrapper.eKinOutPlot.getValueY(cav_wrapper.livePhase) eKin_avg = 0. for i_ep in range(cav_wrapper.eKinOutPlot.getNumbOfPoints()): eKin_avg += cav_wrapper.eKinOutPlot.getY(i_ep) if(cav_wrapper.eKinOutPlot.getNumbOfPoints() != 0.): eKin_avg /= cav_wrapper.eKinOutPlot.getNumbOfPoints() cav_wrapper.eKin_in_guess = eKin_avg # let's calculate statistics for "not done" BPMs' offsets for bpm_wrapper in bpm_wrappers_not_done_arr: phase_arr = bpm_wrapper.right_phase_offset.phaseOffset_arr (phase0_avg, phase0_err) = calculateAvgErr(phase_arr) phase_arr = [] for phase in bpm_wrapper.right_phase_offset.phaseOffset_arr: phase_arr.append(makePhaseNear(phase-180.,0.)) (phase1_avg, phase1_err) = calculateAvgErr(phase_arr) phase1_avg = makePhaseNear(phase1_avg+180.,0.) if(phase1_err < phase0_err): bpm_wrapper.right_phase_offset.phaseOffset_avg = phase1_avg bpm_wrapper.right_phase_offset.phaseOffset_err = phase1_err else: bpm_wrapper.right_phase_offset.phaseOffset_avg = phase0_avg bpm_wrapper.right_phase_offset.phaseOffset_err = phase0_err bpm_wrapper.right_phase_offset.isReady = true
def calculateEnergy(self, eKin_in):
mass = self.scl_long_tuneup_controller.mass / 1.0e+6
c_light = self.scl_long_tuneup_controller.c_light
bpm_freq = self.scl_long_tuneup_controller.bpm_freq
coeff_init = 360.0 * bpm_freq / c_light
beta = math.sqrt(eKin_in * (eKin_in + 2 * mass)) / (eKin_in + mass)
coeff = coeff_init / beta
#------ calculate avg bpm phases
res_arr = []
for bpm_ind in range(len(self.em_bpm_wrpprs)):
bpm_wrapper = self.em_bpm_wrpprs[bpm_ind]
if (not self.use_bpms[bpm_ind]): continue
if (not self.bpm_amp_phase_data_dict.has_key(bpm_wrapper)):
continue
(amp_arr, phase_arr) = self.bpm_amp_phase_data_dict[bpm_wrapper]
(phase_avg, phase_err) = calculateAvgErr(phase_arr)
#print "debug bpm=",bpm_wrapper.alias," (phase_avg,phase_err) =",(phase_avg,phase_err)
res_arr.append([bpm_ind, bpm_wrapper, phase_avg, phase_err])
n_res = len(res_arr)
scl_long_tuneup_energy_meter_controller = self.scl_long_tuneup_controller.scl_long_tuneup_energy_meter_controller
table_and_plots_panel = scl_long_tuneup_energy_meter_controller.table_and_plots_panel
init_start_stop_panel = scl_long_tuneup_energy_meter_controller.init_start_stop_panel
fixInitEenergy_RadioButton = init_start_stop_panel.fixInitEenergy_RadioButton
buffer_size = int(init_start_stop_panel.buffer_size_text.getValue())
if (n_res < 2): return eKin_in
[bpm_ind0, bpm_wrapper0, phase_avg0, phase_err0] = res_arr[0]
phase_avg0 = phase_avg0 - self.bpm_phase_offsets[0]
res_arr[0][2] = phase_avg0
base_pos = bpm_wrapper0.pos
#"""
for ind in range(n_res - 1):
[bpm_ind0, bpm_wrapper0, phase_avg0, phase_err0] = res_arr[ind]
[bpm_ind1, bpm_wrapper1, phase_avg1, phase_err1] = res_arr[ind + 1]
bpm1_phase = phase_avg1 - self.bpm_phase_offsets[bpm_ind1]
bpm1_phase_guess = phase_avg0 + coeff * (bpm_wrapper1.pos -
bpm_wrapper0.pos)
bpm1_phase = makePhaseNear(bpm1_phase, bpm1_phase_guess)
res_arr[ind + 1][2] = bpm1_phase
"""
for ind in range(1,n_res):
[bpm_ind,bpm_wrapper,phase_avg,phase_err] = res_arr[ind]
bpm_phase = phase_avg - self.bpm_phase_offsets[bpm_ind]
delta_pos = bpm_wrapper.pos - base_pos
bpm_phase_guess = phase_avg0 + coeff*delta_pos
bpm_phase = makePhaseNear(bpm_phase,bpm_phase_guess)
res_arr[ind][2] = bpm_phase
"""
#----- make phase plot
gd = BasicGraphData()
for ind in range(n_res):
[bpm_ind, bpm_wrapper, phase_avg, phase_err] = res_arr[ind]
gd.addPoint(bpm_wrapper.pos - base_pos, phase_avg, phase_err)
res_poly_arr = GraphDataOperations.polynomialFit(
gd, -1.e+36, +1.e+36, 1)
if (res_poly_arr == null): return eKin_in
slope = res_poly_arr[0][1]
init_phase = res_poly_arr[0][0]
if (fixInitEenergy_RadioButton.isSelected()):
slope = coeff
init_phase = phase_avg0
beta = coeff_init / slope
gamma = 1. / math.sqrt(1.0 - beta * beta)
eKin = mass * (gamma - 1.0)
slope_err = res_poly_arr[1][1]
delta_eKin = mass * gamma**3 * beta**3 * slope_err / coeff_init
#make phase error plot
x_arr = []
y_arr = []
err_arr = []
for ind in range(n_res):
[bpm_ind, bpm_wrapper, phase_avg, phase_err] = res_arr[ind]
x_arr.append(bpm_wrapper.pos)
phase_diff = makePhaseNear(
phase_avg - (init_phase + slope *
(bpm_wrapper.pos - base_pos)), 0.)
self.bpm_phase_diff_arr[bpm_ind].append(phase_diff)
if (len(self.bpm_phase_diff_arr[bpm_ind]) > buffer_size):
self.bpm_phase_diff_arr[bpm_ind] = self.bpm_phase_diff_arr[
bpm_ind][1:]
(phase_diff,
phase_err) = calculateAvgErr(self.bpm_phase_diff_arr[bpm_ind])
y_arr.append(phase_diff)
err_arr.append(phase_err)
table_and_plots_panel.bpm_phase_err_gd.removeAllPoints()
table_and_plots_panel.bpm_phase_err_gd.addPoint(x_arr, y_arr, err_arr)
return (eKin, delta_eKin)
def __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 TestHarmFunc(param_arr, x):
""" param_arr = [base,(amp,shift)...] """
coeff = math.pi / 180.
y = param_arr[0]
for i0 in range((len(param_arr) - 1) / 2):
y += param_arr[2 * i0 + 1] * math.cos(
((i0 + 1) * x + param_arr[2 * i0 + 2]) * coeff)
return y
#---------------------------------------------------
# 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)
