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,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)	
Beispiel #3
0
	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,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, 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.
Beispiel #6
0
	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.
Beispiel #7
0
 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 __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, 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 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 __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 __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
Beispiel #13
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)
Beispiel #14
0
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
Beispiel #15
0
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()
	def getPositionOfMax(self):
		return self.harm_func.findMax()	
	
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)
	
Beispiel #17
0
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)
Beispiel #18
0
	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)
class SCL_One_Cavity_Tracker_Model:
	def __init__(self,scl_long_tuneup_controller):
		self.scl_long_tuneup_controller = scl_long_tuneup_controller
		self.scl_accSeq = self.scl_long_tuneup_controller.scl_accSeq
		self.part_tracker = AlgorithmFactory.createParticleTracker(self.scl_accSeq)
		self.part_tracker.setRfGapPhaseCalculation(true)
		self.part_probe_init = ProbeFactory.createParticleProbe(self.scl_accSeq,self.part_tracker)
		self.scenario = Scenario.newScenarioFor(self.scl_accSeq)
		self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN)
		self.scenario.resync()
		# in the dictionary we will have 
		# cav_wrappers_param_dict[cav_wrapper] = [cavAmp,phase,[[gapLattElem,E0,ETL],...]]
		# E0 and ETL are parameters for all RF gaps
		self.cav_wrappers_param_dict = {}
		cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers
		self.cav_amp_phase_dict = {}
		for cav_wrapper in cav_wrappers:
			amp = cav_wrapper.cav.getDfltCavAmp()
			phase = cav_wrapper.cav.getDfltCavPhase()
			self.cav_amp_phase_dict[cav_wrapper] = (amp,phase)
		#------ Make rf gap arrays for each cavity. 
		#------ The elements are IdealRfGap instances not AcceleratorNode. 
		#------ self.cavToGapsDict has {cav_name:[irfGaps]}
		rfGaps = self.scl_accSeq.getAllNodesWithQualifier(AndTypeQualifier().and((OrTypeQualifier()).or(RfGap.s_strType)))	
		self.cavToGapsDict = {}		
		for cav_wrapper in cav_wrappers:
			self.cavToGapsDict[cav_wrapper] = []
			for rfGap in rfGaps:
				if(rfGap.getId().find(cav_wrapper.cav.getId()) >= 0):
					irfGaps = self.scenario.elementsMappedTo(rfGap)
					self.cavToGapsDict[cav_wrapper].append(irfGaps[0])				
		#self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_PHASE,phase)
		#self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_ETL,val)
		#self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_E0,val)
		#self.scenario.setModelInput(quad,ElectromagnetPropertyAccessor,PROPERTY_FIELD,val)		
		#----------------------------------------------------------------
		self.scan_gd = BasicGraphData()
		self.harmonicsAnalyzer = HarmonicsAnalyzer(2)
		self.eKin_in = 185.6
		self.cav_amp = 14.0
		self.cav_phase_shift = 0.
		#------------------------
		self.active_cav_wrapper = null
		self.solver = null
		
	def restoreInitAmpPhases(self):
		cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers
		for cav_wrapper in cav_wrappers:
			(amp,phase) = self.cav_amp_phase_dict[cav_wrapper]
			self.active_cav_wrapper.cav.updateDesignAmp(amp)
			self.active_cav_wrapper.cav.updateDesignPhase(phase)
		self.setActiveCavity(null)
		
	def getEkinAmpPhaseShift(self):
		return (self.eKin_in,self.cav_amp,self.cav_phase_shift)
		
	def setModelAmpPhaseToActiveCav(self,amp,phase,phase_shift):
		if(self.active_cav_wrapper != null):
			self.active_cav_wrapper.cav.updateDesignAmp(amp)
			self.active_cav_wrapper.cav.updateDesignPhase(phase-phase_shift)
			
	def getAvgGapPhase(self):
		#------------- calculate avg. RF gap phase -----------
		if(self.active_cav_wrapper == null): return 0.
		rf_gap_arr = self.cavToGapsDict[self.active_cav_wrapper]
		phase_rf_gaps_avg = 0.
		for irfGap in rf_gap_arr:
			phase_rf_gaps_avg += makePhaseNear(irfGap.getPhase(),0.)
		phase_rf_gaps_avg /= len(rf_gap_arr)
		phase_rf_gaps_avg = makePhaseNear((phase_rf_gaps_avg*180./math.pi)%360.,0.)
		return phase_rf_gaps_avg
			
	def getModelEnergyOut(self,eKin_in,amp,phase,phase_shift):
		if(self.active_cav_wrapper == null): return 0.
		self.setModelAmpPhaseToActiveCav(amp,phase,phase_shift)
		part_probe = ParticleProbe(self.part_probe_init)
		part_probe.setKineticEnergy(eKin_in*1.0e+6)
		self.scenario.setProbe(part_probe)	
		self.scenario.resync()
		self.scenario.run()
		return self.scenario.getTrajectory().finalState().getKineticEnergy()/1.0e+6
			
	def fillOutEneregyVsPhase(self,eKin_in,amp,phase_shift,phase_arr):
		self.scan_gd.removeAllPoints()
		if(self.active_cav_wrapper == null): return
		self.active_cav_wrapper.cav.updateDesignAmp(amp)
		self.scenario.resync()
		irfGap = self.cavToGapsDict[self.active_cav_wrapper][0]	
		for phase in phase_arr:
			part_probe = ParticleProbe(self.part_probe_init)
			part_probe.setKineticEnergy(eKin_in*1.0e+6)
			self.scenario.setProbe(part_probe)		
			#self.active_cav_wrapper.cav.updateDesignPhase(phase-phase_shift)
			#self.scenario.resync()
			irfGap.setPhase((phase-phase_shift)*math.pi/180.)
			self.scenario.run()
			eKin_out = self.scenario.getTrajectory().finalState().getKineticEnergy()/1.0e+6
			self.scan_gd.addPoint(phase,eKin_out)
		return self.scan_gd
			
	def getDiff2(self,eKin_in,amp,phase_shift):
		if(self.active_cav_wrapper == null): return 0.
		scan_gdExp = self.active_cav_wrapper.eKinOutPlot
		n_points = scan_gdExp.getNumbOfPoints()
		if(n_points <= 0): return 0.
		phase_arr = []
		for ip in range(n_points):
			phase_arr.append(scan_gdExp.getX(ip))
		scan_gd = self.fillOutEneregyVsPhase(eKin_in,amp,phase_shift,phase_arr)
		diff2 = 0.
		for ip in range(n_points):
			diff2 += (scan_gd.getY(ip) - scan_gdExp.getY(ip))**2
		diff2 /= n_points
		return diff2
			
	def setActiveCavity(self,cav_wrapper):
		self.active_cav_wrapper = cav_wrapper
		if(cav_wrapper != null):
			self.gap_list = cav_wrapper.cav.getGapsAsList()
			self.gap_first = self.gap_list.get(0)
			self.gap_last = self.gap_list.get(self.gap_list.size()-1)
			self.scenario.setStartNode(self.gap_first.getId())
			self.scenario.setStopNode(self.gap_last.getId())
		else:
			self.scenario.unsetStartNode()
			self.scenario.unsetStopNode()
			self.gap_first = null
			self.gap_last = null	
			self.gap_list = null
			
	def harmonicsAnalysisStep(self):
		if(self.active_cav_wrapper == null): return
		self.eKin_in = self.active_cav_wrapper.eKin_in
		self.cav_amp = 14.0
		self.cav_phase_shift = 0.
		#--------- first iteration
		self.getDiff2(self.eKin_in,self.cav_amp,self.cav_phase_shift)
		err = self.harmonicsAnalyzer.analyzeData(self.scan_gd)	
		harm_function = self.harmonicsAnalyzer.getHrmonicsFunction()
		energy_amp_test = harm_function.getParamArr()[1]
		energy_amp_exp = self.active_cav_wrapper.energy_guess_harm_funcion.getParamArr()[1]
		self.cav_amp = self.cav_amp*energy_amp_exp/energy_amp_test
		#--------- second iteration	
		self.getDiff2(self.eKin_in,self.cav_amp,self.cav_phase_shift)
		err = self.harmonicsAnalyzer.analyzeData(self.scan_gd)	
		harm_function = self.harmonicsAnalyzer.getHrmonicsFunction()
		energy_amp_test = harm_function.getParamArr()[1]
		energy_amp_exp = self.active_cav_wrapper.energy_guess_harm_funcion.getParamArr()[1]
		self.cav_amp = self.cav_amp*energy_amp_exp/energy_amp_test
		max_model_energy_phase = self.harmonicsAnalyzer.getPositionOfMax()
		max_exp_energy_phase = self.active_cav_wrapper.energy_guess_harm_funcion.findMax()
		self.cav_phase_shift = makePhaseNear(-(max_model_energy_phase - max_exp_energy_phase),0.)
		#print "debug model max=",max_model_energy_phase," exp=",max_exp_energy_phase," shift=",self.cav_phase_shift," amp=",self.cav_amp
		
	def fit(self):
		if(self.active_cav_wrapper == null): return
		variables = ArrayList()
		delta_hint = InitialDelta()
		#----- variable eKin_in
		var = Variable("eKin_in",self.eKin_in, - Double.MAX_VALUE, Double.MAX_VALUE)
		variables.add(var)
		delta_hint.addInitialDelta(var,0.3)
		#----- variable cavity amplitude
		var = Variable("cav_amp",self.cav_amp, - Double.MAX_VALUE, Double.MAX_VALUE)
		variables.add(var)
		delta_hint.addInitialDelta(var,self.cav_amp*0.01)
		#----- variable cavity phase offset
		var = Variable("phase_offset",self.cav_phase_shift, - Double.MAX_VALUE, Double.MAX_VALUE)
		variables.add(var)
		delta_hint.addInitialDelta(var,1.0)
		#-------- solve the fitting problem
		scorer = CavAmpPhaseScorer(self,variables)
		maxSolutionStopper = SolveStopperFactory.maxEvaluationsStopper(120) 
		self.solver = Solver(SimplexSearchAlgorithm(),maxSolutionStopper)
		problem = ProblemFactory.getInverseSquareMinimizerProblem(variables,scorer,0.0001)
		problem.addHint(delta_hint)
		self.solver.solve(problem)
		#------- get results
		trial = self.solver.getScoreBoard().getBestSolution()
		err2 = scorer.score(trial,variables)	
		[self.eKin_in,self.cav_amp,self.cav_phase_shift] = scorer	.getTrialParams(trial)	
		self.active_cav_wrapper.eKin_in = self.eKin_in
		self.active_cav_wrapper.designPhase = makePhaseNear(self.active_cav_wrapper.livePhase - self.cav_phase_shift,0.)
		self.active_cav_wrapper.eKin_err = math.sqrt(err2)
		cav_phase = self.active_cav_wrapper.livePhase
		self.active_cav_wrapper.eKin_out = self.getModelEnergyOut(self.eKin_in,self.cav_amp,cav_phase,self.cav_phase_shift)
		#print "debug cav=",self.active_cav_wrapper.alias," shift=",self.cav_phase_shift," amp=",self.cav_amp," err2=",	math.sqrt(err2)," ekinOut=",	self.active_cav_wrapper.eKin_out		
		#----- this defenition of the avg. gap phase will be replaced by another with self.model_eKin_in
		self.active_cav_wrapper.avg_gap_phase = self.getAvgGapPhase()
		self.active_cav_wrapper.designAmp = self.cav_amp
		self.solver = null
		#----make theory graph plot
		x_arr = []
		y_arr = []
		for i in range(self.scan_gd.getNumbOfPoints()):
			phase = self.scan_gd.getX(i)
			y = self.scan_gd.getY(i)
			x_arr.append(phase)
			y_arr.append(y)
		self.active_cav_wrapper.eKinOutPlotTh.addPoint(x_arr,y_arr)			
		
	def stopFitting(self):
		if(self.solver != null):
			self.solver.stopSolving()
 def __init__(self, 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 __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)
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")
class SCL_Cavity_Wrapper:
    def __init__(self, cav):
        #self.bpm_ch_amp_phase_dic[BPM_Wrapper] = (graphDataAmp,graphDataPhase)
        self.cav = cav
        self.alias = cav.getId().split(":")[1]
        self.isGood = true
        self.isMeasured = false
        self.isAnalyzed = false
        self.pos = 0.
        self.bpm_amp_phase_dict = {}
        self.bpm_wrappers = []
        #--- use or not in phase scan analysis
        self.bpm_wrappers_useInPhaseAnalysis = []
        #--- use or not in BPMs' amplitudes analysis
        self.bpm_wrappers_useInAmpBPMs = []
        #--- BPM wrappers for BPM0 and BPM1 during cavity phase setup after the phase scan
        self.bpm_wrapper0 = null
        self.bpm_wrapper1 = null
        self.phaseDiffPlot = BasicGraphData()
        self.phaseDiffPlot.setGraphPointSize(7)
        self.phaseDiffPlot.setGraphColor(Color.BLUE)
        self.phaseDiffPlotTh = BasicGraphData()
        self.phaseDiffPlotTh.setDrawPointsOn(false)
        self.phaseDiffPlotTh.setGraphColor(Color.RED)
        self.phaseDiffPlotTh.setLineThick(3)
        #----cavity's parameters
        self.initDesignAmp = 0.
        self.initDesignPhase = 0.
        #-- design parameters will be defined after analysis of the phase scan data
        self.designAmp = 0.
        self.designPhase = 0.
        self.avg_gap_phase = 0.  # this is a model parameter that will be used in rescaling
        #--- initial live parameters are measured after initialization
        self.initLiveAmp = 0.
        self.initLivePhase = 0.
        #live phase will be defined after scan
        self.livePhase = 0.
        self.scanPhaseShift = -18.0
        self.real_scanPhaseShift = 0.
        #--- avg. phase error and harmonic amp after harmonics fitting during phase scan
        self.phase_scan_harm_err = 0.
        self.phase_scan_harm_amp = 0.
        self.phase_scan_harm_funcion = HramonicsFunc([
            0.,
        ])
        self.energy_guess_harm_funcion = HramonicsFunc([
            0.,
        ])
        self.eKinOutPlot = BasicGraphData()
        self.eKinOutPlot.setGraphPointSize(7)
        self.eKinOutPlot.setGraphColor(Color.BLUE)
        self.eKinOutPlotTh = BasicGraphData()
        self.eKinOutPlotTh.setDrawPointsOn(false)
        self.eKinOutPlotTh.setGraphColor(Color.RED)
        self.eKinOutPlotTh.setLineThick(3)
        self.eKinOutPlot.setGraphProperty(GRAPH_LEGEND_KEY,
                                          " Ekin Out " + self.alias)
        self.eKinOutPlotTh.setGraphProperty(GRAPH_LEGEND_KEY,
                                            " Ekin Out Fit " + self.alias)
        #--- energy params
        self.eKin_in_guess = 0.  # is used for CCL4 forward analysis
        self.eKin_out_guess = 0.  # is used for CCL4 forward analysis
        self.eKin_in = 0.
        self.eKin_out = 0.
        self.eKin_err = 0.
        self.bpm_eKin_out = 0.
        self.model_eKin_out = 0.
        #------- the rescale data bucket
        self.rescaleBacket = CavityRescaleBucket(self)
        #------- the longitudinal Twiss parameters bucket
        self.longTwissBucket = Long_Twiss_Bucket(self)
        #------- LLRF Buffer resettings PVs
        self.ch_aff_mode = ChannelFactory.defaultFactory().getChannel(
            "SCL_LLRF:FCM" + self.alias.replace("Cav", "") + ":AFF_Mode")
        self.ch_aff_reset = ChannelFactory.defaultFactory().getChannel(
            "SCL_LLRF:FCM" + self.alias.replace("Cav", "") + ":AFF_Reset")
        #------- Amplitude set goal value PV
        self.ampl_goal_pv = ChannelFactory.defaultFactory().getChannel(
            "SCL_LLRF:FCM" + self.alias.replace("Cav", "") + ":cavAmpGoal")
        #print "debug conncted cav=",self.alias

    def getLiveAmlitudeSetGoal(self):
        if (self.ampl_goal_pv.connectAndWait(3.0)):
            return self.ampl_goal_pv.getValDbl()
        return 0.

    def setAFF_Off(self):
        if (self.ch_aff_mode.connectAndWait(0.1)):
            self.ch_aff_mode.putVal(0)

    def setAFF_On(self):
        if (self.ch_aff_mode.connectAndWait(0.1)):
            self.ch_aff_mode.putVal(2)

    def resetAFF(self):
        if (self.ch_aff_reset.connectAndWait(0.1)):
            self.ch_aff_reset.putVal(1)

    def setBlankBeam(self, bool_val):
        self.cav.setBlankBeam(bool_val)

    def setUpBPM_Wrappers(self, bpm_wrappers, scl_long_tuneup_controller):
        self.bpm_amp_phase_dict = {}
        self.bpm_wrappers = []
        self.bpm_wrappers_useInPhaseAnalysis = []
        self.bpm_wrappers_useInAmpBPMs = []
        for bpm_wrapper in bpm_wrappers:
            #we will use all bpm_wrappers even if they are before the cavity
            #if(bpm_wrapper.getPosition() > self.getPosition() and bpm_wrapper.isGood):
            if (bpm_wrapper.isGood):
                self.bpm_wrappers.append(bpm_wrapper)
                self.bpm_wrappers_useInPhaseAnalysis.append(true)
                self.bpm_wrappers_useInAmpBPMs.append(true)
                (graphDataAmp, graphDataPhase) = (BasicGraphData(),
                                                  BasicGraphData())
                graphDataAmp.setGraphPointSize(5)
                graphDataPhase.setGraphPointSize(5)
                graphDataAmp.setGraphColor(Color.BLUE)
                graphDataPhase.setGraphColor(Color.BLUE)
                graphDataPhase.setGraphProperty(GRAPH_LEGEND_KEY,
                                                " Phase " + bpm_wrapper.alias)
                graphDataAmp.setGraphProperty(GRAPH_LEGEND_KEY,
                                              " Amp " + bpm_wrapper.alias)
                self.bpm_amp_phase_dict[bpm_wrapper] = (graphDataAmp,
                                                        graphDataPhase)
        # HEBT2 BPMs should not be used in the phase and amp analysis (pending the XAL Online Model fix)
        for ind in range(len(self.bpm_wrappers)):
            bpm_wrapper = self.bpm_wrappers[ind]
            #---- HEBT2 should be excluded - usually energy is wrong for beam transport to HEBT2
            if (bpm_wrapper.pos > 280.):
                self.bpm_wrappers_useInPhaseAnalysis[ind] = false
                self.bpm_wrappers_useInAmpBPMs[ind] = false
        # longitudinal twiss bucket update
        self.longTwissBucket.update()

    def setBPM_0_1_Wrappers(self, bpm_wrapper0, bpm_wrapper1):
        self.phaseDiffPlot.removeAllPoints()
        self.phaseDiffPlotTh.removeAllPoints()
        self.bpm_wrapper0 = null
        self.bpm_wrapper1 = null
        if (self.bpm_amp_phase_dict.has_key(bpm_wrapper0)):
            self.bpm_wrapper0 = bpm_wrapper0
        if (self.bpm_amp_phase_dict.has_key(bpm_wrapper1)):
            self.bpm_wrapper1 = bpm_wrapper1
        self.phaseDiffPlot.removeAllPoints()
        legendKey = GRAPH_LEGEND_KEY
        txt = self.alias + " Phase diff "
        self.phaseDiffPlotTh.setGraphProperty(legendKey, txt + "Fit")
        if (self.bpm_wrapper0 != null and self.bpm_wrapper1 != null):
            self.phaseDiffPlot.setGraphProperty(
                legendKey,
                txt + self.bpm_wrapper0.alias + " " + self.bpm_wrapper1.alias)
        else:
            self.phaseDiffPlot.setGraphProperty(legendKey, txt)

    def clean(self):
        for bpm_wrapper in self.bpm_wrappers:
            (graphDataAmp,
             graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper]
            graphDataAmp.removeAllPoints()
            graphDataPhase.removeAllPoints()
        self.livePhase = 0.
        self.isMeasured = false
        self.isAnalyzed = false
        self.phase_scan_harm_err = 0.
        self.phase_scan_harm_amp = 0.
        self.avg_gap_phase = 0.
        self.eKin_err = 0.
        self.model_eKin_out = 0.
        self.bpm_eKin_out = 0.
        self.real_scanPhaseShift = 0.
        self.phase_scan_harm_funcion.setParamArr([
            0.,
        ])
        self.phaseDiffPlot.removeAllPoints()
        self.phaseDiffPlotTh.removeAllPoints()
        self.eKinOutPlot.removeAllPoints()
        self.eKinOutPlotTh.removeAllPoints()
        #---clean the rescale data
        self.rescaleBacket.clean()
        #---clean longitudinal Twiss data
        self.longTwissBucket.clean()

    def addScanPointToPhaseDiffData(self):
        if (self.bpm_wrapper0 == null or self.bpm_wrapper1 == null): return
        (graphDataAmp0,
         graphDataPhase0) = self.bpm_amp_phase_dict[self.bpm_wrapper0]
        (graphDataAmp1,
         graphDataPhase1) = self.bpm_amp_phase_dict[self.bpm_wrapper1]
        if (graphDataPhase0.getNumbOfPoints() !=
                graphDataPhase1.getNumbOfPoints()):
            return
        n_points = graphDataPhase0.getNumbOfPoints()
        ind = n_points - 1
        x = graphDataPhase0.getX(ind)
        y = graphDataPhase1.getY(ind) - graphDataPhase0.getY(ind)
        self.phaseDiffPlot.addPoint(x, y)

    def recalculatePhaseDiffData(self):
        if (self.bpm_wrapper0 == null or self.bpm_wrapper1 == null): return
        (graphDataAmp0,
         graphDataPhase0) = self.bpm_amp_phase_dict[self.bpm_wrapper0]
        (graphDataAmp1,
         graphDataPhase1) = self.bpm_amp_phase_dict[self.bpm_wrapper1]
        if (graphDataPhase0.getNumbOfPoints() !=
                graphDataPhase1.getNumbOfPoints()):
            return
        x_arr = []
        y_arr = []
        for ind in range(graphDataPhase0.getNumbOfPoints()):
            x_arr.append(graphDataPhase0.getX(ind))
            y_arr.append(graphDataPhase1.getY(ind) - graphDataPhase0.getY(ind))
        self.phaseDiffPlot.removeAllPoints()
        self.phaseDiffPlot.addPoint(x_arr, y_arr)

    def getAmpPhaseGraphs(self, bpm_wrapper):
        if (self.bpm_amp_phase_dict.has_key(bpm_wrapper)):
            (graphDataAmp,
             graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper]
            return (graphDataAmp, graphDataPhase)
        return (null, null)

    def setPosition(self, accSeq):
        self.pos = accSeq.getPosition(self.cav)

    def getPosition(self):
        return self.pos

    def writeDataToXML(self, root_da):
        cav_wrapper_da = root_da.createChild(self.alias)
        cav_wrapper_da.setValue("cav", self.cav.getId())
        bpm0_name = "null"
        bpm1_name = "null"
        if (self.bpm_wrapper0 != null): bpm0_name = self.bpm_wrapper0.alias
        if (self.bpm_wrapper1 != null): bpm1_name = self.bpm_wrapper1.alias
        cav_wrapper_da.setValue("bpm0", bpm0_name)
        cav_wrapper_da.setValue("bpm1", bpm1_name)
        cav_wrapper_da.setValue("isGood", self.isGood)
        cav_wrapper_da.setValue("isMeasured", self.isMeasured)
        cav_wrapper_da.setValue("isAnalyzed", self.isAnalyzed)
        #--------------------------------
        cav_wrapper_params_da = cav_wrapper_da.createChild("Params")
        cav_wrapper_params_da.setValue("initDesignAmp", self.initDesignAmp)
        cav_wrapper_params_da.setValue("initDesignPhase", self.initDesignPhase)
        cav_wrapper_params_da.setValue("designAmp", self.designAmp)
        cav_wrapper_params_da.setValue("designPhase", self.designPhase)
        cav_wrapper_params_da.setValue("avg_gap_phase", self.avg_gap_phase)
        cav_wrapper_params_da.setValue("initLiveAmp", self.initLiveAmp)
        cav_wrapper_params_da.setValue("initLivePhase", self.initLivePhase)
        cav_wrapper_params_da.setValue("livePhase", self.livePhase)
        cav_wrapper_params_da.setValue("scanPhaseShift", self.scanPhaseShift)
        cav_wrapper_params_da.setValue("phase_scan_harm_err",
                                       self.phase_scan_harm_err)
        cav_wrapper_params_da.setValue("phase_scan_harm_amp",
                                       self.phase_scan_harm_amp)
        cav_wrapper_params_da.setValue("eKin_in_guess", self.eKin_in_guess)
        cav_wrapper_params_da.setValue("eKin_out_guess", self.eKin_out_guess)
        cav_wrapper_params_da.setValue("eKin_in", self.eKin_in)
        cav_wrapper_params_da.setValue("eKin_out", self.eKin_out)
        cav_wrapper_params_da.setValue("eKin_err", self.eKin_err)
        cav_wrapper_params_da.setValue("bpm_eKin_out", self.bpm_eKin_out)
        cav_wrapper_params_da.setValue("model_eKin_out", self.model_eKin_out)
        cav_wrapper_params_da.setValue("real_scanPhaseShift",
                                       self.real_scanPhaseShift)
        #--------- write the cavity rescale data
        self.rescaleBacket.writeDataToXML(cav_wrapper_da)
        #---------------------------------
        cav_wrapper_phase_harm_da = cav_wrapper_da.createChild(
            "Phase_Harm_Func")
        cav_wrapper_phase_harm_da.setValue(
            "params_arr", self.phase_scan_harm_funcion.getTxtParamArr())
        cav_wrapper_energy_harm_da = cav_wrapper_da.createChild(
            "Eenergy_guess_Harm_Func")
        cav_wrapper_energy_harm_da.setValue(
            "params_arr", self.energy_guess_harm_funcion.getTxtParamArr())
        #----------------------------------
        dumpGraphDataToDA(self.phaseDiffPlot, cav_wrapper_da, "Phase_Diff_GD",
                          "%8.3f", "%8.3f")
        dumpGraphDataToDA(self.phaseDiffPlotTh, cav_wrapper_da,
                          "Phase_Diff_Fit_GD", "%8.3f", "%8.3f")
        dumpGraphDataToDA(self.eKinOutPlot, cav_wrapper_da, "Ekin_Out_GD",
                          "%8.3f", "%10.4f")
        dumpGraphDataToDA(self.eKinOutPlotTh, cav_wrapper_da,
                          "Ekin_Out_Fit_GD", "%8.3f", "%10.4f")
        #------------------------------------
        cav_wrapper_bpm_list_da = cav_wrapper_da.createChild("bpm_arr")
        txt = ""
        for bpm_wrapper in self.bpm_wrappers:
            txt = txt + " " + bpm_wrapper.alias
        cav_wrapper_bpm_list_da.setValue("bpm_wrappers", txt)
        cav_wrapper_bpm_list_da = cav_wrapper_da.createChild(
            "bpm_use_in_phase_analysis_arr")
        txt = ""
        for bool_val in self.bpm_wrappers_useInPhaseAnalysis:
            val = "0"
            if (bool_val): val = "1"
            txt = txt + " " + val
        cav_wrapper_bpm_list_da.setValue("use_arr", txt)
        cav_wrapper_bpm_list_da = cav_wrapper_da.createChild(
            "bpm_use_in_amp_analysis_arr")
        txt = ""
        for bool_val in self.bpm_wrappers_useInAmpBPMs:
            val = "0"
            if (bool_val): val = "1"
            txt = txt + " " + val
        cav_wrapper_bpm_list_da.setValue("use_arr", txt)
        #---------------------------------------------
        cav_wrapper_scan_data_da = cav_wrapper_da.createChild("scan_data")
        for bpm_wrapper in self.bpm_wrappers:
            if (self.bpm_amp_phase_dict.has_key(bpm_wrapper)):
                (graphDataAmp,
                 graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper]
                cav_wrapper_scan_data_bpm_da = cav_wrapper_scan_data_da.createChild(
                    bpm_wrapper.alias)
                dumpGraphDataToDA(graphDataPhase, cav_wrapper_scan_data_bpm_da,
                                  "phase", "%8.3f", "%8.3f")
                dumpGraphDataToDA(graphDataAmp, cav_wrapper_scan_data_bpm_da,
                                  "amplitude", "%8.3f", "%10.3g")

    def readDataFromXML(self, cav_wrapper_da, scl_long_tuneup_controller):
        #print "debug ============= cav_wrapper_da=",cav_wrapper_da.name()
        self.bpm_wrapper0 = scl_long_tuneup_controller.getBPM_Wrapper(
            cav_wrapper_da.stringValue("bpm0"))
        self.bpm_wrapper1 = scl_long_tuneup_controller.getBPM_Wrapper(
            cav_wrapper_da.stringValue("bpm1"))
        self.isGood = Boolean(cav_wrapper_da.intValue("isGood")).booleanValue()
        self.isMeasured = Boolean(
            cav_wrapper_da.intValue("isMeasured")).booleanValue()
        self.isAnalyzed = Boolean(
            cav_wrapper_da.intValue("isAnalyzed")).booleanValue()
        #--------- read parameters-------------------------
        cav_wrapper_params_da = cav_wrapper_da.childAdaptor("Params")
        self.initDesignAmp = cav_wrapper_params_da.doubleValue("initDesignAmp")
        self.initDesignPhase = cav_wrapper_params_da.doubleValue(
            "initDesignPhase")
        self.designAmp = cav_wrapper_params_da.doubleValue("designAmp")
        self.designPhase = cav_wrapper_params_da.doubleValue("designPhase")
        self.avg_gap_phase = cav_wrapper_params_da.doubleValue("avg_gap_phase")
        self.initLiveAmp = cav_wrapper_params_da.doubleValue("initLiveAmp")
        self.initLivePhase = cav_wrapper_params_da.doubleValue("initLivePhase")
        self.livePhase = cav_wrapper_params_da.doubleValue("livePhase")
        self.scanPhaseShift = cav_wrapper_params_da.doubleValue(
            "scanPhaseShift")
        self.phase_scan_harm_err = cav_wrapper_params_da.doubleValue(
            "phase_scan_harm_err")
        self.phase_scan_harm_amp = cav_wrapper_params_da.doubleValue(
            "phase_scan_harm_amp")
        self.eKin_in_guess = cav_wrapper_params_da.doubleValue("eKin_in_guess")
        self.eKin_out_guess = cav_wrapper_params_da.doubleValue(
            "eKin_out_guess")
        self.eKin_in = cav_wrapper_params_da.doubleValue("eKin_in")
        self.eKin_out = cav_wrapper_params_da.doubleValue("eKin_out")
        self.eKin_err = cav_wrapper_params_da.doubleValue("eKin_err")
        self.bpm_eKin_out = cav_wrapper_params_da.doubleValue("bpm_eKin_out")
        self.model_eKin_out = cav_wrapper_params_da.doubleValue(
            "model_eKin_out")
        self.real_scanPhaseShift = cav_wrapper_params_da.doubleValue(
            "real_scanPhaseShift")
        #--------- read the cavity rescale data
        self.rescaleBacket.readDataFromXML(cav_wrapper_da)
        #--------- read harm. functions-------------------------
        cav_wrapper_phase_harm_da = cav_wrapper_da.childAdaptor(
            "Phase_Harm_Func")
        self.phase_scan_harm_funcion.parsePramArr(
            cav_wrapper_phase_harm_da.stringValue("params_arr"))
        cav_wrapper_energy_harm_da = cav_wrapper_da.childAdaptor(
            "Eenergy_guess_Harm_Func")
        self.energy_guess_harm_funcion.parsePramArr(
            cav_wrapper_energy_harm_da.stringValue("params_arr"))
        #--------- read phase Diff. graph data
        readGraphDataFromDA(self.phaseDiffPlot, cav_wrapper_da,
                            "Phase_Diff_GD")
        readGraphDataFromDA(self.phaseDiffPlotTh, cav_wrapper_da,
                            "Phase_Diff_Fit_GD")
        readGraphDataFromDA(self.eKinOutPlot, cav_wrapper_da, "Ekin_Out_GD")
        readGraphDataFromDA(self.eKinOutPlotTh, cav_wrapper_da,
                            "Ekin_Out_Fit_GD")
        #--------- loop over bpm wrappers for this cavity
        cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor("bpm_arr")
        bpm_wrapper_alias_arr = cav_wrapper_bpm_list_da.stringValue(
            "bpm_wrappers").split()
        cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor(
            "bpm_use_in_phase_analysis_arr")
        use_in_phase_analysis_arr = cav_wrapper_bpm_list_da.stringValue(
            "use_arr").split()
        cav_wrapper_bpm_list_da = cav_wrapper_da.childAdaptor(
            "bpm_use_in_amp_analysis_arr")
        use_in_amp_analysis_arr = cav_wrapper_bpm_list_da.stringValue(
            "use_arr").split()
        bpm_wrapper_arr = []
        for bpm_wrapper_alias in bpm_wrapper_alias_arr:
            bpm_wrapper = scl_long_tuneup_controller.getBPM_Wrapper(
                bpm_wrapper_alias)
            bpm_wrapper_arr.append(bpm_wrapper)
        bpm_wrappers = []
        use_in_phase_arr = []
        use_in_amp_arr = []
        for ind in range(len(bpm_wrapper_arr)):
            bpm_wrapper = bpm_wrapper_arr[ind]
            if (bpm_wrapper != null):
                bpm_wrappers.append(bpm_wrapper)
                use_in_phase_arr.append(use_in_phase_analysis_arr[ind])
                use_in_amp_arr.append(use_in_amp_analysis_arr[ind])
        use_in_phase_analysis_arr = use_in_phase_arr
        use_in_amp_analysis_arr = use_in_amp_arr
        self.setUpBPM_Wrappers(bpm_wrappers, scl_long_tuneup_controller)
        for ind in range(len(self.bpm_wrappers)):
            bpm_wrapper = self.bpm_wrappers[ind]
            self.bpm_wrappers_useInPhaseAnalysis[ind] = Boolean(
                int(use_in_phase_analysis_arr[ind])).booleanValue()
            self.bpm_wrappers_useInAmpBPMs[ind] = Boolean(
                int(use_in_amp_analysis_arr[ind])).booleanValue()
        #-------- read the phase scan data
        # we have to keep in mind that in self.bpm_wrappers we have only bpm wrappers that exist in the
        # scl_long_tuneup_controller.bpm_wrappers and therefore exist in the self.bpm_amp_phase_dict as keys
        # Threfore they have (graphDataAmp,graphDataPhase) and we just have to fill them out.
        cav_wrapper_scan_data_da = cav_wrapper_da.childAdaptor("scan_data")
        for bpm_wrapper in self.bpm_wrappers:
            if (not self.bpm_amp_phase_dict.has_key(bpm_wrapper)): continue
            (graphDataAmp,
             graphDataPhase) = self.bpm_amp_phase_dict[bpm_wrapper]
            cav_wrapper_scan_data_bpm_da = cav_wrapper_scan_data_da.childAdaptor(
                bpm_wrapper.alias)
            if (cav_wrapper_scan_data_bpm_da != null):
                readGraphDataFromDA(graphDataPhase,
                                    cav_wrapper_scan_data_bpm_da, "phase")
                readGraphDataFromDA(graphDataAmp, cav_wrapper_scan_data_bpm_da,
                                    "amplitude")
def calculateOffsetsForNotDoneBPMsLeft(cav_wrapper,scl_long_tuneup_controller,bpm_wrappers_good_arr,bpm_wrappers_not_done_arr):
	# this function will calculate offsets for "left" offsets of 
	# "Not yet Done" BPMs by using "good" (already done) BPMs
	eKin_in = cav_wrapper.eKin_in_guess
	mass = scl_long_tuneup_controller.mass/1.0e+6			
	c_light = scl_long_tuneup_controller.c_light	
	bpm_freq = scl_long_tuneup_controller.bpm_freq
	coeff_init = 360.0*bpm_freq/c_light
	for bpm_wrapper in bpm_wrappers_not_done_arr:
		bpm_wrapper.left_phase_offset.phaseOffset_arr = []
	phaseDiffPlot = cav_wrapper.phaseDiffPlot
	cav_wrapper.eKinOutPlot.removeAllPoints()
	cav_wrapper.eKinOutPlotTh.removeAllPoints()
	for ip in range(phaseDiffPlot.getNumbOfPoints()):
		cav_phase = phaseDiffPlot.getX(ip)
		ekin_guess =  cav_wrapper.energy_guess_harm_funcion.getValue(cav_phase)
		beta_guess = math.sqrt(ekin_guess*(ekin_guess+2*mass))/(ekin_guess+mass)
		coeff = coeff_init/beta_guess
		# let's make bpm_phase(z) points for good BPMs
		gd = BasicGraphData()
		base_bpm_wrapper = bpm_wrappers_good_arr[0]
		(graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[base_bpm_wrapper]
		base_bpm_offset = base_bpm_wrapper.left_phase_offset.phaseOffset_avg	
		base_bpm_phase = graphDataPhase.getY(ip) - base_bpm_offset
		#print "debug ==== ip=",ip," cav_phase=",cav_phase," eKin_guess=",ekin_guess	
		gd.addPoint(base_bpm_wrapper.pos,base_bpm_phase)
		for bpm_ind in range(1,len(bpm_wrappers_good_arr)):
			bpm_wrapper = bpm_wrappers_good_arr[bpm_ind]
			(graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper]
			bpm_phase = graphDataPhase.getY(ip) - bpm_wrapper.left_phase_offset.phaseOffset_avg
			bpm_pos = bpm_wrapper.pos
			bpm_phase_guess = gd.getY(bpm_ind-1) + coeff*(bpm_pos-gd.getX(bpm_ind-1))
			bpm_phase = makePhaseNear(bpm_phase,bpm_phase_guess)
			gd.addPoint(bpm_pos,bpm_phase)
			#print "debug bpm=",bpm_wrapper.alias," pos=",bpm_pos," phase=",bpm_phase
		res_arr = GraphDataOperations.polynomialFit(gd,-1.e+36,+1.e+36,1)
		slope = res_arr[0][1]
		slope_err = res_arr[1][1]
		init_phase = res_arr[0][0]
		init_phase_err = res_arr[1][0]
		beta = coeff_init/slope
		gamma = 1./math.sqrt(1.0-beta*beta)
		eKin = mass*(gamma-1.0)	
		delta_eKin = mass*gamma**3*beta**3*slope_err/coeff_init
		cav_wrapper.eKinOutPlot.addPoint(cav_phase,eKin,delta_eKin)
		#print "debug cav_phase=",cav_phase,"eKin_guess=",ekin_guess," eKin=",eKin," delta_E=",delta_eKin
		# let's go over the bad BPMs and calculate offsets for particular cavity phase
		for bpm_wrapper in bpm_wrappers_not_done_arr:
			bpm_pos = bpm_wrapper.pos
			bpm_phase_th = init_phase + slope*bpm_pos
			(graphDataAmp,graphDataPhase) = cav_wrapper.bpm_amp_phase_dict[bpm_wrapper]
			bpm_phase = graphDataPhase.getY(ip)
			bpm_offset = makePhaseNear(bpm_phase - bpm_phase_th,0.)
			bpm_wrapper.left_phase_offset.phaseOffset_arr.append(bpm_offset)
	#----set up the output energy guess
	cav_wrapper.eKin_out_guess = cav_wrapper.eKinOutPlot.getValueY(cav_wrapper.livePhase)
	# let's calculate statistics for "not done" BPMs' offsets
	for bpm_wrapper in bpm_wrappers_not_done_arr:
		phase_arr = bpm_wrapper.left_phase_offset.phaseOffset_arr
		(phase0_avg, phase0_err) = calculateAvgErr(phase_arr)
		phase_arr = []
		for phase in bpm_wrapper.left_phase_offset.phaseOffset_arr:
			phase_arr.append(makePhaseNear(phase-180.,0.))
		(phase1_avg, phase1_err) = calculateAvgErr(phase_arr)
		phase1_avg = makePhaseNear(phase1_avg+180.,0.)
		if(phase1_err < phase0_err):
			bpm_wrapper.left_phase_offset.phaseOffset_avg = phase1_avg
			bpm_wrapper.left_phase_offset.phaseOffset_err = phase1_err
		else:
			bpm_wrapper.left_phase_offset.phaseOffset_avg = phase0_avg
			bpm_wrapper.left_phase_offset.phaseOffset_err = phase0_err
		bpm_wrapper.left_phase_offset.isReady = true
	def __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)
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")	
Beispiel #27
0
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 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()
Beispiel #29
0
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 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)
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
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
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
Beispiel #34
0
    def calculateEnergy(self, eKin_in):
        mass = self.scl_long_tuneup_controller.mass / 1.0e+6
        c_light = self.scl_long_tuneup_controller.c_light
        bpm_freq = self.scl_long_tuneup_controller.bpm_freq
        coeff_init = 360.0 * bpm_freq / c_light
        beta = math.sqrt(eKin_in * (eKin_in + 2 * mass)) / (eKin_in + mass)
        coeff = coeff_init / beta
        #------ calculate avg bpm phases
        res_arr = []
        for bpm_ind in range(len(self.em_bpm_wrpprs)):
            bpm_wrapper = self.em_bpm_wrpprs[bpm_ind]
            if (not self.use_bpms[bpm_ind]): continue
            if (not self.bpm_amp_phase_data_dict.has_key(bpm_wrapper)):
                continue
            (amp_arr, phase_arr) = self.bpm_amp_phase_data_dict[bpm_wrapper]
            (phase_avg, phase_err) = calculateAvgErr(phase_arr)
            #print "debug bpm=",bpm_wrapper.alias," (phase_avg,phase_err) =",(phase_avg,phase_err)
            res_arr.append([bpm_ind, bpm_wrapper, phase_avg, phase_err])
        n_res = len(res_arr)
        scl_long_tuneup_energy_meter_controller = self.scl_long_tuneup_controller.scl_long_tuneup_energy_meter_controller
        table_and_plots_panel = scl_long_tuneup_energy_meter_controller.table_and_plots_panel
        init_start_stop_panel = scl_long_tuneup_energy_meter_controller.init_start_stop_panel
        fixInitEenergy_RadioButton = init_start_stop_panel.fixInitEenergy_RadioButton
        buffer_size = int(init_start_stop_panel.buffer_size_text.getValue())
        if (n_res < 2): return eKin_in
        [bpm_ind0, bpm_wrapper0, phase_avg0, phase_err0] = res_arr[0]
        phase_avg0 = phase_avg0 - self.bpm_phase_offsets[0]
        res_arr[0][2] = phase_avg0
        base_pos = bpm_wrapper0.pos
        #"""
        for ind in range(n_res - 1):
            [bpm_ind0, bpm_wrapper0, phase_avg0, phase_err0] = res_arr[ind]
            [bpm_ind1, bpm_wrapper1, phase_avg1, phase_err1] = res_arr[ind + 1]
            bpm1_phase = phase_avg1 - self.bpm_phase_offsets[bpm_ind1]
            bpm1_phase_guess = phase_avg0 + coeff * (bpm_wrapper1.pos -
                                                     bpm_wrapper0.pos)
            bpm1_phase = makePhaseNear(bpm1_phase, bpm1_phase_guess)
            res_arr[ind + 1][2] = bpm1_phase
        """
		for ind in range(1,n_res):
			[bpm_ind,bpm_wrapper,phase_avg,phase_err] = res_arr[ind]
			bpm_phase = phase_avg - self.bpm_phase_offsets[bpm_ind]
			delta_pos = bpm_wrapper.pos - base_pos
			bpm_phase_guess = phase_avg0 + coeff*delta_pos
			bpm_phase = makePhaseNear(bpm_phase,bpm_phase_guess)
			res_arr[ind][2] = bpm_phase	
		"""
        #----- make phase plot
        gd = BasicGraphData()
        for ind in range(n_res):
            [bpm_ind, bpm_wrapper, phase_avg, phase_err] = res_arr[ind]
            gd.addPoint(bpm_wrapper.pos - base_pos, phase_avg, phase_err)
        res_poly_arr = GraphDataOperations.polynomialFit(
            gd, -1.e+36, +1.e+36, 1)
        if (res_poly_arr == null): return eKin_in
        slope = res_poly_arr[0][1]
        init_phase = res_poly_arr[0][0]
        if (fixInitEenergy_RadioButton.isSelected()):
            slope = coeff
            init_phase = phase_avg0
        beta = coeff_init / slope
        gamma = 1. / math.sqrt(1.0 - beta * beta)
        eKin = mass * (gamma - 1.0)
        slope_err = res_poly_arr[1][1]
        delta_eKin = mass * gamma**3 * beta**3 * slope_err / coeff_init
        #make phase error plot
        x_arr = []
        y_arr = []
        err_arr = []
        for ind in range(n_res):
            [bpm_ind, bpm_wrapper, phase_avg, phase_err] = res_arr[ind]
            x_arr.append(bpm_wrapper.pos)
            phase_diff = makePhaseNear(
                phase_avg - (init_phase + slope *
                             (bpm_wrapper.pos - base_pos)), 0.)
            self.bpm_phase_diff_arr[bpm_ind].append(phase_diff)
            if (len(self.bpm_phase_diff_arr[bpm_ind]) > buffer_size):
                self.bpm_phase_diff_arr[bpm_ind] = self.bpm_phase_diff_arr[
                    bpm_ind][1:]
            (phase_diff,
             phase_err) = calculateAvgErr(self.bpm_phase_diff_arr[bpm_ind])
            y_arr.append(phase_diff)
            err_arr.append(phase_err)
        table_and_plots_panel.bpm_phase_err_gd.removeAllPoints()
        table_and_plots_panel.bpm_phase_err_gd.addPoint(x_arr, y_arr, err_arr)
        return (eKin, delta_eKin)