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 runModel(self): quad_wrappers = self.mebt_main_orbit_diff_cntrl.quad_wrappers for quad_wrapper in quad_wrappers: quad_wrapper.magnet.setDfltField(quad_wrapper.field) dc_wrappers = self.mebt_main_orbit_diff_cntrl.dc_wrappers for dc_wrapper in dc_wrappers: dc_wrapper.magnet.setDfltField(dc_wrapper.field) #""" self.scenario = Scenario.newScenarioFor(self.accSeq) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.unsetStartNode() self.scenario.unsetStopNode() #""" 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,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)
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
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.env_tracker = AlgorithmFactory.createEnvTrackerAdapt(self.accSeq) self.env_tracker.setRfGapPhaseCalculation(true) self.env_probe = ProbeFactory.getEnvelopeProbe(self.accSeq,self.env_tracker) self.scenario = Scenario.newScenarioFor(self.accSeq) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.resync() self.scenario.setProbe(self.env_probe) self.scenario.run() #------------------------------------------------- for cav_wrapper_ind in range(len(cav_wrappers)): cav_wrapper = cav_wrappers[cav_wrapper_ind] gap_list = cav_wrapper.cav.getGapsAsList() gap_first = gap_list.get(0) gap_last = gap_list.get(gap_list.size()-1) ind0 = self.scenario.getTrajectory().indicesForElement(gap_first.getId())[0] - 1 ind1 = self.scenario.getTrajectory().indicesForElement(gap_last.getId())[0] state_in = self.scenario.getTrajectory().stateWithIndex(ind0) state_out = self.scenario.getTrajectory().stateWithIndex(ind1) Ekin_in = state_in.getKineticEnergy()/1.0e+6 Ekin_out = state_out.getKineticEnergy()/1.0e+6 twiss_in = state_in.twissParameters()[2] twiss_out = state_out.twissParameters()[2] z_prim_in = math.sqrt(twiss_in.getGamma()*twiss_in.getEmittance()) z_prim_out = math.sqrt(twiss_out.getGamma()*twiss_out.getEmittance()) beta_gamma_in = state_in.getBeta()*state_in.getGamma() beta_gamma_out = state_out.getBeta()*state_out.getGamma() mass = state_in.getSpeciesRestEnergy()/1.0e+6 delta_Ekin_in = (mass+Ekin_in)*beta_gamma_in**2*z_prim_in delta_Ekin_out = (mass+Ekin_out)*beta_gamma_out**2*z_prim_out cav_wrapper.Ekin_in = Ekin_in cav_wrapper.Ekin_out = Ekin_out cav_wrapper.Ekin_in_design = Ekin_in cav_wrapper.Ekin_in_delta_design = delta_Ekin_in cav_wrapper.Ekin_out_design = Ekin_out cav_wrapper.Ekin_out_delta_design = delta_Ekin_out for cav_wrapper_ind in range(len(cav_wrappers)-1): cav_wrappers[cav_wrapper_ind].Ekin_out_delta_design = cav_wrappers[cav_wrapper_ind+1].Ekin_in_delta_design
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)
), " 1st gap=", cav.getGaps()[0], " phase=", cav.getGaps(
)[0].getGapDfltPhase()
bpms = accSeq.getAllNodesOfType("BPM")
bpm_names_dict = {}
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()):
from xal.smf.data import XMLDataManager
from xal.sim.scenario import Scenario, AlgorithmFactory, ProbeFactory
accl = XMLDataManager.acceleratorWithPath(
'/home/student/lib/openxal/site/optics/production/main.xal')
seq = accl.findSequence("MEBT")
scenario = Scenario.newScenarioFor(seq)
tracker = AlgorithmFactory.createEnvTrackerAdapt(seq)
probe = ProbeFactory.getEnvelopeProbe(seq, tracker)
scenario.setProbe(probe)
scenario.run()
traj = scenario.getProbe().getTrajectory()
xsz = map(
lambda s: (s.getPosition(), s.twissParameters()[0].getEnvelopeRadius()),
traj.iterator())
print(list(xsz))
