xcoll 0.3.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

xcoll/beam_elements/collimators_src/everest_crystal.h

@@ -1,6 +1,6 @@
 // copyright ############################### #
 // This file is part of the Xcoll Package.   #
-// Copyright (c) CERN, 2023.                 #
+// Copyright (c) CERN, 2024.                 #
 // ######################################### #
 
 #ifndef XCOLL_EVEREST_CRYSTAL_H
@@ -9,106 +9,250 @@
 #include <stdio.h>
 
 
-/*gpufun*/
 void EverestCrystal_set_material(EverestCrystalData el){
     CrystalMaterialData material = EverestCrystalData_getp__material(el);
     RandomRutherfordData rng = EverestCrystalData_getp_rutherford_rng(el);
     RandomRutherford_set_by_xcoll_material(rng, (GeneralMaterialData) material);
 }
 
+
 /*gpufun*/
-void EverestCrystal_track_local_particle(EverestCrystalData el, LocalParticle* part0) {
-    int8_t active      = EverestCrystalData_get_active(el);
-    active            *= EverestCrystalData_get__tracking(el);
-    double const inactive_front = EverestCrystalData_get_inactive_front(el);
-    double const active_length  = EverestCrystalData_get_active_length(el);
-    double const inactive_back  = EverestCrystalData_get_inactive_back(el);
+CrystalGeometry EverestCrystal_init_geometry(EverestCrystalData el, LocalParticle* part0, int8_t active){
+    CrystalGeometry cg = (CrystalGeometry) malloc(sizeof(CrystalGeometry_));
+    if (active){ // This is needed in order to avoid that the initialisation is called during a twiss!
+        cg->length = EverestCrystalData_get_length(el);
+        cg->side   = EverestCrystalData_get__side(el);
+        if (cg->side == 0){
+            kill_all_particles(part0, XC_ERR_INVALID_XOFIELD);
+            return cg;
+        }
+        double R   = EverestCrystalData_get__bending_radius(el);
+        double t_R = EverestCrystalData_get__bending_angle(el);
+        cg->bending_radius = R;
+        cg->bending_angle  = t_R;
+        cg->miscut_angle   = EverestCrystalData_get_miscut(el);
+        cg->width  = EverestCrystalData_get_width(el);
+        cg->height = EverestCrystalData_get_height(el);
+        cg->jaw_U  = EverestCrystalData_get__jaw_U(el);
+        cg->sin_z  = EverestCrystalData_get__sin_z(el);
+        cg->cos_z  = EverestCrystalData_get__cos_z(el);
+        cg->sin_y  = EverestCrystalData_get__sin_y(el);
+        cg->cos_y  = EverestCrystalData_get__cos_y(el);
+        // Segments
+        if (cg->side == 1){
+            cg->segments = create_crystal(cg->bending_radius, cg->width, cg->length, cg->jaw_U, \
+                                          cg->sin_y, cg->cos_y);
+        } else if (cg->side == -1){
+            // jaw_U is the inner corner (shifted if right-sided crystal)
+            cg->segments = create_crystal(cg->bending_radius, cg->width, cg->length, cg->jaw_U - cg->width, \
+                                          cg->sin_y, cg->cos_y);
+        }
+        // Bend centre
+        cg->s_B = 0;
+        cg->x_B = cg->bending_radius;
+        // Miscut centre
+        cg->s_P = -R*sin(cg->miscut_angle);
+        cg->x_P = R*cos(cg->miscut_angle);
+        // Mirror the crystal geometry
+        if (cg->side == -1){
+            cg->bending_radius = -cg->bending_radius;
+            cg->bending_angle  = -cg->bending_angle;
+            cg->miscut_angle   = -cg->miscut_angle;
+            cg->x_P            = -cg->x_P;
+            cg->x_B            = -cg->x_B;
+        }
+        if (R < 0){
+            // If R<0, a left-sided crystal bends towards the beam
+            cg->x_P = cg->x_P + cg->width;
+            cg->x_B = cg->x_B + cg->width;
+        }
+        // From here on, crystal geometry parameters can always be treated as left-sided.
+        // Note that the segments are not mirrored, which is fine as get_s_of_first_crossing_with_vlimit
+        // is absolute (not in the jaw reference frame). It is only after a hit is registered, that we
+        // need to transform the particle to the jaw reference frame.
+        double Rb;
+        if (cg->miscut_angle > 0){
+            Rb = R - cg->width;
+        } else {
+            Rb = R;
+        }
+        cg->t_VImax = atan( (Rb*sin(t_R) - cg->s_P) / (R - Rb*cos(t_R) - cg->x_P) );
+        // Impact table
+        cg->record = EverestCrystalData_getp_internal_record(el, part0);
+        cg->record_index = NULL;
+        cg->record_touches = 0;
+        if (cg->record){
+            cg->record_index = InteractionRecordData_getp__index(cg->record);
+            cg->record_touches = EverestCrystalData_get_record_touches(el);
+        }
+    }
 
-    CrystalMaterialData material = EverestCrystalData_getp__material(el);
-    RandomRutherfordData rng = EverestCrystalData_getp_rutherford_rng(el);
+    return cg;
+}
 
-    // Crystal properties
-    double length  = EverestCrystalData_get_active_length(el);
-    double const co_x       = EverestCrystalData_get_ref_x(el);
-    double const co_y       = EverestCrystalData_get_ref_y(el);
-    // TODO: use xtrack C-code for rotation element
-    // TODO: we are ignoring the angle of the right jaw
-    // TODO: is a crystal always one-sided...?
-    double const sin_zL     = EverestCrystalData_get_sin_zL(el);
-    double const cos_zL     = EverestCrystalData_get_cos_zL(el);
-    double const sin_zR     = EverestCrystalData_get_sin_zR(el);
-    double const cos_zR     = EverestCrystalData_get_cos_zR(el);
-    if (fabs(sin_zL-sin_zR) > 1.e-10 || fabs(cos_zL-cos_zR) > 1.e-10 ){
-        kill_all_particles(part0, XC_ERR_NOT_IMPLEMENTED);
-    };
-    double const c_aperture = EverestCrystalData_get_jaw_L(el) - EverestCrystalData_get_jaw_R(el);
-    double const c_offset   = ( EverestCrystalData_get_jaw_L(el) + EverestCrystalData_get_jaw_R(el) ) /2;
-    double const c_tilt0    = asin(EverestCrystalData_get_sin_yL(el));
-    double const c_tilt1    = asin(EverestCrystalData_get_sin_yR(el));
-    if (fabs(c_tilt1) > 1.e-10){
-        kill_all_particles(part0, XC_ERR_INVALID_XOFIELD);
-    };
-    int    const side       = EverestCrystalData_get__side(el);
-    double const bend       = EverestCrystalData_get__bending_radius(el);
-    // TODO: cry_tilt should be given by jaw positions...?
-    double const cry_tilt   = EverestCrystalData_get_align_angle(el) + c_tilt0;
-    double const bend_ang   = length/bend;    // temporary value
-    if (cry_tilt >= -bend_ang) {
-        length = bend*(sin(bend_ang + cry_tilt) - sin(cry_tilt));
-    } else {
-        length = bend*(sin(bend_ang - cry_tilt) + sin(cry_tilt));
+/*gpufun*/
+void EverestCrystal_free(CrystalGeometry restrict cg, int8_t active){
+    if (active){
+        destroy_crystal(cg->segments);
     }
-    double const cry_rcurv  = bend;
-    double const cry_bend   = length/cry_rcurv; //final value (with corrected length)
-    double const cry_alayer = EverestCrystalData_get_thick(el);
-    double const cry_xmax   = EverestCrystalData_get_xdim(el);
-    double const cry_ymax   = EverestCrystalData_get_ydim(el);
-    double const cry_orient = EverestCrystalData_get__orient(el);
-    double const cry_miscut = EverestCrystalData_get_miscut(el);
-
-    // Impact table
-    CollimatorImpactsData record = EverestCrystalData_getp_internal_record(el, part0);
-    RecordIndex record_index = NULL;
-    if (record){
-        record_index = CollimatorImpactsData_getp__index(record);
+    free(cg);
+}
+
+
+// TODO: it would be great if we could set EverestData as an xofield, because then we could
+// run this function at creation of the collimator instead of every turn
+/*gpufun*/
+EverestCollData EverestCrystal_init(EverestCrystalData el, LocalParticle* part0, int8_t active){
+    EverestCollData coll = (EverestCollData) malloc(sizeof(EverestCollData_));
+    if (active){ // This is needed in order to avoid that the initialisation is called during a twiss!
+        // Random generator and material
+        coll->rng = EverestCrystalData_getp_rutherford_rng(el);
+        CrystalMaterialData material = EverestCrystalData_getp__material(el);
+        coll->exenergy = CrystalMaterialData_get_excitation_energy(material)*1.0e3; // MeV
+        coll->rho      = CrystalMaterialData_get_density(material);
+        coll->anuc     = CrystalMaterialData_get_A(material);
+        coll->zatom    = CrystalMaterialData_get_Z(material);
+        coll->bnref    = CrystalMaterialData_get_nuclear_elastic_slope(material);
+        coll->csref[0] = CrystalMaterialData_get_cross_section(material, 0);
+        coll->csref[1] = CrystalMaterialData_get_cross_section(material, 1);
+        coll->csref[5] = CrystalMaterialData_get_cross_section(material, 5);
+        coll->dlri     = CrystalMaterialData_get_crystal_radiation_length(material);
+        coll->dlyi     = CrystalMaterialData_get_crystal_nuclear_length(material);
+        coll->ai       = CrystalMaterialData_get_crystal_plane_distance(material);
+        coll->eum      = CrystalMaterialData_get_crystal_potential(material);
+        coll->collnt   = CrystalMaterialData_get_nuclear_collision_length(material);
+        coll->eta      = 0.9;  // Hard-coded channeling saturation factor
+        coll->orient   = EverestCrystalData_get__orient(el);
+        // Impact table
+        coll->record = EverestCrystalData_getp_internal_record(el, part0);
+        coll->record_index = NULL;
+        if (coll->record){
+            coll->record_index = InteractionRecordData_getp__index(coll->record);
+            coll->record_scatterings = EverestCrystalData_get_record_scatterings(el);
+            coll->record_touches = EverestCrystalData_get_record_touches(el);
+        }
     }
+    return coll;
+}
+
+
+/*gpufun*/
+EverestData EverestCrystal_init_data(LocalParticle* part, EverestCollData restrict coll, CrystalGeometry restrict cg){
+    EverestData everest = (EverestData) malloc(sizeof(EverestData_));
+    everest->coll = coll;
+    everest->rescale_scattering = 1;
+#ifndef XCOLL_REFINE_ENERGY
+    // Preinitialise scattering parameters
+    double charge_ratio = LocalParticle_get_charge_ratio(part);
+    double mass_ratio = charge_ratio / LocalParticle_get_chi(part);
+    double energy = ( LocalParticle_get_ptau(part) + 1 / LocalParticle_get_beta0(part)
+                     ) * mass_ratio * LocalParticle_get_p0c(part) / 1e9; // energy in GeV
+    calculate_scattering(everest, energy);
+    calculate_ionisation_properties(everest, energy);
+    calculate_critical_angle(everest, part, cg, energy);
+    calculate_VI_parameters(everest, part, energy);
+#endif
+    return everest;
+}
+
+
+/*gpufun*/
+void EverestCrystal_track_local_particle(EverestCrystalData el, LocalParticle* part0) {
+    int8_t active = EverestCrystalData_get_active(el);
+    active       *= EverestCrystalData_get__tracking(el);
+    double length = EverestCrystalData_get_length(el);
+
+    // Initialise collimator data
+    // TODO: we want this to happen before tracking (instead of every turn), as a separate kernel
+    EverestCollData coll = EverestCrystal_init(el, part0, active);
+    CrystalGeometry cg   = EverestCrystal_init_geometry(el, part0, active);
+
+    double t_c = 0;
 
     //start_per_particle_block (part0->part)
         if (!active){
             // Drift full length
-            Drift_single_particle(part, inactive_front+active_length+inactive_back);
+            Drift_single_particle(part, length);
 
         } else {
             // Check collimator initialisation
-            int8_t is_tracking = assert_tracking(part, XC_ERR_INVALID_TRACK);
-            int8_t rng_is_set  = assert_rng_set(part, RNG_ERR_SEEDS_NOT_SET);
-            int8_t ruth_is_set = assert_rutherford_set(rng, part, RNG_ERR_RUTH_NOT_SET);
+            int8_t is_valid = xcoll_check_particle_init(coll->rng, part);
 
-            if (is_tracking && rng_is_set && ruth_is_set) {
-                // Drift inactive front
-                Drift_single_particle(part, inactive_front);
+            if (is_valid) {
+                double const s_coll = LocalParticle_get_s(part);
+                LocalParticle_set_s(part, 0);
 
-                // Scatter
+                // Store initial coordinates for updating later
+                double const e0         = LocalParticle_get_energy0(part);
+                double const p0         = LocalParticle_get_p0c(part);
+                double const ptau_in    = LocalParticle_get_ptau(part);
+                double const rvv_in     = LocalParticle_get_rvv(part);
+#ifdef XCOLL_USE_EXACT
+                double const xp_in      = LocalParticle_get_exact_xp(part);
+                double const yp_in      = LocalParticle_get_exact_yp(part);
+#else
+                double const xp_in      = LocalParticle_get_xp(part);
+                double const yp_in      = LocalParticle_get_yp(part);
+#endif
+                double const zeta_in    = LocalParticle_get_zeta(part);
+                double const mass_ratio = LocalParticle_get_charge_ratio(part) / LocalParticle_get_chi(part);   // m/m0
+                double energy           = (p0*ptau_in + e0) * mass_ratio;
 
-                // Move to closed orbit
-                LocalParticle_add_to_x(part, -co_x);
-                LocalParticle_add_to_y(part, -co_y);
+                // Check if hit on jaws
+                int8_t is_hit = hit_crystal_check_and_transform(part, cg);
 
-                scatter_cry(part, length, material, rng, cos_zL, sin_zL, c_aperture, c_offset,
-                            side, cry_tilt, cry_rcurv, cry_bend, cry_alayer, cry_xmax, cry_ymax, cry_orient, 
-                            cry_miscut, record, record_index);
+                if (is_hit != 0) {
+                    // Hit one of the jaws, so scatter
+                    double remaining_length = length - LocalParticle_get_s(part);
+                    // Scatter
+                    EverestData everest = EverestCrystal_init_data(part0, coll, cg);
+                    calculate_initial_angle(everest, part, cg);
+#ifdef XCOLL_USE_EXACT
+                    double const xp = LocalParticle_get_exact_xp(part);
+#else
+                    double const xp = LocalParticle_get_xp(part);
+#endif
+                    if (fabs(xp - everest->t_I) < everest->t_c) {
+                        energy = Channel(everest, part, cg, energy/1.e9, remaining_length)*1.e9;
+                    } else {
+                        energy = Amorphous(everest, part, cg, energy/1.e9, remaining_length)*1.e9;
+                    }
+                    // Temporary workaround to store the critical angle for use later
+                    calculate_critical_angle(everest, part, cg, e0/1.e9);
+                    t_c = everest->t_c;
+                    free(everest);
+                }
 
-                // Return from closed orbit
-                LocalParticle_add_to_x(part, co_x);
-                LocalParticle_add_to_y(part, co_y);
+                // Transform back to the lab frame
+                hit_crystal_transform_back(is_hit, part, cg);
+                LocalParticle_add_to_s(part, s_coll);
 
-                // Drift inactive back (only surviving particles)
-                if (LocalParticle_get_state(part) > 0){
-                    Drift_single_particle(part, inactive_back);
+                LocalParticle_set_zeta(part, zeta_in);
+                // Hit and survived particles need correcting:
+                if (is_hit!=0 && LocalParticle_get_state(part)>0){
+                    // Update energy
+                    double ptau_out = (energy/mass_ratio - e0) / p0;
+                    LocalParticle_update_ptau(part, ptau_out);
+                    // Update zeta
+#ifdef XCOLL_USE_EXACT
+                    double xp  = LocalParticle_get_exact_xp(part);
+                    double yp  = LocalParticle_get_exact_yp(part);
+#else
+                    double xp  = LocalParticle_get_xp(part);
+                    double yp  = LocalParticle_get_yp(part);
+#endif
+                    double rvv = LocalParticle_get_rvv(part);
+                    // First we drift half the length with the old angles:
+                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv_in, xp_in, yp_in, length/2) );
+                    // then half the length with the new angles:
+                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv, xp, yp, length/2) );
                 }
             }
         }
     //end_per_particle_block
+    EverestCrystalData_set__critical_angle(el, t_c);
+    EverestCrystal_free(cg, active);
+    free(coll);
 }
 
 

xcoll/beam_elements/everest.py

@@ -1,6 +1,6 @@
 # copyright ############################### #
 # This file is part of the Xcoll Package.   #
-# Copyright (c) CERN, 2023.                 #
+# Copyright (c) CERN, 2024.                 #
 # ######################################### #
 
 import numpy as np
@@ -9,8 +9,8 @@ import xobjects as xo
 import xpart as xp
 import xtrack as xt
 
-from .base import BaseBlock, BaseCollimator, InvalidXcoll
-from ..scattering_routines.everest import GeneralMaterial, Material, CrystalMaterial, EverestEngine
+from .base import BaseBlock, BaseCollimator, BaseCrystal, InvalidXcoll
+from ..scattering_routines.everest import Material, CrystalMaterial, EverestEngine
 from ..general import _pkg_root
 
 
@@ -21,10 +21,9 @@ from ..general import _pkg_root
 #      only activated around the track command. Furthermore, because of 'iscollective = False' we need to specify
 #      get_backtrack_element. We want it nicer..
 
-# TODO: _per_particle_kernels should be a normal kernel (such that we don't need to pass a dummy Particles() )
 
 class EverestBlock(BaseBlock):
-    _xofields = { **BaseBlock._xofields,
+    _xofields = {**BaseBlock._xofields,
         '_material':        Material,
         'rutherford_rng':   xt.RandomRutherford,
         '_tracking':        xo.Int8
@@ -55,21 +54,15 @@ class EverestBlock(BaseBlock):
 
 
     def __init__(self, **kwargs):
+        to_assign = {}
         if '_xobject' not in kwargs:
-            mat = kwargs.pop('material', None)
-            if mat is None:
-                raise ValueError("Need to provide a material to the block!")
-            if not isinstance(mat, Material):
-                if not isinstance(mat, dict) \
-                or mat['__class__'] != "Material":
-                    raise ValueError("Invalid material!")
-            kwargs['_material'] = mat
+            to_assign['material'] = kwargs.pop('material', None)
+            kwargs['_material'] = Material()
             kwargs.setdefault('rutherford_rng', xt.RandomRutherford())
             kwargs.setdefault('_tracking', True)
-            use_prebuilt_kernels = kwargs.pop('use_prebuilt_kernels', True)
         super().__init__(**kwargs)
-        if '_xobject' not in kwargs:
-            self.EverestBlock_set_material(el=self)
+        for key, val in to_assign.items():
+            setattr(self, key, val)
 
 
     @property
@@ -78,9 +71,12 @@ class EverestBlock(BaseBlock):
 
     @material.setter
     def material(self, material):
+        if material is None:
+            material = Material()
+        if isinstance(material, dict):
+            material = Material.from_dict(material)
         if not isinstance(material, Material):
-            if not isinstance('material', dict) or material['__class__'] != "Material":
-                raise ValueError("Invalid material!")
+            raise ValueError("Invalid material!")
         if not xt.line._dicts_equal(self.material.to_dict(), material.to_dict()):
             self._material = material
             self.EverestBlock_set_material(el=self)
@@ -91,7 +87,7 @@ class EverestBlock(BaseBlock):
 
 
 class EverestCollimator(BaseCollimator):
-    _xofields = { **BaseCollimator._xofields,
+    _xofields = {**BaseCollimator._xofields,
         '_material':        Material,
         'rutherford_rng':   xt.RandomRutherford,
         '_tracking':        xo.Int8
@@ -122,20 +118,15 @@ class EverestCollimator(BaseCollimator):
 
 
     def __init__(self, **kwargs):
+        to_assign = {}
         if '_xobject' not in kwargs:
-            if kwargs.get('material') is None:
-                raise ValueError("Need to provide a material to the collimator!")
-            if not isinstance(kwargs['material'], Material):
-                if not isinstance(kwargs['material'], dict) \
-                or kwargs['material']['__class__'] != "Material":
-                    raise ValueError("Invalid material!")
-            kwargs['_material'] = kwargs.pop('material')
+            to_assign['material'] = kwargs.pop('material', None)
+            kwargs['_material'] = Material()
             kwargs.setdefault('rutherford_rng', xt.RandomRutherford())
             kwargs.setdefault('_tracking', True)
-            use_prebuilt_kernels = kwargs.pop('use_prebuilt_kernels', True)
         super().__init__(**kwargs)
-        if '_xobject' not in kwargs:
-            self.EverestCollimator_set_material(el=self)
+        for key, val in to_assign.items():
+            setattr(self, key, val)
 
     @property
     def material(self):
@@ -143,9 +134,12 @@ class EverestCollimator(BaseCollimator):
 
     @material.setter
     def material(self, material):
+        if material is None:
+            material = Material()
+        if isinstance(material, dict):
+            material = Material.from_dict(material)
         if not isinstance(material, Material):
-            if not isinstance('material', dict) or material['__class__'] != "Material":
-                raise ValueError("Invalid material!")
+            raise ValueError("Invalid material!")
         if not xt.line._dicts_equal(self.material.to_dict(), material.to_dict()):
             self._material = material
             self.EverestCollimator_set_material(el=self)
@@ -156,17 +150,11 @@ class EverestCollimator(BaseCollimator):
 
 
 
-class EverestCrystal(BaseCollimator):
-    _xofields = { **BaseCollimator._xofields,
-        'align_angle':        xo.Float64,  #  = - sqrt(eps/beta)*alpha*nsigma
-        '_bending_radius':    xo.Float64,
-        '_bending_angle':     xo.Float64,
-        '_critical_angle':    xo.Float64,
-        'xdim':               xo.Float64,
-        'ydim':               xo.Float64,
-        'thick':              xo.Float64,
+class EverestCrystal(BaseCrystal):
+    _xofields = {**BaseCrystal._xofields,
         'miscut':             xo.Float64,
         '_orient':            xo.Int8,
+        '_critical_angle':    xo.Float64,
         '_material':          CrystalMaterial,
         'rutherford_rng':     xt.RandomRutherford,
         '_tracking':          xo.Int8
@@ -178,12 +166,11 @@ class EverestCrystal(BaseCollimator):
     behaves_like_drift = True
     skip_in_loss_location_refinement = True
 
-    _skip_in_to_dict       = [*BaseCollimator._skip_in_to_dict, '_orient', '_material', '_bending_radius',
-                              '_bending_angle']
-    _store_in_to_dict      = [*BaseCollimator._store_in_to_dict, 'lattice', 'material', 'bending_radius', 'bending_angle']
-    _internal_record_class = BaseCollimator._internal_record_class
+    _skip_in_to_dict       = [*BaseCrystal._skip_in_to_dict, '_orient', '_material']
+    _store_in_to_dict      = [*BaseCrystal._store_in_to_dict, 'lattice', 'material']
+    _internal_record_class = BaseCrystal._internal_record_class
 
-    _depends_on = [BaseCollimator, EverestEngine]
+    _depends_on = [BaseCrystal, EverestEngine]
 
     _extra_c_sources = [
         _pkg_root.joinpath('beam_elements','collimators_src','everest_crystal.h')
@@ -198,62 +185,38 @@ class EverestCrystal(BaseCollimator):
 
 
     def __init__(self, **kwargs):
+        to_assign = {}
         if '_xobject' not in kwargs:
-            if kwargs.get('material') is None:
-                raise ValueError("Need to provide a material to the collimator!")
-            if not isinstance(kwargs['material'], CrystalMaterial):
-                if not isinstance(kwargs['material'], dict) \
-                or kwargs['material']['__class__'] != "CrystalMaterial":
-                    raise ValueError("Invalid material!")
-            kwargs['_material'] = kwargs.pop('material')
-            bending_radius = False
-            bending_angle  = False
-            if 'bending_radius' in kwargs:
-                if 'bending_angle' in kwargs:
-                    raise ValueError("Need to choose between 'bending_radius' and 'bending_angle'!")
-                bending_radius = kwargs['bending_radius']
-            elif 'bending_angle' in kwargs:
-                bending_angle = kwargs['bending_angle']
-            kwargs['_bending_radius'] = kwargs.pop('bending_radius',0)
-            kwargs['_bending_angle'] = kwargs.pop('bending_angle', 0)
-            kwargs.setdefault('xdim', 0)
-            kwargs.setdefault('ydim', 0)
-            kwargs.setdefault('thick', 0)
+            to_assign['material'] = kwargs.pop('material', None)
+            kwargs['_material'] = CrystalMaterial()
+            to_assign['lattice'] = kwargs.pop('lattice', 'strip')
             kwargs.setdefault('miscut', 0)
-            kwargs['_orient'] = _lattice_setter(kwargs.pop('lattice', 'strip'))
             kwargs.setdefault('rutherford_rng', xt.RandomRutherford())
             kwargs.setdefault('_tracking', True)
-            use_prebuilt_kernels = kwargs.pop('use_prebuilt_kernels', True)
         super().__init__(**kwargs)
-        if '_xobject' not in kwargs:
-            if bending_radius:
-                self._bending_angle = np.arcsin(self.active_length/bending_radius)
-            if bending_angle:
-                self._bending_radius = self.active_length / np.sin(bending_angle)
-            self.EverestCrystal_set_material(el=self)
+        for key, val in to_assign.items():
+            setattr(self, key, val)
 
 
     @property
-    def critical_angle(self):
-        return self._critical_angle if abs(self._critical_angle) > 1.e-10 else None
-
-    @property
-    def bending_radius(self):
-        return self._bending_radius
+    def material(self):
+        return self._material
 
-    @bending_radius.setter
-    def bending_radius(self, bending_radius):
-        self._bending_radius = bending_radius
-        self._bending_angle = np.arcsin(self.active_length/bending_radius)
+    @material.setter
+    def material(self, material):
+        if material is None:
+            material = CrystalMaterial()
+        if isinstance(material, dict):
+            material = CrystalMaterial.from_dict(material)
+        if not isinstance(material, CrystalMaterial):
+            raise ValueError("Invalid material!")
+        if not xt.line._dicts_equal(self.material.to_dict(), material.to_dict()):
+            self._material = material
+            self.EverestCrystal_set_material(el=self)
 
     @property
-    def bending_angle(self):
-        return self._bending_angle
-
-    @bending_angle.setter
-    def bending_angle(self, bending_angle):
-        self._bending_angle = bending_angle
-        self._bending_radius = self.active_length / np.sin(bending_angle)
+    def critical_angle(self):
+        return self._critical_angle if abs(self._critical_angle) > 1.e-10 else None
 
     @property
     def lattice(self):
@@ -266,20 +229,13 @@ class EverestCrystal(BaseCollimator):
 
     @lattice.setter
     def lattice(self, lattice):
-        self._orient = _lattice_setter(lattice)
-
-    @property
-    def material(self):
-        return self._material
-
-    @material.setter
-    def material(self, material):
-        if not isinstance(material, CrystalMaterial):
-            if not isinstance(material, dict) or material['__class__'] != "CrystalMaterial":
-                raise ValueError("Invalid material!")
-        if not xt.line._dicts_equal(self.material.to_dict(), material.to_dict()):
-            self._material = material
-            self.EverestCrystal_set_material(el=self)
+        if lattice == 'strip' or lattice == '110' or lattice == 110:
+            self._orient = 1
+        elif lattice == 'quasi-mosaic' or lattice == '111' or lattice == 111:
+            self._orient = 2
+        else:
+            raise ValueError(f"Illegal value {lattice} for 'lattice'! "
+                            + "Only use 'strip' (110) or 'quasi-mosaic' (111).")
 
 
     def get_backtrack_element(self, _context=None, _buffer=None, _offset=None):
@@ -287,12 +243,3 @@ class EverestCrystal(BaseCollimator):
                                  _buffer=_buffer, _offset=_offset)
 
 
-def _lattice_setter(lattice):
-    if lattice == 'strip' or lattice == '110' or lattice == 110:
-        return 1
-    elif lattice == 'quasi-mosaic' or lattice == '111' or lattice == 111:
-        return 2
-    else:
-        raise ValueError(f"Illegal value {lattice} for 'lattice'! "
-                        + "Only use 'strip' (110) or 'quasi-mosaic' (111).")
-