def findMaxAccelerationPhase(accSeq, scenario, particle_tracker, cav, min_cav_phase, max_cav_phase, cav_phase_step): """ this function will find the cavity's phase for maximal acceleration """ n_steps = int((max_cav_phase - min_cav_phase) / cav_phase_step) + 1 max_accel_phase = min_cav_phase cav.setDfltCavPhase(min_cav_phase) probe = ProbeFactory.createParticleProbe(accSeq, particle_tracker) scenario.resync() scenario.setProbe(probe) scenario.run() traj = scenario.getProbe().getTrajectory() eKin_max = traj.finalState().getKineticEnergy() for ind in range(n_steps): cav_phase = min_cav_phase + ind * cav_phase_step cav.setDfltCavPhase(cav_phase) probe = ProbeFactory.createParticleProbe(accSeq, particle_tracker) scenario.resync() scenario.setProbe(probe) scenario.run() traj = scenario.getProbe().getTrajectory() eKin = traj.finalState().getKineticEnergy() if (eKin_max < eKin): max_accel_phase = cav_phase eKin_max = eKin #print "debug cav=",cav.getId()," eKin_max=",eKin_max/1.0e+6 return max_accel_phase
def __init__(self,main_loop_controller): self.main_loop_controller = main_loop_controller cav_wrappers = self.main_loop_controller.cav_wrappers self.accSeq = self.main_loop_controller.accSeq self.part_tracker = AlgorithmFactory.createParticleTracker(self.accSeq) self.part_tracker.setRfGapPhaseCalculation(true) self.part_probe_init = ProbeFactory.createParticleProbe(self.accSeq,self.part_tracker) self.scenario = Scenario.newScenarioFor(self.accSeq) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.resync() part_probe = ParticleProbe(self.part_probe_init) part_probe.setKineticEnergy(self.part_probe_init.getKineticEnergy()) self.scenario.setProbe(part_probe) self.scenario.run() #------------------------------------------------- # The cavToGapsDict is needed for reference to the irfGap to set phase and do not use scenario.resync() rfGaps = self.accSeq.getAllNodesWithQualifier(AndTypeQualifier().and((OrTypeQualifier()).or(RfGap.s_strType))) self.cavToGapsDict = {} self.cavEnergyInOutDict = {} for cav_wrapper in cav_wrappers: self.cavToGapsDict[cav_wrapper] = [] for rfGap in rfGaps: if(rfGap.getParent().getId() == cav_wrapper.cav.getId()): irfGaps = self.scenario.elementsMappedTo(rfGap) self.cavToGapsDict[cav_wrapper].append(irfGaps[0]) for cav_wrapper_ind in range(len(cav_wrappers)): cav_wrapper = cav_wrappers[cav_wrapper_ind] irfGaps = self.cavToGapsDict[cav_wrapper] nGaps = len(irfGaps) state_in = self.scenario.getTrajectory().statesForElement(irfGaps[0].getId()).get(0) if(cav_wrapper_ind > 0): irfGaps_0 = self.cavToGapsDict[cav_wrappers[cav_wrapper_ind-1]] irfGap_0 = irfGaps_0[len(irfGaps_0)-1] state_in = self.scenario.getTrajectory().statesForElement(irfGap_0.getId()).get(0) state_out = self.scenario.getTrajectory().statesForElement(irfGaps[nGaps-1].getId()).get(0) #print "debug cav=",cav_wrapper.alias," eKin_in=",state_in.getKineticEnergy()/1.0e+6," eKin_out=",state_out.getKineticEnergy()/1.0e+6 self.cavEnergyInOutDict[cav_wrapper] = (state_in.getKineticEnergy()/1.0e+6,state_out.getKineticEnergy()/1.0e+6) # cav_wrappers_param_dict[cav_wrapper] = (cavAmp,phase) self.cav_wrappers_param_dict = {} 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) #---------------------------------------------------------------- self.active_cav_wrapper = null self.gap_first = null self.gap_last = null self.gap_list = null
def __init__(self,mebt_main_orbit_diff_cntrl): self.mebt_main_orbit_diff_cntrl = mebt_main_orbit_diff_cntrl self.accSeq = self.mebt_main_orbit_diff_cntrl.accSeq self.scenario = Scenario.newScenarioFor(self.accSeq) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.unsetStartNode() self.scenario.unsetStopNode() self.part_tracker = AlgorithmFactory.createParticleTracker(self.accSeq) self.part_tracker.setRfGapPhaseCalculation(true) self.part_probe_init = ProbeFactory.createParticleProbe(self.accSeq,self.part_tracker) self.scenario.resync() part_probe = ParticleProbe(self.part_probe_init) self.scenario.setProbe(part_probe) self.scenario.run() self.traj = self.scenario.getTrajectory()
def __init__(self,linac_wizard_document): #--- linac_wizard_document the parent document for all controllers self.linac_wizard_document = linac_wizard_document #----scl_accSeq is a specific for this controller accl = self.linac_wizard_document.accl lst = ArrayList() for seqName in ["SCLMed","SCLHigh","HEBT1","HEBT2"]: lst.add(accl.getSequence(seqName)) self.scl_accSeq = AcceleratorSeqCombo("SCL_SEQUENCE", lst) part_tracker = AlgorithmFactory.createParticleTracker(self.scl_accSeq) part_probe = ProbeFactory.createParticleProbe(self.scl_accSeq,part_tracker) self.mass = part_probe.getSpeciesRestEnergy() self.bpm_freq = 402.5e+6 self.c_light = 2.99792458e+8 #-------- Ring length self.ring_length = accl.findSequence("Ring").getLength() #-------- BPMs and Cavities arrays self.bpm_wrappers = [] self.cav_wrappers = [] #-------- self.cav0_wrapper is used for all cavities (includind Cav01a) Blanked statistics self.cav0_wrapper = null self.fillOut_Arrays() #--- the main tabbed pane self.tabbedPane = JTabbedPane() #-------- child controllers self.scl_long_tuneup_init_controller = SCL_Long_TuneUp_Init_Controller(self) self.scl_long_tuneup_phase_scan_controller = SCL_Long_TuneUp_PhaseScan_Controller(self) self.scl_long_tuneup_bpm_offsets_controller = SCL_Long_TuneUp_BPM_Offsets_Controller(self) self.scl_long_tuneup_phase_analysis_controller = SCL_Long_TuneUp_PhaseAnalysis_Controller(self) self.scl_long_tuneup_rescale_controller = SCL_Long_TuneUp_Rescale_Controller(self) self.scl_long_tuneup_energy_meter_controller = SCL_Energy_Meter_Controller(self) self.scl_long_twiss_analysis_controller = SCL_Long_Twiss_Analysis_Controller(self) self.scl_long_laser_stripping_controller = SCL_Laser_Stripping_Controller(self) #the beamTrigger will be initialized after the user hit "Init" button in SCL_Long_Init_Controller self.beamTrigger = null #sets of BPMs for BPM_Batch_Reader will be setup in "Init" button in SCL_Long_Init_Controller self.bpmBatchReader = BPM_Batch_Reader(self) #----add all subpanels to the SCL main tab panel self.tabbedPane.add("Init",self.scl_long_tuneup_init_controller.getMainPanel()) self.tabbedPane.add("Phase Scan",self.scl_long_tuneup_phase_scan_controller.getMainPanel()) self.tabbedPane.add("BPM Offsets",self.scl_long_tuneup_bpm_offsets_controller.getMainPanel()) self.tabbedPane.add("Phase Analysis",self.scl_long_tuneup_phase_analysis_controller.getMainPanel()) self.tabbedPane.add("Rescale SCL",self.scl_long_tuneup_rescale_controller.getMainPanel()) self.tabbedPane.add("Energy Meter",self.scl_long_tuneup_energy_meter_controller.getMainPanel()) self.tabbedPane.add("Long. Twiss",self.scl_long_twiss_analysis_controller.getMainPanel()) self.tabbedPane.add("Laser Stripping",self.scl_long_laser_stripping_controller.getMainPanel())
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) scl_long_tuneup_phase_analysis_controller = self.scl_long_tuneup_controller.scl_long_tuneup_phase_analysis_controller self.scenario = scl_long_tuneup_phase_analysis_controller.scl_one_cavity_tracker_model.scenario if(self.scenario == null): self.scenario = Scenario.newScenarioFor(self.scl_accSeq) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.resync() else: self.scenario.unsetStartNode() self.scenario.unsetStopNode() # in the dictionary we will have # cav_wrappers_param_dict[cav_wrapper] = [cavAmp,phase] 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.modelArrivalTimesIsReady = false self.new_cav_amp_phase_dict = {} for cav_wrapper in cav_wrappers: self.new_cav_amp_phase_dict[cav_wrapper] = self.cav_amp_phase_dict[cav_wrapper][:]
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
for bpm in bpms: bpm_names_dict[bpm.getId()] = bpm #print "debug bpm=",bpm.getId()," pos[m]=",accSeq.getPosition(bpm)," freq.=",bpm.getBPMBucket().getFrequency() #---- array of all 1st RF gaps rf_gaps = [] for cav in cavs: rf_gaps.append(cav.getGaps()[0]) #----- New Online Model for the acc. sequence scenario = Scenario.newScenarioFor(accSeq) scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) particle_tracker = AlgorithmFactory.createParticleTracker(accSeq) particle_tracker.setRfGapPhaseCalculation(True) probe = ProbeFactory.createParticleProbe(accSeq, particle_tracker) scenario.resync() scenario.setProbe(probe) scenario.run() traj = scenario.getProbe().getTrajectory() #----- bpm_phases_init_arr = [[bpm,position,phase],...] bpm_phases_init_arr = [] for state_ind in range(traj.numStates()): state = traj.stateWithIndex(state_ind) if (state.getElementId().find("BPM") >= 0): bpm = bpm_names_dict[state.getElementId()] tm = state.getTime() bpm_phase = 360.0 * bpm.getBPMBucket().getFrequency() * 1.0e+6 * tm