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 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 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