Prepare version 0.8.0

Release note for 0.8.0

New features

Intrabeam Scattering

• Implementation of IBS effect in mbtrack2, the IntrabeamScattering class was added in mbtrack2.tracking.ibs.
• It implements an approximate IBS kick based on an analytical model.
• Four analytical models are available: Piwinski Standard, Piwinski Modified, Completely Integrated Piwinski model, and Bane high-energy approximation. It is recommended to use Completely Integrated Piwinski model (CIMP) for fast simulations.

Important behavior change in Optics class

• Default behavior of Optics is changed when AT lattice is loaded: now it defaults to optic function to s=0 instead of average ones.
• Default behavior of LongRangeResistiveWall and ImpedanceModel when an AT lattice is loaded is to normalized by average_beta / local_beta
• Adds Optics.average_beta attribute

Nonlinear chromaticity

• Synchrotron.get_chroma can be used to compute nonlinear chromaticity from pyAT lattice.
• Nonlinear chromaticity can be used in TransverseMap and TransverseSectorMap.
• TransverseMap now inherits from TransverseSectorMap.

SynchrotronRadiation object

• Adds a SynchrotronRadiation.qexcitation optional parameter to turn off quantum excitation.
• Improved performance.

Other improvements and modifications

• General performance improvements in many classes.
• Update CircularResistiveWall class in resistive_wall.py to replace numerical integrations with analytical forms for improved performance.
• Use scipy.integrate.trapezoid for compatibility with newer version of numpy
• Update BeamIonElement to work in a more general case.
• Update TransverseSpaceCharge to work in a more general case.
• ComplexData.name_and_coefficients_table is now a staticmethod.
• Extend WakeField to "mixed" componenets (xydip, yxdip, ...).
• Small fix/improvements for rf.py (CavityResonator for n_bin=1)
• Add Element.track_bunch_if_non_empty decorator.
• Modify Bunch.binning to add a return_full_length optional parameter.
• Modify Mpi.share_distributions for n_bin=1.
• Modify WakePotential for n_bin=1 and use track_bunch_if_non_empty decorator.
• Modify PhysicalModel to return errors if needed.
• Adds Beam.init_bunch_list_mpi, a convenience method to initialize a beam using MPI parallelisation with a Bunch per core.

Project management

• Add > 400 tests and organize them in unit-tests and physics-tests.
• Add assert_attr_changed test function.
• renamed particles_electromagnetic_fields.py into emfields.py and changed all the imports
• added CODEOWNERS file for automatic review assignment for merge requests
• Update pyproject.toml and poetry.lock with pytest-mock

Bugfix

• Fix CavityResonator.is_CBI_stable
• Fix quadrupolar wake potential sign
• Bugfixes with beam_ion_elements.py
• Fix adts in TransverseMapSector
• Fix WakePotential.check_sampling
• Fix Sweep.plot
• Fix Monitor sub-classes sometimes getting stuck when flushing data.
• Fix generate_transverse_map_sector functionality to deduce chromaticity from pyAT lattice.

Authors who took part in this release

Alexis Gamelin, Vadim Gubaidulin, Keon Hee Kim, Watanyu Foosang, Teresia Olsson

mbtrack2/tracking/element.py

@@ -444,6 +444,10 @@ def transverse_map_sector_generator(ring, positions):
     """
     N_sec = len(positions)
     sectors = []
+    if hasattr(ring, "adts") and ring.adts is not None:
+        adts = np.array([val / N_sec for val in ring.adts])
+    else:
+        adts = None
     if ring.optics.use_local_values:
         for i in range(N_sec):
             sectors.append(
@@ -455,56 +459,54 @@ def transverse_map_sector_generator(ring, positions):
                                     ring.optics.local_beta,
                                     ring.optics.local_dispersion,
                                     2 * np.pi * ring.tune / N_sec,
-                                    ring.chro / N_sec,
-                                    adts=ring.adts /
-                                    N_sec if ring.adts else None))
+                                    np.asarray(ring.chro) / N_sec,
+                                    adts=adts))
     else:
         import at
 
-        def _compute_chro(ring, pos, dp=1e-2, order=4):
+        def _compute_chro(ring, N_sec, dp=1e-2, order=4):
             lat = deepcopy(ring.optics.lattice)
             lat.append(at.Marker("END"))
-            fit, dpa, tune = at.physics.nonlinear.chromaticity(lat,
-                                                               method='linopt',
-                                                               dpm=dp,
-                                                               n_points=100,
-                                                               order=order)
+            fit, _, _ = at.physics.nonlinear.chromaticity(lat,
+                                                          method='linopt',
+                                                          dpm=dp,
+                                                          n_points=100,
+                                                          order=order)
             Chrox, Chroy = fit[0, 1:], fit[1, 1:]
-            chrox = np.interp(pos, s, Chrox)
-            chroy = np.interp(pos, s, Chroy)
-
+            chrox = np.array([np.linspace(0, val, N_sec) for val in Chrox])
+            chroy = np.array([np.linspace(0, val, N_sec) for val in Chroy])
             return np.array([chrox, chroy])
 
+        _chro = _compute_chro(ring, N_sec)
         for i in range(N_sec):
             alpha0 = ring.optics.alpha(positions[i])
             beta0 = ring.optics.beta(positions[i])
             dispersion0 = ring.optics.dispersion(positions[i])
             mu0 = ring.optics.mu(positions[i])
-            chro0 = _compute_chro(ring, positions[i])
+            chro0 = _chro[:, i]
             if i != (N_sec - 1):
                 alpha1 = ring.optics.alpha(positions[i + 1])
                 beta1 = ring.optics.beta(positions[i + 1])
                 dispersion1 = ring.optics.dispersion(positions[i + 1])
                 mu1 = ring.optics.mu(positions[i + 1])
-                chro1 = _compute_chro(ring, positions[i + 1])
+                chro1 = _chro[:, i + 1]
             else:
                 alpha1 = ring.optics.alpha(positions[0])
                 beta1 = ring.optics.beta(positions[0])
                 dispersion1 = ring.optics.dispersion(positions[0])
                 mu1 = ring.optics.mu(ring.L)
-                chro1 = _compute_chro(ring, ring.L)
+                chro1 = _chro[:, -1]
             phase_diff = mu1 - mu0
             chro_diff = chro1 - chro0
             sectors.append(
-                TransverseMapSector(
-                    ring,
-                    alpha0,
-                    beta0,
-                    dispersion0,
-                    alpha1,
-                    beta1,
-                    dispersion1,
-                    phase_diff,
-                    chro_diff,
-                ))
+                TransverseMapSector(ring,
+                                    alpha0,
+                                    beta0,
+                                    dispersion0,
+                                    alpha1,
+                                    beta1,
+                                    dispersion1,
+                                    phase_diff,
+                                    chro_diff,
+                                    adts=adts))
     return sectors