def __init__(self, name = "baserfgap"):
"""
Constructor for the simplest RF gap. E0TL parameter is in GeV. Phases are in radians.
It has 3 parts with lengthes: 0.5 + 0. + 0.5
"""
BaseLinacNode.__init__(self,name)
self.addParam("E0TL",0.)
self.addParam("modePhase",0.)
self.addParam("gap_phase",0.)
self.addParam("rfCavity", None)
self.setType("baserfgap")
self.__isFirstGap = False
self.setnParts(3)
self.cppGapModel = MatrixRfGap()
def setCppGapModel(self, cppGapModel = MatrixRfGap()): """ This method will set the fast c++ simple model for the RF Gap. By default it is Matrix RF Gap model which is a linear transport matrix. """ self.cppGapModel = cppGapModel
class BaseRF_Gap(BaseLinacNode):
"""
The simplest RF gap representation. The only E*T*L defines all effects of the node.
By default the Matrix RF Gap model is used. This model can be replaced later with
a more complex RF gap model by using the setCppGapModel(...) method.
"""
def __init__(self, name = "baserfgap"):
"""
Constructor for the simplest RF gap. E0TL parameter is in GeV. Phases are in radians.
It has 3 parts with lengthes: 0.5 + 0. + 0.5
"""
BaseLinacNode.__init__(self,name)
self.addParam("E0TL",0.)
self.addParam("modePhase",0.)
self.addParam("gap_phase",0.)
self.addParam("rfCavity", None)
self.setType("baserfgap")
self.__isFirstGap = False
self.setnParts(3)
self.cppGapModel = MatrixRfGap()
#self.cppGapModel = BaseRfGap()
def setnParts(self, n = 3):
"""
Method. Sets the number of body parts of the node. For the RF gap it will be only 3.
"""
BaseLinacNode.setnParts(self,3)
def setCppGapModel(self, cppGapModel = MatrixRfGap()):
"""
This method will set the fast c++ simple model for the RF Gap.
By default it is Matrix RF Gap model which is a linear transport matrix.
"""
self.cppGapModel = cppGapModel
def initialize(self):
"""
The Ring RF TEAPOT class implementation
of the AccNode class initialize() method.
"""
nParts = self.getnParts()
if(nParts != 3):
msg = "The simple Rf gap should have 3 parts!"
msg = msg + os.linesep
msg = msg + "Method initialize():"
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
msg = msg + "nParts =" + str(nParts)
msg = msg + os.linesep
msg = msg + "lenght =" + str(self.getLength())
orbitFinalize(msg)
length = self.getLength()
self.setLength(length/2.0,0)
self.setLength(0.,1)
self.setLength(length/2.0,2)
def isRFGap(self):
"""
Returns True.
"""
return True
def isFirstRFGap(self):
"""
Returns True if it is the first gap in RF cavity.
"""
return self.__isFirstGap
def setAsFirstRFGap(self, isFirst):
"""
Sets if it is the first gap in RF cavity.
"""
self.__isFirstGap = isFirst
def setRF_Cavity(self, rf_cav):
"""
Sets the parent RF Cavity.
"""
self.addParam("rfCavity",rf_cav)
def getRF_Cavity(self):
"""
Returns the parent RF Cavity.
"""
return self.getParam("rfCavity")
def setGapPhase(self, gap_phase):
"""
Sets the rf gap phase.
"""
self.setParam("gap_phase",gap_phase)
def getGapPhase(self):
"""
Returns the rf gap phase.
"""
return self.getParam("gap_phase")
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)
#print "debug delta_time in deg=",frequency*(arrival_time - designArrivalTime)*380.
#print "debug RF =",self.getName()," E0TL=",E0TL," phase=",(phase*180./math.pi - 180.)," eKin[MeV]=",bunch.getSyncParticle().kinEnergy()*1.0e+3
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)