| | |
- Bunch
class Bunch |
| |
Represents a bunch of particles. Methods to:
- Read/write from a file
- Calculate arbitrary moments
- Apply cuts
- Calculate emittances, beta functions etc
- Extract hit data as float or arrays of floats
- Plots (with ROOT imported)
|
| |
Methods defined here:
- __copy__(self)
- Make a copy but use references to self's data
- __deepcopy__(self, target)
- Make a copy and copy self's data
- __del__(self)
- Called by del
- __delitem__(self, key)
- Called by remove method, deletes the key^th hit in the bunch
- __eq__(self, target, float_tolerance=1e-09)
- Return true if all hits in self are the same as all hits in target, and set_covariance_matrix data are the same
- __getitem__(self, key)
- Called by subscript operator, returns the key^th hit in the bunch
- __init__(self)
- Initialise to an empty bunch. Alternatively use static initialisers defined below - I prefer static initialisers
- __len__(self)
- Number of hits
- __ne__(self, target, float_tolerance=1e-09)
- Return true if any hits in self are not the same as the corresponding hit in target
- __repr__(self)
- Return a long string that contains data in every hit
- __setitem__(self, key, value)
- Called by subscript operator, sets the key^th hit in the bunch
- __str__(self)
- Return an abbreviated string like <Bunch of n Hits>
- abelian_transformation(self, rotation_list, rotation_matrix, translation_dict={}, origin_dict={}, mass_shell_variable='')
- Perform an Abelian Transformation on all variables in the bunch so that V_{out} - O = R*(V_{in}-O)+T
- rotation_list = list of Hit.set_variables() strings that defines the vector V
- rotation_matrix = matrix R
- translation_dict = dict of Hit.set_variables() strings to values that defines the vector T
- mass_shell_variable = set mass shell variable so that E^2=p^2+m^2 after transformation.
Does nothing if equal to ''
- origin_dict = dict of Hit.set_variables() strings to values that defines the vector O. Defaults to
bunch mean.
e.g. bunch.abelian_transformation(['x','px','z'], [[1,0.1,0],[0,1,0],[0,0,1]], {'z':1000}, 'pz') has
V_{in} = ('x','px','z')
R = 1 0.1 0
0 1 0
0 0 1
T = (0,0,1000)
O = bunch mean
(This is like a drift). Note that 'z' has to be explicitly included in the rotation to be present in T
- append(self, hit)
- Append a hit to Bunch self
- bunch_weight(self)
- Return statistical weight of all hits in the bunch
- clear_local_weights(self)
- Set local_weight of all hits in the bunch to 1
- clear_weights(self)
- Set global_weight and local_weight of all hits in the bunch to 1
- conditional_remove(self, variable_value_dict, comparator, value_is_nsigma_bool=False)
- For when a cut is not good enough, remove hits from the bunch altogether if comparator(value, get([variable])) is False
- variable_value_dict = dict of Bunch.get_variables() to the cut value; cut if the hit variable has value > value
- value_is_nsigma_bool = boolean; if True, value is the number of standard deviations
- global_cut = boolean; if True, apply cut to global weights; else apply to local weights
e.g. bunch.cut({'energy':300,}, operator.ge) removes particles if they have
ge(hit.get('energy'),300) here operator.ge is a functional representation of the >= operator
ge(hit.get('energy'),300) is the same as (hit.get('energy') >= 300)
A whole load of useful comparators can be found in the operator module. e.g. ge is >=; le is <=; etc
See also python built-in function "filter".
- copy(self)
- covariance_matrix(self, get_variable_list, origin_dict={})
- Return covariance matrix of variables
- variable_list = list of strings to calculate covariance
- origin_dict = dict of strings to values for origin about which covariances are calculated. Defaults to mean
e.g. bunch.covariance_matrix(['x','px'], {'x':0, 'px':0}) returns a matrix like [[Var(x,x), Var(x,px)], [Var(x,px), Var(px,px)]
- covariances_set(self)
- If internal covariances are set by set_covariance_matrix, return True; else return False
- cut(self, variable_value_dict, comparator, value_is_nsigma_bool=False, global_cut=False)
- Set weight of hits in the bunch to 0 if comparator(value, get([variable])) is False
- variable_value_dict = dict of Bunch.get_variables() to the cut value; cut if the hit variable has value > value
- value_is_nsigma_bool = boolean; if True, value is the number of standard deviations
- global_cut = boolean; if True, apply cut to global weights; else apply to local weights
e.g. bunch.cut({'energy':300,}, operator.ge) sets weight of particles to zero if they have
ge(hit.get('energy'),300) here operator.ge is a functional representation of the >= operator
ge(hit.get('energy'),300) is the same as (hit.get('energy') >= 300)
A whole load of useful comparators can be found in the operator module. e.g. ge is >=; le is <=; etc
- deepcopy(self)
- Make a copy and copy self's data
- get(self, variable_string, variable_list)
- Return a bunch variable taken from the list Bunch.get_variables()
- variable_string = string variable from Bunch.get_variables()
- variable_list = list of variables (see below, a bit complicated)
For 'bunch_weight', axis_list is ignored
For 'dispersion', 'dispersion_prime' the first value of variable_list is used. It should be taken from the list Bunch.get_axes()
For 'mean', the first value in variable_list is used. It should be taken from the list Bunch.hit_get_variables()
For others, variable_list should be a list taken from Bunch.get_axes()
E.g. bunch.get('emittance', ['x','y']) would get emittance x y
E.g. bunch.get('mean', ['x','px','z']) would return mean of x; px and z are ignored
- get_alpha(self, axis_list, geometric=None)
- Return the bunch alpha function, defined by
- For normalised alpha = Sum_{i} Cov(x_i, p_i)/(emittance*mass*n)
- For geometric alpha = Sum_{i} Cov(x_i, p_i)/(emittance*n)
where p_i is a momentum variable from axis_list.
- axis_list = list of axes strings
and n is the length of axis_list. E.g.
~~~~~~~~~~~~~~~{.py}
get_alpha(['x','y'])
~~~~~~~~~~~~~~~
will return ( Var(p_x)+Var(p_y) )/(2*emittance(['x','y')*mass)
- get_beta(self, axis_list, geometric=None)
- Return the bunch beta function, defined by
- For normalised beta = Sum_{i} Var(x_i)*p/(emittance*mass*n)
- For geometric beta = Sum_{i} Var(x_i)/(emittance*n)
where x_i is a position variable from axis_list.
- axis_list = list of axes strings
and n is the length of axis_list. E.g.
~~~~~~~~~~~~~~~{.py}
get_beta(['x','y'])
~~~~~~~~~~~~~~~
will return ( Var(x,x)+Var(y,y) )/(2*pz*emittance(['x','y')*mass)
- get_canonical_angular_momentum(self, bz=None, field_axis_dict={'x': 0, 'y': 0}, rotation_axis_dict={'px': 0, 'py': 0, 'x': 0, 'y': 0})
- Return the bunch canonical angular momentum about some arbitrary axis, defined by
- L = <x py> - <y px> + e Bz (<x^2>+y^2) (momentum variables)
- L = <p>*(<x y'> - <y x'>) + e Bz (<x^2>+y^2) (geometric variables)
- bz = nominal on-axis magnetic field - where axis is as; defaults to the field of the 1st particle in the bunch
- field_axis_dict = dict that defines the nominal solenoid axis
- rotation_axis_dict = dict that defines the axis of rotation
- get_decoupled_emittance(self, coupled_axis_list, emittance_axis_list, covariance_matrix=None, geometric=None)
- Reserved for future development
- get_dispersion(self, axis)
- Return the bunch dispersion D in axis q, defined by
- D = cov(q,E)*mean(E)/var(E)
- axis = string from axis_list that defines the axis q
E.g.
~~~~~~~~~~~~~~~{.py}
my_bunch.get_dispersion('y')
~~~~~~~~~~~~~~~
would return the dispersion in the y-direction
- get_dispersion_prime(self, axis, geometric=None)
- Return the bunch dispersion prime D in axis q, defined by
- D' = cov(p_q,E)*mean(E)/var(E)
- axis = string from axis_list that defines the axis q
E.g.
~~~~~~~~~~~~~~~{.py}
my_bunch.get_dispersion('y')
~~~~~~~~~~~~~~~
would return the dispersion in the y-direction
- get_dispersion_rsquared(self)
- Return a special bunch dispersion defined by
- D = (<r2,E>-<r2>*<E>)*mean(E)/var(E)
where <> are raw moments (not central moments)
- get_emittance(self, axis_list, covariance_matrix=None, geometric=None)
- Return the n dimensional normalised emittance of the bunch
- emittance = (|V|**(1/2n))/mass
where n is the number of elements in axis list and V is a covariance matrix
with elements V_{ij} = cov(u_i, u_j) where u is a vector of elements in the
axis_list and their momentum conjugates, u = (q_i, p_i)
- axis_list = list of axes from Bunch.get_axes().
- covariance_matrix = if specified, use this covariance matrix rather than
calculating a new one each time.
- geometric = if specified, use geometric variables (dx/dz, dy/dz, etc) rather
than normalised variables (px, py, pz).
E.g.
~~~~~~~~~~~~~~~{.py}
get_emittance(['x'])
~~~~~~~~~~~~~~~
will return
|V|**(1/2)
where V is the matrix with elements
V = Var(x,x) Cov(x,px)
Cov(x,px) Var(px,px)
and |V| is the determinant.
- get_gamma(self, axis_list, geometric=None)
- Return the bunch beta function, defined by
- For normalised gamma = Sum_{i} Var(p_i)/(pz*emittance*mass*n)
- For geometric gamma = Sum_{i} Var(p_i)/(emittance*n)
where p_i is a momentum variable from axis_list.
- axis_list = list of axes strings
and n is the length of axis_list. E.g.
~~~~~~~~~~~~~~~{.py}
get_gamma(['x','y'])
~~~~~~~~~~~~~~~
will return ( Var(p_x)+Var(p_y) )/(2*pz*emittance(['x','y')*mass)
- get_hit_variable(self, hit, variable_name, covariance_matrix=None, mean_dict={})
- Return axis variable for hit. Special power is that it can calculate amplitude, unlike hit.get(blah)
- hit = a Hit object
- variable_name = either a variable from Hit.get_variables() or an amplitude variable.
amplitude variables should be formatted like 'amplitude x y' or 'amplitude x y t'
- covariance_matrix = use a pre-calculated covariance matrix, or calculate if set to None
- get_hits(self, variable, value, comparator=<built-in function eq>)
- Returns a list of all hits in the bunch with comparator(variable, value) == True
By default comparator is equality operator, so returns a list of all hits in the bunch with variable == value
- variable = string from Hit.get_variables()
- value = value for comparison
- comparator = function that operates on a hit and returns a boolean
e.g. get_hits('eventNumber', 50) returns a list of all hits in the bunch with hitNumber 50
e.g. get_hits('eventNumber', 50, operator.lt) returns a list of all hits in the bunch with hitNumber less than 50
- get_kinetic_angular_momentum(self, rotation_axis_dict={'px': 0, 'py': 0, 'x': 0, "x'": 0, 'y': 0, "y'": 0})
- Return the bunch kinetic angular momentum about some arbitrary axis, defined by
- L = <x py> - <y px> (momentum variables)
- L = <p>*(<x y'> - <y x'>) (geometric variables)
- rotation_axis_dict = dict that defines the axis of rotation
- histogram(self, x_axis_string, x_axis_units='', y_axis_string='', y_axis_units='', nx_bins=None, ny_bins=None, xmin=None, xmax=None, ymin=None, ymax=None)
- Returns a binned 1D or 2D histogram of hits in the bunch (but doesnt draw anything or call any plotting package).
- x_axis_string = string for call to get_hit_variables()
- x_axis_units = units for x axis
- y_axis_string = string for call to get_hit_variables(). If string is empty, makes a 1D histogram
- y_axis_units = units for y axis
- nx_bins = force histogram to use this number of bins for the x-axis rather than choosing number of bins itself
- ny_bins = force histogram to use this number of bins for the y-axis rather than choosing number of bins itself
- xmin = float that overrides auto-detection of minimum x-axis value
- xmax = float that overrides auto-detection of maximum x-axis value
- ymin = float that overrides auto-detection of minimum y-axis value
- ymax = float that overrides auto-detection of maximum y-axis value
Return value is a list of bin weights for a 1D histogram or a list of lists of bin weights for a 2D histogram
- histogram_var_bins(self, x_axis_string, x_bins, x_axis_units='', y_axis_string='', y_bins=None, y_axis_units='')
- Returns a binned histogram of hits in the bunch.
Requires numpy
- x_axis_string = string for call to get_hit_variables()
- x_bins = list of bin edges used to generate the histogram
- x_axis_units = units for x axis
- y_axis_string = string for call to get_hit_variables()
- y_bins = list of bin edges used to generate the histogram
- y_axis_units = units for y axis
Return value is a tuple containing ((bin weights array),x_bins,y_bins). The bin weights array is always nx*ny, with ny defaulting to 1 in the case of a 1d histogram.
- hit_equality(self, target, float_tolerance=1e-09)
- Return True if all hits in self are the same as all hits in target
- target = bunch to test against
- hit_write_builtin(self, file_type_string, file_name, user_comment=None)
- Write the hits in the bunch using some built-in format to the file file_name
- file_type_string = string that controls which predefined file type will be used
- file_name = string that defines the file name
- user_comment = comment to be included in file header (e.g. problem title)
e.g. my_bunches.hit_write_builtin('g4mice_special_hit', 'Sim.out.gz') would write all hits
from my_bunches formatted in the old G4MICE Special Virtual style in file Sim.out.gz
- hit_write_user(self, format_list, format_units_dict, file_handle, separator=' ', comparator=None)
- Write the hits in the bunch in some user defined format to file_handle, in an order defined by comparator
- format_list = ordered list of strings from get_variables()
- format_units_dict = dict of formats from format_list to units
- file_handle = file handle made using e.g. open() command to which hits are written
- separator = separator that is used to separate hits
- comparator = comparator that is used for sorting prior to writing the file; if left as None, no sorting is performed
e.g. aBunch.hit_write_user(['x','px','y','py'], ['x':'m','y':'m','px':'MeV/c','py':'MeV/c'], some_file, '@') would make output like
0.001@0.002@0.001@0.002
0.003@0.004@0.003@0.004
in some_file
- hits(self)
- Returns the list of all hits in the bunch
- list_get_hit_variable(self, list_of_variables, list_of_units=[], covariance_matrix=None, mean_dict={})
- Return a list of get_hit_variable results, one element for each hit in the bunch
- variable_name = either a variable from Hit.get_variables() or an amplitude variable.
amplitude variables should be formatted like 'amplitude x y' or 'amplitude x y t'
i.e. amplitude followed by a list of axes separated by white space
- covariance_matrix = use a pre-calculated covariance matrix, or calculate if set to None
- matplot_histogram(self, x_axis_string, x_axis_units='', y_axis_string='', y_axis_units='', canvas=None, comparator=None)
- Prints a 1D or 2D histogram of hits in the bunch. Axes are automatically detected
to encapsulate all data. Use Bunch.cut(...) to shrink the axes.
Needs correct matplot installation.
- x_axis_string = string for call to get_hit_variables()
- x_axis_units = units for x axis
- y_axis_string = string for call to get_hit_variables(). If string is empty, makes a 1D histogram
- y_axis_units = units for y axis
- comparator = comparator of bunch1, bunch2 - if none given, will sort by x-axis value
e.g. bunch.matplot_histogram('x', 'cm', 'py', 'GeV/c') will histogram x vs py.
To display plots, call Common.wait_for_matplot() - script waits until all matplot windows are closed
- matplot_scatter_graph(self, x_axis_string, y_axis_string, x_axis_units='', y_axis_units='', include_weightless=True)
- Prints a 2d scatter plot of Hit.get(...) data over a dict of bunches.
Needs correct matplot installation.
- x_axis_string = string for call to Bunch.get_hit_variable() used to calculate x-values
- x_axis_units = units for x axis
- y_axis_string = string for call to Bunch.get_hit_variable() used to calculate y-values
- y_axis_units = units for y axis
- include_weightless = set to True to plot hits with <= 0. weight
e.g. bunch.matplot_scatter_graph('x', 'cm', 'p', 'MeV/c') will graph x vs p.
To display plots, call Common.wait_for_matplot() - script waits until all matplot windows are closed
- mean(self, variable_list)
- Return dict of variables to means
- variable_list = list of strings to calculate means
e.g. bunch.mean(['x','px']) returns a dict like {'x':x_mean, 'px':px_mean}
- means_set(self)
- If means are set by set_covariance_matrix, return True; else return False
- moment(self, variable_list, variable_mean_dict={})
- Return a moment, sum( (u1 - u1_mean)*(u2-u2_mean)*(etc)) where u is a set of Hit get_variables indexed by variable_list
- variable_list = list of strings that index the moment
- variable_mean_dict = dict of variable to means for moment calculation. Assume bunch mean if no value is specified
e.g. bunch.moment(['x','x'], {'x':0.1}) returns the variance of x about a mean of 0.1
e.g. bunch.moment(['x','px']) returns the covariance of x,px about the bunch mean
- period_transformation(self, offset, frequency, variable='t')
- Transform all hit's variable from a linear space to a periodic space with some frequency and offset
- offset = float that defines the offset
- frequency = float that defines the frequency of the periodic space
- variable = string from hit_set_variables. variable for which the periodicity is applied
e.g. bunch.period_transformation( dt, rf_freq) would transform all times into a range between
(-0.5/rf_freq, 0.5/rf_freq). Hits with 't' = n*dt would transform to t=0 (n arbitrary integer)
Used to transform a set of many rf buckets into one rf bucket, for calculating longitudinal emittance etc
- root_histogram(self, x_axis_string, x_axis_units='', y_axis_string='', y_axis_units='', nx_bins=None, ny_bins=None, canvas=None, xmin=None, xmax=None, ymin=None, ymax=None, line_color=1, line_style=1, line_width=2, fill_color=0, stats=False, hist_title_string='', draw_option='')
- Prints a 1D or 2D histogram of hits in the bunch. Axes are automatically detected
to encapsulate all data.
Needs correct root installation.
- x_axis_string = string for call to get_hit_variables()
- x_axis_units = units for x axis
- y_axis_string = string for call to get_hit_variables(). If string is empty, makes a 1D histogram
- y_axis_units = units for y axis
- nx_bins = force root_histogram to use this number of bins for the x-axis rather than choosing number of bins itself
- ny_bins = force root_histogram to use this number of bins for the y-axis rather than choosing number of bins itself
- canvas = if canvas=None, root_histogram will create a new tcanvas and plot histograms on that
else will plot on the existing canvas, attempting to plot on existing axes
- xmin = float that overrides auto-detection of minimum x-axis value
- xmax = float that overrides auto-detection of maximum x-axis value
- ymin = float that overrides auto-detection of minimum y-axis value
- ymax = float that overrides auto-detection of maximum y-axis value
- line_color = int that sets the line colour of the histogram
- line_style = int that sets the line style of the histogram
- line_width = int that sets the line width of the histogram
- fill_color = int that sets the fill color of the histogram
- stats = set to True to plot a stats box on the histogram
- hist_title_string = specify the string that will appear as a title on the canvas
e.g. bunch.root_histogram('x', 'cm', 'py', 'GeV/c') will histogram x vs py.
Returns a tuple of the (canvas, histogram)
- root_scatter_graph(self, x_axis_string, y_axis_string, x_axis_units='', y_axis_units='', include_weightless=True, canvas=None, xmin=None, xmax=None, ymin=None, ymax=None, line_color=1, line_style=1, line_width=2, fill_color=10, hist_title_string='')
- Prints a 2d scatter plot of Hit.get(...) data over a dict of bunches.
Needs correct root installation.
- x_axis_string = string for call to Bunch.get_hit_variable() used to calculate x-values
- x_axis_units = units for x axis
- y_axis_string = string for call to Bunch.get_hit_variable() used to calculate y-values
- y_axis_units = units for y axis
- include_weightless = set to True to plot hits with <= 0. weight
- canvas = if canvas=None, root_graph will create a new tcanvas and plot graphs on that
else will plot on the existing canvas, attempting to plot on existing axes
- xmin = float that overrides auto-detection of minimum x-axis value
- xmax = float that overrides auto-detection of maximum x-axis value
- ymin = float that overrides auto-detection of minimum y-axis value
- ymax = float that overrides auto-detection of maximum y-axis value
- line_color = int that sets the line colour of the histogram
- line_style = int that sets the line style of the histogram
- line_width = int that sets the line width of the histogram
- fill_color = int that sets the fill color of the histogram
- hist_title_string = specify the string that will appear as a title on the canvas
e.g. bunch.root_scatter_graph('x', 'p', 'cm', 'MeV/c') will graph x vs p.
Returns a tuple of (canvas, histogram, graph) where the histogram contains the axes
- set_covariance_matrix(self, use_internal_covariance_matrix=True, covariance_matrix=None, mean_dict={})
- Choose whether to use an internal covariance matrix for calculations
- use_internal_covariance_matrix = boolean. If set to True, x-boa will recalculate its internal covariance matrix and use this
for some calculations. If set to False, x-boa will calculate the covariance matrix each time.
- covariance_matrix = NumPy matrix. x-boa will use this matrix as the internal covariance matrix; should be a 10x10 matrix ordered like
(x, px, y, py, z, pz, t, enegry, ct, energy). Ignored if equal to None
- mean_dict = dict of variables to means. x-boa will use this dict to index means; should contain means of
(x, px, y, py, z, pz, t, enegry, ct, energy). Ignored if equal to None
As a speed optimisation, x-boa can calculate a covariance matrix and use this for all calculations involving covariances, i.e. Twiss parameters, emittances, amplitudes etc. Otherwise x-boa will re-calculate this each time, which can be slow. Be careful though - x-boa does not automatically detect for hits being added or removed from the bunch, etc. The user must call this function each time the bunch changes (events added, weightings changed, etc) to update the internal covariance matrix
- standard_deviation(self, variable, variable_mean={})
- Return a standard deviation, given by sum( (u-u_mean)**2 )**0.5 where u is the variable specified
- variable = a variable from Hit.get_variables(). Can be a list, in which
case only the first hit is taken
- variable_mean = use this as u_mean rather than calculating a priori. Can
be a dict, in which case if variable is in the keys will
use that value.
e.g. bunch.standard_deviation('x') returns the standard deviation of x
e.g. bunch.standard_deviation('x', 1.) returns the standard deviation of x
about a mean of 1.
e.g. bunch.standard_deviation(['x'], {'x':1.}) returns the standard
deviation of x about a mean of 1.
- transform_to(self, transform_list, target_covariances, translation_dict={}, origin_dict={}, mass_shell_variable='')
- Perform a linear transformation on all particles in the bunch to get a bunch with covariance matrix
similar to target_covariances. The transformation always has determinant 1, and so is emittance conserving.
Then performs a translation using translation_dict
- transform_list = list of Hit.set_variables() strings that defines the vector V
- target_covariances = target covariance matrix. Must be n*n dimensions where n is the length of transform_list
- translation_dict = dict of Hit.set_variables() strings to values that defines a translation
- origin_dict = dict of Hit.set_variables() strings to values that defines the vector O. Defaults to
bunch mean.
- mass_shell_variable = set mass shell variable so that E^2=p^2+m^2 after transformation.
Does nothing if equal to ''
e.g. bunch.transform_to(['x','px'], [[1,0],[0,1]], {'pz':10}, 'energy') will apply a transformation to all hits in the
bunch that diagonalises the bunch and makes Var(x,x) equal to Var(px,px), but conserving emittance; then will add
10 to pz for all tracks; then adjust energy to keep mass shell condition.
- translate(self, dict_variables_values, mass_shell_variable='')
- Translate all events in the bunch by dict_variables_values
- dict_variables_values = dict of variable names from Hit.set_variables() to variable values
- mass_shell_variable = set mass shell variable so that E^2=p^2+m^2 after translation.
Does nothing if equal to ''
e.g. bunch.translate({'pz':-10,'z':100}, 'energy') reduces particle pz by 10 MeV/c and increases
E by 100 mm then sets E so that mass shell condition is still obeyed
- transmission_cut(self, test_bunch, global_cut=False, test_variable=['spill', 'event_number', 'particle_number'], float_tolerance=1e-09)
- Set weight of hits in the bunch to 0 if no events can be found in test_bunch with the
same test_variable
- test_bunch = bunch to test against
- global_cut = if True, apply cut to global weights
- test_variable = cut a hit in self if no hits are found in test_bunch with
the same test_variable. If test_variable is a list, then
cut from self if no hits are found in test_bunch with all
test_variables the same.
E.g. bunch.transmission_cut( some_other_bunch, True ) will apply a global
cut if a hit with the same [spill, event_number, particle_number] is
not in some_other_bunch (for all hits)
- value = __mean_for_get(self, variable_list)
Static methods defined here:
- axis_list_to_covariance_list(axis_list, geometric=None)
- Convert from a list of position variables to a list of position
and conjugate momentum variables
- axis_list = list of strings from get_axes()
- build_ET_ellipse()
- Not implemented
- build_MR_ellipse()
- Not implemented
- build_ellipse_2d(beta, alpha, emittance, p, mass, geometric)
- Build a 2x2 ellipse matrix, given by
For geometric = true
- var(x, x) = beta*emittance
- var(x, x') = alpha*emittance
- var(x',x') = gamma*emittance
For geometric = false
- var(x, x ) = beta*emittance*mass/p
- var(x, px) = alpha*emittance*mass
- var(px,px) = gamma*emittance*mass*p
- build_ellipse_from_transfer_matrix(M)
- Not implemented
- build_penn_ellipse(emittance_t, mass, beta_t, alpha_t, p, Ltwiddle_t, bz, q)
- Build an ellipse using Penn formalism for solenoids.
- emittance_t = nominal beam emittance
- mass = particle mass
- beta_t = transverse beta function
- alpha_t = transverse alpha function
- p = reference momentum
- Ltwiddle_t = normalised canonical angular momentum
- bz = magnetic field strength
- q = particle charge
Output ellipse is a 4*4 matrix with elements v_ij where i,j indexes the vector (x,px,y,py)
- bunch_overview_doc(verbose=False)
- Creates some summary documentation for the Bunch class. If verbose is True then will also print any functions or data not included in summary
- clear_global_weights()
- Set global_weight of all hits in the bunch to 1
- convert_string_to_axis_list(axis_string)
- Return a list of axes from a string.
- axis_string = string that contains a list of axis. Either format
as axis_strings separated by white space or as a python list
of axis_strings
- get_amplitude(bunch, hit, axis_list, covariance_matrix=None, mean_dict={}, geometric=None)
- Return the particle amplitude for a hit relative to a bunch, defined by
- amplitude = emittance*x^T.V^-1.x
where x is a vector of particle coordinates and V is a covariance matrix
- bunch = bunch from which the covariance matrix is calculated
- hit = hit from which the particle vector is taken
- axis_list = list of axes that defines the covariance matrix and particle vector
- covariance_matrix = if this is not set to None, will use this covariance_matrix
for the calculation rather than taking one from bunch. Should be a numpy matrix
like "x","px","y","py"
E.g.
~~~~~~~{.py}
Bunch.get_amplitude(my_bunch, my_hit, ['x','y'])
~~~~~~~
will return
emittance*(x,px,y,py)^T*V^{-1}(x,px,y,py)*(x,px,y,py)
- get_axes()
- Return list of axis variables (position-type variables)
- get_geometric_momentum()
- Set the default for conjugate momenta; either geometric (x', y', etc) or kinetic (px, py, etc)
- new_value_bool = if True, use geometric momenta. If False, use kinetic momenta (default)
- get_list_of_maus_dicts(maus_type, spill)
- Get a list of maus_dicts from a maus_spill for a particular maus_type
- maus_type = type to extract from the spill
- spill = dict containing a single maus spill
Returns dict formatted according to maus but for one hit
- get_variables()
- Return a list of variables suitable for calls to Bunch.get
- hit_get_variables()
- Return a list of variables suitable for calls to Bunch.get
- hit_write_builtin_from_dict(dict_of_bunches, file_type_string, file_name, user_comment=None)
- Write the hits in the dict of bunches using some built-in format to the file file_name
- dict_of_bunches = list of hits
- file_type_string = string that controls which predefined file type will be used
- file_name = string that defines the file name
- user_comment = comment to be included in file header (e.g. problem title)
e.g. Bunch.hit_write_builtin_from_dict(my_bunches, 'g4mice_special_hit', 'Sim.out.gz') would write all hits
from my_bunches formatted in the G4MICE Special Virtual style in file Sim.out.gz
- list_get(dict_of_bunches, list_of_variables, list_of_axis_lists)
- Get a list of lists of variables from each bunch in the dict_of_bunches
- dict_of_bunches = dict of bunches from which the lists will be taken
- list_of_variables = list of variables that will be used in the calculation
- list_of_axis_lists = axis_list that will be used in the calculation of the
corresponding variable
E.g. list_get(my_dict_of_bunches, ['mean', 'emittance'], [['z'],['x','y']])
would calculate a list of two arrays: (i) mean z; (ii) emittance x y
Output is sorted by the first variable in the list. This might be useful to interface
with E.g. a plotting package
- matplot_graph(bunches, x_axis_string, x_axis_list, y_axis_string, y_axis_list, x_axis_units='', y_axis_units='', comparator=None)
- Prints a graph of Bunch.get(...) data over a dict of bunches.
Needs correct matplot installation.
- x_axis_string = string for call to Bunch.get() used to calculate x axis variables
- x_axis_list = list of variables for call to Bunch.get() used to calculate x axis variables
- y_axis_string = string for call to Bunch.get() used to calculate y axis variables
- y_axis_list = list of variables for call to Bunch.get() used to calculate y axis variables
- x_axis_units = units for x axis
- y_axis_units = units for y axis
- comparator = comparator of bunch1, bunch2 - if none given, will sort by x-axis value
e.g. bunch.matplot_graph('mean', ['x'], 'cm', 'emittance', ['x','y'], 'mm') will graph mean x vs emittance x y.
To display plots, call Common.wait_for_matplot() - script waits until all matplot windows are closed
- momentum_variable(axis_variable, geometric_momentum)
- Return the momentum conjugate for axis_variable
- new_dict_from_read_builtin(file_type_string, file_name, indexing_variable='station')
- Create a dict of all bunches in a file using a built-in format
- file_type_string = string from Hit.file_types() that defines the formatting of the file
- file_name = name of the file that contains hit data
- indexing_variable = variable that will be used to define a bunch
e.g. bunch_dict = new_dict_from_read_builtin('icool_for003', 'for003.dat', 'pid') will return a new dict of bunches
loaded from for003.dat in icool_for003 format, where each entry in the dict will be a reference from a pid value to a bunch
e.g. bunch_dict = new_dict_from_read_builtin('icool_for009', 'for009.dat', 'station') will return a new dict of bunches
loaded from for009.dat in icool_for009 format, where each entry in the dict will be a reference from a station value to a bunch
- new_from_hits(hits_list, covs=None, means={}, weights=[])
- Initialise from a list of hits, making a deepcopy of the hits (so allocating new memory for each hit)
- hits_list = list of Hit objects
e.g. myBunch = new_from_hits([hit1, hit2, hit3]) will return a new bunch containing hit1, hit2, hit3
- new_from_read_builtin(file_type_string, file_name, test_function=None, number_of_hits=-1)
- Initialise a bunch from a file using a built in format
- file_type_string = string from Hit.file_types() that defines the file format
- file_name = string that defines the file_name to be used
- test_function = Hits with test_function(hit) == False will be ignored, unless test_function==None
- number_of_hits = only loads the first number_of_hits Hits
e.g. myBunch = Bunch.new_from_read_builtin('icool_for009', for009.dat, lambda hit: hit['station'] == 1, 1000)
will return a bunch containing first 1000 hits from for009.dat with stationNumber=1
- new_from_read_user(format_list, format_units_dict, filehandle, number_of_skip_lines, test_function=None, number_of_hits=-1)
- Initialise a bunch from a file using a user defined format
- format_list = ordered list of variables from get_variables() that contains the particle variables on each line of your input file
- format_units_dict = dict of variables:units that are used to transform to internal system of units
- filehandle = file handle, created using e.g. filehandle = open('for009.dat')
- number_of_skip_lines = integer; skip this many lines at the start of the file
- test_function = Hits with test_function(hit) == False will be ignored, unless test_function==None
- number_of_hits = only loads the first number_of_hits Hits. Will read to end of file if this is negative
e.g. myBunch = Bunch.new_from_read_user(['x','y','z','px','py','pz'], {'x':'mm', 'y':'mm', 'z':'mm', 'px':'MeV/c', 'py':'MeV/c', 'pz':'MeV/c'}, my_input_file, 3)
will skip the first 3 lines of the file and then read in all events from my_input_file, assuming the formatting listed
- new_hit_shell(n_per_dimension, ellipse, set_variable_list, mass_shell_variable, defaults={})
- Create a set of particles that sit on the shell of an ellipse in some arbitrary dimensional space
- n_per_dimension = number of particles in each dimension. Total number of particles is n_per_dimension^dimension
- ellipse = numpy.matrix that defines the ellipse of particles
- set_variable_list = list of set variables that defines what each dimension in the ellipse corresponds to
- mass_shell_variable = variable that will be used to set the mass shell condition for each hit
- defaults = dict of default set variables that each hit will get.
e.g. new_bunch_as_hit_shell(2, numpy.matrix([[1,0],[0,1]]),['x','y'],'energy',{'pid':-13,'mass':Common.pdg_pid_to_mass[13],'pz':200.})
will make a set of muons on a circle in x-y space with 200. MeV/c momentum. Event number is automatically allocated
incrementing from 0.
- new_list_from_read_builtin(file_type_string, file_name, sort_variable='station')
- Create a sorted list of all bunches in a file using a built-in format
- file_type_string = string from Hit.file_types() that defines the formatting of the file
- file_name = name of the file that contains hit data
- sort_variable = variable that will be used to define a bunch and used for sort order
e.g. bunch_list = new_list_from_read_builtin('icool_for003', 'for003.dat', 'pid') will return a new list of bunches
loaded from for003.dat in icool_for003 format, where each entry in the list will contain only one pid value with first entry
having lowest pid
e.g. bunch_list = new_list_from_read_builtin('icool_for009', 'for009.dat', 'station') will return a new list of bunches
loaded from for009.dat in icool_for009 format, where each entry in the list will contain only one station value with first entry
having lowest station
- read_g4mice_file(file_name, number_of_hits=-1, list_of_classes=['SpecialHits', 'VirtualHits'])
- Initialise a bunch from a g4mice file.
- file_name = string that defines the file_name to be used
- number_of_hits = only loads the first number_of_hits Hits
- list_of_classes = ignores g4mice classes that are not in list_of_classes
- read_maus_file(file_name, number_of_hits=-1, list_of_maus_types=['maus_virtual_hit', 'maus_primary'])
- Initialise a bunch from a MAUS file.
- file_name = string that defines the file_name to be used
- number_of_hits = only loads the first number_of_hits Hits
- list_of_converters = list of converter functions that will be executed on
the maus file (one for each hit type)
- read_maus_root_file(file_name, number_of_hits=-1, list_of_maus_types=['maus_root_virtual_hit', 'maus_root_primary'])
- Read hits from a maus ROOT file
- file_name = name of the file to read
- number_of_hits = Not used
- list_of_maus_types = only make hits from these types
Returns a list of hits
- root_graph(bunches, x_axis_string, x_axis_list, y_axis_string, y_axis_list, x_axis_units='', y_axis_units='', canvas='', comparator=None, xmin=None, xmax=None, ymin=None, ymax=None, line_color=1, line_style=1, line_width=2, fill_color=10, hist_title_string='')
- Prints a graph of Bunch.get(...) data over a set of bunches and returns the root canvas.
Needs correct root installation.
- bunches = either a dict or a list of bunches
- x_axis_string = string for call to Bunch.get() used to calculate x axis variables
- x_axis_list = list of variables for call to Bunch.get() used to calculate x axis variables
- x_axis_units = units for x axis
- y_axis_string = string for call to Bunch.get() used to calculate y axis variables
- y_axis_list = list of variables for call to Bunch.get() used to calculate y axis variables
- y_axis_units = units for y axis
- canvas = if canvas=None, root_graph will create a new tcanvas and plot graphs on that
else will plot on the existing canvas, attempting to plot on existing axes
- comparator = comparator of bunch1, bunch2 - if none given, will sort by x-axis value
- xmin = float that overrides auto-detection of minimum x-axis value
- xmax = float that overrides auto-detection of maximum x-axis value
- ymin = float that overrides auto-detection of minimum y-axis value
- ymax = float that overrides auto-detection of maximum y-axis value
- line_color = int that sets the line colour of the histogram
- line_style = int that sets the line style of the histogram
- line_width = int that sets the line width of the histogram
- fill_color = int that sets the fill color of the histogram
- hist_title_string = specify the string that will appear as a title on the canvas
e.g. root_graph(bunch_dict, 'mean', ['x'], 'emittance', ['x','y'], 'cm', 'mm') will graph mean x vs emittance x y.
Returns a tuple of (canvas, histogram, graph) where the histogram contains the axes
- set_geometric_momentum(new_value_bool)
- Set the default for conjugate momenta; either geometric (x', y', etc) or kinetic (px, py, etc)
- new_value_bool = if True, use geometric momenta. If False, use kinetic momenta (default)
- setup_file(file_format_type_string, file_name)
- Returns a file handle with special phrases and characters stripped. Returned file_handle contains only hit data
Data and other attributes defined here:
- key = 'mean'
| |