simba-accelerator 0.3.0__tar.gz → 0.4.0__tar.gz

{simba_accelerator-0.3.0 → simba_accelerator-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simba-accelerator
-Version: 0.3.0
+Version: 0.4.0
 Summary: A python framework for particle accelerator simulations
 Author-email: James Jones <james.jones@stfc.ac.uk>
 Maintainer-email: James Jones <james.jones@stfc.ac.uk>, Alex Brynes <alexander.brynes@stfc.ac.uk>, Mark Johnson <mark.johnson@stfc.ac.uk>

{simba_accelerator-0.3.0 → simba_accelerator-0.4.0}/requirements.txt

@@ -18,7 +18,7 @@ numba>=0.61.2
 pyFFTW==0.15.0
 sphinx>=8.1.0
 cheetah-accelerator>=0.7.5
-openpmd-beamphysics>=0.10
+openpmd-beamphysics>=0.15
 sphinx-rtd-theme
 myst-nb
 sphinx_autodoc_typehints>=3.0.0

{simba_accelerator-0.3.0 → simba_accelerator-0.4.0}/simba/Codes/Generators/Generators.py

@@ -1,4 +1,4 @@
-""" 
+"""
 SIMBA Beam Generator module
 
 This module defines a class for generating a beam distribution. The beam properties, code and number of particles
@@ -105,39 +105,39 @@ from easygdf import load
 import warnings
 
 with open(
-    os.path.dirname(os.path.abspath(__file__)) + "/astra.yaml",
-    "r",
+        os.path.dirname(os.path.abspath(__file__)) + "/astra.yaml",
+        "r",
 ) as infile:
     astra_generator_keywords = yaml.safe_load(infile)
 
 with open(
-    os.path.dirname(os.path.abspath(__file__)) + "/gpt.yaml",
-    "r",
+        os.path.dirname(os.path.abspath(__file__)) + "/gpt.yaml",
+        "r",
 ) as infile:
     gpt_generator_keywords = yaml.safe_load(infile)
 
 with open(
-    os.path.dirname(os.path.abspath(__file__)) + "/elegant.yaml",
-    "r",
+        os.path.dirname(os.path.abspath(__file__)) + "/elegant.yaml",
+        "r",
 ) as infile:
     elegant_generator_keywords = {"defaults": {}}
     elegant_generator_keywords.update(yaml.safe_load(infile))
 
 with open(
-    os.path.dirname(os.path.abspath(__file__)) + "/opal.yaml",
-    "r",
+        os.path.dirname(os.path.abspath(__file__)) + "/opal.yaml",
+        "r",
 ) as infile:
     opal_generator_keywords = yaml.safe_load(infile)
 
 with open(
-    os.path.dirname(os.path.abspath(__file__)) + "/aliases.yaml",
-    "r",
+        os.path.dirname(os.path.abspath(__file__)) + "/aliases.yaml",
+        "r",
 ) as infile:
     aliases = yaml.safe_load(infile)
 
 with open(
-    os.path.dirname(os.path.abspath(__file__)) + "/species.yaml",
-    "r",
+        os.path.dirname(os.path.abspath(__file__)) + "/species.yaml",
+        "r",
 ) as infile:
     code_species = yaml.safe_load(infile)
 
@@ -457,7 +457,6 @@ class frameworkGenerator(BaseModel):
     generator_keywords: Dict = {}
     """Generator keywords from :class:`~simba.Framework.Framework` class"""
 
-
     model_config = ConfigDict(
         extra="allow",
         arbitrary_types_allowed=True,
@@ -598,10 +597,10 @@ class frameworkGenerator(BaseModel):
         """
         return float(
             (
-                3
-                * self.thermal_emittance**2
-                * self.speed_of_light**2
-                * self.particle_mass
+                    3
+                    * self.thermal_emittance ** 2
+                    * self.speed_of_light ** 2
+                    * self.particle_mass
             )
             / 2
             / self.elementary_charge
@@ -614,7 +613,7 @@ class frameworkGenerator(BaseModel):
         """
         return self.name
 
-    def write(self):
+    def generate(self):
         if self.initial_momentum <= 0:
             raise ValueError("initial_momentum must be set to a non-zero value")
         q_over_c = UnitValue(
@@ -642,6 +641,11 @@ class frameworkGenerator(BaseModel):
         beam.Particles.t = UnitValue(abs(-z / constants.speed_of_light), units="s")
         beam.Particles.set_total_charge(self.charge)
         beam.set_species(self.species)
+        return beam
+
+    def write(self, beam=None):
+        if beam is None:
+            beam = self.generate()
         rbf.openpmd.write_openpmd_beam_file(
             beam,
             self.global_parameters["master_subdir"] + "/" + self.filename,
@@ -765,8 +769,10 @@ class frameworkGenerator(BaseModel):
     #     }
     #     return latticedict
 
+
 def poly_curve(x, coeffs):
-    return sum(c * x**i for i, c in enumerate(coeffs, start=1))
+    return sum(c * x ** i for i, c in enumerate(coeffs, start=1))
+
 
 def sample_2d_gaussian_with_axis_cutoffs(N, mean, cov, cutoffs):
     """
@@ -789,8 +795,8 @@ def sample_2d_gaussian_with_axis_cutoffs(N, mean, cov, cutoffs):
 
         # Apply per-axis cutoffs
         mask = (
-            (np.abs(z_white[:, 0]) <= cutoffs[0]) &
-            (np.abs(z_white[:, 1]) <= cutoffs[1])
+                (np.abs(z_white[:, 0]) <= cutoffs[0]) &
+                (np.abs(z_white[:, 1]) <= cutoffs[1])
         )
 
         accepted = x[mask]
@@ -798,6 +804,7 @@ def sample_2d_gaussian_with_axis_cutoffs(N, mean, cov, cutoffs):
 
     return np.array(samples[:N])
 
+
 def sample_gaussian(offset, sigma, cutoff, size):
     while True:
         samples = np.random.normal(offset, sigma, size * 2)
@@ -805,6 +812,7 @@ def sample_gaussian(offset, sigma, cutoff, size):
         if len(accepted) >= size:
             return accepted[:size]
 
+
 def sample_flat_top(offset, sigma, cutoff, edge_width, size):
     """
     Create a flat-top distribution centered at 0,

{simba_accelerator-0.3.0 → simba_accelerator-0.4.0}/simba/Codes/Generators/aliases.yaml

@@ -60,7 +60,7 @@ aliases:
       alias: sig_px
     correlation_px:
       alias: cor_px
-      multiplier: 1000
+      multiplier: 1000000
     distribution_type_y:
       alias: dist_y
     sigma_y:
@@ -70,7 +70,7 @@ aliases:
       alias: sig_py
     correlation_py:
       alias: cor_py
-      multiplier: 1000
+      multiplier: 1000000
     distribution_type_px:
       alias: dist_px
     distribution_type_py:

{simba_accelerator-0.3.0 → simba_accelerator-0.4.0}/simba/Codes/Generators/gpt.py

@@ -492,6 +492,7 @@ setGBphidist("beam","u", 0, 2*pi);
             HDF5filename = "laser.openpmd.hdf5"
         else:
             HDF5filename = self.filename
+        self.global_parameters["beam"].set_species(self.species)
         rbf.openpmd.write_openpmd_beam_file(
             self.global_parameters["beam"],
             self.global_parameters["master_subdir"] + "/" + HDF5filename,

{simba_accelerator-0.3.0 → simba_accelerator-0.4.0}/simba/Codes/Genesis/Genesis.py

@@ -5,6 +5,14 @@ Various objects and functions to handle Genesis lattices and commands. See `Gene
 
     .. _Genesis manual: https://github.com/svenreiche/Genesis-1.3-Version4/tree/master/manual
 
+SASE and HGHG are currently supported, with HGHG running if a laser is associated with the first
+undulator in the lattice. In this case, a chicane should also be defined after the first undulator in
+the simulation configuration file. Harmonic conversion is calculated based on the strength of
+the first undulator in the beamline after `<lattice>.split_element` which must also be passed
+to the simulation configuration file.
+
+Advanced schemes such as EEHG are not yet supported.
+
 Classes:
     - :class:`~simba.Codes.Genesis.Genesis.genesisLattice`: The Genesis lattice object, used for
     creating a string representation of the lattice suitable for Genesis input and lattice files.
@@ -116,6 +124,7 @@ from ...Framework_objects import (
 from ...FrameworkHelperFunctions import saveFile
 from ...Modules import Beams as rbf
 from typing import Dict, List, Literal
+import h5py
 
 command_files_order = [
     "setup",
@@ -124,20 +133,38 @@ command_files_order = [
     "profile_file",
     "profile_const",
     "profile_polynom",
-    "profile_gauus",
+    "profile_gauss",
     "field",
     "importdistribution",
     "importbeam",
     "importfield",
     "beam",
+    "track_first",
     "alter_setup",
     "alter_beam",
+    "field_2",
     "sort",
     "track",
     "write",
     "end",
 ]
 
+beam_profile_properties = [
+    "betax",
+    "betay",
+    "alphax",
+    "alphay",
+    "gamma",
+    "delgam",
+    "current",
+    # "xcenter",
+    # "ycenter",
+    # "pxcenter",
+    # "pycenter",
+    "ex",
+    "ey"
+]
+
 class genesisLattice(frameworkLattice):
     """
     Class for defining the Genesis lattice object, used for
@@ -192,7 +219,7 @@ class genesisLattice(frameworkLattice):
     npart: int = None
     """Number of macro particles per slice; if not provided, calculate from the beam"""
 
-    nbins: int = 4
+    nbins: int = 16
     """Number of macro particles to be grouped into beamlets"""
 
     seed: int = randint(1,10000000)
@@ -205,7 +232,7 @@ class genesisLattice(frameworkLattice):
     field_power: float = 1e3
     """Initial power for :class:`~simba.Codes.Genesis.Genesis.genesis_field_command`"""
 
-    dgrid: float = 1e-4
+    dgrid: float = 1e-3
     """Grid size for :class:`~simba.Codes.Genesis.Genesis.genesis_field_command`"""
 
     ngrid: int = 251
@@ -228,6 +255,15 @@ class genesisLattice(frameworkLattice):
     one4one: bool = False
     """If `True`, run in one-for-one mode; if not, use :attr:`~npart` and :attr:`~nbins`"""
 
+    chicanes: str | list = None
+    """Names of chicanes in the beamline; these should be defined as `chicane` groups
+    in the simulation configuration file."""
+
+    split_element: str = None
+    """Name of the element at which to split the lattice for hamonic conversion.
+    Only one split is currently allowed. Harmonic conversion is based on the strength of the 
+    first undulator after the split."""
+
 
     def model_post_init(self, __context):
         super().model_post_init(__context)
@@ -250,7 +286,27 @@ class genesisLattice(frameworkLattice):
         str
             The lattice represented as a string compatible with Genesis
         """
-        return self.section.to_genesis()
+        chicane_dict = {}
+        if self.chicanes is not None:
+            if isinstance(self.chicanes, str):
+                self.chicanes = [self.chicanes]
+            for chicane in self.chicanes:
+                if chicane in self.groupObjects:
+                    chicane_dict.update(
+                        {
+                            chicane: {
+                                "start": self.groupObjects[chicane].elementObjects[0].name,
+                                "end": self.groupObjects[chicane].elementObjects[-1].name,
+                                "r56": self.groupObjects[chicane].r56,
+                                "dipole_length": self.groupObjects[chicane].elementObjects[0].magnetic.length,
+                                "drift_length": self.groupObjects[chicane].elementObjects[1].start.z -
+                                                self.groupObjects[chicane].elementObjects[0].end.z,
+                                "length": self.groupObjects[chicane].elementObjects[-1].end.z -
+                                          self.groupObjects[chicane].elementObjects[0].start.z,
+                            },
+                        },
+                    )
+        return self.section.to_genesis(split_element=self.split_element, chicanes=chicane_dict)
 
     def write(self) -> None:
         """
@@ -308,13 +364,38 @@ class genesisLattice(frameworkLattice):
                 zmatch=self.match_location,
             )
         self.commandFiles["field"] = genesis_field_command(
-            power=self.field_power,
+            power=self.get_field_power(),
             ngrid=self.ngrid,
             dgrid=self.dgrid,
-            waist_size=self.waist_size,
+            waist_size=self.get_waist_size(),
             waist_pos=self.wigglers[0].physical.middle.z - self.startObject.physical.start.z
         )
         self.commandFiles["track"] = genesis_track_command()
+        if isinstance(self.split_element, str):
+            first_wiggler = None
+            for elem in self.elementObjects.values():
+                if elem.name == self.split_element:
+                    continue
+                if elem.hardware_class.lower() == "wiggler":
+                    first_wiggler = elem
+                    break
+            if first_wiggler is None:
+                raise ValueError(f"No undulator found after split_element {self.split_element}")
+            gamma0 = self.global_parameters["beam"].beam.centroids.mean_gamma.val
+            lambda0_from_und = first_wiggler.period / (2 * gamma0 ** 2) * (1 + first_wiggler.normalized_strength ** 2)
+            harmonic_number = int(round(self.fundamental_wavelength / lambda0_from_und))
+            self.commandFiles["track_first"] = genesis_track_command()
+            self.commandFiles["alter_setup"] = genesis_alter_setup_command(
+                beamline=f"{self.objectname}_SPLIT_2",
+                delz=first_wiggler.period,
+                harmonic=harmonic_number,
+            )
+            self.commandFiles["field_2"] = genesis_field_command(
+                power=0,
+                ngrid=self.ngrid,
+                dgrid=self.dgrid,
+                accumulate=True,
+            )
         self.commandFiles["write"] = genesis_write_command(
             field=f"{self.end}_FIELD",
             beam=f"{self.end}_BEAM",
@@ -334,7 +415,30 @@ class genesisLattice(frameworkLattice):
         HDF5filename = f"{rootname}.openpmd.hdf5"
         rbf.openpmd.write_openpmd_beam_file(beam, HDF5filename)
         self.commandFiles = {}
-
+        outfields = sorted(
+            [
+                e for e in os.listdir(self.global_parameters["master_subdir"]) if ".fld.h5" in e and self.end not in e
+            ]
+        )
+        outbeams = sorted(
+            [
+                e for e in os.listdir(self.global_parameters["master_subdir"]) if ".par.h5" in e and self.end not in e
+            ]
+        )
+        subd = self.global_parameters["master_subdir"]
+        for outf, photon in zip(outfields, self.getElementType("photon_monitor")):
+            os.rename(f"{subd}/{outf}", f"{subd}/{photon.name}.fld.h5")
+        for outb, scr in zip(outbeams, self.getElementType("screen")):
+            os.rename(f"{subd}/{outb}", f"{subd}/{scr.name}.par.h5")
+        with h5py.File(f"{self.global_parameters['master_subdir']}/{self.objectname}.out.h5", "r+") as f:
+            dset = f["/Lattice/z"]
+            dset[:] = dset[:] + self.startObject.physical.start.z
+        try:
+            with h5py.File(f"{self.global_parameters['master_subdir']}/{self.objectname}.Run2.out.h5", "r+") as f:
+                dset = f["/Lattice/z"]
+                dset[:] = dset[:] + self.elementObjects[self.split_element].physical.start.z
+        except FileNotFoundError:
+            pass
 
     def write_setup_file(self) -> None:
         gamma0 = self.global_parameters["beam"].beam.centroids.mean_gamma.val
@@ -347,11 +451,18 @@ class genesisLattice(frameworkLattice):
             if not np.isclose([self.fundamental_wavelength], [lambda0_from_und]):
                 warn(f"First undulator strength is not close to fundamental_wavelength")
         delz = first_wiggler.period
+        if isinstance(self.split_element, str):
+            if self.split_element in self.elements:
+                beamline = f"{self.objectname}_SPLIT_1"
+            else:
+                raise ValueError(f"split_element {self.split_element} not found in elements")
+        else:
+            beamline = self.objectname
         self.commandFiles["setup"] = genesis_setup_command(
             rootname=self.objectname,
             lattice=self.objectname + ".lat",
             #outputdir=self.global_parameters["master_subdir"],
-            beamline=self.objectname,
+            beamline=beamline,
             one4one=self.one4one,
             lambda0=self.fundamental_wavelength,
             gamma0=gamma0,
@@ -390,7 +501,6 @@ class genesisLattice(frameworkLattice):
                 genesisbeamfilename,
                 n_slice = int(self.nbins),
             )
-            beam_profile_properties = self.get_beam_profile_properties()
             props = {}
             self.commandFiles["profile_file"] = []
             for b in beam_profile_properties:
@@ -401,7 +511,7 @@ class genesisLattice(frameworkLattice):
                         ydata=f"{self.start}.genesis.hdf5/{b}",
                     )
                 )
-                props.update({b: f"{b}_profile"})
+                props.update({b: f"@{b}_profile"})
             self.commandFiles["beam"] = genesis_beam_command(**props)
             self.files.append(f"{self.global_parameters['master_subdir']}/{self.start}.genesis.hdf5")
         elif self.beam_type == "beam":
@@ -416,44 +526,64 @@ class genesisLattice(frameworkLattice):
             E0_eV = float(beam.E0_eV.val)
         else:
             E0_eV = float(beam.E0_eV.val[0])
+        slmom = beam.slice.slice_momentum_spread.val
+        lenslmom = len(slmom)
+        delgam = float(np.mean(slmom[int(lenslmom/2 - 3): int(lenslmom/2 + 3)])) / E0_eV
         ddd =  {
             "betax": float(beam.twiss.beta_x.val),
             "betay": float(beam.twiss.beta_y.val),
             "alphax": float(beam.twiss.alpha_x.val),
             "alphay": float(beam.twiss.alpha_y.val),
             "gamma": float(beam.centroids.mean_gamma.val),
-            "delgam": float(beam.sigmas.sigma_cp_eV.val) / E0_eV,
+            "delgam": delgam,
             "current": float(beam.slice.peak_current.val),
-            "xcenter": float(beam.centroids.mean_x.val),
-            "ycenter": float(beam.centroids.mean_y.val),
-            "pxcenter": float(beam.centroids.mean_cpx.val) / E0_eV,
-            "pycenter": float(beam.centroids.mean_cpy.val) / E0_eV,
+            # "xcenter": float(beam.centroids.mean_x.val),
+            # "ycenter": float(beam.centroids.mean_y.val),
+            # "pxcenter": float(beam.centroids.mean_cpx.val) / E0_eV,
+            # "pycenter": float(beam.centroids.mean_cpy.val) / E0_eV,
             "ex": float(beam.emittance.normalized_horizontal_emittance.val),
             "ey": float(beam.emittance.normalized_vertical_emittance.val),
         }
         return ddd
 
-    def get_beam_profile_properties(self) -> List:
-        return [
-            "betax",
-            "betay",
-            "alphax",
-            "alphay",
-            "gamma",
-            "delgam",
-            "current",
-            "xcenter",
-            "ycenter",
-            "pxcenter",
-            "pycenter",
-            "ex",
-            "ey"
-        ]
-
-        # ocebeamfilename = hdf5outname.replace("hdf5", "ocelot.npz")
-        # self.pin = rbf.beam.write_ocelot_beam_file(
-        #     self.global_parameters["beam"], ocebeamfilename, write=write
-        # )
+    def get_field_power(self) -> float | str:
+        """
+        Get the initial field power if the first undulator has a laser associated with it.
+        If not, return :attr:`~field_power`.
+
+        Returns
+        -------
+        float
+            Label of laser field profile if laser is associated with first undulator; else, :attr:`~field_power`
+        """
+        first_wiggler = self.wigglers[0]
+        if first_wiggler.laser:
+            self.commandFiles["profile_gauss"] = genesis_profile_gauss_command(
+                label=first_wiggler.name + "_laser_profile",
+                c0=first_wiggler.laser.max_power,
+                s0=first_wiggler.laser.initial_position,
+                sig=first_wiggler.laser.pulse_duration_rms * speed_of_light,
+            )
+            return f"@{first_wiggler.name}_laser_profile"
+        else:
+            return self.field_power
+
+    def get_waist_size(self) -> float:
+        """
+        Get the waist size if the first undulator has a laser associated with it.
+        If not, return :attr:`~waist_size`.
+
+        Returns
+        -------
+        float
+            Waist size
+        """
+        first_wiggler = self.wigglers[0]
+        if first_wiggler.laser:
+            waist = first_wiggler.laser.waist
+            return waist
+        else:
+            return self.waist_size
 
     def run(self) -> None:
         """
@@ -632,7 +762,7 @@ class genesis_alter_setup_command(genesisCommandFile):
     objecttype: str = "alter_setup"
     """Type of object for frameworkObject"""
 
-    rootname: str
+    rootname: str | None = None
     """The basic string, with which all output files will start, 
     unless the output filename is directly overwritten (see 
     :class:`~simba.Codes.Genesis.Genesis.genesis_write_command`)"""
@@ -1099,7 +1229,7 @@ class genesis_field_command(genesisCommandFile):
     """Position where the focal point is located relative to the undulator entrance. 
     Negative values place it before, resulting in a diverging radiation field."""
 
-    waist_size: float | str
+    waist_size: float | str | None = None
     """Waist size according to the definition of w 0 according to Siegman’s ’Laser’ handbook"""
 
     xcenter: float = 0.0

{simba_accelerator-0.3.0 → simba_accelerator-0.4.0}/simba/Framework.py

@@ -33,6 +33,7 @@ from laura.Exporters.YAML import export_machine, export_elements
 from .Modules.merge_two_dicts import merge_two_dicts
 from .Modules import Beams as rbf
 from .Modules import Twiss as rtf
+from .Modules import Wavefronts as rwf
 from .Modules import constants
 from .Codes import Executables as exes
 from .Codes.Generators import (
@@ -693,7 +694,10 @@ class Framework(BaseModel):
                     exclude_keys=["controls", "electrical", "manufacturer", "reference"],
                 )
 
-            self.elementObjects = {k: v for k, v in self.machine.elements.items()}
+            for k in list(self.machine.elements.keys()):
+                _ = self.machine.elements[k]
+
+            self.elementObjects = dict(self.machine.elements)
 
             # for name, elem in list(elements.items()):
             #     self.read_Element(name, elem)
@@ -1066,7 +1070,7 @@ class Framework(BaseModel):
                 end = np.array([elem.physical.end.x, elem.physical.end.y, elem.physical.end.z])
                 length = elem.physical.length
                 physical_angle = elem.physical.physical_angle
-    
+
                 # Calculate local offset from middle to end
                 if abs(physical_angle) > 1e-9:
                     # Bent element - correct arc geometry
@@ -1078,15 +1082,15 @@ class Framework(BaseModel):
                     ex_local = 0
                     ey_local = 0
                     ez_local = length / 2.0
-    
+
                 local_offset = np.array([ex_local, ey_local, ez_local])
-    
+
                 # Apply the full 3D rotation matrix
                 rotated_offset = elem.physical.rotated_position(local_offset.tolist())
-    
+
                 # Calculate expected end position
                 cend = middle + np.array(rotated_offset)
-    
+
                 # Check if calculated end matches actual end
                 diff = cend - end
                 if not np.allclose(diff, 0, atol=10 ** (-decimals)):
@@ -2098,6 +2102,9 @@ class frameworkDirectory(BaseModel):
     beams: bool | rbf.beamGroup | None = False
     """Flag to indicate whether to load beam files"""
 
+    wavefronts: bool | rwf.wavefrontGroup | None = False
+    """Flag to indicate whether to load wavefront files"""
+
     verbose: bool = False
     """Flag to print status updates"""
 
@@ -2154,6 +2161,8 @@ class frameworkDirectory(BaseModel):
         else:
             self.beams = None
             self.twiss = rtf.twiss()
+        if self.wavefronts:
+            self.wavefronts = rwf.load_directory(directory)
         if self.twiss:
             self.twiss.load_directory(directory, verbose=self.verbose)
 
@@ -2270,8 +2279,8 @@ class frameworkDirectory(BaseModel):
 
 
 def load_directory(
-    directory: str = ".", twiss: bool = True, beams: bool = False, **kwargs
+    directory: str = ".", twiss: bool = True, beams: bool = False, wavefronts: bool = False, **kwargs
 ) -> frameworkDirectory:
     """Load a directory from a SIMBA tracking run and return a frameworkDirectory object"""
-    fw = frameworkDirectory(directory=directory, twiss=twiss, beams=beams, **kwargs)
+    fw = frameworkDirectory(directory=directory, twiss=twiss, beams=beams, wavefronts=wavefronts, **kwargs)
     return fw

{simba_accelerator-0.3.0 → simba_accelerator-0.4.0}/simba/Framework_objects.py

@@ -1081,6 +1081,18 @@ class frameworkLattice(BaseModel):
         """
         return self.getElementType("wiggler")
 
+    @property
+    def photon_monitors(self) -> list:
+        """
+        Property to get all photon monitor elements in the lattice.
+
+        Returns
+        -------
+        list
+            A list of photon monitor elements in the lattice.
+        """
+        return self.getElementType("photon_monitor")
+
     @property
     def lines(self) -> list:
         """
@@ -2290,6 +2302,7 @@ class chicane(frameworkGroup):
     def __init__(self, name, elementObjects, type, elements, **kwargs):
         super(chicane, self).__init__(name, elementObjects, type, elements, **kwargs)
         self.ratios = (1, -1, -1, 1)
+        self.elementObjects = [self.allElementObjects[e] for e in self.elements]
 
     def update(self, **kwargs) -> None:
         """
@@ -2308,6 +2321,46 @@ class chicane(frameworkGroup):
             self.change_Parameter("gap", kwargs["gap"])
         return None
 
+    @property
+    def drift_d1_to_d2(self) -> float:
+        """
+        Drift length between dipole 1 and dipole 2
+
+        Returns
+        -------
+        float
+            The drift length between dipole 1 and dipole 2
+        """
+        e1 = self.elementObjects[0]
+        e2 = self.elementObjects[1]
+        return np.sqrt(np.sum([(getattr(e2.start, d) - getattr(e1.end, d)) ** 2 for d in ["x", "y", "z"]]))
+
+    @property
+    def r56(self) -> float:
+        """
+        R56 of the chicane
+
+        Returns
+        -------
+        float
+            R56 = 2 * angle^2 * (L1 + 2/3 * L2)
+        """
+        e1 = self.elementObjects[0]
+        ld = self.drift_d1_to_d2
+        return 2 * self.angle ** 2 * (ld * (2 * e1.magnetic.length) / 3)
+
+    @property
+    def delay(self) -> float:
+        """
+        Delay (longitudinal slippage) of the chicane
+
+        Returns
+        -------
+        float
+            Delay = 2 * R56
+        """
+        return 2 * self.r56
+
     @property
     def angle(self) -> float:
         """