def setM(arr): n = len(arr) m = Matrix(n, n) for i in xrange(n): for j in xrange(n): m.set(i, j, arr[i][j]) return m
def trackOrbit(self, z0): """ Returns the tuple ([(position, x),...], [(position, y),...] ). The tracking starts from the values specified as the initial parameters. z0 fulfill: z0 = Mz0 with M as one turn matrix """ eps_length = 0.00001 # 10^-6 meter pos_arr = [] orbitX_arr = [] orbitY_arr = [] orbitXP_arr = [] orbitYP_arr = [] position = 0. pos_arr.append(position) track_o = Matrix(6, 6) track_ov = PhaseVector(6) track_ov.set(0, z0[0]) track_ov.set(1, z0[1]) track_ov.set(2, z0[2]) track_ov.set(3, z0[3]) track_ov.set(4, z0[4]) track_ov.set(5, z0[5]) orbitX_arr.append(track_ov.get(0)) orbitY_arr.append(track_ov.get(2)) orbitXP_arr.append(track_ov.get(1)) orbitYP_arr.append(track_ov.get(3)) position_old = position for matrixNode in self.getNodes(): if (isinstance(matrixNode, BaseMATRIX) == True): if (abs(position_old - position) > eps_length): pos_arr.append(position) orbitX_arr.append(track_ov.get(0)) orbitY_arr.append(track_ov.get(2)) orbitXP_arr.append(track_ov.get(1)) orbitYP_arr.append(track_ov.get(3)) mt = matrixNode.getMatrix() for i in range(6): for j in range(6): track_o.set(i, j, mt.get(i, j)) track_ov = track_o.mult(track_ov) for i in range(6): tmp = track_ov.get(i) track_ov.set(i, tmp + mt.get(i, 6)) position_old = position position = position + matrixNode.getLength() pos_arr.append(position) orbitX_arr.append(track_ov.get(0)) orbitY_arr.append(track_ov.get(2)) orbitXP_arr.append(track_ov.get(1)) orbitYP_arr.append(track_ov.get(3)) #pack the resulting tuple graph_orbitX_arr = [] graph_orbitY_arr = [] for i in range(len(pos_arr)): graph_orbitX_arr.append( (pos_arr[i], orbitX_arr[i], orbitXP_arr[i])) graph_orbitY_arr.append( (pos_arr[i], orbitY_arr[i], orbitYP_arr[i])) return (graph_orbitX_arr, graph_orbitY_arr)
def trackDispersionData(self, momentum, mass, disp, disp_p, direction="x"): """ Returns the tuple ([(position, disp),...],[(position,disp_p),...] ). The tracking starts from the values specified as the initial parameters. The possible values for direction parameter "x" or "y". """ if (direction.lower() != "x" and direction.lower() != "y"): orbitFinalize( "Class orbit.matrix_lattice.MATRIX_Lattice, method trackDispersionData(...): direction should be x or y." ) #track dispersion eps_length = 0.00001 # 10^-6 meter dir_ind = 0 if (direction.lower() == "y"): dir_ind = 2 track_m = Matrix(3, 3) track_m.unit() track_m.set(2, 0, 0.) track_m.set(2, 1, 0.) track_m.set(2, 2, 1.) track_v = PhaseVector(3) #kinematics coefficient calculation Etotal = math.sqrt(momentum**2 + mass**2) beta = momentum / Etotal gamma = Etotal / mass Ekin = Etotal - mass m_coeff = momentum * momentum / (mass + Ekin) track_v.set(0, disp) track_v.set(1, disp_p) track_v.set(2, 1.) position = 0. pos_arr = [] disp_arr = [] disp_p_arr = [] #put in array the initial dispersions #count = 0 pos_arr.append(position) disp_arr.append(track_v.get(0)) disp_p_arr.append(track_v.get(1)) for matrixNode in self.getNodes(): if (isinstance(matrixNode, BaseMATRIX) == True): mt = matrixNode.getMatrix() ind0 = 0 + dir_ind ind1 = 1 + dir_ind track_m.set(0, 0, mt.get(ind0, ind0)) track_m.set(0, 1, mt.get(ind0, ind1)) track_m.set(1, 0, mt.get(ind1, ind0)) track_m.set(1, 1, mt.get(ind1, ind1)) track_m.set(0, 2, mt.get(ind0, 5) * m_coeff) track_m.set(1, 2, mt.get(ind1, 5) * m_coeff) track_v = track_m.mult(track_v) position = position + matrixNode.getLength() #only the main nodes are used, the or-cases deal with markers with zero length if (isinstance(matrixNode, BaseMATRIX) == True): pos_arr.append(position) disp_arr.append(track_v.get(0)) disp_p_arr.append(track_v.get(1)) #pack the resulting tuple graph_disp_arr = [] graph_disp_p_arr = [] for i in range(len(pos_arr)): graph_disp_arr.append((pos_arr[i], disp_arr[i])) graph_disp_p_arr.append((pos_arr[i], disp_p_arr[i])) return (graph_disp_arr, graph_disp_p_arr)
def trackTwissData(self, alpha, beta, direction="x"): """ Returns the tuple ([(position, phase advance/2/pi),...], [(position, alpha),...],[(position,beta),...] ). The tracking starts from the values specified as the initial parameters. The possible values for direction parameter "x" or "y". """ if (direction.lower() != "x" and direction.lower() != "y"): orbitFinalize( "Class orbit.matrix_lattice.MATRIX_Lattice, method trackTwissData(...): direction should be x or y." ) #track twiss eps_length = 0.00001 # 10^-6 meter dir_ind = 0 if (direction.lower() == "y"): dir_ind = 2 gamma = (1.0 + alpha * alpha) / beta track_m = Matrix(3, 3) track_m.unit() track_v = PhaseVector(3) track_v.set(0, alpha) track_v.set(1, beta) track_v.set(2, gamma) position = 0. pos_arr = [] alpha_arr = [] beta_arr = [] #phi is for tune accumulation phi = 0. #phase advance mu_arr = [] #count = 0 pos_arr.append(position) mu_arr.append(phi) alpha_arr.append(track_v.get(0)) beta_arr.append(track_v.get(1)) for matrixNode in self.getNodes(): mt = matrixNode.getMatrix() ind0 = 0 + dir_ind ind1 = 1 + dir_ind track_m.set( 0, 0, mt.get(ind0, ind0) * mt.get(ind1, ind1) + mt.get(ind0, ind1) * mt.get(ind1, ind0)) track_m.set(0, 1, -mt.get(ind0, ind0) * mt.get(ind1, ind0)) track_m.set(0, 2, -mt.get(ind0, ind1) * mt.get(ind1, ind1)) track_m.set(1, 0, -2 * mt.get(ind0, ind0) * mt.get(ind0, ind1)) track_m.set(1, 1, mt.get(ind0, ind0) * mt.get(ind0, ind0)) track_m.set(1, 2, mt.get(ind0, ind1) * mt.get(ind0, ind1)) track_m.set(2, 0, -2 * mt.get(ind1, ind0) * mt.get(ind1, ind1)) track_m.set(2, 1, mt.get(ind1, ind0) * mt.get(ind1, ind0)) track_m.set(2, 2, mt.get(ind1, ind1) * mt.get(ind1, ind1)) alpha_0 = track_v.get(0) beta_0 = track_v.get(1) delta_phi = math.atan( mt.get(ind0, ind1) / (beta_0 * mt.get(ind0, ind0) - alpha_0 * mt.get(ind0, ind1))) phi = phi + delta_phi track_v = track_m.mult(track_v) position = position + matrixNode.getLength() if (isinstance(matrixNode, BaseMATRIX) == True): #only the main nodes are used, the or-cases deal with markers with zero length #print position, matrixNode.getParam("matrix_parent_node_active_index") == 1 #print position, matrixNode.getName(), track_v.get(1) if matrixNode.getLength() > 0: #print position, matrixNode.getName(), track_v.get(1) pos_arr.append(position) alpha_arr.append(track_v.get(0)) beta_arr.append(track_v.get(1)) mu_arr.append(phi / (2 * math.pi)) #count = count + 1 #pack the resulting tuple tune = phi / (2 * math.pi) graph_alpha_arr = [] graph_beta_arr = [] graph_mu_arr = [] #print count, len(pos_arr) for i in range(len(pos_arr)): graph_mu_arr.append((pos_arr[i], mu_arr[i])) graph_alpha_arr.append((pos_arr[i], alpha_arr[i])) graph_beta_arr.append((pos_arr[i], beta_arr[i])) return (graph_mu_arr, graph_alpha_arr, graph_beta_arr)
def _makePolynomial(self): nPoints = len(self.x_y_err_arr) if (nPoints < (self.order + 1)): self.order = nPoints - 1 #check if just one of errors is zero infoZeroErr = 1.0 for [x, y, err] in self.x_y_err_arr: infoZeroErr *= err for i in range(nPoints): [x, y, err] = self.x_y_err_arr[i] sigma = 1.0 if (infoZeroErr != 0.): sigma = 1.0 / (err * err) self.x_y_err_arr[i][2] = sigma #now make A matrix aMatr = Matrix(nPoints, self.order + 1) for i in range(nPoints): for j in range(self.order + 1): x = self.x_y_err_arr[i][0] aMatr.set(i, j, math.pow(x, j)) aTCa = Matrix(self.order + 1, self.order + 1) for i in range(self.order + 1): for j in range(self.order + 1): a = 0. for k in range(nPoints): sigma = self.x_y_err_arr[k][2] a += aMatr.get(k, i) * sigma * aMatr.get(k, j) aTCa.set(i, j, a) #now the resuting coefficients and errors aTCaI = aTCa.invert() e = aTCaI.mult(aTCa) if (aTCa == None): print "python PolynomialFit: Problem with data." for i in range(nPoints): x = self.x_y_err_arr[i][0] y = self.x_y_err_arr[i][1] err = self.x_y_err_arr[i][2] print " x,y,err = %12.5g %12.5g %12.5g " % (x, y, err) print "Stop." sys.exit(1) coef_arr = [0.] * (self.order + 1) err_arr = [0.] * (self.order + 1) for i in range(self.order + 1): err_arr[i] = math.sqrt(math.fabs(aTCaI.get(i, i))) for i in range(self.order + 1): coef_arr[i] = 0. for j in range(self.order + 1): for k in range(nPoints): sigma = self.x_y_err_arr[k][2] y = self.x_y_err_arr[k][1] coef_arr[i] += aTCaI.get(i, j) * aMatr.get(k, j) * sigma * y # polinimial coefficients are found self.polynomial.order(self.order) for i in range(len(coef_arr)): self.polynomial.coefficient(i, coef_arr[i]) # now let's calculate errors if (infoZeroErr == 0.): total_sigma = 0. for k in range(nPoints): x = self.x_y_err_arr[k][0] y = self.x_y_err_arr[k][1] total_sigma += (self.polynomial.value(x) - y)**2 total_sigma = math.sqrt(total_sigma / (nPoints - 2)) for i in range(len(err_arr)): err_arr[i] *= total_sigma # set the resulting coefficients and errors array self.coef_err_arr = [coef_arr, err_arr]
print "Start." n = Nll() k = .01 b = Bunch() b.addParticle(1., 2., 3., 4., 5., 6.) b.dumpBunch() m = Matrix(6, 6) m.unit() m.set(0, 0, math.cos(k)) m.set(0, 1, math.sin(k)) m.set(1, 0, -math.sin(k)) m.set(1, 1, math.cos(k)) m.set(2, 2, math.cos(k)) m.set(2, 3, math.sin(k)) m.set(3, 2, -math.sin(k)) m.set(3, 3, math.cos(k)) printM(m) for i in range(20000): m.track(b) n.TRACK_EXT(b) plotx.append([b.x(0), b.y(0)]) #ploty.append([b.y(0), b.yp(0)]); ploty.append([b.x(0), b.y(0)])
random.random(), random.random(), random.random()) b_in.addParticle(x, xp, y, yp, z, dE) if (b_in_has_ms): b_in.partAttrValue("macrosize", i, 0, random.random()) b_in.addParticle(0., 0., 0., 0., 0., 0.) #----set up ids ParticleIdNumber.addParticleIdNumbers(b_in) b_out = Bunch() b_in.copyEmptyBunchTo(b_out) #-----set up initial transport matix, later we have to extract it from bunches mtrxA_init = Matrix(7, 7) mtrxA_init.zero() for ix in range(6): mtrxA_init.set(ix, 6, 1.0 * ix) mtrxA_init.set(6, 6, 1.0) for ix in range(6): mtrxA_init.set(ix, ix, 1. * (ix + 1)) mtrxA_init.set(0, 1, 1.5 * .001) mtrxA_init.set(2, 3, 1.6 * .001) mtrxA_init.set(4, 5, 1.7 * .001) mtrxA_init.set(1, 0, 1.4 * .001) mtrxA_init.set(3, 2, 1.3 * .001) mtrxA_init.set(5, 4, 1.2 * .001) printM(mtrxA_init, "Init M ") #-----------------------------------------------------------------------------
qv01_pos_start = accLattice.getNodePositionsDict()[accLattice.getNodeForName( "QV01")][0] qh02_pos_start = accLattice.getNodePositionsDict()[accLattice.getNodeForName( "QH02")][0] qv03_pos_start = accLattice.getNodePositionsDict()[accLattice.getNodeForName( "QV03")][0] qh04_pos_start = accLattice.getNodePositionsDict()[accLattice.getNodeForName( "QH04")][0] qv01_pos_center = (qv01_pos_start + qv01_pos_end) / 2.0 #---- qv01_3d coordinate transformation from the lattice system transfCoordsMatrix = Matrix(4, 4) transfCoordsMatrix.unit() dist_from_qv01_center = 0. transfCoordsMatrix.set(2, 3, -dist_from_qv01_center) qv01_3d.transormfMatrix(transfCoordsMatrix) #---- qh02_3d coordinate transformation from the lattice system transfCoordsMatrix = Matrix(4, 4) transfCoordsMatrix.unit() dist_from_qv01_center = qh02_pos_end - qv01_pos_end transfCoordsMatrix.set(2, 3, -dist_from_qv01_center) qh02_3d.transormfMatrix(transfCoordsMatrix) #---- qv03_3d coordinate transformation from the lattice system transfCoordsMatrix = Matrix(4, 4) transfCoordsMatrix.unit() dist_from_qv01_center = qv03_pos_end - qv01_pos_end transfCoordsMatrix.set(2, 3, -dist_from_qv01_center) qv03_3d.transormfMatrix(transfCoordsMatrix)
while ( s != ""): if(len(s_arr) < stack_size): s_arr.append(s) else: #======= we have the full stack of lines =========== if(s_arr[1].find("Element transfer matrix:") >= 0): res_arr = s_arr[0].split() name = res_arr[len(res_arr) - 2][1:] elem_count = elem_count + 1 #print "i=",elem_count," name=",name matrix = Matrix(6,6) for i in range(6): res_arr = s_arr[i+2].split() for j in range(6): matrix.set(i,j, float(res_arr[j])) #printM(matrix) lattice_arr.append((name,matrix)) for it in range(stack_size-1): s_arr[it] = s_arr[it+1] s_arr[stack_size-1] = s #print "debug s=",s s = inF.readline() inF.close() mad_matrix = Matrix(6,6) mad_matrix.unit() n_max = len(lattice_arr) #n_max = 74 for i in range(n_max):
def _makePolynomial(self): nPoints = len(self.x_y_err_arr) if(nPoints < (self.order+1)): self.order = nPoints - 1 #check if just one of errors is zero infoZeroErr = 1.0 for [x,y,err] in self.x_y_err_arr: infoZeroErr *= err for i in range(nPoints): [x,y,err] = self.x_y_err_arr[i] sigma = 1.0 if(infoZeroErr != 0.): sigma = 1.0/(err*err) self.x_y_err_arr[i][2] = sigma #now make A matrix aMatr = Matrix(nPoints,self.order+1) for i in range(nPoints): for j in range(self.order+1): x = self.x_y_err_arr[i][0] aMatr.set(i,j,math.pow(x,j)) aTCa = Matrix(self.order+1,self.order+1) for i in range(self.order+1): for j in range(self.order+1): a = 0. for k in range(nPoints): sigma = self.x_y_err_arr[k][2] a += aMatr.get(k,i)*sigma*aMatr.get(k,j) aTCa.set(i,j,a) #now the resuting coefficients and errors aTCaI = aTCa.invert() e = aTCaI.mult(aTCa) if(aTCa == None): print "python PolynomialFit: Problem with data." for i in range(nPoints): x = self.x_y_err_arr[i][0] y = self.x_y_err_arr[i][1] err = self.x_y_err_arr[i][2] print " x,y,err = %12.5g %12.5g %12.5g "%(x,y,err) print "Stop." sys.exit(1) coef_arr = [0.]*(self.order+1) err_arr = [0.]*(self.order+1) for i in range(self.order+1): err_arr[i] = math.sqrt(math.fabs(aTCaI.get(i,i))) for i in range(self.order+1): coef_arr[i] = 0. for j in range(self.order+1): for k in range(nPoints): sigma = self.x_y_err_arr[k][2] y = self.x_y_err_arr[k][1] coef_arr[i] += aTCaI.get(i,j)*aMatr.get(k,j)*sigma*y # polinimial coefficients are found self.polynomial.order(self.order) for i in range(len(coef_arr)): self.polynomial.coefficient(i,coef_arr[i]) # now let's calculate errors if(infoZeroErr == 0.): total_sigma = 0. for k in range(nPoints): x = self.x_y_err_arr[k][0] y = self.x_y_err_arr[k][1] total_sigma += (self.polynomial.value(x)-y)**2 total_sigma = math.sqrt(total_sigma/(nPoints-2)) for i in range(len(err_arr)): err_arr[i] *= total_sigma # set the resulting coefficients and errors array self.coef_err_arr = [coef_arr,err_arr]
b_in = Bunch() for i in range(nParticles): (x,xp,y,yp,z,dE) = (random.random(),random.random(),random.random(),random.random(),random.random(),random.random()) b_in.addParticle(x,xp,y,yp,z,dE) #----set up ids ParticleIdNumber.addParticleIdNumbers(b_in) b_out = Bunch() b_in.copyEmptyBunchTo(b_out) #-----set up initial transport matix, later we have to extract it from bunches mtrxA_init = Matrix(7,7) mtrxA_init.zero() for ix in range(6): mtrxA_init.set(ix,6,1.0*ix) mtrxA_init.set(6,6,1.0) for ix in range(6): mtrxA_init.set(ix,ix,1.*(ix+1)) printM(mtrxA_init, "Init M ") #----------------------------------------------------------------------------- #------ put particles from b_in bunch to b_out noise_level = 0.000001 for i in range(nParticles): coord_arr = (b_in.x(i),b_in.xp(i),b_in.y(i),b_in.yp(i),b_in.z(i),b_in.dE(i)) coord_arr_res = [0.,0.,0.,0.,0.,0.] for ix in range(6): coord_arr_res[ix] = mtrxA_init.get(ix,6) for iy in range(6): coord_arr_res[ix] += mtrxA_init.get(ix,iy)*coord_arr[iy] coord_arr_res[ix] += noise_level*random.random()
bunch = Bunch() bunch_in.copyBunchTo(bunch) accLattice.trackBunch(bunch, None, None, bnch02_ind) transportMtrxFromInitCoords(bunch, trMtrx, use_twiss_weight_x, use_twiss_weight_y, use_twiss_weight_z) 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 #----transformation from [m] to [deg] and from [GeV] to [MeV] for z, phi and dE trMtrx.set(4, 4 + 1, trMtrx.get(4, 4 + 1) * z_to_phase_coeff / 1000.) trMtrx.set(4 + 1, 4, trMtrx.get(4 + 1, 4) * 1000. / z_to_phase_coeff) mz11 = trMtrx.get(4, 4) mz12 = trMtrx.get(4, 4 + 1) #---------------------------------------------------------- det_z = trMtrx.get(0 + 4, 0 + 4) * trMtrx.get(1 + 4, 1 + 4) - trMtrx.get( 1 + 4, 0 + 4) * trMtrx.get(0 + 4, 1 + 4) res_sizes_trMtrx_arr.append([E0TL, z_rms_deg, z_rms_exp, mz11, mz12]) print "E0TL[keV] = %5.1f (z_rms,z_rms_exp) = %5.3f %5.1f det(TrMtrxZ) = %5.4f " % ( E0TL * 1.0e+6, z_rms_deg, z_rms_exp, det_z) #------------------- #-------------------------------------------------------------- #----------- LSQ method for Longitudinal Twiss parameters #-------------------------------------------------------------- n_cases = len(res_sizes_trMtrx_arr)
def trackDispersionData(self,momentum,mass, disp, disp_p, direction = "x"): """ Returns the tuple ([(position, disp),...],[(position,disp_p),...] ). The tracking starts from the values specified as the initial parameters. The possible values for direction parameter "x" or "y". """ if(direction.lower() != "x" and direction.lower() != "y"): orbitFinalize("Class orbit.matrix_lattice.MATRIX_Lattice, method trackDispersionData(...): direction should be x or y.") #track dispersion eps_length = 0.00001 # 10^-6 meter dir_ind = 0 if(direction.lower() == "y"): dir_ind = 2 track_m = Matrix(3,3) track_m.unit() track_m.set(2,0,0.) track_m.set(2,1,0.) track_m.set(2,2,1.) track_v = PhaseVector(3) #kinematics coefficient calculation Etotal = math.sqrt(momentum**2 + mass**2) beta = momentum/Etotal gamma = Etotal/mass Ekin = Etotal - mass m_coeff = momentum*momentum/(mass + Ekin) track_v.set(0,disp) track_v.set(1,disp_p) track_v.set(2,1.) position = 0. pos_arr = [] disp_arr = [] disp_p_arr = [] #put in array the initial dispersions pos_arr.append(position) disp_arr.append(track_v.get(0)) disp_p_arr.append(track_v.get(1)) position_old = position disp_old = disp #count = 0 for matrixNode in self.getNodes(): if(isinstance(matrixNode,BaseMATRIX) == True): disp = track_v.get(0) if(abs(position_old-position) > eps_length or abs(disp_old - disp) > eps_length): pos_arr.append(position) disp_arr.append(track_v.get(0)) disp_p_arr.append(track_v.get(1)) disp_old = disp position_old = position mt = matrixNode.getMatrix() ind0 = 0+dir_ind ind1 = 1+dir_ind track_m.set(0,0,mt.get(ind0,ind0)) track_m.set(0,1,mt.get(ind0,ind1)) track_m.set(1,0,mt.get(ind1,ind0)) track_m.set(1,1,mt.get(ind1,ind1)) track_m.set(0,2,mt.get(ind0,5)*m_coeff) track_m.set(1,2,mt.get(ind1,5)*m_coeff) track_v = track_m.mult(track_v) position = position + matrixNode.getLength() pos_arr.append(position) disp_arr.append(track_v.get(0)) disp_p_arr.append(track_v.get(1)) #pack the resulting tuple graph_disp_arr = [] graph_disp_p_arr = [] for i in range(len(pos_arr)): graph_disp_arr.append((pos_arr[i],disp_arr[i])) graph_disp_p_arr.append((pos_arr[i],disp_p_arr[i])) return (graph_disp_arr,graph_disp_p_arr)
def trackTwissData(self, alpha, beta, direction = "x"): """ Returns the tuple ([(position, phase advance/2/pi),...], [(position, alpha),...],[(position,beta),...] ). The tracking starts from the values specified as the initial parameters. The possible values for direction parameter "x" or "y". """ if(direction.lower() != "x" and direction.lower() != "y"): orbitFinalize("Class orbit.matrix_lattice.MATRIX_Lattice, method trackTwissData(...): direction should be x or y.") #track twiss eps_length = 0.00001 # 10^-6 meter dir_ind = 0 if(direction.lower() == "y"): dir_ind = 2 gamma = (1.0+alpha*alpha)/beta track_m = Matrix(3,3) track_m.unit() track_v = PhaseVector(3) track_v.set(0,alpha) track_v.set(1,beta) track_v.set(2,gamma) position = 0. pos_arr = [] alpha_arr = [] beta_arr = [] #phi is for tune accumulation phi = 0. #phase advance mu_arr = [] #put in array the initial twiss pos_arr.append(position) mu_arr.append(phi) alpha_arr.append(track_v.get(0)) beta_arr.append(track_v.get(1)) position_old = position beta_old = beta #count = 0 for matrixNode in self.getNodes(): if(isinstance(matrixNode,BaseMATRIX) == True): beta = track_v.get(1) if(abs(position_old-position) > eps_length or abs(beta_old - beta) > eps_length): pos_arr.append(position) alpha_arr.append(track_v.get(0)) beta_arr.append(track_v.get(1)) mu_arr.append(phi/(2*math.pi)) mt = matrixNode.getMatrix() ind0 = 0+dir_ind ind1 = 1+dir_ind track_m.set(0,0,mt.get(ind0,ind0)*mt.get(ind1,ind1)+mt.get(ind0,ind1)*mt.get(ind1,ind0)) track_m.set(0,1,-mt.get(ind0,ind0)*mt.get(ind1,ind0)) track_m.set(0,2,-mt.get(ind0,ind1)*mt.get(ind1,ind1)) track_m.set(1,0,-2*mt.get(ind0,ind0)*mt.get(ind0,ind1)) track_m.set(1,1,mt.get(ind0,ind0)*mt.get(ind0,ind0)) track_m.set(1,2,mt.get(ind0,ind1)*mt.get(ind0,ind1)) track_m.set(2,0,-2*mt.get(ind1,ind0)*mt.get(ind1,ind1)) track_m.set(2,1,mt.get(ind1,ind0)*mt.get(ind1,ind0)) track_m.set(2,2,mt.get(ind1,ind1)*mt.get(ind1,ind1)) alpha_0 = track_v.get(0) beta_0 = track_v.get(1) delta_phi = math.atan( mt.get(ind0,ind1)/( beta_0*mt.get(ind0,ind0) - alpha_0*mt.get(ind0,ind1))) phi = phi + delta_phi track_v = track_m.mult(track_v) position_old = position beta_old = beta_0 position = position + matrixNode.getLength() #count = count + 1 pos_arr.append(position) alpha_arr.append(track_v.get(0)) beta_arr.append(track_v.get(1)) mu_arr.append(phi/(2*math.pi)) #pack the resulting tuple tune = phi/(2*math.pi) graph_alpha_arr = [] graph_beta_arr = [] graph_mu_arr = [] for i in range(len(pos_arr)): graph_mu_arr.append((pos_arr[i], mu_arr[i])) graph_alpha_arr.append((pos_arr[i],alpha_arr[i])) graph_beta_arr.append((pos_arr[i],beta_arr[i])) return (graph_mu_arr,graph_alpha_arr,graph_beta_arr)
g1 = g_func.y(ind) z_avg = (z1+z0)/2 g_avg = (g0+g1)/2 g_avg *= charge dL = z1-z0 #print "debug dL=",dL, " y= %12.3f "%y_avg #---- this is a transport 4x4 matrix for coordinates x,x',y,y' trMtrx = Matrix(4,4) k2 = abs(g_avg/Brho) kq = math.sqrt(k2) sin_kL = math.sin(kq*dL) cos_kL = math.cos(kq*dL) sinh_kL = math.sinh(kq*dL) cosh_kL = math.cosh(kq*dL) if(g_avg == 0.): trMtrx.set(0,0,1.) trMtrx.set(1,1,1.) trMtrx.set(2,2,1.) trMtrx.set(3,3,1.) trMtrx.set(0,1,dL) trMtrx.set(2,3,dL) else: if(g_avg > 0.): trMtrx.set(0,0,cos_kL) trMtrx.set(1,1,cos_kL) trMtrx.set(0,1,sin_kL/kq) trMtrx.set(1,0,-kq*sin_kL) #------------------------- trMtrx.set(2,2,cosh_kL) trMtrx.set(3,3,cosh_kL) trMtrx.set(2,3,sinh_kL/kq)