def addTeapotApertureNode(lattice, position, Aperture_node):
"""
It will put one Teapot Aperture node in the lattice
"""
length_tolerance = 0.0001
lattice.initialize()
if (position > lattice.getLength()):
position = lattice.getLength()
print "User-specified aperture position is larger than lattice length. Resetting it to lattice length."
Aperture_node.setPosition(position)
position_start = position
position_stop = position + Aperture_node.getLength()
(node_start_ind, node_stop_ind, z, ind) = (-1, -1, 0., 0)
for node in lattice.getNodes():
if (position_start >= z and position_start <= z + node.getLength()):
node_start_ind = ind
if (position_stop >= z and position_stop <= z + node.getLength()):
node_stop_ind = ind
ind += 1
z += node.getLength()
#-------now we check that between start and end we have only non-modified drift elements
#-------if the space charge was added first - that is a problem. The collimation should be added first.
for node in lattice.getNodes()[node_start_ind:node_stop_ind + 1]:
#print "debug node=",node.getName()," type=",node.getType()," L=",node.getLength()
if (not isinstance(node, DriftTEAPOT)):
print "Non-drift node=", node.getName(), " type=", node.getType(
), " L=", node.getLength()
orbitFinalize(
"We have non-drift element at the place of the Aperture node! Stop!"
)
#if(node.getNumberOfChildren() != 4):
#print "Node=",node.getName()," type=",node.getType()," L=",node.getLength()," N children nodes=",node.getNumberOfChildren()
#orbitFinalize("Drift element was modified with additional functionality (SC or something else)! Add collimation first! Stop!")
# make array of nodes from Aperture node in the center and possible two drifts if their length is more than length_tollerance [m]
nodes_new_arr = [
Aperture_node,
]
drift_node_start = lattice.getNodes()[node_start_ind]
drift_node_stop = lattice.getNodes()[node_stop_ind]
#------now we will create two drift nodes: before the Aperture node and after
#------if the length of one of these additional drifts less than length_tollerance [m] we skip this drift
if (position_start > lattice.getNodePositionsDict()[drift_node_start][0] +
length_tolerance):
drift_node_start_new = DriftTEAPOT(drift_node_start.getName())
drift_node_start_new.setLength(
position_start -
lattice.getNodePositionsDict()[drift_node_start][0])
nodes_new_arr.insert(0, drift_node_start_new)
if (position_stop < lattice.getNodePositionsDict()[drift_node_stop][1] -
length_tolerance):
drift_node_stop_new = DriftTEAPOT(drift_node_stop.getName())
drift_node_stop_new.setLength(
lattice.getNodePositionsDict()[drift_node_stop][1] - position_stop)
nodes_new_arr.append(drift_node_stop_new)
#------ now we will modify the lattice by replacing the found part with the new nodes
lattice.getNodes()[node_start_ind:node_stop_ind + 1] = nodes_new_arr
# initialize the lattice
lattice.initialize()
def addRFNode(lattice, position, rf_node):
"""
This will put one rf cavity node in the lattice
"""
length_tolerance = 0.0001
lattice.initialize()
position_start = position
position_stop = position + rf_node.getLength()
(node_start_ind, node_stop_ind, z, ind) = (-1, -1, 0., 0)
for node in lattice.getNodes():
if(position_start >= z and\
position_start <= z + node.getLength()):
node_start_ind = ind
if(position_stop >= z and\
position_stop <= z + node.getLength()):
node_stop_ind = ind
ind += 1
z += node.getLength()
#-------Now we check that between start and end
#-------we have only non-modified drift elements
#-------If the rf was added first - that is a problem.
#-------The collimation should be added first.
for node in lattice.getNodes()[node_start_ind:node_stop_ind + 1]:
#print "debug node = ", node.getName(),\
#" type = ", node.getType()," L = ", node.getLength()
if (not isinstance(node, DriftTEAPOT)):
print "Non-drift node = ", node.getName(),\
" type = ", node.getType()," L = ", node.getLength()
orbitFinalize("We have a non-drift element at the\
location of the rf node! Stop!")
# Make array of nodes from rf node in the center and possibly
# two drifts if their length is more than length_tollerance [m]
nodes_new_arr = [
rf_node,
]
drift_node_start = lattice.getNodes()[node_start_ind]
drift_node_stop = lattice.getNodes()[node_stop_ind]
#-------Now we create two drift nodes surrounding the rf node.
#-------If the length of one of these additional drifts is
#-------less than length_tollerance [m] we skip this drift
if(position_start > lattice.getNodePositionsDict()\
[drift_node_start][0] + length_tolerance):
drift_node_start_new = DriftTEAPOT(drift_node_start.getName())
drift_node_start_new.setLength(position_start\
- lattice.getNodePositionsDict()[drift_node_start][0])
nodes_new_arr.insert(0, drift_node_start_new)
if(position_stop < lattice.getNodePositionsDict()\
[drift_node_stop][1] - length_tolerance):
drift_node_stop_new = DriftTEAPOT(drift_node_stop.getName())
drift_node_stop_new.setLength(lattice.getNodePositionsDict\
()[drift_node_stop][1] - position_stop)
nodes_new_arr.append(drift_node_stop_new)
#-------Now modify the lattice by replacing the chosen part
#-------by the new nodes
lattice.getNodes()[node_start_ind:node_stop_ind + 1] = nodes_new_arr
# initialize the lattice
lattice.initialize()
def addTeapotDiagnosticsNode(lattice, position, diagnostics_node):
"""
It will put one Teapot diagnostics node in the lattice
"""
length_tollerance = 0.0001
lattice.initialize()
position_start = position
position_stop = position + diagnostics_node.getLength()
diagnostics_node.setPosition(position)
diagnostics_node.setLatticeLength(lattice.getLength())
(node_start_ind, node_stop_ind, z, ind) = (-1, -1, 0., 0)
for node in lattice.getNodes():
if (position_start >= z and position_start <= z + node.getLength()):
node_start_ind = ind
if (position_stop >= z and position_stop <= z + node.getLength()):
node_stop_ind = ind
ind += 1
z += node.getLength()
#-------now we check that between start and end we have only non-modified drift elements
#-------if the space charge was added first - that is a problem. The collimation should be added first.
for node in lattice.getNodes()[node_start_ind:node_stop_ind + 1]:
#print "debug node=",node.getName()," type=",node.getType()," L=",node.getLength()
if (not isinstance(node, DriftTEAPOT)):
print "Non-drift node=", node.getName(), " type=", node.getType(
), " L=", node.getLength()
orbitFinalize(
"We have non-drift element at the place of the diagnostics! Stop!"
)
# make array of nodes from diagnostics in the center and possible two drifts if their length is more than length_tollerance [m]
nodes_new_arr = [
diagnostics_node,
]
drift_node_start = lattice.getNodes()[node_start_ind]
drift_node_stop = lattice.getNodes()[node_stop_ind]
#------now we will create two drift nodes: before the diagnostics and after
#------if the length of one of these additional drifts less than length_tollerance [m] we skip this drift
if (position_start > lattice.getNodePositionsDict()[drift_node_start][0] +
length_tollerance):
drift_node_start_new = DriftTEAPOT(drift_node_start.getName())
drift_node_start_new.setLength(
position_start -
lattice.getNodePositionsDict()[drift_node_start][0])
nodes_new_arr.insert(0, drift_node_start_new)
if (position_stop < lattice.getNodePositionsDict()[drift_node_stop][1] -
length_tollerance):
drift_node_stop_new = DriftTEAPOT(drift_node_stop.getName())
drift_node_stop_new.setLength(
lattice.getNodePositionsDict()[drift_node_stop][1] - position_stop)
nodes_new_arr.append(drift_node_stop_new)
#------ now we will modify the lattice by replacing the found part with the new nodes
lattice.getNodes()[node_start_ind:node_stop_ind + 1] = nodes_new_arr
# initialize the lattice
lattice.initialize()
def addTeapotCollimatorNode(lattice, position, collimator_node):
"""
It will put one Teapot collimation node in the lattice
"""
length_tolerance = 0.0001
lattice.initialize()
if(position > lattice.getLength() ):
position = lattice.getLength();
print "User-specified aperture position is larger than lattice length. Resetting it to lattice length."
collimator_node.setPosition(position);
position_start = position
position_stop = position + collimator_node.getLength()
(node_start_ind,node_stop_ind,z,ind) = (-1,-1, 0., 0)
for node in lattice.getNodes():
if(position_start >= z and position_start <= z + node.getLength()):
node_start_ind = ind
if(position_stop >= z and position_stop <= z + node.getLength()):
node_stop_ind = ind
ind += 1
z += node.getLength()
#-------now we check that between start and end we have only non-modified drift elements
#-------if the space charge was added first - that is a problem. The collimation should be added first.
for node in lattice.getNodes()[node_start_ind:node_stop_ind+1]:
#print "debug node=",node.getName()," type=",node.getType()," L=",node.getLength()
if(not isinstance(node,DriftTEAPOT)):
print "Non-drift node=",node.getName()," type=",node.getType()," L=",node.getLength()
orbitFinalize("We have non-drift element at the place of the collimator! Stop!")
#if(node.getNumberOfChildren() != 4):
#print "Node=",node.getName()," type=",node.getType()," L=",node.getLength()," N children nodes=",node.getNumberOfChildren()
#orbitFinalize("Drift element was modified with additional functionality (SC or something else)! Add collimation first! Stop!")
# make array of nodes from collimator in the center and possible two drifts if their length is more than length_tolerance [m]
nodes_new_arr = [collimator_node,]
drift_node_start = lattice.getNodes()[node_start_ind]
drift_node_stop = lattice.getNodes()[node_stop_ind]
#------now we will create two drift nodes: before the collimator and after
#------if the length of one of these additional drifts less than length_tollerance [m] we skip this drift
if(position_start > lattice.getNodePositionsDict()[drift_node_start][0] + length_tolerance):
drift_node_start_new = DriftTEAPOT(drift_node_start.getName())
drift_node_start_new.setLength(position_start - lattice.getNodePositionsDict()[drift_node_start][0])
nodes_new_arr.insert(0,drift_node_start_new)
if(position_stop < lattice.getNodePositionsDict()[drift_node_stop][1] - length_tolerance):
drift_node_stop_new = DriftTEAPOT(drift_node_stop.getName())
drift_node_stop_new.setLength(lattice.getNodePositionsDict()[drift_node_stop][1] - position_stop)
nodes_new_arr.append(drift_node_stop_new)
#------ now we will modify the lattice by replacing the found part with the new nodes
lattice.getNodes()[node_start_ind:node_stop_ind+1] = nodes_new_arr
# initialize the lattice
lattice.initialize()
def addTeapotDiagnosticsNode(lattice, position, diagnostics_node):
"""
It will put one Teapot diagnostics node in the lattice
"""
length_tollerance = 0.0001
lattice.initialize()
position_start = position
position_stop = position + diagnostics_node.getLength()
diagnostics_node.setPosition(position)
diagnostics_node.setLatticeLength(lattice.getLength())
(node_start_ind,node_stop_ind,z,ind) = (-1,-1, 0., 0)
for node in lattice.getNodes():
if(position_start >= z and position_start <= z + node.getLength()):
node_start_ind = ind
if(position_stop >= z and position_stop <= z + node.getLength()):
node_stop_ind = ind
ind += 1
z += node.getLength()
#-------now we check that between start and end we have only non-modified drift elements
#-------if the space charge was added first - that is a problem. The collimation should be added first.
for node in lattice.getNodes()[node_start_ind:node_stop_ind+1]:
#print "debug node=",node.getName()," type=",node.getType()," L=",node.getLength()
if(not isinstance(node,DriftTEAPOT)):
print "Non-drift node=",node.getName()," type=",node.getType()," L=",node.getLength()
orbitFinalize("We have non-drift element at the place of the diagnostics! Stop!")
# make array of nodes from diagnostics in the center and possible two drifts if their length is more than length_tollerance [m]
nodes_new_arr = [diagnostics_node,]
drift_node_start = lattice.getNodes()[node_start_ind]
drift_node_stop = lattice.getNodes()[node_stop_ind]
#------now we will create two drift nodes: before the diagnostics and after
#------if the length of one of these additional drifts less than length_tollerance [m] we skip this drift
if(position_start > lattice.getNodePositionsDict()[drift_node_start][0] + length_tollerance):
drift_node_start_new = DriftTEAPOT(drift_node_start.getName())
drift_node_start_new.setLength(position_start - lattice.getNodePositionsDict()[drift_node_start][0])
nodes_new_arr.insert(0,drift_node_start_new)
if(position_stop < lattice.getNodePositionsDict()[drift_node_stop][1] - length_tollerance):
drift_node_stop_new = DriftTEAPOT(drift_node_stop.getName())
drift_node_stop_new.setLength(lattice.getNodePositionsDict()[drift_node_stop][1] - position_stop)
nodes_new_arr.append(drift_node_stop_new)
#------ now we will modify the lattice by replacing the found part with the new nodes
lattice.getNodes()[node_start_ind:node_stop_ind+1] = nodes_new_arr
# initialize the lattice
lattice.initialize()
#---PRINT Function for Matrix
def printM(m):
print "----matrix--- size=",m.size()
for i in xrange(m.size()[0]):
for j in xrange(m.size()[1]):
print ("(%1d,%1d)=% 6.5e "%(i,j,m.get(i,j))),
print ""
b = Bunch()
Ekin = 1.0 # in GeV
b.getSyncParticle().kinEnergy(Ekin)
#define TEAPOT drift
node0 = DriftTEAPOT("drift")
node0.setLength(1.0)
#define TEAPOT quad
node1 = QuadTEAPOT("quad")
node1.setLength(1.0)
node1.addParam("kq",0.5)
matrixGenerator = MatrixGenerator()
#========matrix for drift =====
m = Matrix(6,6)
matrixGenerator.initBunch(b)
node0.trackBunch(b)
matrixGenerator.calculateMatrix(b,m)
print "drift matrix L=",node0.getLength()
printM(m)
def addErrorNode(lattice, position, Error_Node):
"""
This will put one error node into the lattice
"""
length_tolerance = 0.0001
lattice.initialize()
position_start = position
position_stop = position + Error_Node.getLength()
(node_start_ind, node_stop_ind, z, ind) = (-1, -1, 0.0, 0)
for node in lattice.getNodes():
if (position_start >= z and position_start <= z + node.getLength()):
node_start_ind = ind
if (position_stop >= z and position_stop <= z + node.getLength()):
node_stop_ind = ind
ind += 1
z += node.getLength()
"""
Check that between start and end there are only non-modified
drift elements. If space charge was added first - that is a problem.
The collimation should be added first.
"""
for node in lattice.getNodes()[node_start_ind:node_stop_ind + 1]:
"""
print "debug node = ", node.getName(), " type = ", node.getType(),\
" L = ", node.getLength()
"""
if (not isinstance(node, DriftTEAPOT)):
print "Non-drift node = ", node.getName(), " type = ",\
node.getType(), " L = ", node.getLength()
orbitFinalize("We have non-drift element at the place of \
the error node! Stop!")
"""
if(node.getNumberOfChildren() != 4):
print "Node = ", node.getName()," type = ", node.getType(),\
" L = ", node.getLength(), " N child nodes = ",\
node.getNumberOfChildren()
orbitFinalize("Drift element was modified with additional \
functionality (SC or something else)! Add collimation first! \
Stop!")
"""
"""
Make array of nodes with error node in the center and two possible drifts,
if their length is more than length_tollerance [m]
"""
nodes_new_arr = [
Error_Node,
]
drift_node_start = lattice.getNodes()[node_start_ind]
drift_node_stop = lattice.getNodes()[node_stop_ind]
"""
Now create two drift nodes: before and after the error node.
If the length of either of these additional drifts is less than
length_tollerance [m], skip this drift.
"""
if(position_start > lattice.getNodePositionsDict()[drift_node_start][0] +\
length_tolerance):
drift_node_start_new = DriftTEAPOT(drift_node_start.getName())
drift_node_start_new.setLength(position_start -\
lattice.getNodePositionsDict()[drift_node_start][0])
nodes_new_arr.insert(0, drift_node_start_new)
if(position_stop < lattice.getNodePositionsDict()[drift_node_stop][1] -\
length_tolerance):
drift_node_stop_new = DriftTEAPOT(drift_node_stop.getName())
drift_node_stop_new.setLength(lattice.getNodePositionsDict()[drift_node_stop][1] -\
position_stop)
nodes_new_arr.append(drift_node_stop_new)
"""
Now modify the lattice by replacing the old part with the new nodes
"""
lattice.getNodes()[node_start_ind:node_stop_ind + 1] = nodes_new_arr
"""
Initialize the lattice
"""
lattice.initialize()
def addErrorNode(lattice, position, Error_Node):
"""
This will put one error node into the lattice
"""
length_tolerance = 0.0001
lattice.initialize()
position_start = position
position_stop = position + Error_Node.getLength()
(node_start_ind, node_stop_ind, z, ind) = (-1, -1, 0.0, 0)
for node in lattice.getNodes():
if(position_start >= z and position_start <= z + node.getLength()):
node_start_ind = ind
if(position_stop >= z and position_stop <= z + node.getLength()):
node_stop_ind = ind
ind += 1
z += node.getLength()
"""
Check that between start and end there are only non-modified
drift elements. If space charge was added first - that is a problem.
The collimation should be added first.
"""
for node in lattice.getNodes()[node_start_ind:node_stop_ind + 1]:
"""
print "debug node = ", node.getName(), " type = ", node.getType(),\
" L = ", node.getLength()
"""
if(not isinstance(node, DriftTEAPOT)):
print "Non-drift node = ", node.getName(), " type = ",\
node.getType(), " L = ", node.getLength()
orbitFinalize("We have non-drift element at the place of \
the error node! Stop!")
"""
if(node.getNumberOfChildren() != 4):
print "Node = ", node.getName()," type = ", node.getType(),\
" L = ", node.getLength(), " N child nodes = ",\
node.getNumberOfChildren()
orbitFinalize("Drift element was modified with additional \
functionality (SC or something else)! Add collimation first! \
Stop!")
"""
"""
Make array of nodes with error node in the center and two possible drifts,
if their length is more than length_tollerance [m]
"""
nodes_new_arr = [Error_Node,]
drift_node_start = lattice.getNodes()[node_start_ind]
drift_node_stop = lattice.getNodes()[node_stop_ind]
"""
Now create two drift nodes: before and after the error node.
If the length of either of these additional drifts is less than
length_tollerance [m], skip this drift.
"""
if(position_start > lattice.getNodePositionsDict()[drift_node_start][0] +\
length_tolerance):
drift_node_start_new = DriftTEAPOT(drift_node_start.getName())
drift_node_start_new.setLength(position_start -\
lattice.getNodePositionsDict()[drift_node_start][0])
nodes_new_arr.insert(0, drift_node_start_new)
if(position_stop < lattice.getNodePositionsDict()[drift_node_stop][1] -\
length_tolerance):
drift_node_stop_new = DriftTEAPOT(drift_node_stop.getName())
drift_node_stop_new.setLength(lattice.getNodePositionsDict()[drift_node_stop][1] -\
position_stop)
nodes_new_arr.append(drift_node_stop_new)
"""
Now modify the lattice by replacing the old part with the new nodes
"""
lattice.getNodes()[node_start_ind:node_stop_ind + 1] = nodes_new_arr
"""
Initialize the lattice
"""
lattice.initialize()
