at.tracking.patpass#

Simple parallelisation of atpass() using multiprocessing.

Functions

patpass(lattice, r_in[, nturns, refpts, ...])

Simple parallel implementation of lattice_pass().
patpass(lattice, r_in, nturns=1, refpts=RefptsCode.End, pool_size=None, start_method=None, **kwargs)[source]#

Simple parallel implementation of lattice_pass(). If more than one particle is supplied, use multiprocessing. For a single particle or if the lattice contains Collective elements, atpass() is used.

patpass() tracks particles through each element of a lattice calling the element-specific tracking function specified in the Element’s PassMethod field.

Parameters:

  • lattice (Iterable[Element]) – list of elements

  • r_in – (6, N) array: input coordinates of N particles. r_in is modified in-place and reports the coordinates at the end of the element. For the best efficiency, r_in should be given as F_CONTIGUOUS numpy array.

  • nturns (int) – number of turns to be tracked

  • refpts (Union[Type[Element], Element, Callable[[Element], bool], str, None, int, Sequence[int], bool, Sequence[bool], RefptsCode]) – Selects the location of coordinates output. See “Selecting elements in a lattice”

  • pool_size (int) – number of processes. If None, min(npart,nproc) is used

  • start_method (str) – python multiprocessing start method. None uses the python default that is considered safe. Available values: 'fork', 'spawn', 'forkserver'. Default for linux is 'fork', default for macOS and Windows is 'spawn'. 'fork' may be used on macOS to speed up the calculation or to solve Runtime Errors, however it is considered unsafe.

Keyword Arguments:

  • keep_lattice (bool) – Use elements persisted from a previous call. If True, assume that the lattice has not changed since the previous call.

  • keep_counter (bool) – Keep the turn number from the previous call.

  • turn (int) – Starting turn number. Ignored if keep_counter is True. The turn number is necessary to compute the absolute path length used in RFCavityPass.

  • losses (bool) – Boolean to activate loss maps output

  • omp_num_threads (int) – Number of OpenMP threads (default: automatic)

The following keyword arguments overload the Lattice values

Keyword Arguments:

  • particle (Particle) – circulating particle. Default: lattice.particle if existing, otherwise Particle(‘relativistic’)

  • energy (float) – lattice energy. Default 0.

If energy is not available, relativistic tracking if forced, rest_energy is ignored.

Returns:

  • r_out – (6, N, R, T) array containing output coordinates of N particles at R reference points for T turns.

  • loss_map – If losses is True: dictionary with the following key:

    islost

    (npart,) bool array indicating lost particles

    turn

    (npart,) int array indicating the turn at which the particle is lost

    element

    ((npart,) int array indicating the element at which the particle is lost

    coord

    (6, npart) float array giving the coordinates at which the particle is lost (zero for surviving particles)

Note

  • For multiparticle tracking with large number of turn the size of r_out may increase excessively. To avoid memory issues lattice_pass(lattice, r_in, refpts=[]) can be used. An empty list is returned and the tracking results of the last turn are stored in r_in.

  • By default, patpass() will use all the available CPUs. To change the number of cores used in ALL functions using patpass() (acceptance module for example) it is possible to set at.DConstant.patpass_poolsize to the desired value.