def addTrMatrxGenNodes(self,
accLattice,
node_or_nodes,
place=MarkerLinacNode.ENTRANCE):
"""
Adds the LinacTrMatrixGenNode to the nodes as child nodes.
"""
nodes = []
if (type(node_or_nodes) in [tuple, list]):
for node in node_or_nodes:
nodes.append(node)
else:
nodes.append(node_or_nodes)
#-----------------------------
for node in nodes:
trMatrxGenNode = LinacTrMatrixGenNode(self,
node.getName() + ":trMatrx")
node.addChildNode(trMatrxGenNode, place)
#----- set up the position of the TrMatrix nodes
actions = AccActionsContainer()
def accNodeExitAction(paramsDict):
"""
Nonbound function. Sets the position of the TrMatrix nodes.
"""
node = paramsDict["node"]
if (isinstance(node, LinacTrMatrixGenNode)):
pos = paramsDict["path_length"]
node.setPosition(pos)
actions.addAction(accNodeExitAction, AccNode.EXIT)
accLattice.trackActions(actions)
self.init()
return self.trMatrxNodes
def getChromaticitiesXY(self):
"""
Calculates chromaticities for X,Y planes for the whole ring
"""
(tuneX,tmp0,tmp1) = self.getRingTwissDataX()
(tuneY,tmp0,tmp1) = self.getRingTwissDataY()
tuneX = tuneX[1][-1]
tuneY = tuneY[1][-1]
self.matrixGenerator.initBunchChromCoeff(self.bunch)
#track bunch through the TEAPOT nodes
def twissAction(paramsDict):
node = paramsDict["node"]
if(isinstance(node, BaseTEAPOT) == True and isinstance(node,RingRFTEAPOT) == False):
node.track(paramsDict)
accContainer = AccActionsContainer()
accContainer.addAction(twissAction,AccActionsContainer.BODY)
paramsDict = {}
paramsDict["bunch"] = self.bunch
self.teapot_lattice.trackActions(accContainer,paramsDict)
res_coeff = self.matrixGenerator.calcChromCoeff(self.bunch)
(coeff_x_dE,coeff_xp_dE,coeff_y_dE,coeff_yp_dE) = res_coeff
momentum = self.bunch.getSyncParticle().momentum()
mass = self.bunch.getSyncParticle().mass()
Ekin = self.bunch.getSyncParticle().kinEnergy()
chromX = - (momentum/(2*math.sin(2*math.pi*tuneX)))*(coeff_x_dE+coeff_xp_dE)
chromX = (momentum/(mass+Ekin))*chromX
chromY = - (momentum/(2*math.sin(2*math.pi*tuneY)))*(coeff_y_dE+coeff_yp_dE)
chromY = (momentum/(mass+Ekin))*chromY
return (chromX/(2*math.pi),chromY/(2*math.pi))
def trackDesignBunch(self,
bunch_in,
paramsDict=None,
actionContainer=None,
index_start=-1,
index_stop=-1):
"""
This will track the design bunch through the linac and set up RF Cavities times of
arrivals.
"""
if (actionContainer == None):
actionContainer = AccActionsContainer("Design Bunch Tracking")
if (paramsDict == None): paramsDict = {}
bunch = Bunch()
bunch_in.copyEmptyBunchTo(bunch)
bunch.getSyncParticle().time(0.)
paramsDict["bunch"] = bunch
def trackDesign(localParamsDict):
node = localParamsDict["node"]
node.trackDesign(localParamsDict)
actionContainer.addAction(trackDesign, AccActionsContainer.BODY)
self.trackActions(actionContainer, paramsDict, index_start, index_stop)
actionContainer.removeAction(trackDesign, AccActionsContainer.BODY)
return bunch
def getResultsDict():
bunch = Bunch()
bunch_init.copyEmptyBunchTo(bunch)
#set up design
accLattice.trackDesignBunch(bunch)
#track through the lattice START SCL with 95.610
rf_gaps_eKin_phases_dict = {}
paramsDict = {"test_pos":95.605984,"count":0,"rf_gap_dict":rf_gaps_eKin_phases_dict}
actionContainer = AccActionsContainer("Bunch Tracking")
def action_exit(paramsDict):
node = paramsDict["node"]
length = node.getLength()
pos = paramsDict["test_pos"] + length
paramsDict["test_pos"] = pos
if(isinstance(paramsDict["parentNode"],AccLattice)):
if(isinstance(node,BaseRF_Gap)):
bunch_inner = paramsDict["bunch"]
eKin_out = bunch_inner.getSyncParticle().kinEnergy()*1.0e+3
phase = makePhaseNear(node.getGapPhase()*180./math.pi-180.,0.)
rf_gaps_eKin_phases_dict = paramsDict["rf_gap_dict"]
rf_gaps_eKin_phases_dict[node] = [eKin_out,phase]
#print "debug eKin out=",eKin_out
actionContainer.addAction(action_exit, AccActionsContainer.EXIT)
accLattice.trackBunch(bunch, paramsDict = paramsDict, actionContainer = actionContainer)
return rf_gaps_eKin_phases_dict
def getNodeForNameFromWholeLattice(accLattice, name):
"""
Returns the accelerator node or an array of nodes with the same name.
This function could be replaced later by the method in the AccLattice class.
"""
paramsDict = {}
actions = AccActionsContainer()
nodes = []
def accNodeExitAction(paramsDict):
"""
Non-bound function. Finds the node in the lattice
with the specified name.
positions. This is a closure (well, maybe not
exactly). It uses external objects.
"""
node = paramsDict["node"]
if (node.getName() == name):
nodes.append(node)
actions.addAction(accNodeExitAction, AccNode.EXIT)
accLattice.trackActions(actions, paramsDict)
if (len(nodes) == 1):
return nodes[0]
elif (len(nodes) == 0):
return None
else:
return nodes
def __init__(self, teapot_lattice, bunch, name=None):
MATRIX_Lattice.__init__(self, name)
if (isinstance(teapot_lattice, TEAPOT_Lattice) != True):
orbitFinalize(
"Constructor orbit.teapot.TEAPOT_MATRIX_Lattice needs the TEAPOT_Lattice instance."
)
#memorize the TEAPOT LATTICE
if (name == None):
name = teapot_lattice.getName()
self.setName(name)
self.teapot_lattice = teapot_lattice
self.bunch = Bunch()
self.lost_bunch = Bunch()
bunch.copyEmptyBunchTo(self.bunch)
bunch.copyEmptyBunchTo(self.lost_bunch)
self.matrixGenerator = MatrixGenerator()
#----------make MATRIX lattice from TEAPOT
def twissAction(paramsDict):
node = paramsDict["node"]
bunch = paramsDict["bunch"]
active_index = node.getActivePartIndex()
n_parts = node.getnParts()
length = node.getLength(active_index)
if (isinstance(node, BaseTEAPOT) == True
and isinstance(node, RingRFTEAPOT) == False):
self.matrixGenerator.initBunch(bunch)
node.track(paramsDict)
#bunch is ready
matrixNode = BaseMATRIX(node.getName() + "_" +
str(active_index))
matrixNode.addParam("matrix_parent_node", node)
matrixNode.addParam("matrix_parent_node_type", node.getType())
matrixNode.addParam("matrix_parent_node_n_nodes", n_parts)
matrixNode.addParam("matrix_parent_node_active_index",
active_index)
matrixNode.setLength(length)
self.matrixGenerator.calculateMatrix(bunch,
matrixNode.getMatrix())
#print "============= name=",matrixNode.getName(),
#print " type=",matrixNode.getParam("matrix_parent_node_type"),
#print " L=",matrixNode.getLength()
self.addNode(matrixNode)
if (isinstance(node, RingRFTEAPOT) == True):
rf_node = RingRFTEAPOT(node.getName())
rf_node.setParamsDict(node.getParamsDict().copy())
self.addNode(rf_node)
accContainer = AccActionsContainer()
accContainer.addAction(twissAction, AccActionsContainer.BODY)
paramsDict = {}
paramsDict["bunch"] = self.bunch
paramsDict["lostbunch"] = self.lost_bunch
paramsDict["position"] = 0.
paramsDict["useCharge"] = self.teapot_lattice.getUseRealCharge()
self.teapot_lattice.trackActions(accContainer, paramsDict)
self.makeOneTurnMatrix()
self.initialize()
def getTransportMatrixArray(self, teapot_lattice):
accContainer = AccActionsContainer()
accContainer.addAction(self._twissAction, AccActionsContainer.BODY)
paramsDict = {}
paramsDict["bunch"] = self.b
paramsDict["position"] = 0.
self.matrixArr = []
self.index = 0
teapot_lattice.trackActions(accContainer, paramsDict)
return self.matrixArr
def getTransportMatrixArray(self,teapot_lattice):
accContainer = AccActionsContainer()
accContainer.addAction(self._twissAction,AccActionsContainer.BODY)
paramsDict = {}
paramsDict["bunch"] = self.b
paramsDict["position"] = 0.
self.matrixArr = []
self.index = 0
teapot_lattice.trackActions(accContainer,paramsDict)
return self.matrixArr
def __init__(self, teapot_lattice, bunch, name = None):
MATRIX_Lattice.__init__(self,name)
if(isinstance(teapot_lattice,TEAPOT_Lattice) != True):
orbitFinalize("Constructor orbit.teapot.TEAPOT_MATRIX_Lattice needs the TEAPOT_Lattice instance.")
#memorize the TEAPOT LATTICE
if(name == None):
name = teapot_lattice.getName()
self.setName(name)
self.teapot_lattice = teapot_lattice
self.bunch = Bunch()
self.lost_bunch = Bunch()
bunch.copyEmptyBunchTo(self.bunch)
bunch.copyEmptyBunchTo(self.lost_bunch)
self.matrixGenerator = MatrixGenerator()
#----------make MATRIX lattice from TEAPOT
def twissAction(paramsDict):
node = paramsDict["node"]
bunch = paramsDict["bunch"]
active_index = node.getActivePartIndex()
n_parts = node.getnParts()
length = node.getLength(active_index)
if(isinstance(node,BaseTEAPOT) == True and isinstance(node,RingRFTEAPOT) == False):
self.matrixGenerator.initBunch(bunch)
node.track(paramsDict)
#bunch is ready
matrixNode = BaseMATRIX(node.getName()+"_"+str(active_index))
matrixNode.addParam("matrix_parent_node",node)
matrixNode.addParam("matrix_parent_node_type",node.getType())
matrixNode.addParam("matrix_parent_node_n_nodes",n_parts)
matrixNode.addParam("matrix_parent_node_active_index",active_index)
matrixNode.setLength(length)
self.matrixGenerator.calculateMatrix(bunch,matrixNode.getMatrix())
#print "============= name=",matrixNode.getName(),
#print " type=",matrixNode.getParam("matrix_parent_node_type"),
#print " L=",matrixNode.getLength()
self.addNode(matrixNode)
if(isinstance(node,RingRFTEAPOT) == True):
rf_node = RingRFTEAPOT(node.getName())
rf_node.setParamsDict(node.getParamsDict().copy())
self.addNode(rf_node)
accContainer = AccActionsContainer()
accContainer.addAction(twissAction,AccActionsContainer.BODY)
paramsDict = {}
paramsDict["bunch"] = self.bunch
paramsDict["lostbunch"] = self.lost_bunch
paramsDict["position"] = 0.
paramsDict["useCharge"] = self.teapot_lattice.getUseRealCharge()
self.teapot_lattice.trackActions(accContainer,paramsDict)
self.makeOneTurnMatrix()
self.initialize()
def trackDesignBunch(self, bunch, paramsDict = {}, actionContainer = None):
"""
It tracks the bunch through the AccNodeBunchTracker instance.
"""
if(actionContainer == None): actionContainer = AccActionsContainer("Design Bunch Tracking")
paramsDict["bunch"] = bunch
def trackDesign(paramsDict):
node = paramsDict["node"]
node.trackDesign(paramsDict)
actionContainer.addAction(trackDesign, AccActionsContainer.BODY)
self.trackActions(actionContainer,paramsDict)
actionContainer.removeAction(trackDesign, AccActionsContainer.BODY)
def trackBunch(self, bunch, paramsDict = {}, actionContainer = None):
"""
It tracks the bunch through the lattice.
"""
if(actionContainer == None): actionContainer = AccActionsContainer("Bunch Tracking")
paramsDict["bunch"] = bunch
def track(paramsDict):
node = paramsDict["node"]
node.track(paramsDict)
actionContainer.addAction(track, AccActionsContainer.BODY)
self.trackActions(actionContainer,paramsDict)
actionContainer.removeAction(track, AccActionsContainer.BODY)
def trackBunch(self, bunch, paramsDict={}, actionContainer=None):
"""
It tracks the bunch through the lattice.
"""
if (actionContainer == None):
actionContainer = AccActionsContainer("Bunch Tracking")
paramsDict["bunch"] = bunch
def track(paramsDict):
node = paramsDict["node"]
node.track(paramsDict)
actionContainer.addAction(track, AccActionsContainer.BODY)
self.trackActions(actionContainer, paramsDict)
actionContainer.removeAction(track, AccActionsContainer.BODY)
def trackBunch(self, bunch, paramsDict = None, actionContainer = None, index_start = -1, index_stop = -1):
"""
It tracks the bunch through the lattice.
"""
if(actionContainer == None): actionContainer = AccActionsContainer("Bunch Tracking")
if(paramsDict == None): paramsDict = {}
paramsDict["bunch"] = bunch
bunch.getSyncParticle().time(0.)
def track(paramsDict):
node = paramsDict["node"]
node.track(paramsDict)
actionContainer.addAction(track, AccActionsContainer.BODY)
self.trackActions(actionContainer,paramsDict,index_start,index_stop)
actionContainer.removeAction(track, AccActionsContainer.BODY)
def initialize(self):
"""
Method. Initializes the lattice and child node structures.
"""
res_dict = {}
for node in self.__children:
if(res_dict.has_key(node)):
msg = "The AccLattice class instance should not have duplicate nodes!"
msg = msg + os.linesep
msg = msg + "Method initialize():"
msg = msg + os.linesep
msg = msg + "Name of node=" + node.getName()
msg = msg + os.linesep
msg = msg + "Type of node=" + node.getType()
msg = msg + os.linesep
orbitFinalize(msg)
else:
res_dict[node] = None
node.initialize()
del res_dict
paramsDict = {}
actions = AccActionsContainer()
d = [0.]
posn = {}
def accNodeExitAction(paramsDict):
"""
Nonbound function. Sets lattice length and node
positions. This is a closure (well, maybe not
exactly). It uses external objects.
"""
node = paramsDict["node"]
parentNode = paramsDict["parentNode"]
if(isinstance(parentNode, AccLattice)):
posBefore = d[0]
d[0] += node.getLength()
posAfter = d[0]
posn[node]=(posBefore, posAfter)
actions.addAction(accNodeExitAction, AccNode.EXIT)
self.trackActions(actions, paramsDict)
self.__length = d[0]
self.__childPositions = posn
self.__isInitialized = True
def initialize(self):
"""
Method. Initializes the lattice and child node structures.
"""
res_dict = {}
for node in self.__children:
if(res_dict.has_key(node)):
msg = "The AccLattice class instance should not have duplicate nodes!"
msg = msg + os.linesep
msg = msg + "Method initialize():"
msg = msg + os.linesep
msg = msg + "Name of node=" + node.getName()
msg = msg + os.linesep
msg = msg + "Type of node=" + node.getType()
msg = msg + os.linesep
orbitFinalize(msg)
else:
res_dict[node] = None
node.initialize()
del res_dict
paramsDict = {}
actions = AccActionsContainer()
d = [0.]
posn = {}
def accNodeExitAction(paramsDict):
"""
Nonbound function. Sets lattice length and node
positions. This is a closure (well, maybe not
exactly). It uses external objects.
"""
node = paramsDict["node"]
parentNode = paramsDict["parentNode"]
if(isinstance(parentNode, AccLattice)):
posBefore = d[0]
d[0] += node.getLength()
posAfter = d[0]
posn[node]=(posBefore, posAfter)
actions.addAction(accNodeExitAction, AccNode.EXIT)
self.trackActions(actions, paramsDict)
self.__length = d[0]
self.__childPositions = posn
self.__isInitialized = True
def trackDesignBunch(self, bunch_in, paramsDict = None, actionContainer = None, index_start = -1, index_stop = -1):
"""
This will track the design bunch through the linac and set up RF Cavities times of
arrivals.
"""
if(actionContainer == None): actionContainer = AccActionsContainer("Design Bunch Tracking")
if(paramsDict == None): paramsDict = {}
bunch = Bunch()
bunch_in.copyEmptyBunchTo(bunch)
bunch.getSyncParticle().time(0.)
paramsDict["bunch"] = bunch
def trackDesign(localParamsDict):
node = localParamsDict["node"]
node.trackDesign(localParamsDict)
actionContainer.addAction(trackDesign, AccActionsContainer.BODY)
self.trackActions(actionContainer,paramsDict,index_start,index_stop)
actionContainer.removeAction(trackDesign, AccActionsContainer.BODY)
def trackBunch(self,
bunch,
paramsDict={},
actionContainer=None,
index_start=-1,
index_stop=-1):
"""
It tracks the bunch through the lattice. Indexes index_start and index_stop are inclusive.
"""
if (actionContainer == None):
actionContainer = AccActionsContainer("Bunch Tracking")
paramsDict["bunch"] = bunch
paramsDict["useCharge"] = self.useCharge
def track(paramsDict):
node = paramsDict["node"]
node.track(paramsDict)
actionContainer.addAction(track, AccActionsContainer.BODY)
self.trackActions(actionContainer, paramsDict, index_start, index_stop)
actionContainer.removeAction(track, AccActionsContainer.BODY)
def getNodePosDictForWholeLattice(accLattice):
"""
Returns the dict[node] = (posStart,posEnd) for all nodes (not only for the firts level).
This function could be replaced later by the method in the AccLattice class.
"""
paramsDict = {}
actions = AccActionsContainer()
posStartDict = {}
posStopDict = {}
def accNodeEntranceAction(paramsDict):
"""
Non-bound function. Sets node's end positions.
This is a closure (well, maybe not exactly). .
"""
node = paramsDict["node"]
pos = paramsDict["path_length"]
posStartDict[node] = pos
def accNodeExitAction(paramsDict):
"""
Non-bound function. Sets node's end positions.
This is a closure (well, maybe not exactly). .
"""
node = paramsDict["node"]
pos = paramsDict["path_length"]
posStopDict[node] = pos
actions.addAction(accNodeEntranceAction, AccNode.ENTRANCE)
actions.addAction(accNodeExitAction, AccNode.EXIT)
accLattice.trackActions(actions, paramsDict)
posStartStopDict = {}
for key in posStartDict:
pos_start = posStartDict[key]
pos_end = posStopDict[key]
posStartStopDict[key] = (pos_start, pos_end)
return posStartStopDict
def trackBunch(self,
bunch,
paramsDict=None,
actionContainer=None,
index_start=-1,
index_stop=-1):
"""
It tracks the bunch through the lattice.
"""
if (actionContainer == None):
actionContainer = AccActionsContainer("Bunch Tracking")
if (paramsDict == None): paramsDict = {}
paramsDict["bunch"] = bunch
bunch.getSyncParticle().time(0.)
def track(paramsDict):
node = paramsDict["node"]
node.track(paramsDict)
actionContainer.addAction(track, AccActionsContainer.BODY)
self.trackActions(actionContainer, paramsDict, index_start, index_stop)
actionContainer.removeAction(track, AccActionsContainer.BODY)
def getAllNodesInLattice(accLattice):
"""
Returns the array with all nodes on all levels (even sub-child).
"""
nodes = []
paramsDict = {}
actions = AccActionsContainer()
def accNodeEntranceAction(paramsDict):
"""
Non-bound function. Add the node to the nodes array
at the entrance inside the node.
This is a closure (well, maybe not
exactly). It uses external objects.
"""
node = paramsDict["node"]
nodes.append(node)
actions.addAction(accNodeEntranceAction, AccNode.ENTRANCE)
accLattice.trackActions(actions, paramsDict)
return nodes
def getAllMagnetsInLattice(accLattice):
"""
Returns the array with all magnets including magnets on all levels (e.g correctors)
"""
magnets = []
paramsDict = {}
actions = AccActionsContainer()
def accNodeExitAction(paramsDict):
"""
Non-bound function. Finds the node in the lattice
with the specified name.
positions. This is a closure (well, maybe not
exactly). It uses external objects.
"""
node = paramsDict["node"]
if (isinstance(node, LinacMagnetNode)):
magnets.append(node)
actions.addAction(accNodeExitAction, AccNode.EXIT)
accLattice.trackActions(actions, paramsDict)
return magnets
def getChromaticitiesXY(self):
"""
Calculates chromaticities for X,Y planes for the whole ring
"""
(tuneX, tmp0, tmp1) = self.getRingTwissDataX()
(tuneY, tmp0, tmp1) = self.getRingTwissDataY()
tuneX = tuneX[1][-1]
tuneY = tuneY[1][-1]
self.matrixGenerator.initBunchChromCoeff(self.bunch)
#track bunch through the TEAPOT nodes
def twissAction(paramsDict):
node = paramsDict["node"]
if (isinstance(node, BaseTEAPOT) == True
and isinstance(node, RingRFTEAPOT) == False):
node.track(paramsDict)
accContainer = AccActionsContainer()
accContainer.addAction(twissAction, AccActionsContainer.BODY)
paramsDict = {}
paramsDict["bunch"] = self.bunch
self.teapot_lattice.trackActions(accContainer, paramsDict)
res_coeff = self.matrixGenerator.calcChromCoeff(self.bunch)
(coeff_x_dE, coeff_xp_dE, coeff_y_dE, coeff_yp_dE) = res_coeff
momentum = self.bunch.getSyncParticle().momentum()
mass = self.bunch.getSyncParticle().mass()
Ekin = self.bunch.getSyncParticle().kinEnergy()
chromX = -(momentum /
(2 * math.sin(2 * math.pi * tuneX))) * (coeff_x_dE +
coeff_xp_dE)
chromX = (momentum / (mass + Ekin)) * chromX
chromY = -(momentum /
(2 * math.sin(2 * math.pi * tuneY))) * (coeff_y_dE +
coeff_yp_dE)
chromY = (momentum / (mass + Ekin)) * chromY
return (chromX / (2 * math.pi), chromY / (2 * math.pi))
def initialize(self):
AccLattice.initialize(self)
#set up ring length for RF nodes
ringRF_Node = RingRFTEAPOT()
bunchwrap_Node = BunchWrapTEAPOT()
for node in self.getNodes():
if (node.getType() == ringRF_Node.getType()):
node.getParamsDict()["ring_length"] = self.getLength()
paramsDict = {}
actions = AccActionsContainer()
def accSetWrapLengthAction(paramsDict):
"""
Nonbound function. Sets lattice length for wrapper nodes
"""
node = paramsDict["node"]
bunchwrap_node = BunchWrapTEAPOT()
if (node.getType() == bunchwrap_Node.getType()):
node.getParamsDict()["ring_length"] = self.getLength()
actions.addAction(accSetWrapLengthAction, AccNode.EXIT)
self.trackActions(actions, paramsDict)
actions.removeAction(accSetWrapLengthAction, AccNode.EXIT)
def initialize(self):
AccLattice.initialize(self)
#set up ring length for RF nodes
ringRF_Node = RingRFTEAPOT()
bunchwrap_Node = BunchWrapTEAPOT()
for node in self.getNodes():
if(node.getType() == ringRF_Node.getType()):
node.getParamsDict()["ring_length"] = self.getLength()
paramsDict = {}
actions = AccActionsContainer()
def accSetWrapLengthAction(paramsDict):
"""
Nonbound function. Sets lattice length for wrapper nodes
"""
node = paramsDict["node"]
bunchwrap_node = BunchWrapTEAPOT()
if(node.getType() == bunchwrap_Node.getType()):
node.getParamsDict()["ring_length"] = self.getLength()
actions.addAction(accSetWrapLengthAction, AccNode.EXIT)
self.trackActions(actions, paramsDict)
actions.removeAction(accSetWrapLengthAction, AccNode.EXIT)
def getResultsDict():
bunch = Bunch()
bunch_init.copyEmptyBunchTo(bunch)
#set up design
accLattice.trackDesignBunch(bunch)
#track through the lattice START SCL with 95.610
rf_gaps_eKin_phases_dict = {}
paramsDict = {
"test_pos": 95.605984,
"count": 0,
"rf_gap_dict": rf_gaps_eKin_phases_dict
}
actionContainer = AccActionsContainer("Bunch Tracking")
def action_exit(paramsDict):
node = paramsDict["node"]
length = node.getLength()
pos = paramsDict["test_pos"] + length
paramsDict["test_pos"] = pos
if (isinstance(paramsDict["parentNode"], AccLattice)):
if (isinstance(node, BaseRF_Gap)):
bunch_inner = paramsDict["bunch"]
eKin_out = bunch_inner.getSyncParticle().kinEnergy() * 1.0e+3
phase = makePhaseNear(
node.getGapPhase() * 180. / math.pi - 180., 0.)
rf_gaps_eKin_phases_dict = paramsDict["rf_gap_dict"]
rf_gaps_eKin_phases_dict[node] = [eKin_out, phase]
#print "debug eKin out=",eKin_out
actionContainer.addAction(action_exit, AccActionsContainer.EXIT)
accLattice.trackBunch(bunch,
paramsDict=paramsDict,
actionContainer=actionContainer)
return rf_gaps_eKin_phases_dict
def funcExit(paramsDict):
node = paramsDict["node"]
if (paramsDict.has_key("print") and paramsDict["print"] == True):
print Blanks(
nLevel[0]), "EXIT level=", nLevel[0], " node=", node.getName()
nLevel[0] -= 1
def funcTrack(paramsDict):
node = paramsDict["node"]
if (paramsDict.has_key("print") and paramsDict["print"] == True):
print Blanks(nLevel[0]), "BODY TRACK through node =", node.getName(
), " level=", nLevel[0]
acts.addAction(funcEntrance, AccActionsContainer.ENTRANCE)
acts.addAction(funcTrack, AccActionsContainer.BODY)
acts.addAction(funcExit, AccActionsContainer.EXIT)
lattice.initialize()
print "Total length=", lattice.getLength()
nodes = lattice.getNodes()
for node in nodes:
print "node=", node.getName(
), " s start,stop = %4.3f %4.3f " % lattice.getNodePositionsDict()[node]
d = {"print": True}
lattice.trackActions(acts, d)
x = bunch.x(0) * 1000.
y = bunch.y(0) * 1000.
xp = bunch.xp(0) * 1000.
yp = bunch.yp(0) * 1000.
st = " %35s %4.5f " % (node.getName(), pos + pos_start)
st += " %6.4f %6.4f %6.4f %6.4f" % (x, xp, y, yp)
file_out.write(st + "\n")
file_out.flush()
print st
def action_exit(paramsDict):
action_entrance(paramsDict)
actionContainer.addAction(action_entrance, AccActionsContainer.ENTRANCE)
actionContainer.addAction(action_exit, AccActionsContainer.EXIT)
time_start = time.clock()
accLattice.trackBunch(bunch_init,
paramsDict=paramsDict,
actionContainer=actionContainer)
time_exec = time.clock() - time_start
print "time[sec]=", time_exec
file_out.close()
trajCorrection = TrajectoryCorrection(accLattice)
"""
def TrackingBunch(accLattice, bunch, print_info=False):
#set up design
accLattice.trackDesignBunch(bunch)
#track through the lattice
paramsDict = {"old_pos": -1., "count": 0, "pos_step": 0.01}
actionContainer = AccActionsContainer("Bunch Tracking")
pos_start = 0.
twiss_analysis = BunchTwissAnalysis()
results_arr = []
def action_entrance(paramsDict):
node = paramsDict["node"]
bunch = paramsDict["bunch"]
pos = paramsDict["path_length"]
if (paramsDict["old_pos"] == pos): return
if (paramsDict["old_pos"] + paramsDict["pos_step"] > pos): return
paramsDict["old_pos"] = pos
paramsDict["count"] += 1
gamma = bunch.getSyncParticle().gamma()
beta = bunch.getSyncParticle().beta()
twiss_analysis.analyzeBunch(bunch)
x_rms = math.sqrt(
twiss_analysis.getTwiss(0)[1] *
twiss_analysis.getTwiss(0)[3]) * 1000.
y_rms = math.sqrt(
twiss_analysis.getTwiss(1)[1] *
twiss_analysis.getTwiss(1)[3]) * 1000.
z_rms = math.sqrt(
twiss_analysis.getTwiss(2)[1] *
twiss_analysis.getTwiss(2)[3]) * 1000.
z_to_phase_coeff = bunch_gen.getZtoPhaseCoeff(bunch)
z_rms_deg = z_to_phase_coeff * z_rms / 1000.0
nParts = bunch.getSizeGlobal()
(alphaX, betaX, emittX) = (twiss_analysis.getTwiss(0)[0],
twiss_analysis.getTwiss(0)[1],
twiss_analysis.getTwiss(0)[3] * 1.0e+6)
(alphaY, betaY, emittY) = (twiss_analysis.getTwiss(1)[0],
twiss_analysis.getTwiss(1)[1],
twiss_analysis.getTwiss(1)[3] * 1.0e+6)
(alphaZ, betaZ, emittZ) = (twiss_analysis.getTwiss(2)[0],
twiss_analysis.getTwiss(2)[1],
twiss_analysis.getTwiss(2)[3] * 1.0e+6)
norm_emittX = emittX * gamma * beta
norm_emittY = emittY * gamma * beta
#---- phi_de_emittZ will be in [pi*deg*MeV]
phi_de_emittZ = z_to_phase_coeff * emittZ
eKin = bunch.getSyncParticle().kinEnergy() * 1.0e+3
s_prt = " %5d %35s %4.5f " % (paramsDict["count"], node.getName(),
pos + pos_start)
s_prt += " %5.3f %5.3f %5.3f " % (x_rms, y_rms, z_rms_deg)
s_prt += " %10.6f %8d " % (eKin, nParts)
if (print_info): print s_prt
twiss_arr = [(alphaX, betaX, emittX, norm_emittX),
(alphaY, betaY, emittY, norm_emittY),
(alphaZ, betaZ, emittZ, phi_de_emittZ)]
rms_arr = [x_rms, y_rms, z_rms_deg]
results_arr.append(
[node.getName(), pos, rms_arr, twiss_arr, eKin, nParts])
def action_exit(paramsDict):
action_entrance(paramsDict)
actionContainer.addAction(action_entrance, AccActionsContainer.ENTRANCE)
actionContainer.addAction(action_exit, AccActionsContainer.EXIT)
accLattice.trackBunch(bunch,
paramsDict=paramsDict,
actionContainer=actionContainer)
return results_arr
z_to_phase_coeff = bunch_generator.getZtoPhaseCoeff(bunch)
z_rms_deg = z_to_phase_coeff * z_rms / 1000.0
nParts = bunch.getSizeGlobal()
x_avg = twiss_analysis.getAverage(0) * 1000.
y_avg = twiss_analysis.getAverage(2) * 1000.
z_deg_avg = twiss_analysis.getAverage(4) * z_to_phase_coeff
dE_avg = twiss_analysis.getAverage(5) * 1.0e+3
eKin = bunch.getSyncParticle().kinEnergy() * 1.0e+3
s = " %20s %4.5f " % (node.getName(), pos + pos_start)
s += " %8.2f %8.2f %8.5f " % (x_avg, y_avg, dE_avg)
s += " %8.2f %8.2f %8.6f " % (x_rms, y_rms, dE_rms)
s += " %8.2f %8.6f " % (x_z_corr, x_dE_corr)
s += " %8.2f %8.6f " % (y_z_corr, y_dE_corr)
s += " %6.3f %8d " % (eKin, nParts)
print s
actionContainer.addAction(actions_all, AccActionsContainer.ENTRANCE)
actionContainer.addAction(actions_all, AccActionsContainer.BODY)
actionContainer.addAction(actions_all, AccActionsContainer.EXIT)
accLattice.trackBunch(bunch,
paramsDict=paramsDict,
actionContainer=actionContainer)
#--------------------------------------------------------------------------
# You can see the shift of average coordinates in the quad_1
#--------------------------------------------------------------------------
print "Done."
sx = math.sqrt(sx/bunch.getSize())
sy = math.sqrt(sy/bunch.getSize())
sz = math.sqrt(sz/bunch.getSize())
return sx,sy,sz
sx, sy, sz = get_rms()
file_out.write(str(pos)+"\t"+str(sx)+"\t"+str(sy)+"\t"+str(sz)+"\t"+str(eKin) +"\n")
length = node.getLength()
pos = paramsDict["test_pos"] + length
paramsDict["test_pos"] = pos
actionContainer.addAction(action_entrance, AccActionsContainer.ENTRANCE)
accLattice.trackDesignBunch(b, paramsDict = paramsDict)
accLattice.trackBunch(b, paramsDict = paramsDict, actionContainer = actionContainer)
#accLattice.trackBunch(b, paramsDict = paramsDict)
#b.dumpBunch("bunch_ls_out.txt")
file_out.close()
sys.exit()
if(paramsDict.has_key("print") and paramsDict["print"] == True):
print Blanks(nLevel[0]),"ENTER level=",nLevel[0]," node=",node.getName()
nElems[0] += 1
def funcExit(paramsDict):
node = paramsDict["node"]
if(paramsDict.has_key("print") and paramsDict["print"] == True):
print Blanks(nLevel[0]),"EXIT level=",nLevel[0]," node=",node.getName()
nLevel[0] -= 1
def funcTrack(paramsDict):
node = paramsDict["node"]
if(paramsDict.has_key("print") and paramsDict["print"] == True):
print Blanks(nLevel[0]),"BODY TRACK through node =",node.getName()," level=",nLevel[0]
acts.addAction(funcEntrance,AccActionsContainer.ENTRANCE)
acts.addAction(funcTrack,AccActionsContainer.BODY)
acts.addAction(funcExit,AccActionsContainer.EXIT)
lattice.initialize()
print "Total length=",lattice.getLength()
nodes = lattice.getNodes()
for node in nodes:
print "node=",node.getName()," s start,stop = %4.3f %4.3f "%lattice.getNodePositionsDict()[node]
d = {"print":True}
lattice.trackActions(acts,d)
print " N node position kinEnergy[MeV] "
def test_action(paramsDict):
node = paramsDict["node"]
length = node.getLength()
pos = paramsDict["test_pos"] + length
paramsDict["test_pos"] = pos
bunch = paramsDict["bunch"]
eKin = bunch.getSyncParticle().kinEnergy() * 1.0e+3
if (node.getName().find(":Rg") >= 0):
paramsDict["count"] += 1
s = " %5d %35s %4.5f %5.3f " % (paramsDict["count"],
node.getName(),
(pos - length / 2), eKin)
#outF.write(s+"\n")
print s
actionContainer.addAction(test_action, AccActionsContainer.EXIT)
accLattice.trackDesignBunch(b,
paramsDict=paramsDict,
actionContainer=actionContainer)
outF.close()
accLattice.trackBunch(b,
paramsDict=paramsDict,
actionContainer=actionContainer)
#///////////////////////////////////////////////////////////
print "==============BEFORE============================"
b.dumpBunch()
print "=========================================="
#=====track action ============
def bodyAction(paramsDict):
node = paramsDict["node"]
node.track(paramsDict)
accContainer = AccActionsContainer()
accContainer.addAction(bodyAction, AccActionsContainer.BODY)
paramsDict = {}
paramsDict["bunch"] = b
lattice.trackActions(accContainer, paramsDict)
print "=============AFTER============================="
b.dumpBunch()
print "=========================================="
print "lattice length=", lattice.getLength()
print "beta=", b.getSyncParticle().beta()
print "TEAPOT time[sec]=", b.getSyncParticle().time()
print "SIMPLE time[sec]=", lattice.getLength() / (b.getSyncParticle().beta() *
2.99792458e+8)
print "Stop."
print "RFVoltage = ", RFVoltage
print "RFPhase = ", RFPhase
#///////////////////////////////////////////////////////////
print "==============BEFORE============================"
b.dumpBunch()
print "=========================================="
#=====track action ============
def bodyAction(paramsDict):
node = paramsDict["node"]
node.track(paramsDict)
accContainer = AccActionsContainer()
accContainer.addAction(bodyAction,AccActionsContainer.BODY)
paramsDict = {}
paramsDict["bunch"] = b
lattice.trackActions(accContainer,paramsDict)
print "=============AFTER============================="
b.dumpBunch()
print "=========================================="
print "lattice length=",lattice.getLength()
print "beta=",b.getSyncParticle().beta()
print "TEAPOT time[sec]=",b.getSyncParticle().time()
print "SIMPLE time[sec]=",lattice.getLength()/(b.getSyncParticle().beta()*2.99792458e+8)
print "Stop."
traj_xp_function.add(pos + pos_start, bunchI.xp(0) * 1000.)
st = "i= %3d " % paramsDict["count"] + " pos= %8.3f " % (pos + pos_start)
(x, xp, y, yp, z, dE) = (bunchI.x(0) * 1000., bunchI.xp(0) * 1000.,
bunchI.y(0) * 1000., bunchI.yp(0) * 1000.,
bunchI.z(0) * 1000., bunchI.dE(0) * 1000.)
st += " (x,xp,y,yp,z,dE) = ( %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f )" % (
x, xp, y, yp, z, dE)
(x, xp, y, yp, z, dE) = (bunchI.x(1) * 1000., bunchI.xp(1) * 1000.,
bunchI.y(1) * 1000., bunchI.yp(1) * 1000.,
bunchI.z(1) * 1000., bunchI.dE(1) * 1000.)
st += " ( %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f )" % (x, xp, y, yp, z,
dE)
print st
actionContainer.addAction(action_account, AccActionsContainer.ENTRANCE)
actionContainer.addAction(action_account, AccActionsContainer.BODY)
actionContainer.addAction(action_account, AccActionsContainer.EXIT)
print "============================================================================================"
accLattice.trackBunch(bunch_tmp,
paramsDict=paramsDict,
actionContainer=actionContainer,
index_start=start_ind,
index_stop=stop_ind)
print "============================================================================================"
print "============================ final TEAPOT bunch ==========================="
st = ""
(x, xp, y, yp, z, dE) = (bunch_tmp.x(0) * 1000., bunch_tmp.xp(0) * 1000.,
bunch_tmp.y(0) * 1000., bunch_tmp.yp(0) * 1000.,
#
bunch.deleteParticleFast(ind)
loss_part_pos_arr.append(pos)
bunch.compress()
fl_loss_pos_coord_out.flush()
eKin = bunch.getSyncParticle().kinEnergy() * 1.0e+3
s = " %5d %35s %4.5f %5.3f %5.3f %5.3f %5.3f %5.3f %5.3f %7.5f %10.6f %8d " % (
paramsDict["count"], node.getName(), pos, x_rms, y_rms, z_rms,
z_rms_deg, xp_rms, yp_rms, dE_rms, eKin, bunch.getSize())
file_out.write(s + "\n")
print s
#actionContainer.addAction(action_entrance, AccActionsContainer.ENTRANCE)
actionContainer.addAction(action_exit, AccActionsContainer.EXIT)
time_start = time.clock()
accLattice.trackBunch(bunch_in,
paramsDict=paramsDict,
actionContainer=actionContainer)
time_exec = time.clock() - time_start
print "time[sec]=", time_exec
fl_loss_pos_coord_out.close()
file_out.close()
eKin = bunch_in.getSyncParticle().kinEnergy() * 1.0e+3
twiss_analysis.analyzeBunch(bunch_in)
x_rms = math.sqrt(twiss_analysis.getTwiss(0)[1]*twiss_analysis.getTwiss(0)[3])*1000. y_rms = math.sqrt(twiss_analysis.getTwiss(1)[1]*twiss_analysis.getTwiss(1)[3])*1000. z_rms = math.sqrt(twiss_analysis.getTwiss(2)[1]*twiss_analysis.getTwiss(2)[3])*1000. z_rms_deg = bunch_gen.getZtoPhaseCoeff(bunch)*z_rms/1000.0 xp_rms = math.sqrt(twiss_analysis.getTwiss(0)[2]*twiss_analysis.getTwiss(0)[3])*1000. yp_rms = math.sqrt(twiss_analysis.getTwiss(1)[2]*twiss_analysis.getTwiss(1)[3])*1000. dE_rms = math.sqrt(twiss_analysis.getTwiss(2)[2]*twiss_analysis.getTwiss(2)[3])*1000. #emittX = twiss_analysis.getTwiss(0)[3]*1000.0*1000.0 *bunch.getSyncParticle().gamma()*bunch.getSyncParticle().beta() eKin = bunch.getSyncParticle().kinEnergy()*1.0e+3 s = " %5d %35s %4.5f %5.3f %5.3f %5.3f %5.3f %5.3f %5.3f %7.5f %10.6f %8d "%(paramsDict["count"],node.getName(),pos,x_rms,y_rms,z_rms,z_rms_deg,xp_rms,yp_rms,dE_rms,eKin,bunch.getSize()) file_out.write(s +"\n") print s #actionContainer.addAction(action_entrance, AccActionsContainer.ENTRANCE) actionContainer.addAction(action_exit, AccActionsContainer.EXIT) time_start = time.clock() accLattice.trackBunch(bunch_in, paramsDict = paramsDict, actionContainer = actionContainer) time_exec = time.clock() - time_start print "time[sec]=",time_exec file_out.close() eKin = bunch_in.getSyncParticle().kinEnergy()*1.0e+3 twiss_analysis.analyzeBunch(bunch_in) (alphaX,betaX,emittX) = (twiss_analysis.getTwiss(0)[0],twiss_analysis.getTwiss(0)[1],twiss_analysis.getTwiss(0)[3]) (alphaY,betaY,emittY) = (twiss_analysis.getTwiss(1)[0],twiss_analysis.getTwiss(1)[1],twiss_analysis.getTwiss(1)[3]) (alphaZ,betaZ,emittZ) = (twiss_analysis.getTwiss(2)[0],twiss_analysis.getTwiss(2)[1],twiss_analysis.getTwiss(2)[3])
#set up design
paramsDict = {"test_pos":0.,"count":0}
actionContainer = AccActionsContainer("Test Design Bunch Tracking")
outF = open("sns_linac_energy.dat","w")
print " N node position kinEnergy[MeV] "
def test_action(paramsDict):
node = paramsDict["node"]
length = node.getLength()
pos = paramsDict["test_pos"] + length
paramsDict["test_pos"] = pos
bunch = paramsDict["bunch"]
eKin = bunch.getSyncParticle().kinEnergy()*1.0e+3
if(node.getName().find(":Rg") >= 0):
paramsDict["count"] += 1
s = " %5d %35s %4.5f %5.3f "%(paramsDict["count"],node.getName(),(pos - length/2),eKin)
#outF.write(s+"\n")
print s
actionContainer.addAction(test_action, AccActionsContainer.EXIT)
accLattice.trackDesignBunch(b, paramsDict = paramsDict, actionContainer = actionContainer)
outF.close()
accLattice.trackBunch(b, paramsDict = paramsDict, actionContainer = actionContainer)