xcoll 0.5.9__py3-none-any.whl → 0.5.10__py3-none-any.whl

xcoll/beam_elements/base.py

@@ -198,6 +198,10 @@ class BaseCollimator(BaseBlock):
                 to_assign['angle_L'] = kwargs.pop('angle_L', 0)
                 to_assign['angle_R'] = kwargs.pop('angle_R', 0)
 
+            # We do not allow any combination of jaw_ and gap_ attributes
+            # (except when jaw=..., gap=None or jaw=None, gap=... is used, as this is how the colldb installs it)
+            kwargs = {kk: vv for kk, vv in kwargs.items() if not vv is None}
+
             # Set jaw
             if 'jaw' in kwargs:
                 for key in ['jaw_L', 'jaw_R', 'jaw_LU', 'jaw_LD', 'jaw_RU', 'jaw_RD', 'gap', 'gap_L', 'gap_R']:
@@ -333,7 +337,7 @@ class BaseCollimator(BaseBlock):
         or   (self.tilt_L == 0 and self.tilt_R == 0):
             return [self.jaw_L, self.jaw_R]
         else:
-            return [[self.jaw_LU, self.jaw_RU], [self.jaw_LD, self.jaw_RD]]
+            return [[self.jaw_LU, self.jaw_LD], [self.jaw_RU, self.jaw_RD]]
 
     @jaw.setter   # Keeps the tilts unless all 4 corners are specified
     def jaw(self, val):
@@ -352,8 +356,8 @@ class BaseCollimator(BaseBlock):
             if hasattr(val[0], '__iter__'):
                 if hasattr(val[1], '__iter__') and len(val[0]) == 2 and len(val[1]) == 2:
                     self.jaw_LU = val[0][0]
-                    self.jaw_RU = val[0][1]
-                    self.jaw_LD = val[1][0]
+                    self.jaw_LD = val[0][1]
+                    self.jaw_RU = val[1][0]
                     self.jaw_RD = val[1][1]
                     return
             else:
@@ -556,6 +560,8 @@ class BaseCollimator(BaseBlock):
             print("Warning: Setting a tilt does not preserve the hierarchy, as there "
                 + "will always be one corner that tightens (the tilt is applied at "
                 + "the centre of the jaw).")
+            if val > np.pi/2 or val < -np.pi/2:
+                raise ValueError("Tilts larger than 90 degrees are not supported.")
         self._sin_yL = np.sin(val)
         self._cos_yL = np.cos(val)
         self._tan_yL = np.tan(val)
@@ -577,6 +583,8 @@ class BaseCollimator(BaseBlock):
             print("Warning: Setting a tilt does not preserve the hierarchy, as there "
                 + "will always be one corner that tightens (the tilt is applied at "
                 + "the centre of the jaw).")
+            if val > np.pi/2 or val < -np.pi/2:
+                raise ValueError("Tilts larger than 90 degrees are not supported.")
         self._sin_yR = np.sin(val)
         self._cos_yR = np.cos(val)
         self._tan_yR = np.tan(val)
@@ -965,8 +973,6 @@ class BaseCollimator(BaseBlock):
             assert self._jaws_parallel == False
             assert np.isclose(self._sin_zDiff, self._cos_zL*self._sin_zR - self._sin_zL*self._cos_zR)
             assert np.isclose(self._cos_zDiff, self._cos_zL*self._cos_zR + self._sin_zL*self._sin_zR)
-        if self.side == 'both' and abs(self.tilt_L - self.tilt_R) >= 90.:
-            raise ValueError("Tilts of both jaws differ more than 90 degrees!")
         if self.side != 'right':
             ang = abs(np.arccos(self._cos_yL))
             ang = np.pi - ang if ang > np.pi/2 else ang
@@ -1058,6 +1064,11 @@ class BaseCrystal(BaseBlock):
             # Set angle
             to_assign['angle'] = kwargs.pop('angle', 0)
 
+            # We do not allow any combination of jaw_ and gap_ attributes
+            # (except when jaw=..., gap=None or jaw=None, gap=... is used, as this is how the colldb installs it)
+            kwargs = {kk: vv for kk, vv in kwargs.items() if not vv is None}
+
+
             # Set jaw
             if 'jaw' in kwargs:
                 for key in ['jaw_U', 'jaw_D', 'gap']:
@@ -1214,6 +1225,8 @@ class BaseCrystal(BaseBlock):
             if val > min(0, -self.bending_angle/2):
                 print("Warning: Setting a positive tilt does not preserve the hierarchy, as the "
                     + "crystal tightens towards the beam.")
+        if val > np.pi/2 or val < -np.pi/2:
+            raise ValueError("Tilts larger than 90 degrees are not supported.")
         self._sin_y = np.sin(val)
         self._cos_y = np.cos(val)
         self._tan_y = np.tan(val)

xcoll/colldb.py

@@ -358,156 +358,158 @@ class CollimatorDatabase:
         return pd.DataFrame(self._collimator_dict).transpose()
 
     def to_yaml(self, out, lhc_style=True):
-        """
-        Writes a colldb in memory to disk in the yaml format.
-
-        > colldb_object.write_to_yaml(<path+name>, lhc_style=Bool)
-
-        if lhc_style == True, it will add comments assuming that the collimators are named
-        as in the lhc.
-
-        The function can dump b1, b2 and a general bx, however multi-beam functionality is not yet
-        added to the collmanager. TODO
-
-        If any of the dumped keys contains capital letters (e.g. gap_L), it will not be possible
-        to load it back into xcoll, since all keys are set to lowercase when importing TODO
-        """
-        # Dumps collimator database to a YAML file with optional LHC style formatting
-        import re
-
-        # Local helper functions
-        def _format_dict_entry(key, value, spacing='', mapping=False, key_width=15):
-            # Formats a dictionary entry into a string for YAML output
-            formatted_values = ',    '.join(f"{k}: {v}" for k, v in value.items())
-            formatted_values = re.sub(r'none', 'null', formatted_values, flags=re.IGNORECASE)
-            # Ensure key has a fixed width for alignment
-            if mapping:
-                formatted_key = f'{key}'.ljust(key_width)
-            else:
-                formatted_key = f'{key}:'.ljust(key_width)
-            #formatted_values = formatted_values.ljust(key_width)
-            return f"{spacing}{formatted_key} {{ {formatted_values} }}\n"
-
-        def _print_values(keys, dct, file, spacing='', mapping=False):
-            # Writes formatted dictionary entries to a file
-            for key in keys:
-                file.write(_format_dict_entry(key, dct[key], spacing=spacing, mapping=mapping))
-
-        def _print_colls(colls, dcts, beam, file):
-            # Filters and formats collimator data, then writes to a file
-            coll_items_to_print = ['<<','gap','angle','material','active','length','side']
-            file.write(f'  {beam}:\n')
-            for coll in colls:
-                coll_dict = dcts.to_pandas().transpose().to_dict()[coll]
-                fam = coll_dict['family']
-                fam_keys = []
-                if fam is not None:
-                    fam_keys = dcts._family_dict[fam].keys()
-                    coll_dict = {**{'<<': '*'+fam}, **coll_dict}
-                temp_items_to_print = []
-                if coll_dict['crystal'] and str(coll_dict['crystal'])!='nan':
-                    temp_items_to_print = ['bending_radius','width','height','miscut','crystal']
-                # if 'angle_L' in coll_dict and coll_dict['angle_L'] == coll_dict['angle_R']:
-                #     coll_dict.update({'angle': coll_dict['angle_L']})
-                # else:
-                #     temp_items_to_print = temp_items_to_print + ['angle_L','angle_R']
-                # if coll_dict['gap_L'] == coll_dict['gap_R']:
-                #     coll_dict.update({'gap': coll_dict['gap_L']})
-                # elif coll_dict['gap_L'] is None and coll_dict['gap_R'] is not None:
-                #     coll_dict.update({'gap': coll_dict['gap_R']})
-                # elif coll_dict['gap_L'] is not None and coll_dict['gap_R'] is None:
-                #     coll_dict.update({'gap': coll_dict['gap_L']})
-                # else:
-                #     temp_items_to_print = temp_items_to_print + ['gap_L','gap_R']
-                value = {}
-                overwritten_keys = coll_dict['overwritten_keys']
-                for key, val in coll_dict.items():
-                    if key == 'active_length':
-                        key = 'length' 
-                    if (key in coll_items_to_print+temp_items_to_print) and (key not in (set(fam_keys)-set(overwritten_keys))) and (val != 'both'):
-                        value.update({key: val})
-                file.write(_format_dict_entry(coll, value, spacing='    '))
-            file.write('\n')
-
-        LHC_families = ['tcp3', 'tcsg3', 'tcsm3', 'tcla3', 'tcp7', 'tcsg7', 'tcsm7', 'tcla7', 'tcli', 'tdi', 'tcdq', 'tcstcdq', 'tcth1', 'tcth2', 'tcth5', 'tcth8', 'tctv1', 'tctv2', 'tctv5', 'tctv8', 'tclp', 'tcxrp', 'tcryo', 'tcl4', 'tcl5', 'tcl6', 'tct15', 'tct2', 'tct8', 'tcsp', 'tcld']
-        with open(f'{out}.yaml', 'w') as file:
-            if '_family_dict' in self.__dict__.keys():
-                file.write('families:\n')
-                if lhc_style:
-                    printed_families = []
-                    fams_in_dict = self._family_dict.keys()
-
-                    # Momentum cleaning
-                    file.write('  # Momentum cleaning\n')
-                    sel_fam = [fam for fam in LHC_families if re.match('.*3', fam) and (fam in fams_in_dict)]
-                    printed_families += sel_fam
-                    _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
-
-                    # Betatron cleaning
-                    file.write('  # Betatron cleaning\n')
-                    sel_fam = [fam for fam in LHC_families if re.match('.*7', fam) and (fam in fams_in_dict)]
-                    printed_families += sel_fam
-                    _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
-
-                    # Injection protection
-                    file.write('  # Injection protection\n')
-                    sel_fam = [fam for fam in LHC_families if (fam in ['tcli', 'tdi']) and (fam in fams_in_dict)]
-                    printed_families += sel_fam
-                    _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
-
-                    # Dump protection
-                    file.write('  # Dump protection\n')
-                    sel_fam = [fam for fam in LHC_families if (fam in ['tcdq', 'tcsp', 'tcstcdq']) and (fam in fams_in_dict)]
-                    printed_families += sel_fam
-                    _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
-
-                    # Physics background / debris
-                    file.write('  # Physics background / debris\n')
-                    sel_fam = [fam for fam in LHC_families if ((re.match('tc[lt][0-9dp].*', fam)) or (fam in ['tcryo', 'tcxrp'])) and (fam in fams_in_dict)]
-                    printed_families += sel_fam
-                    _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
-
-                    # Other families
-                    if set(printed_families) != set(fams_in_dict):
-                        file.write('  # Other families\n')
-                        _print_values(set(fams_in_dict) - set(printed_families), self._family_dict, file, spacing='  - &', mapping=True)
-                else:
-                    file.write('  # Families\n')
-                    _print_values(self._family_dict.keys(), self._family_dict, file, spacing='  - &', mapping=True)
-
-            # Emittance section
-            ex = self.nemitt_x
-            ey = self.nemitt_y
-            file.write(f'\nemittance:\n  x: {ex}\n  y: {ey}\n')
-
-            # Collimators section
-            file.write('\ncollimators:\n')
-            b1_colls, b2_colls, bx_colls = [], [], []
-            for coll in self.to_pandas().index:
-                if coll == 'tclia.4r2' or coll == 'tclia.4l8':    # TODO: hardcoded!!!
-                    b1_colls.append(coll)
-                    b2_colls.append(coll)
-                elif coll[-2:] == 'b1':
-                    b1_colls.append(coll)
-                elif coll[-2:] == 'b2':
-                    b2_colls.append(coll)
-                else:
-                    bx_colls.append(coll)
-
-            # Handle special cases for collimators
-            if (('tclia.4r2' in b1_colls) or ('tclia.4l8' in b1_colls)) and (len(b1_colls) <= 2):
-                b1_colls = []
-            if (('tclia.4r2' in b2_colls) or ('tclia.4l8' in b2_colls)) and (len(b2_colls) <= 2):
-                b2_colls = []
-
-            # Print collimators for each beam
-            if len(b1_colls) > 0:
-                _print_colls(b1_colls, self, 'b1', file)
-            if len(b2_colls) > 0:
-                _print_colls(b2_colls, self, 'b2', file)
-            if len(bx_colls) > 0:
-                _print_colls(bx_colls, self, 'bx', file)
-                print('WARNING -- some collimators could not be assigned to b1 or b2. Tracking might not work with those collimators. Please manually change the output file if necessary.')
+        raise NotImplementedError("This functionality needs to be updated to be compatible with tilts and read "
+                                + "the families from the colldb instead of hard-coding them!")
+        # """
+        # Writes a colldb in memory to disk in the yaml format.
+
+        # > colldb_object.write_to_yaml(<path+name>, lhc_style=Bool)
+
+        # if lhc_style == True, it will add comments assuming that the collimators are named
+        # as in the lhc.
+
+        # The function can dump b1, b2 and a general bx, however multi-beam functionality is not yet
+        # added to the collmanager. TODO
+
+        # If any of the dumped keys contains capital letters (e.g. gap_L), it will not be possible
+        # to load it back into xcoll, since all keys are set to lowercase when importing TODO
+        # """
+        # # Dumps collimator database to a YAML file with optional LHC style formatting
+        # import re
+
+        # # Local helper functions
+        # def _format_dict_entry(key, value, spacing='', mapping=False, key_width=15):
+        #     # Formats a dictionary entry into a string for YAML output
+        #     formatted_values = ',    '.join(f"{k}: {v}" for k, v in value.items())
+        #     formatted_values = re.sub(r'none', 'null', formatted_values, flags=re.IGNORECASE)
+        #     # Ensure key has a fixed width for alignment
+        #     if mapping:
+        #         formatted_key = f'{key}'.ljust(key_width)
+        #     else:
+        #         formatted_key = f'{key}:'.ljust(key_width)
+        #     #formatted_values = formatted_values.ljust(key_width)
+        #     return f"{spacing}{formatted_key} {{ {formatted_values} }}\n"
+
+        # def _print_values(keys, dct, file, spacing='', mapping=False):
+        #     # Writes formatted dictionary entries to a file
+        #     for key in keys:
+        #         file.write(_format_dict_entry(key, dct[key], spacing=spacing, mapping=mapping))
+
+        # def _print_colls(colls, dcts, beam, file):
+        #     # Filters and formats collimator data, then writes to a file
+        #     coll_items_to_print = ['<<','gap','angle','material','active','length','side']
+        #     file.write(f'  {beam}:\n')
+        #     for coll in colls:
+        #         coll_dict = dcts.to_pandas().transpose().to_dict()[coll]
+        #         fam = coll_dict['family']
+        #         fam_keys = []
+        #         if fam is not None:
+        #             fam_keys = dcts._family_dict[fam].keys()
+        #             coll_dict = {**{'<<': '*'+fam}, **coll_dict}
+        #         temp_items_to_print = []
+        #         if coll_dict['crystal'] and str(coll_dict['crystal'])!='nan':
+        #             temp_items_to_print = ['bending_radius','width','height','miscut','crystal']
+        #         # if 'angle_L' in coll_dict and coll_dict['angle_L'] == coll_dict['angle_R']:
+        #         #     coll_dict.update({'angle': coll_dict['angle_L']})
+        #         # else:
+        #         #     temp_items_to_print = temp_items_to_print + ['angle_L','angle_R']
+        #         # if coll_dict['gap_L'] == coll_dict['gap_R']:
+        #         #     coll_dict.update({'gap': coll_dict['gap_L']})
+        #         # elif coll_dict['gap_L'] is None and coll_dict['gap_R'] is not None:
+        #         #     coll_dict.update({'gap': coll_dict['gap_R']})
+        #         # elif coll_dict['gap_L'] is not None and coll_dict['gap_R'] is None:
+        #         #     coll_dict.update({'gap': coll_dict['gap_L']})
+        #         # else:
+        #         #     temp_items_to_print = temp_items_to_print + ['gap_L','gap_R']
+        #         value = {}
+        #         overwritten_keys = coll_dict['overwritten_keys']
+        #         for key, val in coll_dict.items():
+        #             if key == 'active_length':
+        #                 key = 'length'
+        #             if (key in coll_items_to_print+temp_items_to_print) and (key not in (set(fam_keys)-set(overwritten_keys))) and (val != 'both'):
+        #                 value.update({key: val})
+        #         file.write(_format_dict_entry(coll, value, spacing='    '))
+        #     file.write('\n')
+
+        # LHC_families = ['tcp3', 'tcsg3', 'tcsm3', 'tcla3', 'tcp7', 'tcsg7', 'tcsm7', 'tcla7', 'tcli', 'tdi', 'tcdq', 'tcstcdq', 'tcth1', 'tcth2', 'tcth5', 'tcth8', 'tctv1', 'tctv2', 'tctv5', 'tctv8', 'tclp', 'tcxrp', 'tcryo', 'tcl4', 'tcl5', 'tcl6', 'tct15', 'tct2', 'tct8', 'tcsp', 'tcld']
+        # with open(f'{out}.yaml', 'w') as file:
+        #     if '_family_dict' in self.__dict__.keys():
+        #         file.write('families:\n')
+        #         if lhc_style:
+        #             printed_families = []
+        #             fams_in_dict = self._family_dict.keys()
+
+        #             # Momentum cleaning
+        #             file.write('  # Momentum cleaning\n')
+        #             sel_fam = [fam for fam in LHC_families if re.match('.*3', fam) and (fam in fams_in_dict)]
+        #             printed_families += sel_fam
+        #             _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
+
+        #             # Betatron cleaning
+        #             file.write('  # Betatron cleaning\n')
+        #             sel_fam = [fam for fam in LHC_families if re.match('.*7', fam) and (fam in fams_in_dict)]
+        #             printed_families += sel_fam
+        #             _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
+
+        #             # Injection protection
+        #             file.write('  # Injection protection\n')
+        #             sel_fam = [fam for fam in LHC_families if (fam in ['tcli', 'tdi']) and (fam in fams_in_dict)]
+        #             printed_families += sel_fam
+        #             _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
+
+        #             # Dump protection
+        #             file.write('  # Dump protection\n')
+        #             sel_fam = [fam for fam in LHC_families if (fam in ['tcdq', 'tcsp', 'tcstcdq']) and (fam in fams_in_dict)]
+        #             printed_families += sel_fam
+        #             _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
+
+        #             # Physics background / debris
+        #             file.write('  # Physics background / debris\n')
+        #             sel_fam = [fam for fam in LHC_families if ((re.match('tc[lt][0-9dp].*', fam)) or (fam in ['tcryo', 'tcxrp'])) and (fam in fams_in_dict)]
+        #             printed_families += sel_fam
+        #             _print_values(sel_fam, self._family_dict, file, spacing='  - &', mapping=True)
+
+        #             # Other families
+        #             if set(printed_families) != set(fams_in_dict):
+        #                 file.write('  # Other families\n')
+        #                 _print_values(set(fams_in_dict) - set(printed_families), self._family_dict, file, spacing='  - &', mapping=True)
+        #         else:
+        #             file.write('  # Families\n')
+        #             _print_values(self._family_dict.keys(), self._family_dict, file, spacing='  - &', mapping=True)
+
+        #     # Emittance section
+        #     ex = self.nemitt_x
+        #     ey = self.nemitt_y
+        #     file.write(f'\nemittance:\n  x: {ex}\n  y: {ey}\n')
+
+        #     # Collimators section
+        #     file.write('\ncollimators:\n')
+        #     b1_colls, b2_colls, bx_colls = [], [], []
+        #     for coll in self.to_pandas().index:
+        #         if coll == 'tclia.4r2' or coll == 'tclia.4l8':    # TODO: hardcoded!!!
+        #             b1_colls.append(coll)
+        #             b2_colls.append(coll)
+        #         elif coll[-2:] == 'b1':
+        #             b1_colls.append(coll)
+        #         elif coll[-2:] == 'b2':
+        #             b2_colls.append(coll)
+        #         else:
+        #             bx_colls.append(coll)
+
+        #     # Handle special cases for collimators
+        #     if (('tclia.4r2' in b1_colls) or ('tclia.4l8' in b1_colls)) and (len(b1_colls) <= 2):
+        #         b1_colls = []
+        #     if (('tclia.4r2' in b2_colls) or ('tclia.4l8' in b2_colls)) and (len(b2_colls) <= 2):
+        #         b2_colls = []
+
+        #     # Print collimators for each beam
+        #     if len(b1_colls) > 0:
+        #         _print_colls(b1_colls, self, 'b1', file)
+        #     if len(b2_colls) > 0:
+        #         _print_colls(b2_colls, self, 'b2', file)
+        #     if len(bx_colls) > 0:
+        #         _print_colls(bx_colls, self, 'bx', file)
+        #         print('WARNING -- some collimators could not be assigned to b1 or b2. Tracking might not work with those collimators. Please manually change the output file if necessary.')
 
 
     # ====================================
@@ -539,27 +541,14 @@ class CollimatorDatabase:
                                + f"(or xtrack.Drift)!\nPlease check the name, or correct the "
                                + f"element.")
 
-    def _create_collimator(self, line, collimator_class, name, **kwargs):
-        assert issubclass(collimator_class, BaseCollimator)
-        self._check_installed(line, name, collimator_class)
+    def _create_collimator(self, cls, line, name, **kwargs):
+        self._check_installed(line, name, cls)
         if kwargs.pop('verbose', False):
-            print(f"Installing {name:20} as {collimator_class.__name__}")
-        el = collimator_class(gap=self[name]['gap'], angle=self[name]['angle'],
-                              length=self[name]['length'], side=self[name]['side'],
-                              _tracking=False, **kwargs)
-        el.emittance = [self.nemitt_x, self.nemitt_y]
-        self._elements[name] = el
-
-    def _create_crystal(self, line, crystal_class, name, **kwargs):
-        assert issubclass(crystal_class, BaseCrystal)
-        self._check_installed(line, name, crystal_class)
-        if kwargs.pop('verbose', False):
-            print(f"Installing {name:20} as {crystal_class.__name__}")
-        el = crystal_class(gap=self[name]['gap'], angle=self[name]['angle'],
-                           length=self[name]['length'], side=self[name]['side'],
-                           bending_radius=self[name]['bending_radius'],
-                           width=self[name]['width'], height=self[name]['height'],
-                           _tracking=False, **kwargs)
+            print(f"Installing {name:20} as {cls.__name__}")
+        prop_dict = {kk: vv for kk, vv in self[name].items() \
+                     if kk in cls._xofields or kk in cls._store_in_to_dict}
+        prop_dict.update(kwargs)
+        el = cls(**prop_dict)
         el.emittance = [self.nemitt_x, self.nemitt_y]
         self._elements[name] = el
 
@@ -567,9 +556,9 @@ class CollimatorDatabase:
         names = self._get_names_from_line(line, names, families)
         for name in names:
             if self[name]['bending_radius'] is None:
-                self._create_collimator(line, BlackAbsorber, name, verbose=verbose)
+                self._create_collimator(BlackAbsorber, line, name, verbose=verbose)
             else:
-                self._create_crystal(line, BlackCrystal, name, verbose=verbose)
+                self._create_collimator(BlackCrystal, line, name, verbose=verbose)
         elements = [self._elements[name] for name in names]
         line.collimators.install(names, elements, need_apertures=need_apertures)
 
@@ -578,12 +567,11 @@ class CollimatorDatabase:
         for name in names:
             mat = SixTrack_to_xcoll(self[name]['material'])
             if self[name]['bending_radius'] is None:
-                self._create_collimator(line, EverestCollimator, name, material=mat[0],
+                self._create_collimator(EverestCollimator, line, name, material=mat[0],
                                         verbose=verbose)
             else:
-                self._create_crystal(line, EverestCrystal, name, material=mat[1],
-                                     lattice=self[name]['crystal'], verbose=verbose,
-                                     miscut=self[name]['miscut'])
+                self._create_collimator(EverestCrystal, line, name, material=mat[1],
+                                        verbose=verbose)
         elements = [self._elements[name] for name in names]
         line.collimators.install(names, elements, need_apertures=need_apertures)
 

xcoll/general.py

@@ -12,5 +12,5 @@ citation = "F.F. Van der Veken, et al.: Recent Developments with the New Tools f
 # ======================
 # Do not change
 # ======================
-__version__ = '0.5.9'
+__version__ = '0.5.10'
 # ======================

{xcoll-0.5.9.dist-info → xcoll-0.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xcoll
-Version: 0.5.9
+Version: 0.5.10
 Summary: Xsuite collimation package
 Home-page: https://github.com/xsuite/xcoll
 License: Apache 2.0
@@ -18,7 +18,7 @@ Provides-Extra: tests
 Requires-Dist: numpy (>=1.0)
 Requires-Dist: pandas (>=1.4)
 Requires-Dist: ruamel-yaml (>=0.17.31,<0.18.0) ; extra == "tests"
-Requires-Dist: xdeps (>=0.7.3)
+Requires-Dist: xdeps (>=0.7.4)
 Requires-Dist: xobjects (>=0.4.5)
 Requires-Dist: xpart (>=0.19.1)
 Requires-Dist: xtrack (>=0.69.7)

{xcoll-0.5.9.dist-info → xcoll-0.5.10.dist-info}/RECORD

@@ -3,9 +3,8 @@ NOTICE,sha256=6DO_E7WCdRKc42vUoVVBPGttvQi4mRt9fAcxj9u8zy8,74
 xcoll/__init__.py,sha256=b_61vh5irhf5fPmqTFJlyhNSt4rmftXg9uXPIEpgVB4,1612
 xcoll/_manager.py,sha256=9NQKaNxZR2I1ChMVBeKQc0A8h6W8gVgRRg72a5NgbXU,808
 xcoll/beam_elements/__init__.py,sha256=06bU8rzvlUPhcvwpaUippddm5IChpcCHBvpmvXJQU74,1122
-xcoll/beam_elements/__init__.py.orig,sha256=XZMbC-0IzLmKN4LXXT5zm2zOXzRWvkpuElCBGE3VWtw,1507
 xcoll/beam_elements/absorber.py,sha256=efK6gyUgD4x_FnBLpMR7-5_HCdp_753nkYikcdn6ulw,2502
-xcoll/beam_elements/base.py,sha256=6scwhofls5AHPJcUyEbTJOJ8U86EQU4S7BB7NGoE_j0,52728
+xcoll/beam_elements/base.py,sha256=5k4ngEXNgvoiJWu7dx2bwHlv73tfaxn-4JlCdLwHdYo,53495
 xcoll/beam_elements/blowup.py,sha256=gBXdlISvoDiMjXVpA77ls5QdAU3H9krwvFt2bSW_NII,8029
 xcoll/beam_elements/elements_src/black_absorber.h,sha256=jCyQoaZ7VsIu8coQ99J1dDtAGqZpFIxxFLBlfhO6Drw,5027
 xcoll/beam_elements/elements_src/black_crystal.h,sha256=x7oUwsrkUwUrFvhFsq8vtPkJJTSi1hYAhSt6fjzkJQo,4622
@@ -16,13 +15,11 @@ xcoll/beam_elements/elements_src/everest_collimator.h,sha256=DlWkb5RORnp5VwI7E31
 xcoll/beam_elements/elements_src/everest_crystal.h,sha256=WwwNF6it7TuOimhpSXJa7UXqp_i3wVZ_fXlTStn4db0,12193
 xcoll/beam_elements/everest.py,sha256=PA_VWpnPrIuO1xN__eKyT_ejbGZK7p93QHDVi3re7cM,8541
 xcoll/beam_elements/monitor.py,sha256=zzMdN3JMFSAs-30_ntRvd5qZGdsXfGtColhiFDuMcIk,16928
-xcoll/colldb.py,sha256=lEpkDRAT54szT9i7-jbTMRvkuW_0W2piZCdDaungcIs,30983
-xcoll/colldb.py.orig,sha256=v4AXbY44o_mlealtFXzMzDNLVt-Hkt_ZkjKs5QUJlec,31898
-xcoll/general.py,sha256=-xLa-F2jd_1I3hIhlntMYsz_B-DZw_bj0qqh1SR1Cno,534
+xcoll/colldb.py,sha256=hGScl4lU93KDemHrgHOKfu2OqVAufP1BtgKKHJ_THDc,30501
+xcoll/general.py,sha256=wIlggzlMxO2sa0ntCbJyJatOL4CSQ7ndh3Ff9SNuOsc,535
 xcoll/headers/checks.h,sha256=qdXsOTBOK1MwW6bdFF93j4yE648mcDtEv5rGN1w9sfk,1582
 xcoll/headers/particle_states.h,sha256=DZa_ZSaJrjnA8aHFriZKfRCkArQ8nK1t445MRwevDtA,840
 xcoll/initial_distribution.py,sha256=x5G4LTXn4boEg5jBFrQCk_l759h91XiAUhDTdcUvLkc,8779
-xcoll/initial_distribution.py.orig,sha256=NOtDtAoNYx8p5l-hUO9ueafl3jtbIzGU0z8-xHtTX_E,9026
 xcoll/install.py,sha256=SxEFQnhWXlsXyPBIo847q6wPgId_f5ZtFRR1awGbkjc,2108
 xcoll/interaction_record/__init__.py,sha256=UFoLiKa-z2oX7YoszP-7Vgdt1nM6kT382v1CaIu8_u0,50
 xcoll/interaction_record/interaction_record.py,sha256=ixsQtVZn71vVEuTAA27a2NWcZZZ8iAcWFOa58bcWEQU,13271
@@ -409,8 +406,8 @@ xcoll/scattering_routines/geometry/objects.h,sha256=A5ktGvVlSkC4hUsI_PQFsE80CuDw
 xcoll/scattering_routines/geometry/rotation.h,sha256=lO3RaQBys9r0ROMjR8T8Rr7UsIEm-H9_C_70Nwz4MXY,701
 xcoll/scattering_routines/geometry/segments.h,sha256=7nKnnin2ByxkKyaYwGvFaqgLQg5uBba4CdLHL7L3iQs,7667
 xcoll/scattering_routines/geometry/sort.h,sha256=b1MkFO2ddzv1fWGeQzsLuz46qo2pKyRSXHjoAEVU7Ts,5763
-xcoll-0.5.9.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-xcoll-0.5.9.dist-info/METADATA,sha256=ZBJuoHNhd-lFobMiSbj1SmSZ8yyie9OC_QTUo2Af4PI,2675
-xcoll-0.5.9.dist-info/NOTICE,sha256=6DO_E7WCdRKc42vUoVVBPGttvQi4mRt9fAcxj9u8zy8,74
-xcoll-0.5.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-xcoll-0.5.9.dist-info/RECORD,,
+xcoll-0.5.10.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+xcoll-0.5.10.dist-info/METADATA,sha256=QjZzi_xm9l64o5NVMUqkX5E0Tn5RrbW4pJbGMdqyrPI,2676
+xcoll-0.5.10.dist-info/NOTICE,sha256=6DO_E7WCdRKc42vUoVVBPGttvQi4mRt9fAcxj9u8zy8,74
+xcoll-0.5.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+xcoll-0.5.10.dist-info/RECORD,,

xcoll/beam_elements/__init__.py.orig

@@ -1,32 +0,0 @@
-# copyright ############################### #
-# This file is part of the Xcoll package.   #
-# Copyright (c) CERN, 2024.                 #
-# ######################################### #
-
-from .base import BaseBlock, BaseCollimator, BaseCrystal
-from .absorber import BlackAbsorber, BlackCrystal
-from .everest import EverestBlock, EverestCollimator, EverestCrystal
-from .blowup import BlowUp
-from .monitor import EmittanceMonitor
-
-block_classes = tuple(v for v in globals().values()
-                      if isinstance(v, type) and issubclass(v, BaseBlock) and v != BaseBlock
-                      and v != BaseCollimator and v != BaseCrystal)
-# Includes crystals
-collimator_classes = tuple(v for v in globals().values()
-                           if isinstance(v, type) and (issubclass(v, BaseCollimator) or issubclass(v, BaseCrystal))
-                           and v != BaseCollimator and v != BaseCrystal)
-crystal_classes = tuple(v for v in globals().values()
-                        if isinstance(v, type) and issubclass(v, BaseCrystal) and v != BaseCrystal)
-
-element_classes = block_classes + (BlowUp, EmittanceMonitor)
-<<<<<<< HEAD
-
-# These should not go into any of the classes lists
-# but are added for compatibility with _K2
-from .k2 import _K2Collimator, _K2Crystal
-_all_block_classes      = block_classes + (_K2Collimator, _K2Crystal)
-_all_collimator_classes = collimator_classes + (_K2Collimator, _K2Crystal)
-_all_crystal_classes    = crystal_classes + (_K2Crystal,)
-=======
->>>>>>> release/v0.6.0