v0.7.0

New features

Space Charge

• Adds transverse space-charge module, implemented in TransverseSpaceCharge class.
• Space-charge is implemented as a slice-by-slice kick utilising the Bassetti-Erskine formula.
• Adds electromagnetic fields module. Handles Faddeeva function and electromagnetic fields for space-charge and beam-ion interactions.

Ions

• Adds a beam_ion_effects module. It handles the generation of ions from a given residual gas pressure and the interaction between ions and the stored beam.
• Beam-ion interaction is implemented with weak-strong, strong-strong and Particle-In-Cell models.
• New classes: BeamIonElement, IonParticles, IonAperture, IonMonitor

Add a Sweep element

• The new Sweep element can excite the beam between two frequencies, i.e., apply frequency sweep (chirp) to all or a given bunch in the chosen plane.
• Add option to save higher order spectrums in BunchSpectrumMonitor.
• Modify plot_bunchspectrum and streak_bunchspectrum to plot higher order spectrums.

Other improvements and modifications

• Updated yokoya_elliptic with an analytical implementation.
• BeamLoadingEquilibrium is now computed on a grid and much faster.
• Add bunch_spectrum and plot_bunch_spectrum to BeamLoadingEquilibrium.
• Add R_factor calculation (Touschek lifetime ratio) to BeamLoadingEquilibrium.
• Add form factor contribution to lcbi_growth_rate_mode and lcbi_growth_rate.
• The energy_loss and power_loss_spectrum methods for ImpedanceModel can now take any bunch spectrum in an optional argument.

Project management

• Added sphinx/readthedocs documentation
• Update README.md
• Added dynamic versioning and version print on import
• Added "please cite the following papers" on import
• Add Dockerfile based on gitlab-registry.synchrotron-soleil.fr/pa/collective-effects/python_mpi
• Add gitlab CI/CD .gitlab-ci.yml file
  • Add run test suite and formatters when there is a merge request or commit on "stable" or "develop" branch.
  • Build docker image and pip package when a tag is pushed and committed on "develop".

Bugfix

• Fix resonator longitudinal wake function
• Fix an issue with random sampling in PhaseSpaceMonitor
• Fix plotting in plot_phasespacedata
• Fix some docstrings
• Fix emittance and CS invariant calculation when dispersion is included.

Authors who took part in this release

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

mbtrack2/tracking/monitors/monitors.py

@@ -1083,12 +1083,18 @@ class BunchSpectrumMonitor(Monitor):
         dict_buffer = {
             "incoherent": (3, self.n_fft // 2 + 1, buffer_size),
             "coherent": (3, self.n_fft // 2 + 1, buffer_size),
+            "coherent_q":(3, self.n_fft//2+1, buffer_size),
+            "coherent_s":(3, self.n_fft//2+1, buffer_size),
+            "coherent_o":(3, self.n_fft//2+1, buffer_size),
             "mean_incoherent": (3, buffer_size),
             "std_incoherent": (3, buffer_size)
         }
         dict_file = {
             "incoherent": (3, self.n_fft // 2 + 1, total_size),
             "coherent": (3, self.n_fft // 2 + 1, total_size),
+            "coherent_q":(3, self.n_fft//2+1, total_size),
+            "coherent_s":(3, self.n_fft//2+1, total_size),
+            "coherent_o":(3, self.n_fft//2+1, total_size),
             "mean_incoherent": (3, total_size),
             "std_incoherent": (3, total_size)
         }
@@ -1104,6 +1110,9 @@ class BunchSpectrumMonitor(Monitor):
         self.positions = np.zeros(
             (self.size_list, self.sample_size, self.save_every + 1))
         self.mean = np.zeros((self.size_list, self.save_every + 1))
+        self.std = np.zeros((self.size_list, self.save_every+1))
+        self.skew = np.zeros((self.size_list, self.save_every+1))
+        self.kurtosis = np.zeros((self.size_list, self.save_every+1))
 
         index = np.arange(0, int(mp_number))
         self.index_sample = sorted(random.sample(list(index),
@@ -1111,6 +1120,9 @@ class BunchSpectrumMonitor(Monitor):
 
         self.incoherent = np.zeros((3, self.n_fft // 2 + 1, self.buffer_size))
         self.coherent = np.zeros((3, self.n_fft // 2 + 1, self.buffer_size))
+        self.coherent_q = np.zeros((3, self.n_fft//2+1, self.buffer_size))
+        self.coherent_s = np.zeros((3, self.n_fft//2+1, self.buffer_size))
+        self.coherent_o = np.zeros((3, self.n_fft//2+1, self.buffer_size))
 
         self.file[self.group_name].create_dataset("freq",
                                                   data=self.frequency_samples)
@@ -1172,6 +1184,9 @@ class BunchSpectrumMonitor(Monitor):
                 self.positions[value, :, self.save_count] = np.nan
 
             self.mean[:, self.save_count] = bunch.mean[self.mean_index]
+            self.std[:, self.save_count] = bunch.std[self.mean_index]
+            self.skew[:, self.save_count] = bunch.skew[self.mean_index]
+            self.kurtosis[:, self.save_count] = bunch.kurtosis[self.mean_index]
 
             self.save_count += 1
 
@@ -1201,6 +1216,10 @@ class BunchSpectrumMonitor(Monitor):
             self.coherent[self.store_dict[key], :,
                           self.buffer_count] = self.get_coherent_spectrum(
                               self.mean[value])
+            self.coherent_q[self.store_dict[key],:,self.buffer_count] = self.get_coherent_spectrum(self.std[value])
+            self.coherent_s[self.store_dict[key],:,self.buffer_count] = self.get_coherent_spectrum(self.skew[value])
+            self.coherent_o[self.store_dict[key],:,self.buffer_count] = self.get_coherent_spectrum(self.kurtosis[value])
+
 
         self.buffer_count += 1
 
@@ -1236,6 +1255,15 @@ class BunchSpectrumMonitor(Monitor):
                                          self.buffer_size:(self.write_count +
                                                            1) *
                                          self.buffer_size] = self.coherent
+        self.file[self.group_name]["coherent_q"][:,:, 
+                self.write_count * self.buffer_size:(self.write_count+1) * 
+                self.buffer_size] = self.coherent_q
+        self.file[self.group_name]["coherent_s"][:,:, 
+                self.write_count * self.buffer_size:(self.write_count+1) * 
+                self.buffer_size] = self.coherent_s
+        self.file[self.group_name]["coherent_o"][:,:, 
+                self.write_count * self.buffer_size:(self.write_count+1) * 
+                self.buffer_size] = self.coherent_o
 
         self.file.flush()
         self.write_count += 1