def track(self, paramsDict):
"""
The Kick TEAPOT class implementation of
the AccNodeBunchTracker class track(probe) method.
"""
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
strength = 1.0
if (self.waveform):
strength = self.waveform.getStrength()
kx = strength * self.getParam("kx") / (nParts - 1)
ky = strength * self.getParam("ky") / (nParts - 1)
dE = self.getParam("dE") / (nParts - 1)
bunch = paramsDict["bunch"]
useCharge = 1
if (paramsDict.has_key("useCharge")):
useCharge = paramsDict["useCharge"]
if (index == 0):
TPB.drift(bunch, length)
TPB.kick(bunch, kx, ky, dE, useCharge)
return
if (index > 0 and index < (nParts - 1)):
TPB.drift(bunch, length)
TPB.kick(bunch, kx, ky, dE, useCharge)
return
if (index == (nParts - 1)):
TPB.drift(bunch, length)
return
def track(self, paramsDict):
"""
The Multipole Combined Function TEAPOT class
implementation of the AccNodeBunchTracker class track(probe) method.
"""
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
bunch = paramsDict["bunch"]
useCharge = 1
if (paramsDict.has_key("useCharge")):
useCharge = paramsDict["useCharge"]
poleArr = self.getParam("poles")
klArr = self.getParam("kls")
skewArr = self.getParam("skews")
if (index == 0):
TPB.drift(bunch, length)
return
if (index > 0 and index < (nParts - 1)):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew, useCharge)
TPB.drift(bunch, length)
return
if (index == (nParts - 1)):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew, useCharge)
TPB.drift(bunch, length)
return
def track(self, paramsDict):
"""
The Multipole Combined Function TEAPOT class
implementation of the AccNodeBunchTracker class track(probe) method.
"""
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
bunch = paramsDict["bunch"]
useCharge = 1
if(paramsDict.has_key("useCharge")): useCharge = paramsDict["useCharge"]
poleArr = self.getParam("poles")
klArr = self.getParam("kls")
skewArr = self.getParam("skews")
if(index == 0):
TPB.drift(bunch, length)
return
if(index > 0 and index < (nParts-1)):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/(nParts - 1)
skew = skewArr[i]
TPB.multp(bunch,pole,kl,skew,useCharge)
TPB.drift(bunch, length)
return
if(index == (nParts-1)):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/(nParts - 1)
skew = skewArr[i]
TPB.multp(bunch,pole,kl,skew,useCharge)
TPB.drift(bunch, length)
return
def track(self, paramsDict):
"""
The Kick TEAPOT class implementation of
the AccNodeBunchTracker class track(probe) method.
"""
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
strength = 1.0
if(self.waveform):
strength = self.waveform.getKickFactor()
kx = strength * self.getParam("kx")/(nParts-1)
ky = strength * self.getParam("ky")/(nParts-1)
dE = self.getParam("dE")/(nParts-1)
bunch = paramsDict["bunch"]
useCharge = 1
if(paramsDict.has_key("useCharge")): useCharge = paramsDict["useCharge"]
if(index == 0):
TPB.drift(bunch, length)
TPB.kick(bunch,kx,ky,dE,useCharge)
return
if(index > 0 and index < (nParts-1)):
TPB.drift(bunch, length)
TPB.kick(bunch,kx,ky,dE,useCharge)
return
if(index == (nParts-1)):
TPB.drift(bunch, length)
return
def fringeOUT(node, paramsDict):
usageOUT = node.getUsage()
if (not usageOUT):
return
strength = 1.0
if (self.waveform):
strength = self.waveform.getStrength()
kq = strength * node.getParam("kq")
poleArr = node.getParam("poles")
klArr = node.getParam("kls")
skewArr = node.getParam("skews")
length = paramsDict["parentNode"].getLength()
bunch = paramsDict["bunch"]
useCharge = 1
if (paramsDict.has_key("useCharge")): \
useCharge = paramsDict["useCharge"]
TPB.quadfringeOUT(bunch, kq, useCharge)
if (length == 0.):
return
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = strength * klArr[i]
skew = skewArr[i]
TPB.multpfringeOUT(bunch, pole, kl/length, \
skew,useCharge)
def track(self, paramsDict):
"""
The Kick TEAPOT class implementation of
the AccNodeBunchTracker class track(probe) method.
"""
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
amplitude = self.waveform.getAmplitude() if self.waveform else 1.0
kx = amplitude * self.getParam("kx") / (nParts - 1)
ky = amplitude * self.getParam("ky") / (nParts - 1)
dE = self.getParam("dE") / (nParts - 1)
bunch = paramsDict["bunch"]
useCharge = 1
if paramsDict.has_key("useCharge"):
useCharge = paramsDict["useCharge"]
if index == 0:
TPB.drift(bunch, length)
TPB.kick(bunch, kx, ky, dE, useCharge)
return
if index > 0 and index < nParts - 1:
TPB.drift(bunch, length)
TPB.kick(bunch, kx, ky, dE, useCharge)
return
if index == nParts - 1:
TPB.drift(bunch, length)
return
def track(self, paramsDict):
"""
The drift class implementation of the AccNodeBunchTracker class track(probe) method.
"""
length = self.getLength(self.getActivePartIndex())
bunch = paramsDict["bunch"]
TPB.drift(bunch, length)
def track(self, paramsDict): """ The drift class implementation of the AccNode class track(probe) method. """ length = self.getLength(self.getActivePartIndex()) bunch = paramsDict["bunch"] TPB.drift(bunch, length)
def track(self, paramsDict):
"""
The bunch wrap class implementation of the AccNodeBunchTracker class track(probe) method.
"""
length = self.getLength(self.getActivePartIndex())
bunch = paramsDict["bunch"]
length = self.getParam("ring_length")
TPB.wrapbunch(bunch, length)
def track(self, paramsDict):
"""
It is tracking the dictionary with parameters through
the titlt node.
"""
if (self.__angle != 0.):
bunch = paramsDict["bunch"]
TPB.rotatexy(bunch, self.__angle)
def track(self, paramsDict): """ It is tracking the dictionary with parameters through the titlt node. """ if(self.__angle != 0.): bunch = paramsDict["bunch"] TPB.rotatexy(bunch,self.__angle)
def track(self, paramsDict):
"""
The bunch wrap class implementation of the AccNodeBunchTracker class track(probe) method.
"""
length = self.getLength(self.getActivePartIndex())
bunch = paramsDict["bunch"]
length = self.getParam("ring_length")
TPB.wrapbunch(bunch, length)
def track(self, paramsDict):
"""
The simplest RF gap class implementation of
the AccNode class track(probe) method.
"""
index = self.getActivePartIndex()
length = self.getLength(index)
bunch = paramsDict["bunch"]
syncPart = bunch.getSyncParticle()
if (index == 0 or index == 2):
gapOffset = 0.
if (self.hasParam("gapOffset")):
gapOffset = self.getParam("gapOffset")
if (index == 2): gapOffset = -gapOffset
TPB.drift(bunch, length + gapOffset)
return
E0TL = self.getParam("E0TL")
modePhase = self.getParam("modePhase") * math.pi
rfCavity = self.getRF_Cavity()
frequency = rfCavity.getFrequency()
rfPhase = rfCavity.getPhase() + modePhase
rf_ampl = rfCavity.getAmp()
phase = rfPhase
arrival_time = syncPart.time()
designArrivalTime = rfCavity.getDesignArrivalTime()
if (self.__isFirstGap):
if (rfCavity.isDesignSetUp()):
#print "debug RF =",self.getName()," phase=",(phase*180./math.pi - 180.)
phase = math.fmod(
frequency *
(arrival_time - designArrivalTime) * 2.0 * math.pi +
rfPhase, 2.0 * math.pi)
#print "debug RF =",self.getName()," phase=",(phase*180./math.pi - 180.)
else:
sequence = self.getSequence()
accLattice = sequence.getLinacAccLattice()
msg = "The BaseRF_Gap class. You have to run trackDesign on the LinacAccLattice first to initialize all RF Cavities' phases!"
msg = msg + os.linesep
msg = msg + "Lattice =" + accLattice.getName()
msg = msg + os.linesep
msg = msg + "Sequence =" + sequence.getName()
msg = msg + os.linesep
msg = msg + "RF Cavity =" + rfCavity.getName()
msg = msg + os.linesep
msg = msg + "Name of element=" + self.getName()
msg = msg + os.linesep
msg = msg + "Type of element=" + self.getType()
msg = msg + os.linesep
orbitFinalize(msg)
else:
phase = math.fmod(
frequency *
(arrival_time - designArrivalTime) * 2.0 * math.pi + rfPhase,
2.0 * math.pi)
#------------------------------------------------------
#call rf gap with E0TL phase phase of the gap and a longitudinal shift parameter
self.cppGapModel.trackBunch(bunch, frequency, E0TL, phase)
self.setGapPhase(phase)
def track(self, paramsDict):
"""
The Solenoid TEAPOT class implementation of the AccNodeBunchTracker class track(probe) method.
"""
index = self.getActivePartIndex()
length = self.getLength(index)
bunch = paramsDict["bunch"]
useCharge = 1
if(paramsDict.has_key("useCharge")): useCharge = paramsDict["useCharge"]
B = self.getParam("B")
TPB.soln(bunch,length,B,useCharge)
def track(self, paramsDict):
"""
The Solenoid TEAPOT class implementation of the AccNodeBunchTracker class track(probe) method.
"""
index = self.getActivePartIndex()
length = self.getLength(index)
bunch = paramsDict["bunch"]
useCharge = 1
if (paramsDict.has_key("useCharge")):
useCharge = paramsDict["useCharge"]
B = self.getParam("B")
TPB.soln(bunch, length, B, useCharge)
def track(self, paramsDict):
"""
The simplest RF gap class implementation of
the AccNode class track(probe) method.
"""
index = self.getActivePartIndex()
length = self.getLength(index)
bunch = paramsDict["bunch"]
syncPart = bunch.getSyncParticle()
if(index == 0 or index == 2):
gapOffset = 0.
if(self.hasParam("gapOffset")): gapOffset = self.getParam("gapOffset")
if(index == 2): gapOffset = -gapOffset
TPB.drift(bunch, length + gapOffset)
return
E0TL = self.getParam("E0TL")
modePhase = self.getParam("modePhase")*math.pi
rfCavity = self.getRF_Cavity()
frequency = rfCavity.getFrequency()
rfPhase = rfCavity.getPhase() + modePhase
rf_ampl = rfCavity.getAmp()
phase = rfPhase
arrival_time = syncPart.time()
designArrivalTime = rfCavity.getDesignArrivalTime()
if(self.__isFirstGap):
if(rfCavity.isDesignSetUp()):
#print "debug RF =",self.getName()," phase=",(phase*180./math.pi - 180.)
phase = math.fmod(frequency*(arrival_time - designArrivalTime)*2.0*math.pi + rfPhase,2.0*math.pi)
#print "debug RF =",self.getName()," phase=",(phase*180./math.pi - 180.)
else:
sequence = self.getSequence()
accLattice = sequence.getLinacAccLattice()
msg = "The BaseRF_Gap class. You have to run trackDesign on the LinacAccLattice first to initialize all RF Cavities' phases!"
msg = msg + os.linesep
msg = msg + "Lattice =" + accLattice.getName()
msg = msg + os.linesep
msg = msg + "Sequence =" + sequence.getName()
msg = msg + os.linesep
msg = msg + "RF Cavity =" + rfCavity.getName()
msg = msg + os.linesep
msg = msg + "Name of element=" + self.getName()
msg = msg + os.linesep
msg = msg + "Type of element=" + self.getType()
msg = msg + os.linesep
orbitFinalize(msg)
else:
phase = math.fmod(frequency*(arrival_time - designArrivalTime)*2.0*math.pi+rfPhase,2.0*math.pi)
#------------------------------------------------------
#call rf gap with E0TL phase phase of the gap and a longitudinal shift parameter
self.cppGapModel.trackBunch(bunch,frequency,E0TL,phase)
self.setGapPhase(phase)
def track(self, paramsDict):
"""
The Vertical Dipole Corrector class implementation of
the AccNode class track(probe) method.
"""
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getParam("effLength") / nParts
field = self.getParam("B")
bunch = paramsDict["bunch"]
syncPart = bunch.getSyncParticle()
momentum = syncPart.momentum()
q = bunch.charge()
# dp/p = Q*c*B*L/p p in GeV/c, c = 2.99792*10^8/10^9
kick = q * field * length * 0.299792 / momentum
TPB.kick(bunch, 0, kick, 0.)
def track(self, paramsDict):
"""
The Vertical Dipole Corrector class implementation of
the AccNode class track(probe) method.
"""
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getParam("effLength")/nParts
field = self.getParam("B")
bunch = paramsDict["bunch"]
syncPart = bunch.getSyncParticle()
momentum = syncPart.momentum()
q = bunch.charge()
# dp/p = Q*c*B*L/p p in GeV/c, c = 2.99792*10^8/10^9
kick = q*field*length*0.299792/momentum
TPB.kick(bunch,0,kick,0.)
def fringeOUT(node,paramsDict):
usageOUT = node.getUsage()
if(not usageOUT):
return
length = paramsDict["parentNode"].getLength()
if(length == 0.):
return
poleArr = node.getParam("poles")
klArr = node.getParam("kls")
skewArr = node.getParam("skews")
bunch = paramsDict["bunch"]
useCharge = 1
if(paramsDict.has_key("useCharge")): useCharge = paramsDict["useCharge"]
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]
skew = skewArr[i]
TPB.multpfringeOUT(bunch,pole,kl/length,skew,useCharge)
def fringeIN(node,paramsDict):
usageIN = node.getUsage()
if(not usageIN):
return
bunch = paramsDict["bunch"]
momentum = bunch.getSyncParticle().momentum()
kq = node.getParam("dB/dr")/(3.335640952*momentum)
poleArr = node.getParam("poles")
klArr = node.getParam("kls")
skewArr = node.getParam("skews")
length = paramsDict["parentNode"].getLength()
TPB.quadfringeIN(bunch,kq)
if(length == 0.):
return
for i in xrange(len(poleArr)):
pole = poleArr[i]
k = klArr[i]*kq
skew = skewArr[i]
TPB.multpfringeIN(bunch,pole,k,skew)
def fringeOUT(node, paramsDict):
usageOUT = node.getUsage()
if (not usageOUT):
return
length = paramsDict["parentNode"].getLength()
if (length == 0.):
return
poleArr = node.getParam("poles")
klArr = node.getParam("kls")
skewArr = node.getParam("skews")
bunch = paramsDict["bunch"]
useCharge = 1
if (paramsDict.has_key("useCharge")):
useCharge = paramsDict["useCharge"]
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]
skew = skewArr[i]
TPB.multpfringeOUT(bunch, pole, kl / length, skew, useCharge)
def fringeIN(node,paramsDict):
usageIN = node.getUsage()
if(not usageIN):
return
bunch = paramsDict["bunch"]
momentum = bunch.getSyncParticle().momentum()
kq = node.getParam("dB/dr")/(3.335640952*momentum)
poleArr = node.getParam("poles")
klArr = node.getParam("kls")
skewArr = node.getParam("skews")
length = paramsDict["parentNode"].getLength()
TPB.quadfringeIN(bunch,kq)
if(length == 0.):
return
for i in xrange(len(poleArr)):
pole = poleArr[i]
k = klArr[i]*kq
skew = skewArr[i]
TPB.multpfringeIN(bunch,pole,k,skew)
def trackDesign(self, paramsDict):
"""
The RF First Gap node setups the design time of passage
of the bunch through this node.
"""
index = self.getActivePartIndex()
length = self.getLength(index)
bunch = paramsDict["bunch"]
if (index == 0 or index == 2):
gapOffset = 0.
if (self.hasParam("gapOffset")):
gapOffset = self.getParam("gapOffset")
if (index == 2): gapOffset = -gapOffset
TPB.drift(bunch, length + gapOffset)
return
E0TL = self.getParam("E0TL")
rfCavity = self.getRF_Cavity()
modePhase = self.getParam("modePhase") * math.pi
arrival_time = bunch.getSyncParticle().time()
frequency = rfCavity.getFrequency()
rfPhase = rfCavity.getPhase() + modePhase
rf_ampl = rfCavity.getDesignAmp()
phase = rfPhase
if (self.__isFirstGap):
rfCavity.setDesignArrivalTime(arrival_time)
rfCavity.setDesignSetUp(True)
rfCavity._setDesignPhase(rfCavity.getPhase())
rfCavity._setDesignAmp(rfCavity.getAmp())
else:
first_gap_arr_time = rfCavity.getDesignArrivalTime()
#print "debug name=",self.getName()," delta_phase=",frequency*(arrival_time - first_gap_arr_time)*360.0," rfPhase=",rfPhase*180/math.pi
phase = math.fmod(
frequency *
(arrival_time - first_gap_arr_time) * 2.0 * math.pi + rfPhase,
2.0 * math.pi)
#print "debug name=",self.getName()," arr_time=",arrival_time," phase=",phase*180./math.pi," E0TL=",E0TL*1.0e+3," freq=",frequency
#------------------------------------------------------
#call rf gap with E0TL phase phase of the gap and a longitudinal shift parameter
self.cppGapModel.trackBunch(bunch, frequency, E0TL, phase)
self.setGapPhase(phase)
def track(self, paramsDict):
"""
The Quad Combined Function TEAPOT class implementation
of the AccNode class track(probe) method.
"""
bunch = paramsDict["bunch"]
momentum = bunch.getSyncParticle().momentum()
kq = self.getParam("dB/dr") / (3.335640952 * momentum)
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
poleArr = self.getParam("poles")
klArr = self.getParam("kls")
skewArr = self.getParam("skews")
#print "debug name =",self.getName()," kq=",kq," L=",self.getLength()
if (index == 0):
self.tracking_module.quad1(bunch, length, kq)
return
if (index > 0 and index < (nParts - 1)):
self.tracking_module.quad2(bunch, length / 2.0)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew)
self.tracking_module.quad2(bunch, length / 2.0)
self.tracking_module.quad1(bunch, length, kq)
return
if (index == (nParts - 1)):
#print "debug before xp", bunch.xp(0)
self.tracking_module.quad2(bunch, length)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] * kq * length / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew)
self.tracking_module.quad2(bunch, length)
self.tracking_module.quad1(bunch, length, kq)
#print "debug after xp", bunch.xp(0)
return
def trackDesign(self, paramsDict):
"""
The RF First Gap node setups the design time of passage
of the bunch through this node.
"""
index = self.getActivePartIndex()
length = self.getLength(index)
bunch = paramsDict["bunch"]
if(index == 0 or index == 2):
gapOffset = 0.
if(self.hasParam("gapOffset")): gapOffset = self.getParam("gapOffset")
if(index == 2): gapOffset = -gapOffset
TPB.drift(bunch, length + gapOffset)
return
E0TL = self.getParam("E0TL")
rfCavity = self.getRF_Cavity()
modePhase = self.getParam("modePhase")*math.pi
arrival_time = bunch.getSyncParticle().time()
frequency = rfCavity.getFrequency()
rfPhase = rfCavity.getPhase() + modePhase
rf_ampl = rfCavity.getDesignAmp()
phase = rfPhase
if(self.__isFirstGap):
rfCavity.setDesignArrivalTime(arrival_time)
rfCavity.setDesignSetUp(True)
rfCavity._setDesignPhase(rfCavity.getPhase())
rfCavity._setDesignAmp(rfCavity.getAmp())
else:
first_gap_arr_time = rfCavity.getDesignArrivalTime()
#print "debug name=",self.getName()," delta_phase=",frequency*(arrival_time - first_gap_arr_time)*360.0," rfPhase=",rfPhase*180/math.pi
phase = math.fmod(frequency*(arrival_time - first_gap_arr_time)*2.0*math.pi+rfPhase,2.0*math.pi)
#print "debug name=",self.getName()," arr_time=",arrival_time," phase=",phase*180./math.pi," E0TL=",E0TL*1.0e+3," freq=",frequency
#------------------------------------------------------
#call rf gap with E0TL phase phase of the gap and a longitudinal shift parameter
self.cppGapModel.trackBunch(bunch,frequency,E0TL,phase)
self.setGapPhase(phase)
def track(self, paramsDict):
"""
The Ring RF TEAPOT class implementation
of the AccNodeBunchTracker class track(probe) method.
"""
harmArr = self.getParam("harmonics")
voltArr = self.getParam("voltages")
phaseArr = self.getParam("phases")
ring_length = self.getParam("ring_length")
bunch = paramsDict["bunch"]
useCharge = 1
if (paramsDict.has_key("useCharge")):
useCharge = paramsDict["useCharge"]
length = self.getLength(self.getActivePartIndex())
for i in range(len(harmArr)):
#print "debug rl=",ring_length," harm=",harmArr[i]," v=",voltArr[i],
#print " ph0=",phaseArr[i]," L=",self.getLength()
TPB.RingRF(bunch, ring_length, harmArr[i], voltArr[i], phaseArr[i],
useCharge)
def track(self, paramsDict):
"""
The Bend Combined Functions TEAPOT class implementation of
the AccNodeBunchTracker class track(probe) method.
"""
bunch = paramsDict["bunch"]
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
poleArr = self.getParam("poles")
klArr = [-x*bunch.charge()*self.getLength() for x in self.getParam("kls")]
skewArr = self.getParam("skews")
theta = self.getParam("theta")/(nParts - 1)
if(index == 0):
TPB.bend1(bunch, length, theta/2.0)
return
if(index > 0 and index < (nParts-1)):
TPB.bend2(bunch, length/2.0)
TPB.bend3(bunch, theta/2.0)
TPB.bend4(bunch,theta/2.0)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/(nParts - 1)
skew = skewArr[i]
TPB.multp(bunch,pole,kl,skew)
TPB.bend4(bunch,theta/2.0)
TPB.bend3(bunch, theta/2.0)
TPB.bend2(bunch, length/2.0)
TPB.bend1(bunch, length, theta)
return
if(index == (nParts-1)):
TPB.bend2(bunch, length)
TPB.bend3(bunch, theta/2.0)
TPB.bend4(bunch, theta/2.0)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/(nParts - 1)
skew = skewArr[i]
TPB.multp(bunch,pole,kl,skew)
TPB.bend4(bunch, theta/2.0)
TPB.bend3(bunch, theta/2.0)
TPB.bend2(bunch, length)
TPB.bend1(bunch, length, theta/2.0)
return
def fringeOUT(node,paramsDict):
bunch = paramsDict["bunch"]
length = paramsDict["parentNode"].getLength()
usageOUT = node.getUsage()
e = node.getParam("ea2")
rho = node.getParam("rho")
poleArr = node.getParam("poles")
klArr = [-x*bunch.charge()*length for x in self.getParam("kls")]
skewArr = node.getParam("skews")
nParts = paramsDict["parentNode"].getnParts()
if(e != 0.):
inout = 1
TPB.wedgebendCF(bunch, e, inout, rho, len(poleArr), poleArr, klArr, skewArr, nParts - 1)
if(usageOUT):
frinout = 0
TPB.wedgerotate(bunch, -e, frinout)
TPB.bendfringeOUT(bunch, rho)
if(length != 0.):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/length
skew = skewArr[i]
TPB.multpfringeOUT(bunch,pole,kl,skew)
frinout = 1
TPB.wedgerotate(bunch, -e, frinout)
TPB.wedgedrift(bunch,e,inout)
else:
if(usageOUT):
TPB.bendfringeOUT(bunch, rho)
if(length != 0.):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/length
skew = skewArr[i]
TPB.multpfringeOUT(bunch,pole,kl,skew)
def track(self, paramsDict):
"""
The Quad Combined Function TEAPOT class implementation
of the AccNode class track(probe) method.
"""
bunch = paramsDict["bunch"]
momentum = bunch.getSyncParticle().momentum()
kq = self.getParam("dB/dr")/(3.335640952*momentum)
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
poleArr = self.getParam("poles")
klArr = self.getParam("kls")
skewArr = self.getParam("skews")
#print "debug name =",self.getName()," kq=",kq," L=",self.getLength()
if(index == 0):
TPB.quad1(bunch, length, kq)
return
if(index > 0 and index < (nParts-1)):
TPB.quad2(bunch, length/2.0)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/(nParts - 1)
skew = skewArr[i]
TPB.multp(bunch,pole,kl,skew)
TPB.quad2(bunch, length/2.0)
TPB.quad1(bunch, length, kq)
return
if(index == (nParts-1)):
#print "debug before xp", bunch.xp(0)
TPB.quad2(bunch, length)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]*kq*length/(nParts - 1)
skew = skewArr[i]
TPB.multp(bunch,pole,kl,skew)
TPB.quad2(bunch, length)
TPB.quad1(bunch, length, kq)
#print "debug after xp", bunch.xp(0)
return
def fringeIN(node,paramsDict):
usageIN = node.getUsage()
e = node.getParam("ea1")
rho = node.getParam("rho")
poleArr = node.getParam("poles")[:]
klArr = node.getParam("kls")[:]
skewArr = node.getParam("skews")[:]
length = paramsDict["parentNode"].getLength()
bunch = paramsDict["bunch"]
useCharge = 1
if(paramsDict.has_key("useCharge")): useCharge = paramsDict["useCharge"]
nParts = paramsDict["parentNode"].getnParts()
if(e != 0.):
inout = 0
TPB.wedgedrift(bunch,e,inout)
if(usageIN):
frinout = 0
TPB.wedgerotate(bunch, e, frinout)
TPB.bendfringeIN(bunch, rho)
if(length != 0.):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/length
skew = skewArr[i]
TPB.multpfringeIN(bunch,pole,kl,skew,useCharge)
frinout = 1
TPB.wedgerotate(bunch, e, frinout)
TPB.wedgebendCF(bunch, e, inout, rho, len(poleArr), poleArr, klArr, skewArr, nParts - 1, useCharge)
else:
if(usageIN):
TPB.bendfringeIN(bunch, rho)
if(length != 0.):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/length
skew = skewArr[i]
TPB.multpfringeIN(bunch,pole,kl,skew,useCharge)
def track(self, paramsDict): """ The OverlappingQuadsNode class implementation of the AccNode class track(paramDict) method. """ index = self.getActivePartIndex() length = self.getLength(index) if(index == 0): self.z_value = 0. bunch = paramsDict["bunch"] momentum = bunch.getSyncParticle().momentum() n_steps = int(length/self.z_step)+1 z_step = length/n_steps for z_ind in range(n_steps): z = self.z_value + z_step*(z_ind+0.5) G = self.getTotalField(z) kq = G/(3.335640952*momentum) if(abs(kq) == 0.): TPB.drift(bunch,z_step) continue #------- track through a combined quad TPB.quad1(bunch,z_step/4.0, kq) TPB.quad2(bunch,z_step/2.0) TPB.quad1(bunch,z_step/2.0, kq) TPB.quad2(bunch,z_step/2.0) TPB.quad1(bunch,z_step/4.0, kq) self.z_value += length
def track(self, paramsDict):
"""
The Quad Combined Function TEAPOT class implementation
of the AccNodeBunchTracker class track(probe) method.
"""
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
strength = 1.0
if (self.waveform):
strength = self.waveform.getStrength()
kq = strength * self.getParam("kq")
poleArr = self.getParam("poles")
klArr = self.getParam("kls")
skewArr = self.getParam("skews")
bunch = paramsDict["bunch"]
useCharge = 1
if (paramsDict.has_key("useCharge")): \
useCharge = paramsDict["useCharge"]
if (index == 0):
TPB.quad1(bunch, length, kq, useCharge)
return
if (index > 0 and index < (nParts - 1)):
TPB.quad2(bunch, length / 2.0)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = strength * klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew, useCharge)
TPB.quad2(bunch, length / 2.0)
TPB.quad1(bunch, length, kq, useCharge)
return
if (index == (nParts - 1)):
TPB.quad2(bunch, length)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = strength * klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew, useCharge)
TPB.quad2(bunch, length)
TPB.quad1(bunch, length, kq, useCharge)
return
def track(self, paramsDict):
"""
The Bend Combined Functions TEAPOT class implementation of
the AccNodeBunchTracker class track(probe) method.
"""
bunch = paramsDict["bunch"]
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
poleArr = self.getParam("poles")
klArr = [
-x * bunch.charge() * self.getLength()
for x in self.getParam("kls")
]
skewArr = self.getParam("skews")
theta = self.getParam("theta") / (nParts - 1)
if (index == 0):
TPB.bend1(bunch, length, theta / 2.0)
return
if (index > 0 and index < (nParts - 1)):
TPB.bend2(bunch, length / 2.0)
TPB.bend3(bunch, theta / 2.0)
TPB.bend4(bunch, theta / 2.0)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew)
TPB.bend4(bunch, theta / 2.0)
TPB.bend3(bunch, theta / 2.0)
TPB.bend2(bunch, length / 2.0)
TPB.bend1(bunch, length, theta)
return
if (index == (nParts - 1)):
TPB.bend2(bunch, length)
TPB.bend3(bunch, theta / 2.0)
TPB.bend4(bunch, theta / 2.0)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew)
TPB.bend4(bunch, theta / 2.0)
TPB.bend3(bunch, theta / 2.0)
TPB.bend2(bunch, length)
TPB.bend1(bunch, length, theta / 2.0)
return
def fringeOUT(node, paramsDict):
usageOUT = node.getUsage()
e = node.getParam("ea2")
rho = node.getParam("rho")
poleArr = node.getParam("poles")[:]
klArr = node.getParam("kls")[:]
skewArr = node.getParam("skews")[:]
length = paramsDict["parentNode"].getLength()
bunch = paramsDict["bunch"]
useCharge = 1
if (paramsDict.has_key("useCharge")):
useCharge = paramsDict["useCharge"]
nParts = paramsDict["parentNode"].getnParts()
if (e != 0.):
inout = 1
TPB.wedgebendCF(bunch, e, inout, rho, len(poleArr), poleArr,
klArr, skewArr, nParts - 1, useCharge)
if (usageOUT):
frinout = 0
TPB.wedgerotate(bunch, -e, frinout)
TPB.bendfringeOUT(bunch, rho)
if (length != 0.):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / length
skew = skewArr[i]
TPB.multpfringeOUT(bunch, pole, kl, skew,
useCharge)
frinout = 1
TPB.wedgerotate(bunch, -e, frinout)
TPB.wedgedrift(bunch, e, inout)
else:
if (usageOUT):
TPB.bendfringeOUT(bunch, rho)
if (length != 0.):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / length
skew = skewArr[i]
TPB.multpfringeOUT(bunch, pole, kl, skew,
useCharge)
def fringeOUT(node, paramsDict):
bunch = paramsDict["bunch"]
length = paramsDict["parentNode"].getLength()
usageOUT = node.getUsage()
e = node.getParam("ea2")
rho = node.getParam("rho")
poleArr = node.getParam("poles")
klArr = [
-x * bunch.charge() * length for x in self.getParam("kls")
]
skewArr = node.getParam("skews")
nParts = paramsDict["parentNode"].getnParts()
if (e != 0.):
inout = 1
TPB.wedgebendCF(bunch, e, inout, rho, len(poleArr), poleArr,
klArr, skewArr, nParts - 1)
if (usageOUT):
frinout = 0
TPB.wedgerotate(bunch, -e, frinout)
TPB.bendfringeOUT(bunch, rho)
if (length != 0.):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / length
skew = skewArr[i]
TPB.multpfringeOUT(bunch, pole, kl, skew)
frinout = 1
TPB.wedgerotate(bunch, -e, frinout)
TPB.wedgedrift(bunch, e, inout)
else:
if (usageOUT):
TPB.bendfringeOUT(bunch, rho)
if (length != 0.):
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / length
skew = skewArr[i]
TPB.multpfringeOUT(bunch, pole, kl, skew)
def track(self, paramsDict):
"""
The Quad Combined Function TEAPOT class implementation
of the AccNode class track(probe) method.
"""
bunch = paramsDict["bunch"]
momentum = bunch.getSyncParticle().momentum()
kq = self.getParam("dB/dr") / (3.335640952 * momentum)
nParts = self.getnParts()
index = self.getActivePartIndex()
length = self.getLength(index)
poleArr = self.getParam("poles")
klArr = self.getParam("kls")
skewArr = self.getParam("skews")
#print "debug name =",self.getName()," kq=",kq," L=",self.getLength(index)," index=",index
#===============================================================
# This is a 3-sub-parts implementation TEAPOT algorithm
# Now the quad is divided into equally long parts, and
# for each part we use the same tracking.
# It will allow the backward tracking through the
# quad with Space Charge child nodes.
#===============================================================
step = length
self.tracking_module.quad1(bunch, step / 4, kq)
self.tracking_module.quad2(bunch, step / 4)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew)
self.tracking_module.quad2(bunch, step / 4)
self.tracking_module.quad1(bunch, step / 2, kq)
self.tracking_module.quad2(bunch, step / 4)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i] / (nParts - 1)
skew = skewArr[i]
TPB.multp(bunch, pole, kl, skew)
self.tracking_module.quad2(bunch, step / 4)
self.tracking_module.quad1(bunch, step / 4, kq)
"""
#=============================================
# This is an old TEAPOT-like implementation
# of the Quad tracking.
#=============================================
if(index == 0):
self.tracking_module.quad1(bunch, length, kq)
return
if(index > 0 and index < (nParts-1)):
self.tracking_module.quad2(bunch, length/2.0)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]/(nParts - 1)
skew = skewArr[i]
TPB.multp(bunch,pole,kl,skew)
self.tracking_module.quad2(bunch, length/2.0)
self.tracking_module.quad1(bunch, length, kq)
return
if(index == (nParts-1)):
self.tracking_module.quad2(bunch, length)
for i in xrange(len(poleArr)):
pole = poleArr[i]
kl = klArr[i]*kq*length/(nParts - 1)
skew = skewArr[i]
TPB.multp(bunch,pole,kl,skew)
self.tracking_module.quad2(bunch, length)
self.tracking_module.quad1(bunch, length, kq)
"""
return
