diff --git a/ess/SP_Relativity.py b/ess/SP_Relativity.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbdc9169252eed1f3ca5280b6a5601cb22403c6f
--- /dev/null
+++ b/ess/SP_Relativity.py
@@ -0,0 +1,128 @@
+'''
+renamed variables not to have a variable with the same name as the fuction the variable is used within
+-- ME. 2018-07-23
+'''
+def beta(energy: float, mass=938.2720813):
+ '''
+ Parameters
+ ----------
+ energy: float
+ kinetic energy of the particle in MeV/c2
+ mass: float
+ mass of the moving particle, optional, if not given mass of proton is used
+
+ Returns
+ -------
+ relaivistic beta of the particle
+ '''
+ b=(1-gamma(energy, mass)**-2)**0.5
+ return b
+
+def beta_c(energy, mass=938.2720813):
+ '''
+ Parameters
+ ----------
+ energy: float
+ kinetic energy of the particle in MeV/c2
+ mass: float
+ mass of the moving particle, optional, if not given mass of proton is used
+
+ Returns
+ -------
+ relaivistic c*beta of the particle
+ '''
+ bc=c()*(1-gamma(energy, mass)**-2)**0.5
+ return bc
+
+def beta_from_gamma(gamma):
+ '''
+ Parameters
+ ----------
+ gamma: float
+ relaivistic gamma of the particle
+
+ Returns
+ -------
+ relaivistic beta of the particle
+
+ raises
+ ------
+ if given gamma is smaller than one raises a warning
+ '''
+ if gamma < 1:
+ print('gamma cannot be less than one')
+ beta = 0
+ else:
+ beta=(1-gamma**-2)**0.5
+ return beta
+
+def gamma(energy, mass=938.2720813):
+ '''
+ Parameters
+ ----------
+ energy: float
+ kinetic energy of the particle in MeV/c2
+ mass: float
+ mass of the moving particle, optional, if not given mass of proton is used
+
+ Returns
+ -------
+ relaivistic gamma of the particle
+ '''
+ #if mass>0:
+ g=1+(energy/mass)
+ return g
+
+def gamma_from_beta(beta):
+ '''
+ Parameters
+ ----------
+ beta: float
+ relaivistic beta of the particle
+
+ Returns
+ -------
+ relaivistic gamma of the particle
+ '''
+ if beta == 1:
+ from math import inf as math_inf
+ gamma = math_inf
+ else:
+ gamma = (1-beta**2)**-0.5
+ return gamma
+
+def energy(gamma_beta, mass=938.2720813):
+ '''
+ Parameters
+ ----------
+ gamma_beta: float
+ gamma or beta of the particle; if gamma_beta >= 1 the value is gamma, if gamma_beta < 1 the value is beta
+
+ mass: float
+ mass of the moving particle, optional, if not given mass of proton is used
+
+ Returns
+ -------
+ returns kinetic energy of the particle in MeV.
+
+
+ example:
+ sprel.energy(2.55, 938)
+ > 1453.8999999999999
+ if gamma_beta < 1 the value is beta
+ example:
+ sprel.energy(.55, 938)
+ > 185.13182200743233
+ '''
+ if gamma_beta >= 1: #assuming the value given is gamma
+ e = (gamma_beta - 1) * mass
+ elif gamma_beta < 1: #adduming the value given is beta
+ e = mass * (-1 + 1 / (1 - gamma_beta ** 2) ** 0.5)
+ return e
+
+def c():
+ '''
+ speed of light, 299792458 m/s
+ '''
+ return 299792458
+
diff --git a/ess/TTF.py b/ess/TTF.py
new file mode 100644
index 0000000000000000000000000000000000000000..862c2faff58e12f7314f9b82448454785ea6d572
--- /dev/null
+++ b/ess/TTF.py
@@ -0,0 +1,131 @@
+'''
+set of functions for calculating the transit time factor and the input phase resulting in max energy gain in a field map
+-- M. Eshraqi 2018 July 11
+'''
+
+import Batch_Convert_and_Cut_Binary_Fieldmap as bccb
+import SP_Relativity as myrel
+import numpy as np
+#%pylab inline
+
+def field_on_axis(Field, fieldmap_dim, Nz, Nrx, Ny):
+ '''
+ Take a 2D or 3D fieldmap as a 1D numpy array (as from TraceWin) in MV/m,
+ dimension of the fieldmap,
+ number of steps (No points - 1) in z direction,
+ number of steps in x/r direction, and
+ number of steps in the y direction (for 3D fieldmap) and
+ returns the field on-axis in the z direction
+ example:
+ field_on_axis(Field, 3, 100, 10, 10)
+ '''
+ if fieldmap_dim == 2:
+ Fieldmapmatrix = np.reshape(Field, (int(Nz+1), int(Nrx+1)))
+ midpoint = int(Nrx/2)
+ elif fieldmap_dim == 3:
+ Fieldmapmatrix = np.reshape(Field, (int(Nz+1), int((Nrx+1)*(Ny+1))))
+ midpoint = int(Nrx*Ny/2)
+ #print(midpoint)
+ return Fieldmapmatrix[:, midpoint]
+
+def Field_TTF(field_1d, step_dz, freq, E_in, mass, RetMaxPhase):
+ '''
+ takes a 1D field on axis along the acceleration axis in MV/m,
+ the mesh size (length of each step),
+ frequency in MHz,
+ input energy in MeV,
+ mass in MeV and
+ RetMaxPhase as boolean
+ returns the TTF and at the given energy and
+ if RetMaxPhase==True returns also input phase resulting in max energy gain
+ '''
+ omega = freq * 1e6 * 2 * np.pi
+ TTF_Phase = [0]*2
+ dE = E_in
+ Emax = E_in
+ phase_max = 0
+ counter = 0
+ phase_start = 0
+ phase_end = 360
+ d_phase = 90
+
+ for iteration in np.arange(1, 10):
+ for phase in np.arange(int(phase_start/d_phase), int(phase_end/d_phase)):
+ counter+=1
+ t = 0
+ dE = E_in
+ for fval in field_1d:
+ dE += fval[0]*step_dz*np.cos(omega * t + d_phase*np.radians(phase))
+ #print(dE)
+ if dE<0:
+ print('Please adjust the field level, particle decelrated to zero energy!')
+ t += dz/(myrel.c()*myrel.beta(dE, mass))
+ if dE > Emax:
+ Emax = dE
+ #print('Emax', Emax)
+ phase_max = phase*d_phase
+ phase_start = phase_max - d_phase
+ phase_end = phase_max + d_phase
+ d_phase = d_phase/4
+ if d_phase*4 < 0.1:
+ break
+
+ #d_phase*=4
+ #print(counter, d_phase, phase_max, (Emax-E_in)/Field_integral(field_1d, dz))
+ TTF_Phase[0] = (Emax-E_in)/Field_integral(field_1d, dz)
+ if RetMaxPhase == True:
+ TTF_Phase[1] = phase_max
+ return TTF_Phase
+
+def Field_integral(field_1d, dz):
+ '''
+ takes a 1D field on axis along the acceleration axis in MV/m,
+ the mesh size (length of each step) and
+ returns the rectangular integral of field
+ '''
+ field_int = 0
+ for fval in field_1d:
+ #print(abs(fval[0]))
+ field_int += abs(fval[0])
+ return dz*field_int
+
+def TTF_beta(field_1d, step_dz, freq, mass):
+ '''
+ takes a 1D field on axis along the acceleration axis in MV/m,
+ the mesh size (length of each step),
+ freq in MHz, and mass of particle in MeV and
+ returns a 2D array containig the TTF vs. beta. [Not very fast]
+ example
+ TTFarray = TTF_beta(one_d_field_on_axis, step_z, 704.42, 938)
+ beta_list = TTFarray[0]
+ TTF_list = TTFarray[1]
+ '''
+ TTFb = np.zeros((2,50))
+ i = 0
+ beta_in = 0.2
+ beta_out = 1
+ TTFb[0,:] = np.arange(beta_in, beta_out, (beta_out-beta_in)/50)
+ for bt in TTFb[0,:]:
+ dummy = Field_TTF(field_1d, step_dz, freq, myrel.energy(bt, mass), mass, False)
+ TTFb[1,i] = dummy[0]
+ i+=1
+ return TTFb
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
+# #
+# E X A M P L E S #
+# #
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
+
+Header, Field = bccb.read_binary_fieldmap('Data/FM/HB_W_coupler.edz', 3)
+fz = field_on_axis(Field, 3, Header[0], Header[2], Header[5])
+z = np.arange(0,int(Header[0]+1))
+dz = Header[1]/Header[0]
+z_points = dz*z
+
+print('Int_E:', Field_integral(fz, dz), '[TTF, Phase_Max_Energy]: ', Field_TTF(fz, dz, 704.42, 700, 938, True))
+TTFb = TTF_beta(fz, dz, 704.42, 938)
+
+#plot(z_points, fz);
+#plot(TTFb[0,:], 50*TTFb[1,:]);
\ No newline at end of file
diff --git a/ess/fieldmapy.py b/ess/fieldmapy.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ee1805b22a6a544ec18d63d93f7e113ef0ea2b6
--- /dev/null
+++ b/ess/fieldmapy.py
@@ -0,0 +1,653 @@
+'''
+v0.1:
+ Now that TraceWin can also convert binary fieldmaps to ASCII the main usage is reduced to trimming fieldmaps
+ -- M. Eshraqi 2018 July 09
+v0.2:
+ Added function to read ASCII fieldmaps and added descriptions
+ Added function save_to_ascii
+ Added function batch_convert_to_Ascci
+ -- M. Eshraqi 2018 July 23
+
+v0.3:
+ minor bug fixed in 2D fields
+ added function unify_grid_size
+
+v0.4:
+ added function create_TW_fieldmap
+ added function uniform_mesh
+ fixed a bug in function save_to_ascii which was writing Nx, Ny and Nz as floats
+ -- M. Eshraqi 2018 Aug 09
+
+---------------------------------------------------------------------------------------------------------
+
+ From TraceWin manual:
+
+---------------------------------------------------------------------------------------------------------
+
+
+ The field map file syntax is the following in the BINARY format:
+
+ - Dimension 1 :
+ nz (integer 4 bytes) zmax (double 8 bytes)
+ Norm (double 8 bytes)
+
+ # Nz Zmax
+ # Norm
+
+ for k=0 to nz
+ Fz(k.zmax/nz) (float 4 bytes)
+
+ - Dimension 2 :
+ nz (integer 4 bytes) zmax (double 8 bytes)
+ nx (integer 4 bytes) xmax (double 8 bytes)
+ Norm (double 8 bytes)
+
+ # Nz Zmax
+ # Nx Xmax
+ # Norm
+
+ for k=0 to nz
+ for i=0 to nr
+ Fz(k*zmax/nz, i*rmax/nr) (float 4 bytes)
+
+ - Dimension 3 :
+ (Be careful to the dimention order)
+ nz (integer 4 bytes) zmax (double 8 bytes)
+ nx (integer 4 bytes) xmin (double 8 bytes) xmax (double 8 bytes)
+ ny (integer 4 bytes) ymin (double 8 bytes) ymax (double 8 bytes)
+ Norm (double 8 bytes)
+ # Nz Zmax
+ # Nx Xmin Xmax
+ # Ny Ymin Ymax
+ # Norm
+
+ for k=0 to nz
+ for j=0 to ny
+ for i=0 to nx
+ Fz(k*zmax/nz, ymin+j*(ymax-ymin)/ny, xmin+i*(xmax-xmin)/nx) (float 4 bytes)
+ Warning: The lattice has to be regular.
+ The normalization factor is equal to ke/Norm or kb/Norm.
+ Fz are in MV/m for electric field or in T for magnetic field. The dimensions are in meter.
+
+---------------------------------------------------------------------------------------------------------
+
+
+---------------------------------------------------------------------------------------------------------
+'''
+
+__all__ = ['read_binary_fieldmap', 'read_ascii_fieldmap', 'cut_fieldmap_length', 'field_on_axis_from_file'
+ 'save_to_ascii', 'batch_convert_to_ascii', 'unify_grid_size', 'batch_cut_fieldmap',
+ 'uniform_mesh', 'create_TW_fieldmap']
+
+#class FieldMapy:
+#'''
+#class contains functions needed for manipulating fieldmaps for TraceWin.
+#'''
+#__version__ = "0.4"
+
+import os
+import numpy as np
+
+def read_binary_fieldmap(path_plus_file: str, fieldmap_dim: int):
+ '''
+ parameters
+ ----------
+ path_plus_file: string
+ path to the binary fieldmap file including the path, file name and extension
+ fieldmap_dim: int
+ dimension of the fieldmap, 1, 2 and 3 for 1D, 2D and 3D TraceWin formatted fieldmap
+
+ returns
+ -------
+ a list containing Header and Field
+ Header: 1D array of size 3, 5, 8 (for 1D, 2D and 3D fieldmaps)
+ TraceWin fieldmap header info
+ Field: 1D numpy array containing the nD field data
+ '''
+ field_File = open(path_plus_file,'r')
+
+ if fieldmap_dim == 3:
+ Header_Type = np.dtype([('Nz', 'int32'), ('Zmax', 'float64'), ('Nx','int32'), ('Xmin', 'float64'), ('Xmax', 'float64'),
+ ('Ny','int32'), ('Ymin','float64'), ('Ymax','float64'), ('Norm', 'float64')])
+ THeader = np.fromfile(field_File, dtype=Header_Type, count=1)
+ Nz = THeader['Nz'][0]
+ Zmax = THeader['Zmax'][0]
+ Nx = THeader['Nx'][0]
+ Xmin = THeader['Xmin'][0]
+ Xmax = THeader['Xmax'][0]
+ Ny = THeader['Ny'][0]
+ Ymin = THeader['Ymin'][0]
+ Ymax = THeader['Ymax'][0]
+ Norm = THeader['Norm'][0]
+ Header = np.zeros(len(THeader))
+ Header = np.array([Nz, Zmax, Nx, Xmin, Xmax, Ny, Ymin, Ymax, Norm])
+
+ elif fieldmap_dim == 2:
+ Header_Type = np.dtype([('Nz', 'int32'), ('Zmax', 'float64'), ('Nx','int32'), ('Xmax', 'float64'),
+ ('Norm', 'float64')])
+ THeader = np.fromfile(field_File, dtype=Header_Type, count=1)
+ Nz = THeader['Nz'][0]
+ Zmax = THeader['Zmax'][0]
+ Nx = THeader['Nx'][0]
+ Xmax = THeader['Xmax'][0]
+ Norm = THeader['Norm'][0]
+ Header = np.zeros(len(THeader))
+ Header = np.array([Nz, Zmax, Nx, Xmax, Norm])
+
+ elif fieldmap_dim == 1:
+ Header_Type = np.dtype([('Nz', 'int32'), ('Zmax', 'float64'), ('Norm', 'float32')])
+ Header = np.fromfile(field_File, dtype=Header_Type, count=1)
+ Nz = THeader['Nz'][0]
+ Zmax = THeader['Zmax'][0]
+ Norm = THeader['Norm'][0]
+ Header = np.zeros(len(THeader))
+
+ Field_Type = np.dtype([('F_val','float32')])
+
+ Nf = int(Nz+1)
+ if fieldmap_dim == 2:
+ Nf *= int(Nx+1)
+ elif fieldmap_dim == 3:
+ Nf *= (int(Ny+1)*int(Nx+1))
+
+ Field = np.fromfile(field_File, dtype=Field_Type, count=Nf)
+
+ return Header, Field
+
+def read_ascii_fieldmap(path_plus_file, fieldmap_dim: int):
+ '''
+ parameters
+ ----------
+ path_plus_file: string
+ path to the ASCII fieldmap file including the path, file name and extension
+ fieldmap_dim: int
+ dimension of the fieldmap, 1, 2 and 3 for 1D, 2D and 3D TraceWin formatted fieldmap
+
+ returns
+ -------
+ a list containing Header and Field
+ Header: 1D array of size 3, 5, 8 (for 1D, 2D and 3D fieldmaps)
+ TraceWin fieldmap header info
+ Field: 1D numpy array containing the nD field data
+ '''
+
+ from itertools import islice
+ import numpy as np
+
+ items_per_row = np.array([[2, 1, 0, 0],
+ [2, 2, 1, 0],
+ [2, 3, 3, 1]]) # for 1D, 2D and 3D fields in an ASCII fieldmap in TraceWin format
+ l_header = np.sum(items_per_row[fieldmap_dim-1,:], axis=0) # getting the length of the header from the items
+ Header = np.zeros(l_header)
+
+ j = 0
+ with open(path_plus_file, 'r') as f:
+ for i in range(0, fieldmap_dim+1):
+ header_line = list(islice(f, 1))
+ fl = header_line[0]
+ fl = fl.rstrip('\n')
+ fl = fl.split(' ')
+ l_header_line = items_per_row[int(fieldmap_dim)-1, i]
+ Header[j:j+l_header_line] = fl[:]
+ j+=l_header_line
+
+ Nf = int(Header[0]+1)
+ if fieldmap_dim == 2:
+ Nf *= int(Header[2]+1)
+ elif fieldmap_dim == 3:
+ Nf *= int(Header[2]+1)*int(Header[5]+1)
+
+ fieldmap = np.zeros(int(Nf))
+
+ i = 0
+ for line in f:
+ eorb = line.rstrip('\n')
+ fieldmap[i] = eorb[:]
+ i+=1
+
+ return Header, fieldmap
+
+def cut_fieldmap_length(path_plus_file: str, fieldmap_dim: int, entrance_rows_cut: int,
+ exit_rows_cut: int, file_type: str):
+ '''
+ parameters
+ ----------
+ path_plus_file: string
+ path to the fieldmap file (ASCII or binary) including the path, file name and extension
+ fieldmap_dim: int
+ dimension of the fieldmap, 1, 2 and 3 for 1D, 2D and 3D TraceWin formatted fieldmap
+ entrance_rows_cut: int
+ number of data rows to be removed from array from the entrance side of the field
+ exit_rows_cut: int
+ number of data rows to be removed from array from the exit side of the field
+ file_type: str
+ 'b' for binary and 'a' for ascii fieldmap files.
+
+ returns
+ -------
+ a list containing Header and Field
+ Header: 1D array of size 3, 5, 8 (for 1D, 2D and 3D fieldmaps)
+ TraceWin fieldmap header info
+ Field: 1D numpy array containing the nD field data with only the remaining rows
+
+
+ raises
+ ------
+ prints a message if the file_type is not specified to be a (ascii) or b (binary)
+
+ missing
+ -------
+ cutting the field in other directions
+ '''
+
+ if file_type == 'a':
+ Field, Header = read_ascii_fieldmap(path_plus_file, fieldmap_dim)
+ elif file_type == 'b':
+ Field, Header = read_binary_fieldmap(path_plus_file, fieldmap_dim)
+ else:
+ print('file_type should be a for ascii or b for binary')
+
+ lowx = np.arange(0,int(entrance_rows_cut)) #list of rows to be removed from the entrance side
+ highx = np.arange(int(Header[0]+1-exit_rows_cut), int(Header[0]+1)) # list of rows to be removed from the exit side
+
+ newNz = (Header[0]+1)-entrance_rows_cut-exit_rows_cut # new number of field data points after removal of rows
+ stepZ = Header[1] / Header[0]
+
+ # depending the dimension of the field the fieldmap is reshaped for line removal
+ if fieldmap_dim == 1:
+ newlength = newNz
+ elif fieldmap_dim == 2:
+ Fieldmapmatrix = np.reshape(Field, (int(Header[0]+1), int(Header[2]+1)))
+ newlength = newNz*(Header[2]+1)
+ elif fieldmap_dim == 3:
+ Fieldmapmatrix = np.reshape(Field, (int(Header[0]+1), int((Header[2]+1)*(Header[5]+1))))
+ #print(Fieldmapmatrix.shape)
+ newlength = newNz*(Header[2]+1)*(Header[5]+1)
+
+ if (entrance_rows_cut>0 and exit_rows_cut>0):
+ x = np.delete(Fieldmapmatrix,(lowx, highx), axis=0)
+ elif (entrance_rows_cut ==0):
+ x = np.delete(Fieldmapmatrix,(highx), axis=0)
+ elif exit_rows_cut ==0:
+ x = np.delete(Fieldmapmatrix,(lowx), axis=0)
+
+ # reshaping the array back to a 1D array
+ ShortenedMatrix = np.reshape(x, (int(newlength), 1))
+
+ # creating new header data (if other directions are added to the cut fuction the header for those have
+ # to be rewritten too)
+ Header[0] = newNz-1
+ Header[1] = stepZ*(newNz-1)
+
+ return Header, ShortenedMatrix
+
+def field_on_axis_from_file(path_plus_file, fieldmap_dim: int, file_type: str):
+ '''
+ parameters
+ ----------
+ path_plus_file: string
+ name of the fieldmap file including its path and extension
+ fieldmap_dim: int
+ dimesion of the fieldmap, 1, 2, 3 for 1D, 2D and 3D fieldmaps in TraceWin format
+ file_type: string
+ 'b' for binary and 'a' for ascii fieldmap files.
+
+ returns
+ -------
+ returns a 2D array containing the z coordinates and the field on axis in the z direction
+
+ Take a 2D or 3D fieldmap as a 1D numpy array (as from TraceWin) in MV/m,
+ dimension of the fieldmap,
+ returns the field on-axis in the z direction
+ example:
+ field_on_axis_from_file('Data/FM/HB_W_coupler.edz', 3, 'b')
+ '''
+ from numpy import zeros as npzeros
+
+ if file_type == 'b':
+ Header, Field = read_binary_fieldmap(path_plus_file, fieldmap_dim)
+ elif file_type == 'a':
+ Header, Field = read_ascii_fieldmap(path_plus_file, fieldmap_dim)
+ else:
+ print('file_type should be a for ascii or b for binary')
+
+ if fieldmap_dim == 2:
+ Nz, Nrx = Header[0], Header[2]
+ Fieldmapmatrix = np.reshape(Field, (int(Nz+1), int(Nrx+1)))
+ midpoint = 0
+ elif fieldmap_dim == 3:
+ Nz, Nrx, Ny = Header[0], Header[2], Header[5]
+ Fieldmapmatrix = np.reshape(Field, (int(Nz+1), int((Nrx+1)*(Ny+1))))
+ midpoint = int(Nrx*Ny/2)
+
+ dz = Header[1]/Nz
+ field_on_axis = npzeros((2,int(Nz)+1))
+ for i in range(int(Nz+1)):
+ field_on_axis[0,i] = i*dz
+
+ field_on_axis[1,:] = Fieldmapmatrix[:, midpoint]
+ return field_on_axis
+
+def save_to_ascii(Header, Field, fieldmap_dim: int, path_to_out_file: str, out_file_name: str):
+ '''
+ Parameters
+ ----------
+ Header: array like
+ 1D array of size (3, 5 or 8) for 1D, 2D or 3D fieldmap header info, TraceWin format
+ Field: array like
+ 1D array of size Nz fieldmap containing field data
+ fieldmap_dim: int
+ dimesion of the fieldmap, 1, 2, 3 for 1D, 2D and 3D fieldmaps in TraceWin format
+ path_to_out_file: string
+ path to the output file folder
+ out_file_name: string
+ name of the outputfile, including the extension
+
+ Returns
+ -------
+ None
+
+ What does it do
+ ---------------
+ Saves a TraceWin readable ASCII file
+ '''
+ with open(os.path.join(path_to_out_file, out_file_name), 'w') as out_file:
+
+ stepZ = Header[1] / Header[0] #stepZ = Zmax / Nz
+
+ out_file.write(str(int(Header[0])))
+ out_file.write(' ')
+ out_file.write(str(Header[1]))
+ #out_file.write(' '.join(str(hval) for hval in Header[0:2]))
+ out_file.write('\n')
+ if fieldmap_dim == 1:
+ #Norm = Header[2]
+ out_file.write((str(Header[2])))
+ out_file.write('\n')
+
+ elif fieldmap_dim == 2:
+ #Norm = Header[4]
+ stepX = Header[3]/Header[2] #stepX = Xmax / Nx
+
+ out_file.write(str(int(Header[2])))
+ out_file.write(' ')
+ out_file.write(str(int(Header[3])))
+ #out_file.write(' '.join(str(hval) for hval in Header[2:4]))
+ out_file.write('\n')
+ out_file.write(str(Header[4]))
+ out_file.write('\n')
+
+ elif fieldmap_dim == 3:
+ #Norm = Header[8]
+ stepX = (Header[4]-Header[3])/Header[2] #stepX = (Xmax - Xmin) / Nx
+ stepY = (Header[7]-Header[6])/Header[5] #stepY = (Ymax - Ymin) / Ny
+
+ out_file.write(str(int(Header[2])))
+ out_file.write(' ')
+ out_file.write((' '.join(str(hval) for hval in Header[3:5])))
+ out_file.write('\n')
+ out_file.write(str(int(Header[5])))
+ out_file.write(' ')
+ out_file.write((' '.join(str(hval) for hval in Header[6:8])))
+ out_file.write('\n')
+ out_file.write(''.join(str(Header[8])))
+ out_file.write('\n')
+
+ for fval in Field:
+ try:
+ out_file.write(str(fval[0]))
+ out_file.write('\n')#print(fval)
+ except IndexError:
+ out_file.write(str(fval))
+ out_file.write('\n')#print(fval)
+
+ return
+
+def batch_convert_to_ascii(binary_field_path: str, fieldmap_dim: int):
+ '''
+ parameters
+ ----------
+ binary_field_path: string
+ path to the binary files to be converted to ASCII format
+ fieldmap_dim: int
+ dimension of the fieldmap to be converted
+ '''
+ onlyfiles = [f for f in os.listdir(binary_field_path) if os.path.isfile(os.path.join(binary_field_path, f))]
+
+ for f in onlyfiles:
+ if f[0]!=".":
+
+ Header, Field = read_binary_fieldmap(binary_field_path+f, fieldmap_dim)
+ save_to_ascii(Header, Field, fieldmap_dim, binary_field_path+'/ASCII/', f)
+
+ return
+
+def unify_grid_size(old_x: list, old_y: list, new_x: list, **kwargs):
+ '''
+ parameters:
+ old_x: list,
+ old_y: list,
+ new_x: list
+
+ **kwargs: kind
+ ‘linear’,
+ ‘nearest’,
+ ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’: refer to a spline interpolation of zeroth, first, second or third order
+ ‘previous’, ‘next’: return the previous or next value of the point
+ An integer specifying the order of the spline interpolator to use. Default is ‘linear’.
+
+ Retunrs:
+ -------
+ new_y: list
+
+ Takes a mesh as x values and the corresponding values of a function.
+ creates a spline interpolation for those data sets.
+ Using a new_x it returns the correcposnding new_y.
+ Could be used to convert an irregular mesh to a regular mesh or
+ to increase the number of mesh points
+ '''
+ kind = kwargs.get('kind', 'linear')
+ save_to_file = kwargs.get('save_to_file', 'none')
+
+ from scipy import interpolate
+ f = interpolate.interp1d(old_x, old_y, kind)
+ new_y = f(new_x)
+ if save_to_file != 'none':
+ field = np.zeros((2, len(new_x)))
+ field[0,:] = new_x
+ field[1,:] = new_y
+ np.savetxt(save_to_file, np.transpose(field), delimiter='\t')
+
+ return new_y
+
+def batch_cut_fieldmap(fieldmaps_path: str, fieldmap_dim: int, entrance_rows_cut: int,
+ exit_rows_cut: int, file_type: str):
+ '''
+ parameters
+ ----------
+ fieldmaps_path: string
+ path to the fieldmap folder (ASCII or binary) excluding the trailing / and filename
+ fieldmap_dim: int
+ dimension of the fieldmap, 1, 2 and 3 for 1D, 2D and 3D TraceWin formatted fieldmap
+ entrance_rows_cut: int
+ number of data rows to be removed from array from the entrance side of the field
+ exit_rows_cut: int
+ number of data rows to be removed from array from the exit side of the field
+ file_type: str
+ 'b' for binary and 'a' for ascii fieldmap files.
+
+ Returns
+ -------
+ None
+
+ What does it do
+ ---------------
+ Saves a TraceWin readable ASCII file
+ '''
+ onlyfiles = [f for f in os.listdir(fieldmaps_path) if os.path.isfile(os.path.join(fieldmaps_path, f))]
+
+ for f in onlyfiles:
+ if f[0]!=".":
+ if (entrance_rows_cut+exit_rows_cut>0):
+ Header, Field = cut_fieldmap_length(f, fieldmap_dim, entrance_rows_cut, exit_rows_cut, file_type)
+
+ save_to_ascii(Header, Field, fieldmap_dim, fieldmaps_path+'/ASCII/', f)
+
+def uniform_mesh(mesh: list):
+ '''
+ parameters: list
+ a 1D array which is the coordinate values of the field
+ returns: Tuple
+ a tuple containing a boolean (if the mesh is uniform or not), mesh_size (average to reduce the effect of
+ floating point error), and the number of steps from min to max (n numbers would result in n-1)
+ '''
+ unique = np.unique(mesh, return_counts=False)
+ mesh_check = np.zeros(len(unique)-1)
+ for i in range(1,len(unique)):
+ mesh_check[i-1]=(unique[i]-unique[i-1])
+ mesh_check, mesh_size = np.unique(mesh_check, return_counts=True)
+
+ if np.abs(max(mesh_check))>np.abs(min(mesh_check))*1.001:
+ print('Mesh size differs by more than 0.1%, should be fixed')
+ return False, mesh_check, sum(mesh_size)
+ else:
+ return True, np.average(mesh_check), sum(mesh_size)
+
+def create_TW_fieldmap(fieldmaps_path: str, tabular_file_name: str, fieldmap_dim: int = 1, n_col: int = 1, header: bool = True, **kwargs):
+ '''
+ paramters
+ ---------
+ fieldmaps_path: str
+ path to the fieldmap
+ tabular_file_with_path: file name
+ tabular data with coordinates z, x and y or z and r or only z depending on dimension as first 1-3 cols.
+ n_col is the number of data columns except coordinate ones (1-6)
+ coordinates should be on a uniform grid on each axis (but different axes are independent)
+ fieldmap_dim: int
+ dimension of the fieldmap data, default is 1
+ n_col: int
+ number of data columns in fieldmap, default is 1
+ header: boolean
+ if the file has header or not, default is True
+ **kwargs
+ extensions: list
+ list of column names to be used for naming the files, default is [F1, F2, F3, F4, F5, F6]
+ xyz: list
+ order of columns, xyz = [col_number(x), col), col_number(y), col_number(z)]
+ e.g.if column 1 is x, col 2 is y and col 3 is z, xyz list = [1,2,3] (default)
+ delimeter: string
+ delimeter used in the data, default is tab '\t'
+ returns
+ -------
+ fieldmaps in the TraceWin format, one per n_col.
+
+ '''
+ extensions = kwargs.get('extensions', ['F1', 'F2', 'F3', 'F4', 'F5', 'F6'])
+ xyz = kwargs.get('xyz', [1, 2, 3])
+ delim = kwargs.get('delimeter', '\t')
+
+ if len(xyz)<fieldmap_dim:
+ print('xyz array is shorter than the number of dimensions')
+ return
+
+ tabular_file_with_path = fieldmaps_path + tabular_file_name
+ field_File = open(tabular_file_with_path,'r')
+
+ if header==True:
+ field_array = np.genfromtxt(field_File, delimiter=delim, skip_header=1)
+ else:
+ field_array = np.genfromtxt(field_File, delimiter=delim, skip_header=0)
+ field_File.close()
+
+ items_per_row = np.array([[2, 1, 0, 0],
+ [2, 2, 1, 0],
+ [2, 3, 3, 1]]) # for 1D, 2D and 3D fields in an ASCII fieldmap in TraceWin format
+ l_header = np.sum(items_per_row[fieldmap_dim-1,:], axis=0) # getting the length of the header from the items
+ Header = np.zeros(l_header)
+
+ # sort first on x coordinate, then y and then z for TraceWin fieldmap
+ for i in range(0, fieldmap_dim):
+ coor = field_array[:,xyz[i]-1]
+ chk_mesh, d_mesh, n_mesh = uniform_mesh(coor)
+ if chk_mesh:
+ if i == fieldmap_dim - 1:
+ Header[0] = n_mesh
+ Header[1] = max(coor)
+ # \n
+ if fieldmap_dim == 1:
+ Header[2] = 1
+ # \n
+ elif fieldmap_dim == 2:
+ if i == fieldmap_dim - 2:
+ Header[2] = n_mesh
+ Header[3] = max(coor)
+ # \n
+ Header[4] = 1
+ # \n
+ elif fieldmap_dim == 3:
+ if i == fieldmap_dim - 2:
+ Header[2] = n_mesh
+ Header[3] = min(coor)
+ Header[4] = max(coor)
+ # \n
+ elif i == fieldmap_dim - 3:
+ Header[5] = n_mesh
+ Header[6] = min(coor)
+ Header[7] = max(coor)
+ # \n
+ Header[8] = 1
+ # \n
+
+ else: # fieldmap_dim > 3 or fieldmap_dim < 1:
+ print('Invalid dimension, should be 0, 1 or 2')
+ return
+ ordr = np.argsort(coor, kind = 'mergesort')
+ field_array = field_array[ordr, :]
+
+ #print('\n', field_array[:,:3])
+ #print(Header)
+ filename_wo_ext = os.path.splitext(tabular_file_name)[0]
+ for i in range(fieldmap_dim, fieldmap_dim+n_col):
+ #print(len(field_array[:,i]))
+ save_to_ascii(Header, field_array[:,i], fieldmap_dim, fieldmaps_path, filename_wo_ext+"."+extensions[i-fieldmap_dim])
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
+# #
+# C h a n g e t h e f o l l o w i n g v a l u e s #
+# #
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
+
+def example_func():
+ '''
+ Example
+
+ The parameters in the following six rows define the path to your fieldmap, no name is needed, this script
+ scans the folder and converts all files, assumes all are binary fieldmaps, to ASCII fieldmaps.
+ The dimension of the field is also needed.
+ If you need to cut the field, the n_enter and n_exit should be adjusted.
+ '''
+ mypath = 'Data/FM/' # where the fieldmaps are stored
+ fieldmap_dim = 3
+ #fieldmap_dim = 2
+ #fieldmap_dim = 1
+ n_enter = 0 #Number of lines to be removed from entrance of fieldmap
+ n_exit = 0 #Number of lines to be removed from exit of fieldmap
+
+ onlyfiles = [f for f in os.listdir(mypath) if os.path.isfile(os.path.join(mypath, f))]
+
+ for f in onlyfiles:
+ if f[0]!=".":
+
+ if (n_enter+n_exit>0):
+ Header, Field = cut_fieldmap_length(f, fieldmap_dim, n_enter, n_exit, 'b')
+ else:
+ Header, Field = read_binary_fieldmap(mypath+f, fieldmap_dim)
+
+ save_to_ascii(Header, Field, fieldmap_dim, 'Data/FM/ASCII/', f)
+
+ test = False
+ #%pylab inline
+ if test == True:
+ #field = field_on_axis_from_file('Data/FM/MB_W_coupler.edz', 3, 'b')
+ field = field_on_axis_from_file('Data/FM/ASCII/Spoke_W_coupler.edz', 3, 'a')
+ plot(field[0,:], field[1,:])
diff --git a/examples/PhaseScan/Scan_Energy_gain_in_fieldmap-v16.ipynb b/examples/PhaseScan/Scan_Energy_gain_in_fieldmap-v16.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9e26eede3454a33d1e4b1bd11e3b165d69dddb08
--- /dev/null
+++ b/examples/PhaseScan/Scan_Energy_gain_in_fieldmap-v16.ipynb
@@ -0,0 +1,2006 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "'''\n",
+ " Updates:\n",
+ " v7:\n",
+ " Fixed: energy gain and energy gain internal are going only through the length of the cavity (not L_cav + dz)\n",
+ " self.fieldmap reads data into a 2D numpy array usimg bccb's field_on_axis_from_file function\n",
+ " v8:\n",
+ " added description of the functions and cleaned few functions.\n",
+ " added function virtual_cavity\n",
+ " 2018-07-16\n",
+ " v9:\n",
+ " Looking at the mod(BPM_phase, 180) instead of the BPM_phase, not fully implemented yet\n",
+ " 2018-07-18\n",
+ " v10:\n",
+ " Better handling of average of BPM phases and rewrting the amplitude and sync_phase finding routine\n",
+ " 2018-07-19\n",
+ " v11:\n",
+ " using the BPM time/phase for phase scan instead of calculating the energy from them\n",
+ " b: adding class nested_values and changing the functions not to return a tuple\n",
+ " 2018-07-20\n",
+ " v12:|\n",
+ " created function cavity.bpm_phase_sim which replaces cavity.noisy_bpm_phase and cavity.noisy_bpm_phase_internal\n",
+ " added functionality to read ASCII fieldmaps and Tabular data\n",
+ " 2018-07-23\n",
+ " \n",
+ " v13:\n",
+ " created function find_phase_amp, which looking at the BPM phases attempts to find the desired phase and\n",
+ " amplitude (shifts and ratios) \n",
+ " cleaning of the code and minor changes to accomodate the new function\n",
+ " created function Cavity_.fit_and_energy_measure and cleaned up the find_phase_amp function\n",
+ " 2018-07-25\n",
+ " v14:\n",
+ " added modulus to fit_sinusoidal function\n",
+ " added modulus selector to Cavity_.fit_and_energy_measure fucntion\n",
+ " irregular mesh from tabular data will get regular mesh and will get saved to file\n",
+ " 2018-07-26\n",
+ " v15:\n",
+ " fixed modulus assignment in Cavity_.fit_and_energy_measure when BPM_first < 0\n",
+ " added function de_modulus\n",
+ " numbers fed to the fit_sinusodial fucntion go through the de_modulus function if a modulus is given\n",
+ " order of phase and amplitude in the arguments of function find_phase_amp were changed to be\n",
+ " consistent with the other functions\n",
+ " in all functions an amplitude of 1 means 100% of field.\n",
+ " fit_bimodal function removed\n",
+ " 2018-08-03\n",
+ " v16:\n",
+ " first attempt in using all BPMs and fitting a 2D surface to simulation, comparing that to empirical \n",
+ " data points and finding phase and amplitude.\n",
+ " \n",
+ " \n",
+ " \n",
+ " To do list:\n",
+ " -----------\n",
+ " -- merge the energy_gain and energy_gain_internal\n",
+ " it is deprioritized as it will increase the CPU time and make the code less readable\n",
+ " -- check the effect of recacluating beta (length_to_phase) in energy gain calculations, it will same CPU time\n",
+ " -- get energy_out info from several BPMs\n",
+ " -- perform a chi-square test of the adjusted VC vs. simulated energy gain\n",
+ " -- use right bpm frequency for setting the harmonic_selector in np.mod calcs.\n",
+ " -- test and fix the internal energy gain with DTL fieldmap\n",
+ " -- read bpm data from an input file, position, frequency and error\n",
+ "\n",
+ " DONE from To do list:\n",
+ " ---------------------\n",
+ " --v consider using the same standard for the field amplitude in all the functions, now some functions\n",
+ " have a range between 0-100% and someothers between 0-1\n",
+ " --x merge virtual_cavity and energy_gain functions in the Cavity_ class\n",
+ " the purpose of virtual_cavity function is to mimic the real cavity and eventually be replaced with \n",
+ " data coming either from virtual accelerator or the real accelerator\n",
+ " \n",
+ "''';"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from os import listdir\n",
+ "from os.path import isfile, join\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "from scipy.optimize import leastsq\n",
+ "import pylab as plt\n",
+ "import SP_Relativity as sprel\n",
+ "import fieldmapy as bccb\n",
+ "\n",
+ "global mass\n",
+ "mass = 938.2720813\n",
+ "\n",
+ "global q\n",
+ "q = 1\n",
+ "\n",
+ "\n",
+ "class nested_values:\n",
+ " ''' \n",
+ " Class nested values defines a compact data structure. A nested_values data type variable could contain\n",
+ " other parameters.\n",
+ " '''\n",
+ " def __init__(self):\n",
+ " '''\n",
+ " For the variables nested within a parameter read the help of the fucntion which returns the nested_value\n",
+ " '''\n",
+ " # Thanks Yngve!\n",
+ " pass\n",
+ " \n",
+ "class Cavity_:\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " cav_name: string\n",
+ " name of the fieldmap file without extension\n",
+ " freq_MHz: float\n",
+ " resonant frequency of the cavity in MHz\n",
+ " data_type: string\n",
+ " a, b, t: a for ASCII files, b for binary files and t for tabular files.\n",
+ " **kwargs \n",
+ " path: string\n",
+ " path to the fieldmap file\n",
+ " ext: string\n",
+ " extension of the fieldmap file, e.g. '.edz' N.B. The '.' should be included\n",
+ " dimension: int\n",
+ " dimesion of the fieldmap file\n",
+ " scaling: float\n",
+ " scaling the field to MV/m. Field = Field_from_fieldmap * scaling\n",
+ " internal_bpm: boolean\n",
+ " indicated whether the defined Cavity_ has any internal BPMs which are used for \n",
+ " the phase-scan process\n",
+ " energy_start: flaot\n",
+ " input energy to the cavity\n",
+ " n_measurement: int\n",
+ " number of measurements at each phase and amplitude\n",
+ " n_calibration_pulses: int\n",
+ " number of measurements to calibrate the distance of the BPM for each cavity\n",
+ " phase_start: float\n",
+ " starting phase for the phase scan\n",
+ " phase_end: float\n",
+ " end of the phase range for the phase scan\n",
+ " phase_step: float\n",
+ " step of phase change in the phase scan process\n",
+ " amp_start: float\n",
+ " starting field amplitude for the phase scan (1 means 100% of field)\n",
+ " amp_end: float\n",
+ " end of the amplitude range for the phase scan (1 means 100% of field)\n",
+ " amp_step: float\n",
+ " step of amplitude change in the phase scan (1 means 100% of field)\n",
+ " dl_scaling: float\n",
+ " re-scale the length of the grid (e.g.: dl_scaling=0.01 to convert cm to m)\n",
+ " delimeter: string\n",
+ " delimeter used in the tabular data, default is '\\t'\n",
+ " \n",
+ " raises\n",
+ " ------\n",
+ " if the fieldmap doesnt have a regular mesh (check perfomed on first and second step only) or the mesh size \n",
+ " is zero it raises an error\n",
+ "\n",
+ " given a cavity name and its frequency (MHz) My_Cavity reads the fieldmap from \n",
+ " the pre defined directory containing all the fieldmaps which are stored in ASCII format.\n",
+ " The files have a .txt extension and the format is \n",
+ " Z(m):float Ez(MV/m):float \\n \n",
+ " z in meters and Ez in MV/m. \n",
+ " The functions included can calculate the energy gain, TOF including error \n",
+ " for internal to the field and downstream BPMs, and the input phase corresponding \n",
+ " to a zero synchronous phase (max energy gain)\n",
+ " '''\n",
+ " \n",
+ " __version__ = \"0.16.0\"\n",
+ " \n",
+ " def __init__(self, cav_name: str, freq_MHz: float, data_type: str, **kwargs):\n",
+ " '''\n",
+ " This function reads the fieldsmap, sets the frequency, checks the length of the cavity\n",
+ " and the longitudinal mesh size of the field \n",
+ " several kwargs are also defined\n",
+ " '''\n",
+ " self.path_to_field = kwargs.get('path', '/Users/mohammadeshraqi/cernbox/Work/Coding/Python/Data/FM/')\n",
+ " self.extension = kwargs.get('ext', '.edz')\n",
+ " self.dimension = kwargs.get('dimension', 3)\n",
+ " self.scaling = kwargs.get('scaling', 1.0)\n",
+ " self.internal_bpm = kwargs.get('internal_bpm', False)\n",
+ " self.energy_start = kwargs.get('energy_start', 90.0)\n",
+ " self.n_measurement = kwargs.get('n_measurement', 5)\n",
+ " self.n_calibration_pulses = kwargs.get('n_calibrating_pulses', 5)\n",
+ " self.phase_start = kwargs.get('phase_start', 0.0)\n",
+ " self.phase_end = kwargs.get('phase_end', 360.0)\n",
+ " self.phase_step = kwargs.get('phase_step', 60.0)\n",
+ " self.amp_start = kwargs.get('amp_start', 0.8)\n",
+ " self.amp_end = kwargs.get('amp_end', 1.01)\n",
+ " self.amp_step = kwargs.get('amp_step', 0.05)\n",
+ " self.n_bpm = kwargs.get('n_bpm', 10)\n",
+ " self.dl_scaling = kwargs.get('dl_scaling', 1)\n",
+ " self.delimeter = kwargs.get('delimeter', '\\t')\n",
+ " #self.f_skip = kwargs.get('f_skip', 1) not implemented yet\n",
+ "\n",
+ "\n",
+ " \n",
+ " self.name = cav_name\n",
+ " self.freq = freq_MHz * 1E6\n",
+ " self.omega = self.freq * 2 * np.pi\n",
+ " self.bunch_freq = 352.21E6 #Hz\n",
+ " self.bunch_t = 1/self.bunch_freq #s\n",
+ "\n",
+ " if data_type == 'b':\n",
+ " self.fieldmap = bccb.field_on_axis_from_file(self.path_to_field+self.name+self.extension, self.dimension, 'b') \n",
+ " elif data_type == 'a':\n",
+ " '''\n",
+ " requires BCCB_v2 or later\n",
+ " '''\n",
+ " self.fieldmap = bccb.field_on_axis_from_file(self.path_to_field+self.name+self.extension, self.dimension, 'a') \n",
+ " elif data_type == 't':\n",
+ " self.fieldmap = np.genfromtxt(self.path_to_field+self.name+self.extension, delimiter=self.delimeter)\n",
+ " if len(self.fieldmap[:,0]) > len(self.fieldmap[0,:]):\n",
+ " self.fieldmap = np.transpose(self.fieldmap)\n",
+ " #print('Not implemented yet')\n",
+ " else:\n",
+ " print('data_type should be a (ASCII), b (binary), or t (Tabular)')\n",
+ " return\n",
+ " \n",
+ " self.fieldmap[0,:] = self.fieldmap[0,:]*self.dl_scaling\n",
+ " self.fieldmap[1,:] = self.fieldmap[1,:]*self.scaling\n",
+ " \n",
+ " self.length = self.fieldmap[0,-1]\n",
+ " self.dl = self.fieldmap[0,1]-self.fieldmap[0,0]\n",
+ " self.dl_chk = self.fieldmap[0,2]-self.fieldmap[0,1]\n",
+ " \n",
+ " self.waveguidelength = 50.0 # degrees\n",
+ " \n",
+ " if (self.dl == 0 or self.dl != self.dl_chk):\n",
+ " if data_type =='t':\n",
+ " '''\n",
+ " requires BCCB_v3 or later\n",
+ " '''\n",
+ "\n",
+ " if self.fieldmap[0,0] != self.fieldmap[0,0]:\n",
+ " print('please remove the header from file', self.name+self.extension)\n",
+ " return\n",
+ " \n",
+ " num_x = len(self.fieldmap[0,:])\n",
+ " new_x = np.linspace(self.fieldmap[0,0], self.length, num_x)\n",
+ " \n",
+ " self.fieldmap[1,:] = bccb.unify_grid_size(self.fieldmap[0,:], self.fieldmap[1,:], new_x, \n",
+ " kind='linear', save_to_file = self.path_to_field+self.name+'_reg'+self.extension)\n",
+ " self.fieldmap[0,:] = new_x\n",
+ " self.length = self.fieldmap[0,-1]\n",
+ " self.dl = self.fieldmap[0,1]-self.fieldmap[0,0]\n",
+ " self.dl_chk = self.fieldmap[0,2]-self.fieldmap[0,1]\n",
+ " print('Tabular mesh was irregular, regular mesh created and imported for fieldmap')\n",
+ " else:\n",
+ " print('please check the fieldmap file for cavity ', self.name)\n",
+ " return\n",
+ "\n",
+ " self.phase_end = np.ceil(self.phase_end / self.phase_step) * self.phase_step + 1 #to go one step beyong phase_end\n",
+ " self.in_phase_range = np.arange(self.phase_start, self.phase_end, self.phase_step)\n",
+ " if np.ceil(self.phase_end/self.phase_step)<4:\n",
+ " print('At least four points are needed, either increase the range or decrease the step of the phase')\n",
+ " return\n",
+ " self.amp_end = (np.ceil(self.amp_end / self.amp_step)) * self.amp_step + 0.001 #to go one step beyong amp_end\n",
+ " self.field_amp_range = np.arange(self.amp_start, self.amp_end, self.amp_step)\n",
+ " self.build_bpm_info_data()\n",
+ " \n",
+ " def build_bpm_info_data(self):\n",
+ " '''\n",
+ " generates the bpm_info_data array and populates it with initiation and calibbration data\n",
+ " '''\n",
+ "\n",
+ " bpm_position_error = 0.0E-3 # position error of the BPM in m: Max of uniform distribution \n",
+ " bpm_phase_error = 1.0 # RMS error (Precision) of BPM phase measurement, deg, at Bunch frequency!\n",
+ "\n",
+ " self.bpm_info_data_help = ['0: position', '1: position error', '2: position including error', '3: BPM_freq_MHZ', \n",
+ " '4: noise', '5: zero_energy_phase', '6: rsrv2', '7: rsrv3', '8: rsrv4', '9: rsrv5']\n",
+ " #bpm_rows = self.bpm_info_data_help\n",
+ " n_rows = len(self.bpm_info_data_help)+self.n_measurement\n",
+ " self.bpm_info_data = np.zeros((n_rows, self.n_bpm)) \n",
+ " \n",
+ " bpm_position_freqMHz = self.get_bpm_positions()\n",
+ " self.bpm_info_data[0,:] = bpm_position_freqMHz.pos\n",
+ " self.bpm_info_data[1,:] = (2 * np.random.rand(self.n_bpm) - 1) * bpm_position_error\n",
+ " self.bpm_info_data[2,:] = self.bpm_info_data[1,:] + self.bpm_info_data[0,:]\n",
+ " self.bpm_info_data[3,:] = bpm_position_freqMHz.freqMHz\n",
+ " self.bpm_info_data[4,:] = bpm_phase_error\n",
+ "\n",
+ " bpm_calibration = self.bpm_phase_sim(self.energy_start, 0, -90, self.bpm_info_data[2,:], \n",
+ " self.bpm_info_data[4,:], self.n_calibration_pulses, \n",
+ " Internal = self.internal_bpm)\n",
+ " bpm_calibration = np.average(bpm_calibration[:,:], axis = 1)*self.bunch_freq/self.freq\n",
+ " self.bpm_info_data[5,:] = bpm_calibration # average phase of different BPMs at energy_in at bunch frequency\n",
+ " return \n",
+ " \n",
+ " def get_bpm_positions(self):\n",
+ " '''\n",
+ " should be fixed to get the bpm positions from the exit of the cavity from either the lattice, \n",
+ " the database or other sources, to be defined and to be done and load the frequency of each bpm\n",
+ " \n",
+ " returns:\n",
+ " nested_values.pos: array\n",
+ " positions of the bpms from the exit of the cavity in meters\n",
+ " nested_values.freqMHz: array\n",
+ " frequency of each BPM in MHz\n",
+ " '''\n",
+ " bpm_pos_freq=nested_values()\n",
+ "\n",
+ " bpm_pos_freq.pos = [-7, 0.1, 0.5, 3.975, 5.065, 7.829, 9.210, 32, 64, 128] # position from END of the cavity (m)\n",
+ " #bpm_pos_freq.freqMHz = [704.42, 704.42, 704.42, 704.42, 704.42, 704.42, 352.21, 352.21, 352.21, 352.21] #Freq of BPMs\n",
+ " bpm_pos_freq.freqMHz = 2*352.21 #Freq of BPMs\n",
+ " return bpm_pos_freq\n",
+ " \n",
+ " \n",
+ " \n",
+ " def energy_gain(self, energy_in: float, amplitude: float, phase: float):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " energy_in: float\n",
+ " input energy to the fieldmap in MeV\n",
+ " amplitude: float\n",
+ " amplitude of the applied field compared to the values in the fieldmap (between 0 and 1)\n",
+ " phase: float\n",
+ " input phase (deg) to the fieldmap\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " a list containing:\n",
+ " energy_out: float\n",
+ " energy at the exit of the cavity for the given energy, amplitude and phase\n",
+ " tof: float\n",
+ " time of flight through the cavity for the given energy, amplitude and phase\n",
+ " \n",
+ " raises\n",
+ " ------\n",
+ " if the energy of the particle reaches zero (particle coming ro rest) anywhere in the cavity the\n",
+ " function will raise an error\n",
+ " '''\n",
+ " enrg_gain=nested_values()\n",
+ " #print('i am called')\n",
+ " tof = 0 # time through the cavity\n",
+ " waveguide_length = 0 # an arbitrary number representating the phase length of the waveguide\n",
+ " applied_phase = np.radians(phase + waveguide_length)\n",
+ " energy_out = energy_in\n",
+ "\n",
+ " i = 0 # index for going through the fieldmap\n",
+ " for z in self.fieldmap[0,:-1]:\n",
+ " tof += length_to_time(self.dl, energy_out)\n",
+ " acc_field = self.fieldmap[1,i]*amplitude #actual accelerating field including the used scaling\n",
+ " delta_energy = q * acc_field * self.dl * np.cos(self.omega*tof + applied_phase)\n",
+ " energy_out += delta_energy\n",
+ " if energy_out < 0:\n",
+ " print('Message from Cavity.energy_gain\\nPlease adjust field amplitude for cavity ', self.name)\n",
+ " return\n",
+ " i+=1\n",
+ " enrg_gain.energy_out = energy_out\n",
+ " enrg_gain.tof = tof\n",
+ " return enrg_gain\n",
+ " \n",
+ " def virtual_cavity(self, energy_in: float, amplitude: float, phase: float, **kwargs):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " energy_in: float\n",
+ " input energy to the fieldmap in MeV\n",
+ " amplitude: float\n",
+ " amplitude of the applied field compared to the values in the fieldmap (between 0 and 1)\n",
+ " phase: float\n",
+ " input phase (deg) to the fieldmap\n",
+ " \n",
+ " **kwargs \n",
+ " z_bpm: list\n",
+ " list containing the distances from the exit of the cavity to the BPMs\n",
+ " bpm_noise: list\n",
+ " list containing the individual noises of each BPM\n",
+ " n_measurement: int\n",
+ " number of measurements\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " a list containing:\n",
+ " energy_out: float\n",
+ " energy at the exit of the cavity for the given energy, amplitude and phase including\n",
+ " the internal VC_field_norm and VC_phase_shift\n",
+ " \n",
+ " tof: float\n",
+ " time of flight through the cavity for the given energy, amplitude and phase including\n",
+ " the internal VC_field_norm and VC_phase_shift\n",
+ "\n",
+ " noisy_bpm_phase(len(z_bpm), n_measurement): list\n",
+ " a 2D array containing the phase values at each BPMs for\n",
+ " the n_measurement\n",
+ " \n",
+ " raises\n",
+ " ------\n",
+ " if the energy of the particle reaches zero (partciel coming ro rest) anywhere in the cavity the\n",
+ " function will raise an error\n",
+ " '''\n",
+ " z_bpm = kwargs.get('z_bpm', [0, 1, 5])\n",
+ " bpm_noise = kwargs.get('bpm_noise', [1, 1, 1])\n",
+ " n_measurement = kwargs.get('n_measurement', 3)\n",
+ " VC_phase_shift = kwargs.get('vcps', 0)\n",
+ " #VC_phase_shift = 34 # an arbitrary number for shifting the phase of the field\n",
+ " v_cavity=nested_values()\n",
+ "\n",
+ " tof = 0 #time through the cavity\n",
+ " energy_out = energy_in\n",
+ " VC_field_norm = 0.67 # an arbitrary number for scaling the field\n",
+ " VC_amplitude = amplitude*VC_field_norm\n",
+ " waveguide_length = self.waveguidelength # an arbitrary number representating the phase length of the waveguide\n",
+ " applied_phase = np.radians(phase + waveguide_length + VC_phase_shift)\n",
+ " \n",
+ " i = 0 #index for going through the fieldmap\n",
+ " for z in self.fieldmap[0,:-1]:\n",
+ " tof += length_to_time(self.dl, energy_out)\n",
+ " acc_field = self.fieldmap[1,i] * VC_amplitude #actual accelerating field including the used scaling\n",
+ " delta_energy = q * acc_field * self.dl * np.cos(self.omega*tof + applied_phase)\n",
+ " energy_out += delta_energy\n",
+ " if energy_out < 0:\n",
+ " print('Message from Cavity.virtual_cavity\\nPlease adjust field amplitude for cavity ', self.name)\n",
+ " return\n",
+ " i+=1\n",
+ " \n",
+ " noisy_bpm_phase = np.zeros((len(z_bpm), n_measurement)) #phase recorded at BPM positions (BPMs)\n",
+ " \n",
+ " for i in range(0, n_measurement): \n",
+ " noise_contrib = bpm_noise[:] * np.random.randn(len(bpm_noise))\n",
+ " tof_contrib = length_to_phase(z_bpm, energy_out, self.bunch_freq)\n",
+ " noisy_bpm_phase[:,i] = tof_contrib + noise_contrib\n",
+ " \n",
+ " v_cavity.energy_out=energy_out\n",
+ " v_cavity.tof=tof\n",
+ " v_cavity.noisy_bpm_phase=noisy_bpm_phase\n",
+ " \n",
+ " return v_cavity\n",
+ " \n",
+ " def energy_gain_internal(self, energy_in: float, amplitude: float, phase: float, z_bpm: list):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " energy_in: float\n",
+ " input energy to the fieldmap in MeV\n",
+ " amplitude: float\n",
+ " amplitude of the applied field compared to the values in the fieldmap (between 0 and 1)\n",
+ " phase: float\n",
+ " input phase (deg) to the fieldmap\n",
+ " z_bpm: list\n",
+ " list of the positions of the BPMs in meters measured from the exit of the fieldmap\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " a list containing:\n",
+ " energy_out: float\n",
+ " energy at the exit of the cavity for the given energy, amplitude and phase\n",
+ " tof: float\n",
+ " time of flight through the cavity for the given energy, amplitude and phase\n",
+ " tof_internal: list\n",
+ " list of time of flights from the start of the field to the internal BPMs\n",
+ " \n",
+ " raises\n",
+ " ------\n",
+ " if the energy of the particle reaches zero (particle coming ro rest) anywhere in the cavity the\n",
+ " function will raise an error\n",
+ " '''\n",
+ " enrg_gain_internal=nested_values()\n",
+ "\n",
+ " tof = 0 #time through the cavity\n",
+ " tof_internal = np.zeros(len(z_bpm)) # time through the cavity recorded at intermediate positions (BPMs)\n",
+ " energy_out = energy_in\n",
+ " waveguide_length = 0 # an arbitrary number representating the phase length of the waveguide\n",
+ " local_z_bpm = np.zeros(len(z_bpm))\n",
+ " for i in range(0, len(z_bpm)):\n",
+ " local_z_bpm[i] = z_bpm[i] + self.length \n",
+ " \n",
+ " bpm_index = 0\n",
+ " applied_phase = np.radians(phase + waveguide_length)\n",
+ "\n",
+ " i = 0 # index for going through the fieldmap\n",
+ " for z in self.fieldmap[0,:-1]:\n",
+ " tof += length_to_time(self.dl, energy_out)\n",
+ " acc_field = self.fieldmap[1,i]*amplitude #actual accelerating field including the used scaling\n",
+ " delta_energy = q * acc_field * self.dl * np.cos(self.omega*tof + applied_phase)\n",
+ " energy_out += delta_energy\n",
+ " if bpm_index < len(local_z_bpm):\n",
+ " if np.logical_and(local_z_bpm[bpm_index] >= z , local_z_bpm[bpm_index] <= z + self.dl) :\n",
+ " #print('found BPM', z_bpm[bpm_index], bpm_index)\n",
+ " tof_internal[bpm_index] = tof\n",
+ " bpm_index+=1\n",
+ " if energy_out < 0:\n",
+ " print('Message from Cavity.energy_gain_internal\\nPlease adjust field amplitude for cavity ', self.name)\n",
+ " return\n",
+ " i+=1\n",
+ " enrg_gain_internal.energy_out = energy_out\n",
+ " enrg_gain_internal.tof = tof\n",
+ " enrg_gain_internal.tof_internal = tof_internal\n",
+ " \n",
+ " #return energy_out, tof, tof_internal\n",
+ " return enrg_gain_internal\n",
+ " \n",
+ " def bpm_phase_sim(self, energy_in: float, amplitude: float, phase: float, z_bpm: list, bpm_noise: list, n_measurement: int, **kwargs):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " energy_in: float\n",
+ " input energy to the fieldmap in MeV\n",
+ " amplitude: float\n",
+ " amplitude of the applied field compared to the values in the fieldmap (between 0 and 1)\n",
+ " phase: float\n",
+ " input phase (deg) to the fieldmap\n",
+ " z_bpm: list\n",
+ " list of positions of the BPMs measured from the exit of the fieldmap in meters\n",
+ " bpm_noise: list\n",
+ " list of noise level for each BPM in (deg)\n",
+ " n_measurement: int\n",
+ " number of measurements performed \n",
+ " **kwargs:\n",
+ " Internal: boolean\n",
+ " False: only BPMs external to the cavity/fieldmap are used, if not given the default is False\n",
+ " True: internal BPMs present\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " noisy_bpm_phase(len(z_bpm), n_measurement): a 2D array containing the phase values at each BPMs for\n",
+ " the n_measurement \n",
+ " \n",
+ " \n",
+ " at a given input energy to the field map, calculates the energy gain and the TOF through the\n",
+ " cavity and records it also at distances from the end of the cavity including \n",
+ " the noise from the BPMs for given input amplitude (between 0 and 1) and input sync_phase (in degrees)\n",
+ " '''\n",
+ " internal_bpm = kwargs.get('Internal', False)\n",
+ " \n",
+ " tof = 0 #time through the cavity\n",
+ " tof_internal = np.zeros(len(z_bpm)) #time through the cavity recorded at intermediate positions (BPMs)\n",
+ " noisy_bpm_phase = np.zeros((len(z_bpm), n_measurement)) #phase recorded at intermediate BPM positions (BPMs)\n",
+ " \n",
+ " energy_out = energy_in\n",
+ " \n",
+ " if internal_bpm == False:\n",
+ " if amplitude != 0:\n",
+ " nb_energy_gain = self.energy_gain(energy_in, amplitude, phase)\n",
+ " energy_out = nb_energy_gain.energy_out\n",
+ " tof = nb_energy_gain.tof\n",
+ " elif internal_bpm == True:\n",
+ " if amplitude != 0:\n",
+ " nb_energy_gain = self.energy_gain_internal(energy_in, amplitude, phase, z_bpm)\n",
+ " energy_out = nb_energy_gain.energy_out\n",
+ " tof = nb_energy_gain.tof\n",
+ " tof_internal = nb_energy_gain.tof_internal\n",
+ "\n",
+ " tof_contrib = length_to_phase(z_bpm, energy_out, self.bunch_freq)\n",
+ " for i in range(0, n_measurement): \n",
+ " noise_contrib = bpm_noise[:]*np.random.randn(len(bpm_noise))\n",
+ " noisy_bpm_phase[:,i] = tof_contrib + noise_contrib\n",
+ " \n",
+ " return noisy_bpm_phase\n",
+ " \n",
+ " def find_zero_phase(self, energy_in:float, amplitude: float): #, synch_phase: float ):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " energy_in: float\n",
+ " input energy to the cavity in MeV\n",
+ " amplitude: float\n",
+ " amplitude of the cavity field\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " phase at which the energy gain through the cavity is maximized corresponding to the zero phase\n",
+ " \n",
+ " takes a 1D field on axis along the acceleration axis in MV/m, [Z(m), E(MV/m)]\n",
+ " Z(m) is on a uniform mesh\n",
+ " input energy in MeV, \n",
+ " mass in MeV and \n",
+ " Returns the input_phase resulting in maximum energy gain\n",
+ " '''\n",
+ "\n",
+ " Emax = energy_in\n",
+ " phase_max = 0\n",
+ " counter = 0\n",
+ " phase_start = 0\n",
+ " phase_end = 360\n",
+ " d_phase = 90\n",
+ " counter = 0\n",
+ "\n",
+ " for iteration in np.arange(1, 10):\n",
+ " for phase in np.arange(phase_start, phase_end, d_phase):\n",
+ " counter+=1\n",
+ " energy_tof = self.energy_gain(energy_in, amplitude, phase)\n",
+ " dE = energy_tof.energy_out\n",
+ " #print(phase)\n",
+ " if dE > Emax:\n",
+ " Emax = dE\n",
+ " #print('phase', phase, 'Emax', Emax)\n",
+ " phase_max = phase\n",
+ " #print('iteration', iteration)\n",
+ " phase_start = phase_max - d_phase#*0.6 # would decrease the number of iterations by 40%\n",
+ " phase_end = phase_max + d_phase#*0.6 # would decrease the number of iterations by 40%\n",
+ " if d_phase < 0.025:\n",
+ " #print('goal reached')\n",
+ " break\n",
+ " d_phase = d_phase/4\n",
+ " \n",
+ " return phase_max\n",
+ " \n",
+ " def count_int_bunches(self, energy: float, dz_bpm: float):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " energy: float\n",
+ " energy prior to enterance to the cavity in MeV\n",
+ " dz_bpm: float\n",
+ " distance between BPMs in meters\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " n_bunches: int\n",
+ " number of bunches between two BPMs with distance dz_bpm at energy\n",
+ " \n",
+ " '''\n",
+ " phase_diff = length_to_phase(dz_bpm, energy, self.bunch_freq)\n",
+ " \n",
+ " return int(phase_diff/360)\n",
+ " \n",
+ " def energy_from_tof(self, energy: float, dz_bpm: float, t_scope: float):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " energy: float\n",
+ " energy prior to enterance to the cavity in MeV\n",
+ " dz_bpm: float\n",
+ " distance between BPMs in meters\n",
+ " t_scope: float\n",
+ " phase measured at the BPM (which freq?) converted to time\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " energy_measure: float\n",
+ " energy from measurement of the BPM phases (time) in MeV\n",
+ " \n",
+ " beta.c = L / (NT + t_scope)\n",
+ " '''\n",
+ " N_int = self.count_int_bunches(energy, dz_bpm)\n",
+ " #if t_scope < -90:\n",
+ " # N_int+=1\n",
+ " # t_scope+=self.bunch_t\n",
+ " \n",
+ " beta = dz_bpm / (((N_int * self.bunch_t) + t_scope) * sprel.c())\n",
+ " energy_measure = sprel.energy(beta, mass)\n",
+ " \n",
+ " #print('its from E tof printing:', t_scope, N_int, beta)\n",
+ " return energy_measure\n",
+ " \n",
+ " def fit_and_energy_measure(self, scan_cavity: object, energy_in: float, desired_amp: float, delta_phase: float, \n",
+ " vcps: float, BPM_first: int, BPM_second: int, l_n_col_help: int, virtual: bool):\n",
+ " ''' \n",
+ " parameters\n",
+ " ----------\n",
+ " scan_cavity: object\n",
+ " cavity object defined using Cavity_ class\n",
+ " energy_in: float\n",
+ " input energy to the field\n",
+ " desired_amp: float\n",
+ " expected amplitude, 1 means 100%\n",
+ " delta_phase: float\n",
+ " shift in phase in degrees\n",
+ " vcps: float\n",
+ " virtual cavity phase shift\n",
+ " BPM_first: int\n",
+ " if negative the measurement is done compared to the calibration values\n",
+ " BPM_second: int\n",
+ " number of the BPM used for far phase measurement\n",
+ " l_n_col_help: int\n",
+ " number of columns of the n_col_help matrix\n",
+ " virtual: boolean\n",
+ " virtual cavity (using vcps) or simulated cavity\n",
+ "\n",
+ "\n",
+ " returns\n",
+ " -------\n",
+ " .amp\n",
+ " .mean\n",
+ " .freq\n",
+ " .phase\n",
+ " .de\n",
+ " .x_arr\n",
+ " .y_arr \n",
+ " '''\n",
+ " fit_n_nrj = nested_values()\n",
+ " # WARNING: modulus calculation is not generalized, i.e., for .surface value the modulus should\n",
+ " # be calculated per BPM\n",
+ " modulus = 360.0\n",
+ " if(self.bpm_info_data[3,BPM_first]>0):\n",
+ " if(self.bpm_info_data[3,BPM_first]!=self.bunch_freq*1e6 or \n",
+ " self.bpm_info_data[3,BPM_second]!=self.bunch_freq*1e6):\n",
+ " modulus = 180.0\n",
+ " else:\n",
+ " if(self.bpm_info_data[3,BPM_second]!=self.bunch_freq*1e6):\n",
+ " modulus = 180.0\n",
+ " \n",
+ " n_col = l_n_col_help + len(self.bpm_info_data[2,:])\n",
+ " n_row = len(self.in_phase_range)\n",
+ " phase_scan_array = np.zeros((n_row, n_col))\n",
+ " bpm_calib_phase = np.mod(self.bpm_info_data[5,0:], modulus) # 360.0/harmonic_selector\n",
+ " \n",
+ " if BPM_first >= 0:\n",
+ " first_bpm_pos = 0 # self.bpm_info_data[2, BPM_first]\n",
+ " else:\n",
+ " first_bpm_pos = self.bpm_info_data[2, 0]\n",
+ "\n",
+ " dz = self.bpm_info_data[2, BPM_second] - first_bpm_pos\n",
+ " z_bpm=self.bpm_info_data[2,:]\n",
+ " bpm_noise=self.bpm_info_data[4,:]\n",
+ " \n",
+ " for in_phase_X in self.in_phase_range:\n",
+ " i, = np.where(self.in_phase_range == in_phase_X)[0]\n",
+ " in_phase = in_phase_X + delta_phase\n",
+ " \n",
+ " if virtual:\n",
+ " cavity_sim = self.virtual_cavity(energy_in, desired_amp, in_phase, \n",
+ " vcps = vcps, \n",
+ " z_bpm=z_bpm, \n",
+ " bpm_noise=bpm_noise, \n",
+ " n_measurement=self.n_measurement) # << desired_amp -> 1\n",
+ "\n",
+ " ave_tof_bpm = np.average(cavity_sim.noisy_bpm_phase, axis=1)\n",
+ " \n",
+ " \n",
+ " \n",
+ " else:\n",
+ " cavity_sim = self.energy_gain(energy_in, desired_amp, in_phase)\n",
+ " tof_all_bpm = self.bpm_phase_sim(energy_in, desired_amp, in_phase, \n",
+ " z_bpm=z_bpm, \n",
+ " bpm_noise=bpm_noise, \n",
+ " n_measurement=self.n_measurement, \n",
+ " Internal = self.internal_bpm) # << desired_amp -> 1\n",
+ " ave_tof_bpm = np.average(tof_all_bpm, axis=1)\n",
+ "\n",
+ " phase_scan_array[i, 0] = in_phase_X\n",
+ " phase_scan_array[i, 1] = cavity_sim.energy_out\n",
+ " phase_scan_array[i, 2] = cavity_sim.tof\n",
+ " phase_scan_array[i,l_n_col_help:] = np.mod(ave_tof_bpm, modulus) # WARNING: not correct for generalized case\n",
+ " #bpm_phase_varation = phase_scan_array[i,l_n_col_help:] - bpm_calib_phase\n",
+ " #ave_tof_bpm_no = ave_tof_bpm[BPM_no]\n",
+ "\n",
+ " x_arr = phase_scan_array[:, 0]\n",
+ " if BPM_first >=0:\n",
+ " y_arr = phase_scan_array[:, l_n_col_help+BPM_second] - phase_scan_array[:, l_n_col_help+BPM_first]\n",
+ " else:\n",
+ " y_arr = phase_scan_array[:, l_n_col_help+BPM_second] - bpm_calib_phase[BPM_second]\n",
+ "\n",
+ " \n",
+ " cav_fit_param = fit_sinusoidal(x_arr, y_arr, modulus = modulus)\n",
+ " d_energy = energy_from_dphi(energy_in, cav_fit_param.amp/2, dz, self.bunch_freq) - energy_in\n",
+ "\n",
+ " fit_n_nrj.amp = cav_fit_param.amp\n",
+ " fit_n_nrj.mean = cav_fit_param.mean\n",
+ " fit_n_nrj.freq = cav_fit_param.freq\n",
+ " fit_n_nrj.phase = cav_fit_param.phase\n",
+ " fit_n_nrj.de = d_energy\n",
+ " fit_n_nrj.x_arr = x_arr\n",
+ " fit_n_nrj.y_arr = y_arr\n",
+ " fit_n_nrj.surface = phase_scan_array\n",
+ " \n",
+ " return fit_n_nrj\n",
+ " \n",
+ "def phase_scan_all_bpms(self, scan_cavity: object, energy_in: float, amp: float):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " scan_cavity: object\n",
+ " cavity object defined using Cavity_ class\n",
+ " energy_in: float\n",
+ " input energy to the field\n",
+ " amp: float\n",
+ " field amplitude, 1 means 100%\n",
+ "\n",
+ "\n",
+ "\n",
+ " Returns\n",
+ " -------\n",
+ " A 2D array containing the BPM phase at each BPM for different cavity phase values\n",
+ "\n",
+ " '''\n",
+ " bpm_position_freqMHz = self.get_bpm_positions()\n",
+ " n_col = len(self.c)\n",
+ " n_row = len(self.in_phase_range)\n",
+ "\n",
+ " surf_phase_scan = np.zeros((n_row, n_col))\n",
+ "\n",
+ " self.phase_start\n",
+ " self.phase_end\n",
+ " self.phase_step \n",
+ "\n",
+ " print(n_col)\n",
+ "\n",
+ " return n_col\n",
+ "\n",
+ " \n",
+ "'''\n",
+ "------------------------------------------------------------------------------\n",
+ "------------------------------------------------------------------------------\n",
+ "------------------------------------------------------------------------------\n",
+ "\n",
+ "\n",
+ " End of Cavity_\n",
+ "\n",
+ "\n",
+ "------------------------------------------------------------------------------\n",
+ "------------------------------------------------------------------------------\n",
+ "------------------------------------------------------------------------------\n",
+ "''';\n",
+ " \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def find_phase_amp(scan_cavity: object, energy_in: float, desired_amp: float, desired_sync_phase: float, **kwargs):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " scan_cavity: object\n",
+ " scan_cavity is defined and populated by scan_cavity = Cavity_(...)\n",
+ " energy_in: float\n",
+ " input energy to the cavity\n",
+ " desired_sync_phase: float\n",
+ " desired sync phase at the cavity in degrees\n",
+ " desired_amp: float\n",
+ " desired amplitude of the cavity as ratio to the max cavity field (i.e. 1 is 100%)\n",
+ " \n",
+ " **kwargs\n",
+ " BPM_first: int\n",
+ " index of the first BPM to be used for the rough energy measurement\n",
+ " BPM_second: int\n",
+ " index of the second BPM to be used for fine energy measurement\n",
+ " \n",
+ " \n",
+ " returns \n",
+ " -------\n",
+ " the phase shift and amplitude ratio of the VC to acquire \n",
+ " the desired sync phase and amplitude using energy measurement\n",
+ " This function returns the field shift and field ratio for a virtual \n",
+ " cavity such that the energy gain matches that of a cavity at nominal \n",
+ " field using the output energy of the cavity.\n",
+ " '''\n",
+ " BPM_first = kwargs.get('BPM_first', 0)\n",
+ " BPM_second = kwargs.get('BPM_second', 8)\n",
+ " \n",
+ " des_ph_amp = nested_values()\n",
+ " \n",
+ " vcps_loc = 0 # virtual cavity phase shift\n",
+ " desired_sync_phase=np.mod(desired_sync_phase, 360)\n",
+ "\n",
+ " n_col_help = ['0, phase_in', '1, energy', '2, tof through cavity', '3 rsrv', '4: rsrv', '5: rsrv', '6: rsrv',\n",
+ " '7: rsrv', '8: rsrv', '9: rsrv', '10 to 10+n_bpm: bpm phases']\n",
+ " l_n_col_help = len(n_col_help)-1\n",
+ " harmonic_selector = 1\n",
+ "\n",
+ " # finding the zero phase for shifting the simulations signature curve\n",
+ " zero_phase = scan_cavity.find_zero_phase(energy_in, desired_amp) # <<<<<<< 1 -> desired_amp\n",
+ " \n",
+ " fit_and_energy_sim = scan_cavity.fit_and_energy_measure(scan_cavity, energy_in, desired_amp, \n",
+ " zero_phase, 0, BPM_first, BPM_second, \n",
+ " l_n_col_help, False)\n",
+ " #print(np.degrees(fit_and_energy_sim.phase), fit_and_energy_sim.mean, fit_and_energy_sim.amp)\n",
+ " fit_and_energy_vir = scan_cavity.fit_and_energy_measure(scan_cavity, energy_in, desired_amp, \n",
+ " zero_phase, vcps_loc, BPM_first, BPM_second, \n",
+ " l_n_col_help, True)\n",
+ " #print(np.degrees(fit_and_energy_vir.phase), fit_and_energy_vir.mean, fit_and_energy_vir.amp)\n",
+ " ph_shift = np.degrees(fit_and_energy_vir.phase-fit_and_energy_sim.phase)#+180\n",
+ " field_ratio = fit_and_energy_sim.de/fit_and_energy_vir.de\n",
+ "\n",
+ " if field_ratio < 0:\n",
+ " ph_shift = 180+ph_shift#+180\n",
+ " field_ratio*=-1\n",
+ " #else:\n",
+ " # ph_shift = ph_shift#+180\n",
+ " # field_ratio*=1\n",
+ "\n",
+ " fit_and_energy_adj = scan_cavity.fit_and_energy_measure(scan_cavity, energy_in, desired_amp*field_ratio, \n",
+ " -ph_shift, vcps_loc, BPM_first, BPM_second, \n",
+ " l_n_col_help, True)\n",
+ "\n",
+ " #print(np.degrees(fit_and_energy_adj.phase), fit_and_energy_adj.mean, fit_and_energy_adj.amp)\n",
+ "\n",
+ " singlex = desired_sync_phase\n",
+ " vir_cav_adj = scan_cavity.virtual_cavity(energy_in, desired_amp*field_ratio, \n",
+ " desired_sync_phase-ph_shift, vcps = vcps_loc) \n",
+ " #singley = np.average(sync_vc.tof)\n",
+ " singley = np.average(vir_cav_adj.tof)\n",
+ "\n",
+ " # recreate the fitted curve using the optimized parameters\n",
+ " fine_x = np.arange(0, scan_cavity.phase_end, 0.01)\n",
+ " fine_data_fit=fit_and_energy_sim.amp*np.cos(fit_and_energy_sim.freq*np.radians(fine_x)+\n",
+ " fit_and_energy_sim.phase)+fit_and_energy_sim.mean\n",
+ "\n",
+ " plt.plot(fine_x , fine_data_fit, label='Simulation fit')\n",
+ " plt.plot(fit_and_energy_sim.x_arr, fit_and_energy_sim.y_arr, 'x', label='Simulated points')\n",
+ " plt.plot(fit_and_energy_vir.x_arr, fit_and_energy_vir.y_arr, '.', label='VC data')\n",
+ " plt.plot(fit_and_energy_adj.x_arr, fit_and_energy_adj.y_arr, '+', label='VC - Adjusted')\n",
+ " #plt.plot(singlex, singley , 'x', label='Operating point')\n",
+ " plt.xlabel('Rf phase')\n",
+ " plt.ylabel('BPM phase (deg)')\n",
+ " plt.legend(loc = 1)\n",
+ " plt.show()\n",
+ " #print(np.mod(bpm_info_data[5,BPM_no_2], 360), sim_mean, sim_amp, VC_mean, VC_amp )\n",
+ " print('energy_in {:0.3f}, de_sim {:0.3f}, de_vc {:0.3f}'.format(energy_in, fit_and_energy_sim.de, fit_and_energy_vir.de))\n",
+ " print('Multiply cavity amplitude by {:0.3f} and shift the set_phase by {:0.3f} degrees'.format(field_ratio, ph_shift))\n",
+ " des_ph_amp.phase = ph_shift\n",
+ " des_ph_amp.amp = field_ratio\n",
+ " des_ph_amp.energy_out = energy_in + fit_and_energy_vir.de\n",
+ " des_ph_amp.x_sim = fit_and_energy_sim.x_arr\n",
+ " des_ph_amp.y_sim = fit_and_energy_sim.y_arr\n",
+ " des_ph_amp.x_vir = fit_and_energy_vir.x_arr\n",
+ " des_ph_amp.y_vir = fit_and_energy_vir.y_arr\n",
+ " des_ph_amp.x_adj = fit_and_energy_adj.x_arr\n",
+ " des_ph_amp.y_adj = fit_and_energy_adj.y_arr\n",
+ " return des_ph_amp\n",
+ "\n",
+ "\n",
+ "'''\n",
+ "------------------------------------------------------------------------------------------------\n",
+ "------------------------------------------------------------------------------------------------\n",
+ "\n",
+ "------------------------------------------------------------------------------------------------\n",
+ "------------------------------------------------------------------------------------------------\n",
+ "\n",
+ "\n",
+ "Plotting functions \n",
+ "\n",
+ "\n",
+ "ˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇ\n",
+ "ˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇ\n",
+ "\n",
+ "ˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇ\n",
+ "ˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇˇ\n",
+ "''';\n",
+ "\n",
+ "def plot_field(cavity_name: object):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " cavity_name: object\n",
+ " cavity_name=Cavity_(...) which defines a cavity and populates the Cavity_ \n",
+ "\n",
+ " returns\n",
+ " -------\n",
+ " plots the field of the cavity on axis vs. z (with the normalization used while defining the cavity)\n",
+ " '''\n",
+ " plt.plot(cavity_name.fieldmap[0,:], cavity_name.fieldmap[1,:])\n",
+ " return\n",
+ "\n",
+ "def plot_phase_difference(scan_cavity, energy_in: float, amp: float, phase:float, d_amp: float, d_phase: float):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " scan_cavity: string\n",
+ " cavity defined through Cavity_ \n",
+ " energy_in: float\n",
+ " input energy in MeV\n",
+ " amp: float\n",
+ " amplitude ratio (0-1)\n",
+ " phase:float\n",
+ " phase in degrees (0-360)\n",
+ " d_amp: float\n",
+ " change in amplitude (0.01 means 1% change on field)\n",
+ " d_phase: float\n",
+ " change in phase in degrees\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " plots the phase difference recorded at the position of the BPMs for the input energy for the given cavity \n",
+ " at given phase and amplitude plus the recorded phase for a change in phase or amplitude\n",
+ " \n",
+ " '''\n",
+ " bpm_design_posi = scan_cavity.bpm_info_data[0,:]\n",
+ " bpm_posi = scan_cavity.bpm_info_data[2,:]\n",
+ " bpm_nois = scan_cavity.bpm_info_data[4,:]\n",
+ " n_meas = scan_cavity.n_measurement\n",
+ " intr_tf = scan_cavity.internal_bpm\n",
+ "\n",
+ " phase_orig = scan_cavity.bpm_phase_sim(energy_in, amp, phase, bpm_posi, bpm_nois, n_meas, Internal = intr_tf)\n",
+ " phase_plus = scan_cavity.bpm_phase_sim(energy_in, amp*(1+d_amp), phase+d_phase, bpm_posi, bpm_nois, n_meas, Internal = intr_tf)\n",
+ " phase_minus = scan_cavity.bpm_phase_sim(energy_in, amp*(1-d_amp), phase+d_phase, bpm_posi, bpm_nois, n_meas, Internal = intr_tf)\n",
+ " \n",
+ " lbnois = len(bpm_nois)\n",
+ "\n",
+ " ph_orig_mod = [np.average(np.mod(phase_orig[i,:], 180)) for i in range(0, lbnois)]\n",
+ " ph_plus_mod = [np.average(np.mod(phase_plus[i,:], 180)) for i in range(0, lbnois)]\n",
+ " ph_minus_mod = [np.average(np.mod(phase_minus[i,:], 180)) for i in range(0, lbnois)]\n",
+ " \n",
+ " \n",
+ " z1 = [ph_orig_mod[i]-ph_plus_mod[i] for i in range(0, lbnois)]\n",
+ " z2 = [ph_minus_mod[i]-ph_plus_mod[i] for i in range(0, lbnois)]\n",
+ " z3 = [ph_minus_mod[i]-ph_orig_mod[i] for i in range(0, lbnois)]\n",
+ " \n",
+ "\n",
+ " plt.plot(bpm_design_posi, z1, 'o', label='Orig - Plus')\n",
+ " plt.plot(bpm_design_posi, z2, '.', label='Minus - Plus')\n",
+ " plt.plot(bpm_design_posi, z3, 'x', label='Orig - Minus')\n",
+ "\n",
+ " plot_vc = False\n",
+ " if plot_vc == True:\n",
+ " dummyvc = scan_cavity.virtual_cavity(energy_in, 1*field_ratio, 14+ph_shift, z_bpm=bpm_posi, bpm_noise=bpm_nois, n_measurement=n_meas)\n",
+ " en = dummyvc.energy_out\n",
+ " tf = dummyvc.tof\n",
+ " y4 = dummyvc.noisy_bpm_phase\n",
+ " y4 = [np.average(np.mod(y4[i,:], 180)) for i in range(0, dummyl)]\n",
+ " z4 = [y4[i]-yt[i] for i in range(0, dummyl)]\n",
+ " plt.plot(l_drift_arr,z4, '+')\n",
+ " \n",
+ " plt.legend()\n",
+ " plt.show()\n",
+ " return\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "def cheat_find_phase_amp(scan_cavity: object, energy_in: float, desired_ampl: float, desired_sync_phase: float, **kwargs):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " scan_cavity: object\n",
+ " scan_cavity is defined and populated by scan_cavity = Cavity_(...)\n",
+ " energy_in: float\n",
+ " input energy to the cavity\n",
+ " desired_sync_phase: float\n",
+ " desired sync phase at the cavity in degrees\n",
+ " desired_amp: float\n",
+ " desired amplitude of the cavity in percent of the max cavity field\n",
+ " \n",
+ " **kwargs\n",
+ " BPM_no: int\n",
+ " index of the first BPM to be used for the rough energy measurement\n",
+ " BPM_no_2: int\n",
+ " index of the second BPM to be used for fine energy measurement\n",
+ " \n",
+ " \n",
+ " returns \n",
+ " -------\n",
+ " the phase shift and amplitude ratio of the VC to acquire \n",
+ " the desired sync phase and amplitude using energy measurement\n",
+ " This function returns the field shift and field ratio for a virtual \n",
+ " cavity such that the energy gain matches that of a cavity at nominal \n",
+ " field using the output energy of the cavity.\n",
+ " '''\n",
+ "\n",
+ " desired_amp = 1.0 \n",
+ " desired_sync_phase = -20\n",
+ "\n",
+ "\n",
+ " '''\n",
+ " This function returns the field shift and field ratio for a virtual cavity such that the energy gain matches that \n",
+ " of a cavity at nominal field using the output energy of the cavity.\n",
+ " Should be rewritten to use the BPM phases instead.\n",
+ " '''\n",
+ "\n",
+ " '''\n",
+ " '''\n",
+ "\n",
+ " #vcps=float(input())#8000 # virtual cavity phase shift\n",
+ " vcps = 30\n",
+ "\n",
+ " n_col = 2 + len(bpm_info_data[2,:])\n",
+ " SIM_phase_scan = np.zeros((len(in_phase_range), n_col))\n",
+ " VC_phase_scan = np.zeros((len(in_phase_range), n_col))\n",
+ " VC_phase_scan_adj = np.zeros((len(in_phase_range), n_col))\n",
+ "\n",
+ " BPM_no = 0\n",
+ " BPM_no_2 = 1\n",
+ "\n",
+ " zero_phase = cavity.find_zero_phase(energy_in, 1)\n",
+ " #print(zero_phase)\n",
+ "\n",
+ " i = 0\n",
+ " for in_phase_X in in_phase_range:\n",
+ " in_phase = in_phase_X + zero_phase\n",
+ "\n",
+ " energy_sim, tof_sim = cavity.energy_gain(energy_in, 1, in_phase)\n",
+ " SIM_phase_scan[i, 0] = in_phase_X\n",
+ " SIM_phase_scan[i,1] = energy_sim\n",
+ " SIM_phase_scan[i,2] = tof_sim\n",
+ " SIM_tof_bpm = cavity.noisy_bpm_phase_measurement(energy_in, 1, in_phase, z_bpm=bpm_info_data[2,:], bpm_noise=bpm_info_data[4,:], n_measurement=n_measurement) \n",
+ " ave_sim_tof_bpm = np.average(SIM_tof_bpm[BPM_no])\n",
+ "\n",
+ " energy_vc, tof_vc, tof_vc_bpm = cavity.virtual_cavity(energy_in, 1, in_phase_X, vcps = vcps, z_bpm=bpm_info_data[2,:], bpm_noise=bpm_info_data[4,:], n_measurement=n_measurement) \n",
+ " VC_phase_scan[i, 0] = in_phase_X\n",
+ " #VC_phase_scan[i, 1] = energy\n",
+ " VC_phase_scan[i, 2] = tof_vc\n",
+ "\n",
+ " VC_energy_measured = energy_in\n",
+ "\n",
+ " '''\n",
+ " parameters needed for this function:\n",
+ " BPM_no\n",
+ " BPM_no_2\n",
+ " bpm_info_date[3, \n",
+ " energy_in\n",
+ " VC_phase_scan[i, 3]\n",
+ " tof_bpm[BPM_no_2], [BPM_no]\n",
+ " '''\n",
+ "\n",
+ " second_bpm_list = [1, 3, 9] \n",
+ "\n",
+ " for i_bpm_2 in second_bpm_list:\n",
+ " if BPM_no == i_bpm_2:\n",
+ " print('The same BPM ({}) cannot be used as the first and second BPM at the same time'.format(i_bpm_2))\n",
+ " break\n",
+ " if bpm_info_data[3, BPM_no] == cavity.bunch_freq/1e6 or bpm_info_data[3, i_bpm_2] == cavity.bunch_freq/1e6:\n",
+ " harmonic_selector = 360 # BPMs at the frequency of the bunch, in bunch frequency the coverage is 360 deg\n",
+ " else:\n",
+ " harmonic_selector = 180 # BPMs at second harmonic of the bunch, in bunch frequency the coverage is 180 deg\n",
+ "\n",
+ " SIM_phase_scan[i, 3] = np.mod(ave_sim_tof_bpm, harmonic_selector)\n",
+ "\n",
+ " ave_tof_vc_bpm = np.average(tof_vc_bpm[BPM_no])\n",
+ " VC_phase_scan[i, 3] = np.mod(ave_tof_vc_bpm, harmonic_selector)\n",
+ "\n",
+ " ave_tof_vc_bpm_2 = np.average(tof_vc_bpm[i_bpm_2])\n",
+ " ave_tof_vc_bpm = np.average(tof_vc_bpm[BPM_no])\n",
+ " d_phase = np.mod(ave_tof_vc_bpm_2, harmonic_selector) - np.mod(ave_tof_vc_bpm, harmonic_selector)\n",
+ "\n",
+ " if d_phase<0:\n",
+ " d_phase = np.mod(d_phase+harmonic_selector, harmonic_selector)\n",
+ "\n",
+ " dz_bpm = bpm_info_data[0,i_bpm_2] - bpm_info_data[0,BPM_no] \n",
+ "\n",
+ " t_scope = phase_to_time(d_phase, cavity.bunch_freq)\n",
+ " VC_energy_measured = cavity.energy_from_tof(VC_energy_measured, dz_bpm, t_scope)\n",
+ " '''\n",
+ " loop over BPMs for improved precision\n",
+ " '''\n",
+ " VC_phase_scan[i, 1] = VC_energy_measured\n",
+ " i+=1\n",
+ "\n",
+ "\n",
+ "\n",
+ " simx, simy = SIM_phase_scan[:,0], SIM_phase_scan[:,1] #3\n",
+ " sim_amp, sim_freq, sim_phase, sim_mean = fit_sinusoidal(simx, simy)\n",
+ "\n",
+ " vcx, vcy = VC_phase_scan[:,0], VC_phase_scan[:,1]\n",
+ " VC_amp, VC_freq, VC_phase, VC_mean = fit_sinusoidal(vcx, vcy)\n",
+ "\n",
+ " ph_shift = np.degrees(sim_phase-VC_phase)#+180\n",
+ " field_ratio = sim_amp/VC_amp\n",
+ "\n",
+ " if field_ratio < 0:\n",
+ " ph_shift = 180-np.degrees(sim_phase-VC_phase)#+180\n",
+ " field_ratio*=-1\n",
+ " #print('negated')\n",
+ " else:\n",
+ " ph_shift = -np.degrees(sim_phase-VC_phase)#+180\n",
+ " field_ratio*=1\n",
+ "\n",
+ "\n",
+ " i = 0\n",
+ " for in_phase in in_phase_range:\n",
+ " energy_adj, tof_adj, tof_bpm_adj = cavity.virtual_cavity(energy_in, 1*field_ratio, in_phase-ph_shift, vcps = vcps, z_bpm=bpm_info_data[2,:], bpm_noise=bpm_info_data[4,:], n_measurement=n_measurement) \n",
+ " VC_phase_scan_adj[i, 0] = in_phase\n",
+ " VC_phase_scan_adj[i, 1] = energy_adj\n",
+ " VC_phase_scan_adj[i, 2] = tof_adj\n",
+ "\n",
+ " '''\n",
+ " loop over BPMs, from the BPMs get the energy and from the energy adjust the field\n",
+ " '''\n",
+ " ave_tof_bpm_adj = np.average(tof_bpm_adj[BPM_no])\n",
+ " VC_phase_scan_adj[i, 3] = np.mod(ave_tof_bpm_adj, harmonic_selector)\n",
+ " i+=1\n",
+ "\n",
+ " vcxadj, vcyadj = VC_phase_scan_adj[:,0], VC_phase_scan_adj[:,1] #3\n",
+ "\n",
+ " desired_sync_phase=np.mod(desired_sync_phase, 360)\n",
+ " singlex = desired_sync_phase\n",
+ "\n",
+ " energy_sync, tof_sync, tof_sync_bpm = cavity.virtual_cavity(energy_in, desired_amp*field_ratio, desired_sync_phase-ph_shift, vcps = vcps) \n",
+ " singley = np.average(energy_sync)\n",
+ "\n",
+ " # recreate the fitted curve using the optimized parameters\n",
+ " fine_x = np.arange(0, phase_end, 0.01)\n",
+ " fine_data_fit=sim_amp*np.cos(sim_freq*np.radians(fine_x)+sim_phase)+sim_mean\n",
+ "\n",
+ " plt.plot(vcx , vcy , '.', label='VC data')\n",
+ " plt.plot(fine_x , fine_data_fit, label='Simulation data')\n",
+ " plt.plot(vcxadj , vcyadj , '+', label='VC data- Adjusted')\n",
+ " plt.plot(singlex, singley , 'x', label='Operating point')\n",
+ " plt.legend()\n",
+ " plt.show()\n",
+ "\n",
+ " print('\\nMultiply the Virtual Cavity field by: {:0.3f}% \\nand shift the VC input phase by: {:0.2f} degrees'.format(100*field_ratio*desired_amp, desired_sync_phase-ph_shift))\n",
+ " print('vcps: {}, waveguidelength: {}, zero_phase {:0.2f}'.format(vcps, cavity.waveguidelength, zero_phase))\n",
+ " \n",
+ "def phase_and_amp_scan(scan_cavity: object, energy_in, \n",
+ " amp_start, amp_end, amp_step, \n",
+ " phase_start, phase_end, phase_step, \n",
+ " amp_scan: bool, phase_scan: bool, \n",
+ " field_array_name: list, internal_bpm=bool):\n",
+ "\n",
+ " '''\n",
+ " and returns nested_values, scan_sim (containing phase and amplitude) and \n",
+ " '''\n",
+ " # Scan the Field Amplitude and Phase and record the Energy after cavity\n",
+ "\n",
+ " ph_amp_scan = nested_values()\n",
+ "\n",
+ "\n",
+ " n_col = 10 \n",
+ " n_col_vary = len(scan_cavity.bpm_info_data[2,:])\n",
+ " t_drift_arr=np.zeros(len(scan_cavity.bpm_info_data[2,:]))\n",
+ " scan_index = 0\n",
+ "\n",
+ " scan_sim = np.zeros((len(scan_cavity.field_amp_range), len(scan_cavity.in_phase_range), n_col)) \n",
+ " scan_sim_help=np.array([['amplitude_index, phase_index, 0', 'scan_index'],\n",
+ " ['amplitude_index, phase_index, 1', 'field amplitude %'],\n",
+ " ['amplitude_index, phase_index, 2', 'input phase'],\n",
+ " ['amplitude_index, phase_index, 3', 'out energy'],\n",
+ " ['amplitude_index, phase_index, 4', 'TOF'],\n",
+ " ['amplitude_index, 1, 5-8','amp, freq, phase, and mean of fit_sinusoidal(phase, energy)']])\n",
+ " scan_sim_bunchlength = np.zeros((len(scan_cavity.field_amp_range), len(scan_cavity.in_phase_range), n_col_vary))\n",
+ " scan_sim_bpm_phase = np.zeros((len(scan_cavity.field_amp_range), len(scan_cavity.in_phase_range), n_col_vary))\n",
+ " scan_sim_fit_data = np.zeros((len(scan_cavity.field_amp_range), len(scan_cavity.in_phase_range), 5))\n",
+ "\n",
+ "\n",
+ " for field_amp in scan_cavity.field_amp_range:\n",
+ " zero_phase = scan_cavity.find_zero_phase(energy_in, field_amp/100)\n",
+ " for in_phase in scan_cavity.in_phase_range:\n",
+ " energy=energy_in\n",
+ " findex, = np.where(scan_cavity.field_amp_range == field_amp)[0]\n",
+ " phindex, = np.where(scan_cavity.in_phase_range == in_phase)[0]\n",
+ " #findex = findex[0]\n",
+ " #phindex = phindex[0]\n",
+ " scan_sim[findex, phindex, 0] = scan_index\n",
+ " scan_sim[findex, phindex, 1] = field_amp/100\n",
+ " scan_sim[findex, phindex, 2] = in_phase\n",
+ " dummyeg = scan_cavity.energy_gain(energy, field_amp/100, in_phase + zero_phase )\n",
+ " scan_sim[findex, phindex, 3] = dummyeg.energy_out\n",
+ " scan_sim[findex, phindex, 4] = dummyeg.tof\n",
+ "\n",
+ " scan_sim_bunchlength[findex, phindex, 0:] = 0 # Read Data from TraceWin or ELS on the bunch length with given parameters\n",
+ " #Required parameters, fieldmap, energy, field amplitude, field phase, current = 6 mA?, l_drift_arr[]'''\n",
+ "\n",
+ " t_drift_arr = length_to_time(scan_cavity.bpm_info_data[2,:], scan_sim[findex, phindex, 3])\n",
+ "\n",
+ " scan_sim_bpm_phase[findex, phindex, 0:] = time_to_phase_deg(t_drift_arr[:]+\n",
+ " scan_sim[findex, phindex, 4], scan_cavity.freq)\n",
+ " scan_index+=1\n",
+ " dummysimfit=fit_sinusoidal(scan_sim[findex,:,2], scan_sim[findex,:,3])\n",
+ " scan_sim_fit_data[findex, 1, 0] = dummysimfit.amp\n",
+ " scan_sim_fit_data[findex, 1, 1] = dummysimfit.freq\n",
+ " scan_sim_fit_data[findex, 1, 2] = dummysimfit.phase\n",
+ " scan_sim_fit_data[findex, 1, 3] = dummysimfit.mean\n",
+ "\n",
+ " plt.figure(figsize=(9.0, 3.0))\n",
+ "\n",
+ " plt.subplot(1, 2, 1)\n",
+ " plt.title('Energy vs. Phase')\n",
+ " for i in range(len(scan_cavity.field_amp_range)):\n",
+ " #plt.plot(scan_sim[i,:,2], scan_sim[i,:,3], label=scan_sim[i,0,1])\n",
+ " plt.plot(scan_sim[i,:,2], scan_sim_bpm_phase[i,:,1], label=scan_sim[i,0,1])\n",
+ " plt.subplot(1, 2, 2)\n",
+ " plt.title('Energy vs. Field Amplitude')\n",
+ " for i in range(len(scan_cavity.in_phase_range)):\n",
+ " #plt.plot(scan_sim[i,:,2], scan_sim[i,:,3], label=scan_sim[i,0,1])\n",
+ " plt.plot(scan_sim[:,i,1], scan_sim_bpm_phase[:,i,1], label=scan_sim[0,i,2])\n",
+ "\n",
+ "\n",
+ " plt.tight_layout()\n",
+ " plt.show()\n",
+ " \n",
+ " ph_amp_scan.phases = scan_sim[0,:,2]\n",
+ " ph_amp_scan.amps = scan_sim[0,:,1]\n",
+ " ph_amp_scan.bpms = scan_cavity.bpm_info_data[2,:]\n",
+ " ph_amp_scan.readings = scan_sim_bpm_phase[:,:,:]\n",
+ " return ph_amp_scan\n",
+ "\n",
+ "def de_modulus(x_arr: list, y_arr: list, modulus: float, iterations: int, direction: int):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " x_arr: array like\n",
+ " list of x values\n",
+ " y_arr: array like\n",
+ " list of y values which have gone through a mod function\n",
+ " modulus: float\n",
+ " modulus which used in gnerating the y values\n",
+ " iterations: int\n",
+ " number if iterations through the y values\n",
+ " direction: int\n",
+ " defines the direction of movement over the data, +1: forward (recommended), -1: backward, 2: bothways\n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " a list containing new y values assuming a y varies smoothly with x \n",
+ " \n",
+ " ERRORS\n",
+ " ------\n",
+ " for jittered data sets of periodic type the end value could be different from the first value\n",
+ " '''\n",
+ " fwd = True\n",
+ " bwd = True\n",
+ " if direction == 1:\n",
+ " bwd = False\n",
+ " elif direction == -1:\n",
+ " fwd = False\n",
+ " \n",
+ " \n",
+ " y_new = np.zeros(len(y_arr))\n",
+ " y_new[:]=y_arr[:]\n",
+ "\n",
+ " for iteration in range(0,iterations):\n",
+ " if fwd:\n",
+ " i = 0\n",
+ " while i+3 < len(x_arr):\n",
+ " slope_befor = (y_new[i+1] - y_new[i]) / (x_arr[i+1] - x_arr[i])\n",
+ " slope_split = (y_new[i+2] - y_new[i+1]) / (x_arr[i+2] - x_arr[i+1])\n",
+ " slope_after = (y_new[i+3] - y_new[i+2]) / (x_arr[i+3] - x_arr[i+2])\n",
+ " if (slope_befor * slope_after > 0) and (slope_befor * slope_split < 0):# or (slope_after * slope_befor == 0 and y_new[i+1]!=y_new[i+2]):\n",
+ " sgn = -np.sign(slope_split)\n",
+ " y_new[i+2:]=y_new[i+2:]+modulus*sgn\n",
+ " i+=1\n",
+ "\n",
+ " if bwd: #reverse calc\n",
+ " y_new = y_new[::-1]\n",
+ " x_arr = max(x_arr)-x_arr[::-1]\n",
+ " i = 0\n",
+ " while i+3 < len(x_arr):\n",
+ " slope_befor = (y_new[i+1] - y_new[i]) / (x_arr[i+1] - x_arr[i])\n",
+ " slope_split = (y_new[i+2] - y_new[i+1]) / (x_arr[i+2] - x_arr[i+1])\n",
+ " slope_after = (y_new[i+3] - y_new[i+2]) / (x_arr[i+3] - x_arr[i+2])\n",
+ " if (slope_befor * slope_after > 0) and (slope_befor * slope_split < 0):# or (slope_after * slope_befor == 0 and y_new[i+1]!=y_new[i+2]):\n",
+ " sgn = -np.sign(slope_split)\n",
+ " y_new[i+2:]=y_new[i+2:]+modulus*sgn\n",
+ " i+=1\n",
+ " y_new = y_new[::-1]\n",
+ " x_arr = max(x_arr)-x_arr[::-1]\n",
+ "\n",
+ " return y_new\n",
+ "\n",
+ "def length_to_time(length, energy):\n",
+ " '''calculates the time it takes for a particle with given energy to travel the given length'''\n",
+ " if (type(length)==list):\n",
+ " return [l / (sprel.beta_c(energy, mass)) for l in length]\n",
+ " else:\n",
+ " return length/(sprel.beta_c(energy, mass))\n",
+ "\n",
+ "def phase_to_time(phase, freq_Hz):\n",
+ " '''calculates the time corresponding to a phase difference between two points at bunch frequency'''\n",
+ " t_period = 1.0/freq_Hz\n",
+ " if (type(phase)==list):\n",
+ " return [t_period * ph / 360 for ph in phase]\n",
+ " else:\n",
+ " return t_period * phase / 360\n",
+ " \n",
+ "def length_to_phase(length, energy, freq_Hz):\n",
+ " '''calculates the phase change for a particle with given energy to travel the given length'''\n",
+ " if (type(length)==list):\n",
+ " return [freq_Hz * 360 * l / (sprel.beta_c(energy, mass)) for l in length]\n",
+ " else:\n",
+ " return freq_Hz * 360 * length/(sprel.beta_c(energy, mass))\n",
+ "\n",
+ "def time_to_phase_deg(time, freq_Hz): #Time in seconds and freq in Hz\n",
+ " '''converts time to phase in degrees at given frequency in Hz'''\n",
+ " if (type(time)==list):\n",
+ " return [t*freq_Hz*360 for t in time]\n",
+ " else:\n",
+ " return time*freq_Hz*360\n",
+ "\n",
+ "def time_to_phase_rad(time, freq_Hz):\n",
+ " '''converts time to phase in radians at given frequency in Hz'''\n",
+ " if (type(time)==list):\n",
+ " return [t*freq_Hz*2*np.pi for t in time]\n",
+ " else:\n",
+ " return time*freq_Hz*2*np.pi\n",
+ " \n",
+ "def energy_from_dphi(energy_in: float, dphi: float, dz: float, bunch_freqHz: float):\n",
+ " '''\n",
+ " parameters\n",
+ " ----------\n",
+ " energy_in: float\n",
+ " input energy to the scanned cavity in MeV\n",
+ " dphi: float\n",
+ " phase change at 180 degrees vs. the phase change at 90 degrees (in bunch frequency) in degrees\n",
+ " dz: flaot\n",
+ " distance between the two BPMs in meters\n",
+ " bunch_freqHz: float\n",
+ " bunch frequency in Hz\n",
+ " \n",
+ " \n",
+ " returns\n",
+ " -------\n",
+ " energy_out: float\n",
+ " energy_out in MeV from dphi(deg) and dz(m)\n",
+ " '''\n",
+ " \n",
+ " wavelength_bar = sprel.c()/bunch_freqHz/2/np.pi #wavelength at bunch frequency in m\n",
+ " \n",
+ " beta_in = sprel.beta(energy_in, mass)\n",
+ " \n",
+ " d_beta = -1 * dphi * beta_in**2 / (dphi * beta_in + dz / wavelength_bar)\n",
+ " #print('e f p', beta_in, d_beta)\n",
+ " if beta_in+d_beta < 1:\n",
+ " energy_out = sprel.energy(beta_in + d_beta, mass)\n",
+ " else:\n",
+ " energy_out = 0\n",
+ " \n",
+ " return energy_out\n",
+ "\n",
+ "def fit_sinusoidal(x_data: list, y_data: list, **kwargs):\n",
+ " '''\n",
+ " Parameters\n",
+ " ----------\n",
+ " x_data: list\n",
+ " list of phase points in degrees\n",
+ " y_data: list\n",
+ " list of measurement values\n",
+ " **kwargs:\n",
+ " modulus: float\n",
+ " if given, the fit will be done to function y (mod modulus), default is inf\n",
+ "\n",
+ " For a given set of x and corresponding y values, \n",
+ " Returns\n",
+ " -------\n",
+ " fit_sinusoidal.est_amp, fit_sinusoidal.est_freq, fit_sinusoidal.est_phase and fit_sinusoidal.est_mean\n",
+ "\n",
+ " Parameters of the function y = x[0]*np.cos(x[1]*t+x[2]) + x[3]\n",
+ "\n",
+ " where x[0] is the amplitude, x[1] the frequency, x[2] the phase, and x[3] the baseline value\n",
+ " arrays x and y should have the same size and have at least four values\n",
+ " '''\n",
+ " from math import inf as math_inf\n",
+ " import numpy as np\n",
+ "\n",
+ " modulus = kwargs.get('modulus', math_inf)\n",
+ " fit_sin=nested_values()\n",
+ "\n",
+ " if modulus < math_inf:\n",
+ " y_data = de_modulus(x_data, y_data, modulus, 10, 1)\n",
+ "\n",
+ "\n",
+ " # we'll use this to plot our first estimate. This might already be good enough for you\n",
+ " t = np.radians(x_data)\n",
+ " #guess_mean = np.mean(y_data)\n",
+ " guess_mean = (np.max(y_data)+np.min(y_data))/2\n",
+ "\n",
+ " #guess_amp = 3*np.std(y_data)/(2**0.5)\n",
+ " guess_amp = (np.max(y_data)-np.min(y_data))/2\n",
+ "\n",
+ " guess_phase = 0\n",
+ " guess_freq = 1\n",
+ " ###data_first_guess = guess_amp*np.cos(t+guess_phase) + guess_mean\n",
+ " #plt.plot(t, data_first_guess, label='first guess')\n",
+ "\n",
+ "\n",
+ "\n",
+ " # Define the function to optimize, in this case, we want to minimize the difference\n",
+ " # between the actual data and our \"guessed\" parameters\n",
+ " optimize_func = lambda x: x[0]*np.cos(x[1]*t+x[2]) + x[3] - y_data\n",
+ " # optimize_func = lambda x: np.mod((x[0]*np.cos(x[1]*t+x[2]) + x[3]), modulus) - y_data # modulus added\n",
+ " est_amp, est_freq, est_phase, est_mean = leastsq(optimize_func, [guess_amp, guess_freq, guess_phase, guess_mean])[0]\n",
+ "\n",
+ " fit_sin.amp = est_amp\n",
+ " fit_sin.freq = est_freq\n",
+ " fit_sin.phase = est_phase\n",
+ " fit_sin.mean = est_mean\n",
+ "\n",
+ " return fit_sin"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cavity_dtl1=Cavity_('DTL1_reg', 352.21, 't', \n",
+ " scaling = 10,\n",
+ " dl_scaling = 1,\n",
+ " dimension = 1,\n",
+ " internal_bpm = True,\n",
+ " path = '/Users/mohammadeshraqi/cernbox/Work/Coding/Python/Data/FM/',\n",
+ " ext = '.txt',\n",
+ " energy_start = 3.62,\n",
+ " n_measurement = 10,\n",
+ " n_calibrating_pulses = 3,\n",
+ " phase_start = 0.0,\n",
+ " phase_end = 360.1,\n",
+ " phase_step = 60,\n",
+ " amp_start = 0.80,\n",
+ " amp_end = 1.01,\n",
+ " amp_step = 0.10,\n",
+ " n_bpm = 10,\n",
+ " delimeter = ' '\n",
+ " ) \n",
+ "# f_skip = 10"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cavity_spk1=Cavity_('Spoke_W_coupler', 352.21, 'b', \n",
+ " scaling = 1/168048.0,\n",
+ " dimension = 3,\n",
+ " internal_bpm = False,\n",
+ " path = '/Users/mohammadeshraqi/cernbox/Work/Coding/Python/Data/FM/',\n",
+ " ext = '.edz',\n",
+ " energy_start = 90.0,\n",
+ " n_measurement = 10,\n",
+ " n_calibrating_pulses = 3,\n",
+ " phase_start = 0.0,\n",
+ " phase_end = 360.1,\n",
+ " phase_step = 15.0,\n",
+ " amp_start = 0.80,\n",
+ " amp_end = 1.01,\n",
+ " amp_step = 0.10,\n",
+ " n_bpm = 10\n",
+ " ) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cavity_mbl1=Cavity_('MB_W_coupler', 704.42, 'b', \n",
+ " scaling = 1,\n",
+ " dimension = 3,\n",
+ " internal_bpm = False,\n",
+ " path = '/Users/mohammadeshraqi/cernbox/Work/Coding/Python/Data/FM/',\n",
+ " ext = '.edz',\n",
+ " energy_start = 200.0,\n",
+ " n_measurement = 10,\n",
+ " n_calibrating_pulses = 3,\n",
+ " phase_start = 0.0,\n",
+ " phase_end = 360.1,\n",
+ " phase_step = 10.0,\n",
+ " amp_start = 0.80,\n",
+ " amp_end = 1.01,\n",
+ " amp_step = 0.10,\n",
+ " n_bpm = 10\n",
+ " ) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cavity_hbl1=Cavity_('HB_W_coupler', 704.42, 'b', \n",
+ " scaling = 1,\n",
+ " dimension = 3,\n",
+ " internal_bpm = False,\n",
+ " path = '/Users/mohammadeshraqi/cernbox/Work/Coding/Python/Data/FM/',\n",
+ " ext = '.edz',\n",
+ " energy_start = 500.0,\n",
+ " n_measurement = 10,\n",
+ " n_calibrating_pulses = 3,\n",
+ " phase_start = 0.0,\n",
+ " phase_end = 360.1,\n",
+ " phase_step = 10.0,\n",
+ " amp_start = 0.80,\n",
+ " amp_end = 1.01,\n",
+ " amp_step = 0.10,\n",
+ " n_bpm = 10\n",
+ " ) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x150ef6e8d0>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "cac = cavity_dtl1\n",
+ "plt.figure(figsize=(9.0, 3.0))\n",
+ "plt.subplot(1, 2, 1)\n",
+ "plot_field(cac)\n",
+ "#plt.legend(loc = 1)\n",
+ "plt.subplot(1, 2, 2)\n",
+ "plot_phase_difference(cac, cac.energy_start, 1, 25, 0.001, 0)\n",
+ "#plt.legend(loc = 1)\n",
+ "plt.show()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x150ef6e908>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "energy_in 3.620, de_sim -3.620, de_vc -3.620\n",
+ "Multiply cavity amplitude by 1.000 and shift the set_phase by -2.871 degrees\n",
+ "Phase should be shifted by -2.871 and ampitude should be multiplied by 1.000\n"
+ ]
+ }
+ ],
+ "source": [
+ "x_dtl = find_phase_amp(cavity_dtl1, cavity_dtl1.energy_start, 1, -10,BPM_first = -1, BPM_second = 0)\n",
+ "print('Phase should be shifted by {:0.3f} and ampitude should be multiplied by {:0.3f}'.format(x_dtl.phase, x_dtl.amp))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x150f699080>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "energy_in 90.000, de_sim -90.000, de_vc 349.625\n",
+ "Multiply cavity amplitude by 0.257 and shift the set_phase by 228.211 degrees\n",
+ "Phase should be shifted by 228.211 and ampitude should be multiplied by 0.257\n"
+ ]
+ }
+ ],
+ "source": [
+ "x_spk = find_phase_amp(cavity_spk1, cavity_spk1.energy_start, 1, -10, BPM_first = 1, BPM_second = 6)\n",
+ "print('Phase should be shifted by {:0.3f} and ampitude should be multiplied by {:0.3f}'.format(x_spk.phase, x_spk.amp))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x150f7f2ba8>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "energy_in 200.000, de_sim 133.732, de_vc 75.397\n",
+ "Multiply cavity amplitude by 1.774 and shift the set_phase by 53.048 degrees\n",
+ "Phase should be shifted by 53.048 and ampitude should be multiplied by 1.774\n"
+ ]
+ }
+ ],
+ "source": [
+ "x_mbl = find_phase_amp(cavity_mbl1, cavity_mbl1.energy_start, 1, -30, BPM_first = 3, BPM_second = 5)\n",
+ "print('Phase should be shifted by {:0.3f} and ampitude should be multiplied by {:0.3f}'.format(x_mbl.phase, x_mbl.amp))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x150ef10978>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "energy_in 500.000, de_sim 928.021, de_vc 488.944\n",
+ "Multiply cavity amplitude by 1.898 and shift the set_phase by 103.859 degrees\n",
+ "Phase should be shifted by 103.859 and ampitude should be multiplied by 1.898\n"
+ ]
+ }
+ ],
+ "source": [
+ "x_hbl = find_phase_amp(cavity_hbl1, cavity_hbl1.energy_start, 1, -30, BPM_first = 1, BPM_second = 7)\n",
+ "print('Phase should be shifted by {:0.3f} and ampitude should be multiplied by {:0.3f}'.format(x_hbl.phase, x_hbl.amp))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[-7.000e+00 1.000e-01 5.000e-01 3.975e+00 5.065e+00 7.829e+00\n",
+ " 9.210e+00 3.200e+01 6.400e+01 1.280e+02]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x150c356cc0>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x = x_hbl\n",
+ "print(cavity_mbl1.bpm_info_data[0,:])\n",
+ "modul = 180\n",
+ "\n",
+ "plt.plot(x.x_sim, x.y_sim, ':g', label = 'Sim org data');\n",
+ "y_de_mod = de_modulus(x.x_sim, x.y_sim, modul, 5, 1) # the y data with reverse modulus function\n",
+ "plt.plot(x.x_sim, y_de_mod, '.g');\n",
+ "\n",
+ "plt.plot(x.x_vir, x.y_vir, ':b', label = 'Vir org data');\n",
+ "y_de_mod = de_modulus(x.x_vir, x.y_vir, modul, 5, 1) # the y data with reverse modulus function\n",
+ "plt.plot(x.x_vir, y_de_mod, '.b');\n",
+ "\n",
+ "plt.plot(x.x_adj, x.y_adj, ':r', label = 'Adj org data');\n",
+ "y_de_mod = de_modulus(x.x_adj, x.y_adj, modul, 5, 1) # the y data with reverse modulus function\n",
+ "plt.plot(x.x_vir, y_de_mod, '.r');\n",
+ "plt.legend();"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "21.778500695621773 94.91064548375404 206.48979889957167 512.0767660966316\n"
+ ]
+ }
+ ],
+ "source": [
+ "dtl_de = cavity_dtl1.energy_gain(3.62, 1.01, 176)\n",
+ "spk_de = cavity_spk1.energy_gain(90, 1.0, 40)\n",
+ "mbl_de = cavity_mbl1.energy_gain(200, 1, 34)\n",
+ "hbl_de = cavity_hbl1.energy_gain(500, 1, 50)\n",
+ "print(dtl_de.energy_out, spk_de.energy_out, mbl_de.energy_out, hbl_de.energy_out)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x1517fd8b38>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x1517fdc470>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "spk_scan = phase_and_amp_scan(cavity_spk1, 90, \n",
+ " 0.99, 1.01, 1, \n",
+ " 0, 360.1, 40, \n",
+ " True, True, \n",
+ " cavity_spk1.fieldmap, internal_bpm=False)\n",
+ "\n",
+ "mbl_scan = phase_and_amp_scan(cavity_mbl1, 500, \n",
+ " 0.99, 1.01, 1, \n",
+ " 0, 360.1, 40, \n",
+ " True, True, \n",
+ " cavity_mbl1.fieldmap, internal_bpm=False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 168,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x151963c908>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from mpl_toolkits.mplot3d import Axes3D\n",
+ "from matplotlib import cm\n",
+ "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "\n",
+ "phase_zero = cavity_mbl1.bpm_phase_sim(500, 0, -90, cavity_mbl1.bpm_info_data[2,:], cavity_mbl1.bpm_info_data[4,:], 1, Internal = False)\n",
+ "ph_s_list = np.arange(0, 380, 15)\n",
+ "phase_surf = np.zeros((len(ph_s_list), len(cavity_mbl1.bpm_info_data[2,:])))\n",
+ "i = 0\n",
+ "for ph_s in ph_s_list:\n",
+ " phase = cavity_mbl1.bpm_phase_sim(500, 1, ph_s, cavity_mbl1.bpm_info_data[2,:], 10*cavity_mbl1.bpm_info_data[4,:], 1, Internal = False)\n",
+ " phase_surf[i,:] = phase[:,0] - phase_zero[:,0]\n",
+ " i+=1\n",
+ "#print (phase_surf, np.shape(phase_surf))\n",
+ "\n",
+ "X = ph_s_list\n",
+ "Y = cavity_mbl1.bpm_info_data[2,:]\n",
+ "Y, X = np.meshgrid(Y, X)\n",
+ "\n",
+ "base = abs(phase_surf.min())\n",
+ "Z = np.mod(phase_surf+base, 360)\n",
+ "#print(np.shape(Z), np.shape(X), np.shape(Y))\n",
+ "\n",
+ "fig = plt.figure()\n",
+ "ax = fig.gca(projection='3d')\n",
+ "\n",
+ "surf = ax.plot_surface(Y, X, Z, rstride=1, cstride=1, cmap=cm.coolwarm, alpha = 0.2)\n",
+ "scat = ax.scatter(Y, X, Z, depthshade=False, zdir='z')\n",
+ "\n",
+ "#ax.set_zlim(-1.01, 1.01)\n",
+ "#ax.zaxis.set_major_locator(LinearLocator(10))\n",
+ "#ax.zaxis.set_major_formatter(FormatStrFormatter('%.01f'))\n",
+ "#fig.colorbar(surf, shrink=0.5, aspect=10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x1520fd6470>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "'''This is a sample scan of bunch length vs. input phase of the \n",
+ " cavity SPK1 with an input energy of 89.8857 MeV through a \n",
+ " pure drift of 10, 20, 30 and 50 m length\n",
+ " The columns are:\n",
+ " phase_in(deg), energy_out(MeV), sigma_rms(deg) at 10, 20, 30 and 50 m\n",
+ " '''\n",
+ "path_to_all_fields = '/Users/mohammadeshraqi/cernbox/Work/Coding/Python/Data/FM/Other/'\n",
+ "bunch_length_after = pd.read_csv(path_to_all_fields + 'BunchLengthSPK1.txt', sep=\"\\t\")\n",
+ "bunch_length_after = bunch_length_after.values #Converting Pandas dataframce to numpy array\n",
+ "#normalization=[1, 1, 4.393, 2.386, 1.634, 1]\n",
+ "normalization=[1, 1, 1, 1, 1, 1]\n",
+ "for i in np.arange(2,6):\n",
+ " plt.plot(bunch_length_after[0:46,0], normalization[i] * bunch_length_after[0:46,i], '.')\n",
+ "\n",
+ "#print(max(bunch_length_after_x_m[:,5]/max(bunch_length_after_x_m[:,4])))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(dphi/dt)/(dphi/da): -1.0*a*tan(t)\n",
+ "(dphi/dE)/(dphi/da): 1.0/cos(t)\n",
+ " dphi/da: -2.0*L*f*m**2*p*(-m**2/(E + a*cos(t) + m)**2 + 1)**(-1.5)*cos(t)/(c*(E + a*cos(t) + m)**3)\n",
+ "(dphi/da)/(dphi/dL): -1.0*L*m**2*(-m**2/(E + a*cos(t) + m)**2 + 1)**(-1.0)*cos(t)/(E + a*cos(t) + m)**3\n",
+ " dphi/dL: 2*f*p*(-m**2/(E + a*cos(t) + m)**2 + 1)**(-0.5)/c\n"
+ ]
+ }
+ ],
+ "source": [
+ "'''\n",
+ "Looking at the derivatives of the BPM phase change wrt Input energy, Field amplitude, field phase and \n",
+ "distance from the cavity\n",
+ "'''\n",
+ "from sympy import *\n",
+ "#from sympy.plotting import plot\n",
+ "g, b, E, de, m, a, t, c, p, f, phi, L = symbols('g b E de m a t c p f phi L')\n",
+ "# gamma, beta, Energi, dE, mass, alpha, theta, c, pi, freq, phi_bpm, L_bpm\n",
+ "de = a*cos(t)\n",
+ "g = 1 + E/m + de/m\n",
+ "b = (1-g**-2)**0.5\n",
+ "\n",
+ "phi = 2 * p * f * L / (b * c)\n",
+ "\n",
+ "dphidL = diff(phi, L)\n",
+ "dphidE = diff(phi, E)\n",
+ "dphidt = diff(phi, t)\n",
+ "dphida = diff(phi, a)\n",
+ "\n",
+ "print('(dphi/dt)/(dphi/da):', simplify(dphidt/dphida))\n",
+ "print('(dphi/dE)/(dphi/da):', simplify(dphidE/dphida))\n",
+ "print(' dphi/da:', simplify(dphida))\n",
+ "print('(dphi/da)/(dphi/dL):', simplify(dphida/dphidL))\n",
+ "print(' dphi/dL:', simplify(dphidL))\n",
+ "'''\n",
+ "ph, bt, gm = symbols('ph bt gm')\n",
+ "# phi_bpm, beta, gamma\n",
+ "bt = 2 * p * f * L / (ph * c)\n",
+ "gm = (1-bt**2)**-0.5\n",
+ "E = m (gm - 1)\n",
+ "dEdphi = diff(E, ph)\n",
+ "print(simplify(dEdphi))\n",
+ "''';"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.6.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}