diff --git a/pxii_bec/device_configs/device_config.yaml b/pxii_bec/device_configs/device_config.yaml
deleted file mode 100644
index 7926fec..0000000
--- a/pxii_bec/device_configs/device_config.yaml
+++ /dev/null
@@ -1,792 +0,0 @@
-sls_current:
-  description: SLS current
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'ARS07-DPCT-0100:CURR', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - SLS
-  readOnly: true
-  softwareTrigger: false
-ps1_press:
-  description: Photon shutter 1 pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-FE-PSH1-VMCC-1010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-abs_press:
-  description: Absorber pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-FE-VMCC-0000:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-lu_bpmsum:
-  description: LU BPM Summed
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-LUBPM:SumAll:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: true
-  softwareTrigger: false
-ss_bpmsum:
-  description: SS BPM Summed
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-SSBPM1:SumAll:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: true
-  softwareTrigger: false
-ps3_press:
-  description: Pumpstand 3 pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-FE-PUM3-VMCC-2010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-bsf_press:
-  description: BSF pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-BSF-VMFR-0010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-bb1_press:
-  description: BB1 pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-BBU-VMFR-1010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-dcm_press:
-  description: DCM pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-DCM-VMFR-3010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-bb2_press:
-  description: BB2 pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-BBD-VMFR-4010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-lu_press:
-  description: LU pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-LU-VMFR-5010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-ps2_press:
-  description: Photon shutter 2 pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-PSH1-VMFR-7010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-ss_press:
-  description: SS pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-SS1-VMFR-0010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-kb_press:
-  description: KBV pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-KBV-VMFR-0010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-bcu_press:
-  description: BCU pressure
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-BCU-VMFR-0010:PRESSURE', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - press
-  readOnly: true
-  softwareTrigger: false
-fe_sxr:
-  description: 'FE Slit X Ring'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-SLDI:TRXR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - fe
-  readOnly: false 
-  softwareTrigger: false
-fe_syt:
-  description: 'FE Slit Y top'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-SLDI:TRYT'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - fe
-  readOnly: false 
-  softwareTrigger: false
-fe_sxw:
-  description: 'FE Slit X Wall'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-SLDI:TRXW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - fe
-  readOnly: false 
-  softwareTrigger: false
-fe_syb:
-  description: 'FE SlitY Bottom'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-SLDI:TRYB'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - fe
-  readOnly: false 
-  softwareTrigger: false
-fe_sxcen:
-  description: 'FE Slit X Centre'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-SLDI:CENTERX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - fe
-  readOnly: false 
-  softwareTrigger: false
-fe_sxsize:
-  description: 'FE Slit X Size'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-SLDI:SIZEX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - fe
-  readOnly: false 
-  softwareTrigger: false
-fe_sycen:
-  description: 'FE Slit Y Centre'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-SLDI:CENTERY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - fe
-  readOnly: false 
-  softwareTrigger: false
-fe_sysize:
-  description: 'FE Slit Y Size'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-SLDI:SIZEY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - fe
-  readOnly: false 
-  softwareTrigger: false
-s1_xw:
-  description: 'BSF slit outboard'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-SLH:TRXW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-s1_xr:
-  description: 'BSF slit inboard'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-SLH:TRXR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-s1_yt:
-  description: 'BSF slit top'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-SLV:TRYT'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-s1_yb:
-  description: 'BSF slit bottom'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-SLV:TRYB'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-s1_xcen:
-  description: 'BSF X centre'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-SLH:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-s1_xsize:
-  description: 'BSF X size'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-SLH:SIZE'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-s1_ycen:
-  description: 'BSF Y centre'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-SLV:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-opf1_y:
-  description: 'BSF Filter 1 Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-FI1:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-opf2_y:
-  description: 'BSF Filter 2 Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-FI2:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bsf
-  readOnly: false 
-  softwareTrigger: false
-dcm_bragg:
-  description: 'DCM Bragg angle'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-DCM:ROTY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - dcm
-  readOnly: false 
-  softwareTrigger: false
-dcm_x:
-  description: 'DCM lateral'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-DCM:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - dcm
-  readOnly: false 
-  softwareTrigger: false
-dcm_perp:
-  description: 'DCM Perp'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-DCM:TRX-C2'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - dcm
-  readOnly: false 
-  softwareTrigger: false
-dcm_pitch:
-  description: 'DCM 2nd crystal pitch'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-DCM:ROTY-C2'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - dcm
-  readOnly: false 
-  softwareTrigger: false
-ssbpm_x:
-  description: 'SS BPM X'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSBPM1:TRX1'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-ssbpm_y:
-  description: 'SS BPM Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSBPM1:TRY1'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-s2_xw:
-  description: 'SS slit wall'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSH1:TRXW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-s2_xr:
-  description: 'SS slit ring'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSH1:TRXR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-s2_xcen:
-  description: 'SS slit X centre'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSH1:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-s2_xsize:
-  description: 'SS slit X size'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSH1:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-s2_yt:
-  description: 'SS slit top'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSV1:TRYT'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-s2_yb:
-  description: 'SS slit bottom'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSV1:TRYB'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-s2_ycen:
-  description: 'SS slit Y centre'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSV1:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-s2_ysize:
-  description: 'SS slit Y size'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSV1:SIZE'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-xeye_x:
-  description: 'SS X-ray eye X'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSXI1:TRX1'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-xeye_y:
-  description: 'SS X-ray eye Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSXI1:TRY1'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - ss
-  readOnly: false 
-  softwareTrigger: false
-vfm_xu:
-  description: 'VFM Upstream X'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRXU'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_xd:
-  description: 'VFM Downstream X'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRXD'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_yur:
-  description: 'VFM Upstream Ring Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRYUR'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_yw:
-  description: 'VFM Wall Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRYW'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_ydr:
-  description: 'VFM Downstream Ring Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRYDR'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_bu:
-  description: 'VFM Upstream Bender'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:BNDU'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_bd:
-  description: 'VFM Downstream Bender'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:BNDD'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_yaw:
-  description: 'VFM Virtual Yaw'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:YAW'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_roll:
-  description: 'VFM Virtual Roll'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:ROLL'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_pitch:
-  description: 'VFM Virtual Pitch'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:PITCH'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_lat:
-  description: 'VFM Virtual X'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRX'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-vfm_vert:
-  description: 'VFM Virtual Y '
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRY'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - vfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_xu:
-  description: 'HFM Upstream X'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRXU'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_xd:
-  description: 'HFM Downstream X'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRXD'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_yuw:
-  description: 'HFM Upstream Wall Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRYUW'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_yr:
-  description: 'HFM Ring Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRYR'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_ydw:
-  description: 'HFM Downstream Wall Y'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRYDW'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_bu:
-  description: 'HFM Upstream Bender'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:BNDU'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_bd:
-  description: 'HFM Downstream Bender'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:BNDD'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_yaw:
-  description: 'HFM Virtual Yaw'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:YAW'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_roll:
-  description: 'HFM Virtual Roll'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:ROLL'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_pitch:
-  description: 'HFM Virtual Pitch'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:PITCH'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_lat:
-  description: 'HFM Virtual X'
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRX'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
-hfm_vert:
-  description: 'HFM Virtual Y '
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRY'}
-  onFailure: buffer
-  enabled: False
-  readoutPriority: monitored
-  deviceTags:
-    - hfm
-  readOnly: false 
-  softwareTrigger: false
diff --git a/pxii_bec/device_configs/pxii-beamline-states.yaml b/pxii_bec/device_configs/pxii-beamline-states.yaml
index ee4e938..2011edf 100644
--- a/pxii_bec/device_configs/pxii-beamline-states.yaml
+++ b/pxii_bec/device_configs/pxii-beamline-states.yaml
@@ -196,14 +196,14 @@ states:
     det_cov: 'close'
     diag_y: out
     fl_bright: 'on'
-    aerotech_x: in
-    aerotech_y: work
-    aerotech_z: work
-    aerotech_u: mount
-    smargon_x: mount
-    smargon_y: mount
-    smargon_chi: mount
-    smargon_phi: mount
+    # aerotech_x: in
+    # aerotech_y: work
+    # aerotech_z: work
+    # aerotech_u: mount
+    # smargon_x: mount
+    # smargon_y: mount
+    # smargon_chi: mount
+    # smargon_phi: mount
     xrf_pos: out
 
 
diff --git a/pxii_bec/device_configs/pxii-devices.yaml b/pxii_bec/device_configs/pxii-devices.yaml
new file mode 100644
index 0000000..6159d25
--- /dev/null
+++ b/pxii_bec/device_configs/pxii-devices.yaml
@@ -0,0 +1,1772 @@
+# BEC Device Configuration File
+#
+# The device config consists of a mapping of device names to their configurations.
+#
+# The following fields are required for each device:
+# - deviceClass: The class of the device (e.g., ophyd_devices.SimPositioner).
+# - enabled: A boolean indicating if the device is enabled.
+# - readoutPriority: Determines how the device is read out during a scan. Possible values are ["monitored", "baseline", "async", "on_request", "continuous"].
+#
+# Optional fields (defaults shown):
+# - connectionTimeout: Connection timeout in seconds. Default is 5.
+# - description: A string description of the device. Default is "" (empty string).
+# - deviceConfig: A dictionary of configuration parameters specific to the device class. Default is None.
+# - deviceTags: A list/set of tags associated with the device. Default is an empty list/set.
+# - needs: A list of other device names that this device depends on. Default is [].
+# - onFailure: The action to take on failure. Possible values are ["buffer", "retry", "raise"]. Default is "retry".
+# - readOnly: A boolean indicating if the device is read-only. Default is false.
+# - softwareTrigger: A boolean indicating if the device uses software triggering. Default is false.
+# - userParameter: A dictionary of user-defined parameters. Default is {}.
+#
+# Default values may be omitted for brevity.
+##########################################################################################################################
+
+
+# An example device configuration with all fields:
+
+# device1:
+#   deviceClass: ophyd_devices.SimPositioner
+#   description: Sample positioner device
+#   deviceConfig:
+#     delay: 1
+#     update_frequency: 10
+#   deviceTags: 
+#     - frontend
+#     - motor
+#   enabled: true
+#   connectionTimeout: 20
+#   readoutPriority: baseline
+#   needs:
+#     - device2
+#     - device3
+#   onFailure: retry
+#   readOnly: false
+#   softwareTrigger: false
+#   userParameter:
+#     in: 23.1
+#     out: -50
+
+##########################################################################################################################
+
+
+aerotech:
+  description: REST-based device which connects to AareScan and Aerotech
+  deviceClass: pxii_bec.devices.aerotech.Aerotech
+  deviceConfig:
+    prefix: http://mx-x10sa-queue-01:5234
+  deviceTags:
+  - aerotech
+  - motors
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    u:
+      mount: 0
+      work: 0
+    work: null
+    x:
+      in: 0
+      out: -10
+      safe: -50
+    y:
+      mount: 0
+      work: 0
+    z:
+      mount: 0
+      work: 0
+bcu_bpm1:
+  description: BCU BPM Channel 1
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-BCBPM:Current1:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+bcu_bpm2:
+  description: BCU BPM Channel 2
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-BCBPM:Current2:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+bcu_bpm3:
+  description: BCU BPM Channel 3
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-BCBPM:Current3:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+bcu_bpm4:
+  description: BCU BPM Channel 4
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-BCBPM:Current4:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+bcu_bpm_x:
+  description: BCU BPM X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCBPM:TRX
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_bpm_y:
+  description: BCU BPM Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCBPM:TRY
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_bpmsum:
+  description: BCU BPM Summed
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-BCBPM:SumAll:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+bcu_sl_xcen:
+  description: BCU Slit X Centre
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCSLH:CENTER
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_sl_xr:
+  description: BCU Slit Ring
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCSLH:TRXR
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_sl_xsize:
+  description: BCU Slit X Size
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCSLH:SIZE
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_sl_xw:
+  description: BCU Slit Wall
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCSLH:TRXW
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_sl_yb:
+  description: BCU Slit Bottom
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCSLV:TRYB
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_sl_ycen:
+  description: BCU Slit Y Centre
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCSLV:CENTER
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_sl_ysize:
+  description: BCU Slit Y Size
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCSLV:SIZE
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bcu_sl_yt:
+  description: BCU Slit Top
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BCSLV:TRYT
+  deviceTags:
+  - bcu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bl_bright:
+  description: Backlight Brightness
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-BL:SET
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    'off': 0.0
+    'on': 1.3
+    tol: 0.01
+    type: continuous
+bl_pos:
+  description: Backlight Positioner
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-BL:POS-SET
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    in: 1
+    out: 0
+    type: discrete
+bs_pos:
+  description: Beamstop Positioner
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-BS:POS-SET
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    in: 1
+    out: 0
+    type: discrete
+bs_x:
+  description: Beamstop X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BS:TRX
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    in: 1.64
+bs_y:
+  description: Beamstop Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BS:TRY
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    in: -0.6
+bs_z:
+  description: Beamstop Z
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-BS:TRZ
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    max_blin: 45.4
+    max_blout: 70
+    min: 13
+    safe: 45.1
+    samp: 15.3
+    type: continuous
+    work_min: 20
+bsf_f1_y:
+  description: BSF Filter 1 Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFFI1:TRY
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_f2_y:
+  description: BSF Filter 2 Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFFI2:TRY
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_sl_xcen:
+  description: BSF X Centre
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFSLH:CENTER
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_sl_xr:
+  description: BSF Slit Ring
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFSLH:TRXR
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_sl_xsize:
+  description: BSF X Size
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFSLH:SIZE
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_sl_xw:
+  description: BSF Slit Wall
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFSLH:TRXW
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_sl_yb:
+  description: BSF Slit Bottom
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFSLV:TRYB
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_sl_ycen:
+  description: BSF Y Centre
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFSLV:CENTER
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_sl_ysize:
+  description: BSF Y Size
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFSLV:SIZE
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+bsf_sl_yt:
+  description: BSF Slit Top
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-BSFSLV:TRYT
+  deviceTags:
+  - bsf
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+coll_x:
+  description: Collimator X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-COL:TRX
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+coll_y:
+  description: Collimator Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-COL:TRY
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    in: 40.9
+    intermediate: 32
+    out: 20.0
+    park: 1
+    tol: 0.05
+    type: continuous
+cryo_pos:
+  description: Cryo positioner
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-CS:POS-SET
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    in: 1
+    out: 0
+    type: discrete
+cryo_temp:
+  description: Cryo Temperature
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-CS:TEMP_RBV
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+cryo_x:
+  description: Cryo X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-CS:TRX
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+dcm_bragg:
+  description: DCM Bragg Angle
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-DCM:ROTY
+  deviceTags:
+  - dcm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+dcm_fpitch:
+  description: DCM 2nd Crystal Fine Pitch
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-DCM:ROTY-CR2-FINEPITCH
+  deviceTags:
+  - dcm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+dcm_froll:
+  description: DCM 2nd Crystal Fine roll
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-DCM:ROTZ-CR2-FINEROLL
+  deviceTags:
+  - dcm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+dcm_perp:
+  description: DCM Perpendicular
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-DCM:TRX-CR2
+  deviceTags:
+  - dcm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+dcm_pitch:
+  description: DCM 2nd Crystal Pitch
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-DCM:ROTY-CR2-PITCH
+  deviceTags:
+  - dcm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+dcm_x:
+  description: DCM Lateral
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-OP-DCM:TRX
+  deviceTags:
+  - dcm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+det_cov:
+  description: Detector cover
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-DETCOV:SET
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    close: 1
+    open: 2
+    type: discrete
+det_xi_focus:
+  description: X-ray Eye 2 Focus
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-XEYE:FOCUS
+  deviceTags:
+  - det
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+det_xi_x:
+  description: X-ray Eye X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-XEYE:TRX
+  deviceTags:
+  - det
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+det_xi_zoom:
+  description: X-ray Eye 2 Zoom
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-XEYE:ZOOM
+  deviceTags:
+  - det
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+det_y:
+  description: Detector Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-DET:TRY
+  deviceTags:
+  - det
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+det_z:
+  description: Detector Z
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-DET:TRZ
+  deviceTags:
+  - det
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+diag_y:
+  description: Scintillator/diode Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SCL:TRY
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    i1: 43.4
+    out: 20.0
+    park: 1
+    scint: 38.0
+    tol: 0.3
+    type: continuous
+diag_z:
+  description: Scintillator/diode Z
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SCL:TRZ
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_bpm1:
+  description: FE XBPM Channel 1
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-FE-XBPM1:Current1:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+fe_bpm2:
+  description: FE XBPM Channel 2
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-FE-XBPM1:Current2:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+fe_bpm3:
+  description: FE XBPM Channel 3
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-FE-XBPM1:Current3:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+fe_bpm4:
+  description: FE XBPM Channel 4
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-FE-XBPM1:Current4:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+fe_bpm_x:
+  description: FE BPM X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-FE-XBPM1:TRX
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_bpm_y:
+  description: FE BPM Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-FE-XBPM1:TRY
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_bpmsum:
+  description: FE XBPM Summed
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-FE-XBPM1:SumAll:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+fe_sl_xcen:
+  description: FE Slit X Centre
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-FE-SL1:CENTERX
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_sl_xr:
+  description: FE Slit X Ring
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-FE-SL1:TRXR
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_sl_xsize:
+  description: FE Slit X Size
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-FE-SL1:SIZEX
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_sl_xw:
+  description: FE Slit X Wall
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-FE-SL1:TRXW
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_sl_yb:
+  description: FE Slit Y Bottom
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-FE-SL1:TRYB
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_sl_ycen:
+  description: FE Slit Y Centre
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-FE-SL1:CENTERY
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_sl_ysize:
+  description: FE Slit Y Size
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-FE-SL1:SIZEY
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fe_sl_yt:
+  description: FE Slit Y Top
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-FE-SL1:TRYT
+  deviceTags:
+  - fe
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+fl_bright:
+  description: Frontlight Brightness
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-FL:SET
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    'off': 0.0
+    'on': 3.0
+    tol: 0.01
+    type: continuous
+hfm_bd:
+  description: HFM Downstream Bender
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:BNDD
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_bu:
+  description: HFM Upstream Bender
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:BNDU
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_pitch:
+  description: HFM Virtual Pitch
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:PITCH
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_roll:
+  description: HFM Virtual Roll
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:ROLL
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_x:
+  description: HFM Virtual X
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:TRX
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_xd:
+  description: HFM Downstream X
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:TRXD
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_xu:
+  description: HFM Upstream X
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:TRXU
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_y:
+  description: HFM Virtual Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:TRY
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_yaw:
+  description: HFM Virtual Yaw
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:YAW
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_ydw:
+  description: HFM Downstream Wall Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:TRYDW
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_yr:
+  description: HFM Ring Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:TRYR
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+hfm_yuw:
+  description: HFM Upstream Wall Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-HFM:TRYUW
+  deviceTags:
+  - hfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+i1:
+  description: I1 Diode
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SCLDI:READOUT
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+i2:
+  description: I2 Diode
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-XEYEDI:READOUT
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+id_gap:
+  description: undulator gap
+  deviceClass: pxii_bec.devices.undulator.UndulatorGap
+  deviceConfig:
+    prefix: 'X10SA-UIND:'
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_bpm1:
+  description: LU BPM Channel 1
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-OP-LUBPM:Current1:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+lu_bpm2:
+  description: LU BPM Channel 2
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-OP-LUBPM:Current2:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+lu_bpm3:
+  description: LU BPM Channel 3
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-OP-LUBPM:Current3:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+lu_bpm4:
+  description: LU BPM Channel 4
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-OP-LUBPM:Current4:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+lu_bpm_x:
+  description: BPM2 X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUBPM:TRX
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_bpm_y:
+  description: BPM2 Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUBPM:TRY
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_bpmsum:
+  description: LU BPM Summed
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-OP-LUBPM:SumAll:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+lu_pod1_rotx:
+  description: SmarPod1 RX
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD1:ROTX
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod1_roty:
+  description: SmarPod1 RY
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD1:ROTY
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod1_rotz:
+  description: SmarPod1 RZ
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD1:ROTZ
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod1_y:
+  description: SmarPod1 Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD1:TRY
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod1_z:
+  description: SmarPod1 Z
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD1:TRZ
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod2_rotx:
+  description: SmarPod2 RX
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD2:ROTX
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod2_roty:
+  description: SmarPod2 RY
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD2:ROTY
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod2_rotz:
+  description: SmarPod2 RZ
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD2:ROTZ
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod2_y:
+  description: SmarPod2 Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD2:TRY
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_pod2_z:
+  description: SmarPod2 Z
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUPOD2:TRZ
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_z1:
+  description: Lens Z1
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUTRZ1:TRZ
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+lu_z2:
+  description: Lens Z2
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-OP-LUTRZ2:TRZ
+  deviceTags:
+  - lu
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+mag_ok:
+  description: Sample Sensor Check
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-DFS:CBOX-CMP1
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+mag_rbv:
+  description: Sample Sensor RBV
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-DFS:CBOX-USER1
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+mag_ref:
+  description: Sample Sensor Reference
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-DFS:CBOX-REFVAL1
+  deviceTags:
+  - se
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+samcam_exp:
+  description: Sample Camera Exposure
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-MS:cam1:AcquireTime
+  deviceTags:
+  - scam
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+samcam_gain:
+  description: Sample Camera Gain
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-MS:cam1:Gain
+  deviceTags:
+  - scam
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+samcam_max:
+  description: Sample Camera Max
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-MS:Stats5:MaxValue_RBV
+  deviceTags:
+  - scam
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+samcam_x:
+  description: Sample Camera X
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-MS:Stats5:CentroidX_RBV
+  deviceTags:
+  - scam
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+samcam_xsig:
+  description: Sample Camera X Sigma
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-MS:Stats5:SigmaX_RBV
+  deviceTags:
+  - scam
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+samcam_y:
+  description: Sample Camera Y
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-MS:Stats5:CentroidY_RBV
+  deviceTags:
+  - scam
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+samcam_ysig:
+  description: Sample Camera Y Sigma
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-MS:Stats5:SigmaY_RBV
+  deviceTags:
+  - scam
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+scam_zoom:
+  description: Sample Camera Zoom
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-MS:ZOOM
+  deviceTags:
+  - scam
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+sls_current:
+  description: SLS Current
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: ARS07-DPCT-0100:CURR
+  deviceTags:
+  - SLS
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+smargon:
+  description: REST-based device which connects to Smargopolo
+  deviceClass: pxii_bec.devices.smargopolo_smargon.Smargon
+  deviceConfig:
+    prefix: http://x10sa-smargopolo.psi.ch:3000
+  deviceTags:
+  - smargon
+  - motors
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    chi:
+      mount: 0
+    phi:
+      mount: 0
+    x:
+      mount: 0
+    y:
+      mount: 0
+    z:
+      mount: 18
+ss_bpm1:
+  description: SS BPM Channel 1
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSBPM:Current1:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+ss_bpm2:
+  description: SS BPM Channel 2
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSBPM:Current2:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+ss_bpm3:
+  description: SS BPM Channel 3
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSBPM:Current3:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+ss_bpm4:
+  description: SS BPM Channel 4
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSBPM:Current4:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+ss_bpm_x:
+  description: SS BPM X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSBPM:TRX
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_bpm_y:
+  description: SS BPM Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSBPM:TRY
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_bpmsum:
+  description: SS BPM Summed
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSBPM:SumAll:MeanValue_RBV
+  deviceTags:
+  - bpm
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+ss_f1_x:
+  description: SS Filter 1 X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSFI1:TRX
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_f2_x:
+  description: SS Filter 2 X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSFI2:TRX
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_f3_x:
+  description: SS Filter 2 X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSFI3:TRX
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_f4_x:
+  description: SS Filter 4 X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSFI4:TRX
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_sl_xcen:
+  description: SS Slit X Centre
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSSLH:CENTER
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_sl_xr:
+  description: SS Slit Ring
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSSLH:TRXR
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_sl_xsize:
+  description: SS Slit X Size
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSSLH:SIZE
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_sl_xw:
+  description: SS Slit Wall
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSSLH:TRXW
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_sl_yb:
+  description: SS Slit Bottom
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSSLV:TRYB
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_sl_ycen:
+  description: SS Slit Y Centre
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSSLV:CENTER
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_sl_ysize:
+  description: SS Slit Y Size
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSSLV:SIZE
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_sl_yt:
+  description: SS Slit Top
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSSLV:TRYT
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_xi_x:
+  description: SS X-ray Eye X
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSXI:TRX
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    in: 7
+    out: -2.1
+    type: multi-position
+ss_xi_y:
+  description: SS X-ray Eye Y
+  deviceClass: ophyd_devices.EpicsMotor
+  deviceConfig:
+    prefix: X10SA-ES-SSXI:TRY
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_xicam_exp:
+  description: SS Camera Exposure
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSCAM:cam1:AcquireTime
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_xicam_gain:
+  description: SS Camera Gain
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSCAM:cam1:Gain
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+ss_xicam_max:
+  description: SS Cam Max
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSCAM:Stats5:MaxValue_RBV
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: monitored
+ss_xicam_x:
+  description: SS Camera X
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSCAM:Stats5:CentroidX_RBV
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+ss_xicam_xsig:
+  description: SS Camera  X Sigma
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSCAM:Stats5:SigmaX_RBV
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+ss_xicam_y:
+  description: SS Camera Y
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSCAM:Stats5:CentroidY_RBV
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+ss_xicam_ysig:
+  description: SS Camera Y Sigma
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-SSCAM:Stats5:SigmaY_RBV
+  deviceTags:
+  - ss
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+vfm_bd:
+  description: VFM Downstream Bender
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:BNDD
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_bu:
+  description: VFM Upstream Bender
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:BNDU
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_pitch:
+  description: VFM Virtual Pitch
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:PITCH
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_roll:
+  description: VFM Virtual Roll
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:ROLL
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_x:
+  description: VFM Virtual X
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:TRX
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_xd:
+  description: VFM Downstream X
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:TRXD
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_xu:
+  description: VFM Upstream X
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:TRXU
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_y:
+  description: VFM Virtual Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:TRY
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_yaw:
+  description: VFM Virtual Yaw
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:YAW
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_ydr:
+  description: VFM Downstream Ring Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:TRYDR
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_yur:
+  description: VFM Upstream Ring Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:TRYUR
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+vfm_yw:
+  description: VFM Wall Y
+  deviceClass: ophyd_devices.EpicsMotorEC
+  deviceConfig:
+    prefix: X10SA-ES-VFM:TRYW
+  deviceTags:
+  - vfm
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+xrf_pos:
+  description: XRF Positioner
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    auto_monitor: true
+    read_pv: X10SA-ES-XRF:POS-SET
+  deviceTags:
+  - state
+  enabled: true
+  onFailure: buffer
+  readoutPriority: baseline
+  userParameter:
+    in: 1
+    out: 0
+    type: discrete
diff --git a/pxii_bec/device_configs/pxii-rest-devices.yaml b/pxii_bec/device_configs/pxii-rest-devices.yaml
deleted file mode 100644
index abf79ff..0000000
--- a/pxii_bec/device_configs/pxii-rest-devices.yaml
+++ /dev/null
@@ -1,18 +0,0 @@
-aerotech_x:
-  userParameter: {"type": continuous, "in": 0.0, "out": -10.0, "safe": -50, "tol": 0.5}
-aerotech_y:
-  userParameter: {"type": continuous, "mount": 0.0, "work": 0.01, "tol": 0.002}
-aerotech_z:
-  userParameter: {"type": continuous, "mount": 0.0, "work": 0.02, "tol": 0.01}
-aerotech_u:
-  userParameter: {"type": continuous, "mount": 0.0}
-smargon_x:
-  userParameter: {"type": continuous, "mount": 0.0}
-smargon_y:
-  userParameter: {"type": continuous, "mount": 0.0}
-smargon_z:
-  userParameter: {"type": continuous, "mount": 18.0}
-smargon_chi:
-  userParameter: {"type": continuous, "mount": 0.0}
-smargon_phi:
-  userParameter: {"type": continuous, "mount": 0.0}
diff --git a/pxii_bec/device_configs/pxii-standard-devices.yaml b/pxii_bec/device_configs/pxii-standard-devices.yaml
deleted file mode 100644
index 6c2000f..0000000
--- a/pxii_bec/device_configs/pxii-standard-devices.yaml
+++ /dev/null
@@ -1,1657 +0,0 @@
-sls_current:
-  description: SLS Current
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'ARS07-DPCT-0100:CURR', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - SLS
-  readOnly: True
-  softwareTrigger: false
-
-fe_bpm1:
-  description: FE XBPM Channel 1
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-FE-XBPM1:Current1:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-fe_bpm2:
-  description: FE XBPM Channel 2
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-FE-XBPM1:Current2:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-fe_bpm3:
-  description: FE XBPM Channel 3
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-FE-XBPM1:Current3:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-fe_bpm4:
-  description: FE XBPM Channel 4
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-FE-XBPM1:Current4:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-fe_bpmsum:
-  description: FE XBPM Summed
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-FE-XBPM1:SumAll:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-fe_bpm_x:
-  description: FE BPM X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-XBPM1:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_bpm_y:
-  description: FE BPM Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-FE-XBPM1:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_sl_xr:
-  description: FE Slit X Ring
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-FE-SL1:TRXR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_sl_yt:
-  description: FE Slit Y Top
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-FE-SL1:TRYT'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_sl_xw:
-  description: FE Slit X Wall
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-FE-SL1:TRXW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_sl_yb:
-  description: FE Slit Y Bottom
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-FE-SL1:TRYB'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_sl_xcen:
-  description: FE Slit X Centre
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-FE-SL1:CENTERX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_sl_xsize:
-  description: FE Slit X Size
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-FE-SL1:SIZEX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_sl_ycen:
-  description: FE Slit Y Centre
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-FE-SL1:CENTERY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-fe_sl_ysize:
-  description: FE Slit Y Size
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-FE-SL1:SIZEY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - fe
-  readOnly: False
-  softwareTrigger: false
-
-bsf_sl_xw:
-  description: BSF Slit Wall
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFSLH:TRXW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_sl_xr:
-  description: BSF Slit Ring
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFSLH:TRXR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_sl_yt:
-  description: BSF Slit Top
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFSLV:TRYT'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_sl_yb:
-  description: BSF Slit Bottom
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFSLV:TRYB'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_sl_xcen:
-  description: BSF X Centre
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFSLH:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_sl_xsize:
-  description: BSF X Size
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFSLH:SIZE'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_sl_ycen:
-  description: BSF Y Centre
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFSLV:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_sl_ysize:
-  description: BSF Y Size
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFSLV:SIZE'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_f1_y:
-  description: BSF Filter 1 Y
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFFI1:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-bsf_f2_y:
-  description: BSF Filter 2 Y
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-BSFFI2:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bsf
-  readOnly: False
-  softwareTrigger: false
-
-dcm_bragg:
-  description: DCM Bragg Angle
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-DCM:ROTY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - dcm
-  readOnly: False
-  softwareTrigger: false
-
-dcm_x:
-  description: DCM Lateral
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-DCM:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - dcm
-  readOnly: False
-  softwareTrigger: false
-
-dcm_perp:
-  description: DCM Perpendicular
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-DCM:TRX-CR2'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - dcm
-  readOnly: False
-  softwareTrigger: false
-
-dcm_pitch:
-  description: DCM 2nd Crystal Pitch
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-DCM:ROTY-CR2-PITCH'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - dcm
-  readOnly: False
-  softwareTrigger: false
-
-dcm_fpitch:
-  description: DCM 2nd Crystal Fine Pitch
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-DCM:ROTY-CR2-FINEPITCH'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - dcm
-  readOnly: False
-  softwareTrigger: false
-
-dcm_froll:
-  description: DCM 2nd Crystal Fine roll
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-OP-DCM:ROTZ-CR2-FINEROLL'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - dcm
-  readOnly: False
-  softwareTrigger: false
-
-lu_bpm1:
-  description: LU BPM Channel 1
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-LUBPM:Current1:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-lu_bpm2:
-  description: LU BPM Channel 2
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-LUBPM:Current2:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-lu_bpm3:
-  description: LU BPM Channel 3
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-LUBPM:Current3:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-lu_bpm4:
-  description: LU BPM Channel 4
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-LUBPM:Current4:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-lu_bpmsum:
-  description: LU BPM Summed
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-OP-LUBPM:SumAll:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-lu_bpm_x:
-  description: BPM2 X 
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUBPM:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_bpm_y:
-  description: BPM2 Y 
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUBPM:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_z1:
-  description: Lens Z1 
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUTRZ1:TRZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_z2:
-  description: Lens Z2 
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUTRZ2:TRZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod1_y:
-  description: SmarPod1 Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD1:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod1_z:
-  description: SmarPod1 Z
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD1:TRZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod1_rotx:
-  description: SmarPod1 RX
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD1:ROTX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod1_roty:
-  description: SmarPod1 RY
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD1:ROTY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod1_rotz:
-  description: SmarPod1 RZ
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD1:ROTZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod2_y:
-  description: SmarPod2 Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD2:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod2_z:
-  description: SmarPod2 Z
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD2:TRZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod2_rotx:
-  description: SmarPod2 RX
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD2:ROTX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod2_roty:
-  description: SmarPod2 RY
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD2:ROTY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-lu_pod2_rotz:
-  description: SmarPod2 RZ
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-LUPOD2:ROTZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - lu
-  readOnly: False
-  softwareTrigger: false
-
-ss_bpm1:
-  description: SS BPM Channel 1
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-SSBPM:Current1:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-ss_bpm2:
-  description: SS BPM Channel 2
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-SSBPM:Current2:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-ss_bpm3:
-  description: SS BPM Channel 3
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-SSBPM:Current3:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-ss_bpm4:
-  description: SS BPM Channel 4
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-SSBPM:Current4:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-ss_bpmsum:
-  description: SS BPM Summed
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-SSBPM:SumAll:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-ss_bpm_x:
-  description: SS BPM X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSBPM:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_bpm_y:
-  description: SS BPM Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSBPM:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_f1_x:
-  description: SS Filter 1 X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSFI1:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_f2_x:
-  description: SS Filter 2 X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSFI2:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_f3_x:
-  description: SS Filter 2 X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSFI3:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_f4_x:
-  description: SS Filter 4 X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSFI4:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_sl_xw:
-  description: SS Slit Wall
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLH:TRXW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_sl_xr:
-  description: SS Slit Ring
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLH:TRXR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_sl_xcen:
-  description: SS Slit X Centre
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLH:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_sl_xsize:
-  description: SS Slit X Size
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLH:SIZE'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_sl_yt:
-  description: SS Slit Top
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLV:TRYT'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_sl_yb:
-  description: SS Slit Bottom
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLV:TRYB'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_sl_ycen:
-  description: SS Slit Y Centre
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLV:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_sl_ysize:
-  description: SS Slit Y Size
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLV:SIZE'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-ss_xi_x:
-  description: SS X-ray Eye X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSXI:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type": multi-position,"in": 7.5, "out": -2.1}
-
-ss_xi_y:
-  description: SS X-ray Eye Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSXI:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-
-vfm_xu:
-  description: VFM Upstream X
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRXU'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_xd:
-  description: VFM Downstream X
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRXD'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_yur:
-  description: VFM Upstream Ring Y
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRYUR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_yw:
-  description: VFM Wall Y
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRYW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_ydr:
-  description: VFM Downstream Ring Y
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRYDR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_bu:
-  description: VFM Upstream Bender
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:BNDU'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_bd:
-  description: VFM Downstream Bender
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:BNDD'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_yaw:
-  description: VFM Virtual Yaw
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:YAW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_roll:
-  description: VFM Virtual Roll
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:ROLL'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_pitch:
-  description: VFM Virtual Pitch
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:PITCH'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_x:
-  description: VFM Virtual X
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-vfm_y:
-  description: VFM Virtual Y 
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-VFM:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - vfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_xu:
-  description: HFM Upstream X
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRXU'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_xd:
-  description: HFM Downstream X
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRXD'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_yuw:
-  description: HFM Upstream Wall Y
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRYUW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_yr:
-  description: HFM Ring Y
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRYR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_ydw:
-  description: HFM Downstream Wall Y
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRYDW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_bu:
-  description: HFM Upstream Bender
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:BNDU'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_bd:
-  description: HFM Downstream Bender
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:BNDD'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_yaw:
-  description: HFM Virtual Yaw
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:YAW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_roll:
-  description: HFM Virtual Roll
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:ROLL'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_pitch:
-  description: HFM Virtual Pitch
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:PITCH'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_x:
-  description: HFM Virtual X
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-hfm_y:
-  description: HFM Virtual Y 
-  deviceClass: ophyd_devices.EpicsMotorEC
-  deviceConfig: {prefix: 'X10SA-ES-HFM:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - hfm
-  readOnly: False
-  softwareTrigger: false
-
-bcu_bpm1:
-  description: BCU BPM Channel 1 
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-BCBPM:Current1:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-bcu_bpm2:
-  description: BCU BPM Channel 2
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-BCBPM:Current2:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-bcu_bpm3:
-  description: BCU BPM Channel 3
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-BCBPM:Current3:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-bcu_bpm4:
-  description: BCU BPM Channel 4
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-BCBPM:Current4:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-bcu_bpmsum:
-  description: BCU BPM Summed
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-BCBPM:SumAll:MeanValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-bcu_bpm_x:
-  description: BCU BPM X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCBPM:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_bpm_y:
-  description: BCU BPM Y 
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCBPM:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_sl_xw:
-  description: BCU Slit Wall
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCSLH:TRXW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_sl_xr:
-  description: BCU Slit Ring
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCSLH:TRXR'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_sl_xcen:
-  description: BCU Slit X Centre
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCSLH:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_sl_xsize:
-  description: BCU Slit X Size
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCSLH:SIZE'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_sl_yt:
-  description: BCU Slit Top
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCSLV:TRYT'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_sl_yb:
-  description: BCU Slit Bottom
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCSLV:TRYB'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_sl_ycen:
-  description: BCU Slit Y Centre
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCSLV:CENTER'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-bcu_sl_ysize:
-  description: BCU Slit Y Size
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BCSLV:SIZE'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - bcu
-  readOnly: False
-  softwareTrigger: false
-
-samcam_x:
-  description: Sample Camera X 
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-MS:Stats5:CentroidX_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - scam
-  readOnly: True
-  softwareTrigger: false
-
-samcam_xsig:
-  description: Sample Camera X Sigma
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-MS:Stats5:SigmaX_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - scam
-  readOnly: True
-  softwareTrigger: false
-
-samcam_y:
-  description: Sample Camera Y 
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-MS:Stats5:CentroidY_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - scam
-  readOnly: True
-  softwareTrigger: false
-
-samcam_ysig:
-  description: Sample Camera Y Sigma
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-MS:Stats5:SigmaY_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - scam
-  readOnly: True
-  softwareTrigger: false
-
-samcam_max:
-  description: Sample Camera Max 
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-MS:Stats5:MaxValue_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - scam
-  readOnly: True
-  softwareTrigger: false
-
-samcam_exp:
-  description: Sample Camera Exposure
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-MS:cam1:AcquireTime', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - scam
-  readOnly: False
-  softwareTrigger: false
-
-samcam_gain:
-  description: Sample Camera Gain
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-MS:cam1:Gain', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - scam
-  readOnly: False
-  softwareTrigger: false
-
-scam_zoom:
-  description: Sample Camera Zoom
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-MS:ZOOM'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - scam
-  readOnly: False
-  softwareTrigger: false
-
-coll_x:
-  description: Collimator X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-COL:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: False
-  softwareTrigger: false
-
-diag_z:
-  description: Scintillator/diode Z
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SCL:TRZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: False
-  softwareTrigger: false
-
-i1:
-  description: I1 Diode
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-SCLDI:READOUT', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-bs_x:
-  description: Beamstop X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BS:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: False
-  softwareTrigger: false
-
-bs_y:
-  description: Beamstop Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BS:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: False
-  softwareTrigger: false
-
-gon_y:
-  description: Goniometer Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-DF1:TRY1'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-
-gon_z:
-  description: Goniometer X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-DF1:TRZ1'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-
-omega:
-  description: Omega
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-DF1:ROTU'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-
-mag_ok:
-  description: Sample Sensor Check
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-DFS:CBOX-CMP1', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: True
-  softwareTrigger: false
-
-mag_rbv:
-  description: Sample Sensor RBV
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-DFS:CBOX-USER1', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: True
-  softwareTrigger: false
-
-mag_ref:
-  description: Sample Sensor Reference
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-DFS:CBOX-REFVAL1', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: True
-  softwareTrigger: false
-
-cryo_x:
-  description: Cryo X 
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-CS:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: False
-  softwareTrigger: false
-
-cryo_temp:
-  description: Cryo Temperature
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-CS:TEMP_RBV', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: True
-  softwareTrigger: false
-
-det_xi_focus:
-  description: X-ray Eye 2 Focus
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-XEYE:FOCUS'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-
-det_xi_zoom:
-  description: X-ray Eye 2 Zoom
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-XEYE:ZOOM'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-
-det_xi_x:
-  description: X-ray Eye X
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-XEYE:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-
-i2:
-  description: I2 Diode
-  deviceClass: ophyd.EpicsSignalRO
-  deviceConfig: {read_pv: 'X10SA-ES-XEYEDI:READOUT', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: monitored
-  deviceTags:
-    - bpm
-  readOnly: True
-  softwareTrigger: false
-
-det_y:
-  description: Detector Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-DET:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-
-det_z:
-  description: Detector Z
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-DET:TRZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-
diff --git a/pxii_bec/device_configs/pxii-state-devices.yaml b/pxii_bec/device_configs/pxii-state-devices.yaml
deleted file mode 100644
index 9888dc2..0000000
--- a/pxii_bec/device_configs/pxii-state-devices.yaml
+++ /dev/null
@@ -1,130 +0,0 @@
-bl_bright:
-  description: Backlight Brightness
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-BL:SET', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type": continuous, "on": 1.3, "off": 0.0, "tol": 0.01}
-
-bl_pos:
-  description: Backlight Positioner
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-BL:POS-SET', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type":discrete, "in": 1, "out": 0}
-
-bs_pos:
-  description: Beamstop Positioner
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-BS:POS-SET', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type":discrete, "in": 1, "out": 0}
-
-bs_z:
-  description: Beamstop Z
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BS:TRZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type": continuous, "min": 13, "samp": 15, "work_min": 20, "safe": 41, "max_blin": 42, "max_blout": 70}
-
-coll_y:
-  description: Collimator Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-COL:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type": continuous, "in": 41.5, "out": 20.0, "intermediate": 32, "park": 1,"tol":0.05}
-
-cryo_pos:
-  description: Cryo positioner
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-CS:POS-SET', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type":discrete, "in": 1, "out": 0}
-
-det_cov:
-  description: Detector cover
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-DETCOV:SET', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type":discrete, "open": 2, "close": 1}
-
-diag_y:
-  description: Scintillator/diode Y
-  deviceClass: ophyd_devices.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SCL:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type": continuous, "scint": 38.62, "i1": 44.0, "out": 20.0,"park": 1,"tol":0.3}
-
-fl_bright:
-  description: Frontlight Brightness
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-FL:SET', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type": continuous, "on": 3.0, "off": 0.0, "tol": 0.01}
-
-xrf_pos:
-  description: XRF Positioner
-  deviceClass: ophyd.EpicsSignal
-  deviceConfig: {read_pv: 'X10SA-ES-XRF:POS-SET', auto_monitor: true}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - state
-  readOnly: False
-  softwareTrigger: false
-  userParameter: {"type":discrete, "in": 1, "out": 0}
-
diff --git a/pxii_bec/device_configs/smargopolo_smargon.yaml b/pxii_bec/device_configs/smargopolo_smargon.yaml
deleted file mode 100644
index 0b6d982..0000000
--- a/pxii_bec/device_configs/smargopolo_smargon.yaml
+++ /dev/null
@@ -1,12 +0,0 @@
-smargon:
-  description: REST-based device which connects to Smargopolo
-  deviceClass: pxii_bec.devices.smargopolo_smargon.Smargon
-  deviceConfig: {prefix: 'http://localhost:8000'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - smargon
-    - motors
-  readOnly: false 
-  softwareTrigger: false
\ No newline at end of file
diff --git a/pxii_bec/device_configs/x10sa_device_config.yaml b/pxii_bec/device_configs/x10sa_device_config.yaml
index 630ed00..8e54df4 100644
--- a/pxii_bec/device_configs/x10sa_device_config.yaml
+++ b/pxii_bec/device_configs/x10sa_device_config.yaml
@@ -1,40 +1,40 @@
 base_config:
-  - !include ./pxii-standard-devices.yaml
-sample_env:
-  - !include ./se_devices.yaml
-id_gap:
-  readoutPriority: baseline
-  description: undulator gap
-  deviceClass: pxii_bec.devices.undulator.UndulatorGap
-  deviceConfig:
-     prefix: 'X10SA-UIND:'
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-  softwareTrigger: false
+  - !include ./pxii-devices.yaml
+# sample_env:
+#   - !include ./pxii-state-devices.yaml
+# id_gap:
+#   readoutPriority: baseline
+#   description: undulator gap
+#   deviceClass: pxii_bec.devices.undulator.UndulatorGap
+#   deviceConfig:
+#      prefix: 'X10SA-UIND:'
+#   onFailure: buffer
+#   enabled: true
+#   readOnly: false
+#   softwareTrigger: false
 
-smargon:
-  description: REST-based device which connects to Smargopolo
-  deviceClass: pxii_bec.devices.smargopolo_smargon.Smargon
-  deviceConfig: {prefix: 'http://x10sa-smargopolo.psi.ch:3000'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - smargon
-    - motors
-  readOnly: false 
-  softwareTrigger: false
+# smargon:
+#   description: REST-based device which connects to Smargopolo
+#   deviceClass: pxii_bec.devices.smargopolo_smargon.Smargon
+#   deviceConfig: {prefix: 'http://x10sa-smargopolo.psi.ch:3000'}
+#   onFailure: buffer
+#   enabled: True
+#   readoutPriority: baseline
+#   deviceTags:
+#     - smargon
+#     - motors
+#   readOnly: false 
+#   softwareTrigger: false
  
-aerotech:
-  description: REST-based device which connects to AareScan and Aerotech
-  deviceClass: pxii_bec.devices.aerotech.Aerotech
-  deviceConfig: {prefix: 'http://mx-x10sa-queue-01:5234'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - aerotech
-    - motors
-  readOnly: false 
-  softwareTrigger: false
+# aerotech:
+#   description: REST-based device which connects to AareScan and Aerotech
+#   deviceClass: pxii_bec.devices.aerotech.Aerotech
+#   deviceConfig: {prefix: 'http://mx-x10sa-queue-01:5234'}
+#   onFailure: buffer
+#   enabled: True
+#   readoutPriority: baseline
+#   deviceTags:
+#     - aerotech
+#     - motors
+#   readOnly: false 
+#   softwareTrigger: false
diff --git a/pxii_bec/macros/APscripts.py b/pxii_bec/macros/APscripts.py
old mode 100755
new mode 100644
index f8d9597..53378c8
--- a/pxii_bec/macros/APscripts.py
+++ b/pxii_bec/macros/APscripts.py
@@ -139,8 +139,8 @@ def rock(**kwargs):
     import matplotlib.pyplot as plt
 
     ## create a dock area: 
-    dock_area = bec.gui.new()
-    wr = dock_area.new(gui.available_widgets.Waveform)
+    dock_area = bec.gui.new(name="Rock", geometry = [4000, 900, 700, 700])
+    wr = dock_area.new(bec.gui.available_widgets.Waveform)
 
     # width of rocking curve of perfect xtal: at 20 keV: 14 urad == 0.0008 deg
 
@@ -194,12 +194,14 @@ def rock(**kwargs):
         mot = motb
         pos0 = motb_rb
 
-    s = scans.line_scan(mot, -dx, dx, steps=50, exp_time=time, relative=True)
     # md = scan.metadata["bec"]
     wr.title = f"RockingScan at Energy of {e}"
-    wr.plot(x_name=mot.name, y_name=det.name)  ##set names/axes first !
     wr.x_label = mot.name
     wr.y_label = det.name
+    wr.plot(device_x=mot, device_y=det)  ##set names/axes first !
+
+    s = scans.line_scan(mot, -dx, dx, steps=50, exp_time=time, relative=True)
+    
     if ax == 0:
         data_x = s.scan.live_data.dcm_pitch.dcm_pitch.val
     else:
@@ -237,6 +239,23 @@ def rock(**kwargs):
     return
 
 
+
+
+
+
+################################
+### Help PROGRAMS
+
+#############################
+### just reconfigure beaml
+#############################
+def loadmac():
+    
+    bec.macros.load_all_user_macros()
+    # d, planner = init_beamline_environment()
+
+    
+
 ################################
 ### FITTING PROGRAMS
 
@@ -859,8 +878,8 @@ def colliscan(direction: str, range=0.3, nsteps=30, stime=0.5, centre=1):
     """
     import sys
 
-    dock_area = bec.gui.new()
-    wr = dock_area.new().new(bec.gui.available_widgets.Waveform)
+    dock_area = bec.gui.new(name="ColliScan", geometry = [4000, 900, 700, 700])
+    wr = dock_area.new(bec.gui.available_widgets.Waveform)
 
     # check if i1 DIODE is IN
     # if not, aks to be moved
@@ -1033,18 +1052,19 @@ def slitscan(device_location: str, direction: str, range: 1, nsteps=50, centre=0
         print("Ok, cancelled")
         return
 
-    dock_area = bec.gui.new()
-    wr = dock_area.new(gui.available_widgets.Waveform)
+    dock_area = bec.gui.new(name="SlitScan", geometry = [4000, 900, 700, 700])
+    wr = dock_area.new(bec.gui.available_widgets.Waveform)
 
     pos0 = mot.user_readback.get()
     siz0 = size.user_readback.get()
     umv(size, s_closed)
 
-    s = scans.line_scan(mot, -dx, dx, steps=nsteps, exp_time=time, relative=True)
-    wr.plot(x_name=mot.name, y_name=det.name)
+    wr.plot(device_x=mot, device_y=det)
+ 
     wr.x_label = mot.name
     wr.y_label = det.name
 
+    s = scans.line_scan(mot, -dx, dx, steps=nsteps, exp_time=time, relative=True)
     # this gives funny errors: ARRAYS differently read?
     # data_x = s.scan.data.devices[mot.name][mot.name].read()["value"]
     # data_x = s.scan.live_data["fe_sxcen"]["fe_sxcen"].val
@@ -1494,8 +1514,8 @@ def scan_window(wname="Scan", fit=True):
     nam = "waveform_dock_"+wname
     dock_area = bec.gui.new(name=wname, geometry = [4000, 900, 700, 700])
 
-    w1 = dock_area.new(gui.available_widgets.Waveform) # CALL gui.available_widgets to see what is available
-    w2 = dock_area.new(gui.available_widgets.ScanControl)
+    w1 = dock_area.new(bec.gui.available_widgets.Waveform) # CALL gui.available_widgets to see what is available
+    w2 = dock_area.new(bec.gui.available_widgets.ScanControl)
 
     # Add signals to the WaveformWidget
     w1.plot(device_x = dev.id_gap, device_y = dev.lu_bpmsum) 
diff --git a/pxii_bec/macros/KB_Class.py b/pxii_bec/macros/KB_Class.py
new file mode 100644
index 0000000..5e3bbda
--- /dev/null
+++ b/pxii_bec/macros/KB_Class.py
@@ -0,0 +1,83 @@
+import numpy as np
+
+
+class KBMirror:
+    def __init__(self, mirror_type="PXII_HFM"):
+        self.mirror_type = mirror_type
+        self._load_parameters()
+
+    def _load_parameters(self):
+        if self.mirror_type == "PXII_VFM":
+            self.C0 = 0.284078
+            self.C1 = -0.471525
+            self.P2 = 0.583490
+            self.P3 = -0.372950
+            self.L1 = -0.955798
+            self.curv_approx_fact = 1.0121
+            self.s1 = 24.15   #24.35
+            self.s2 = 1.45
+            self.asym0 = 0.08
+
+        elif self.mirror_type == "PXII_HFM":
+            self.C0 = 0.060453
+            self.C1 = -0.457812
+            self.P2 = 0.586057
+            self.P3 = -0.088093
+            self.L1 = -0.999445
+            self.curv_approx_fact = 0.995
+            self.s1 = 24.90   #25.10
+            self.s2 = 0.7
+            self.asym0 = -0.0107
+
+        else:
+            raise ValueError(f"Unknown mirror type: {self.mirror_type}")
+
+    def bend_to_curvature(self, BU, BD):
+        BU0 = (BD - self.L1 * BU - self.P3) / (self.P2 - self.L1)
+        curv = self.C0 + self.C1 * BU0
+        a = BU - BU0
+        asym = a * np.sqrt(1 - self.L1**2)
+        return curv, asym
+
+    def curvature_to_bend(self, curv, asym):
+        BU0 = (curv - self.C0) / self.C1
+        BD0 = self.P2 * BU0 + self.P3
+        a = asym / np.sqrt(1 - self.L1**2)
+        BU = a + BU0
+        BD = BD0 + self.L1 * a
+        return BU, BD
+
+    def ellipse_to_curvature(self, s2, th_mrad):
+        R = 2 * self.s1 * s2 / (self.s1 + s2) / np.sin(th_mrad / 1000)
+        curv = (1 / R) * 1000 * self.curv_approx_fact
+        return curv
+
+    def curvature_to_ellipse(self, curv, th_mrad):
+        curv0 = curv / self.curv_approx_fact / 1000
+        R = 1 / curv0
+        s2 = self.s1 / (2 * self.s1 / (R * np.sin(th_mrad / 1000)) - 1)
+        return s2
+
+    def get_benders(self, th=2.0, defocus_mm=0.0, user_asymmetry=0.0):
+        asym = self.asym0 + user_asymmetry
+        s2_target = self.s2 + defocus_mm / 1000
+        curv = self.ellipse_to_curvature(s2_target, th)
+        BU, BD = self.curvature_to_bend(curv, asym)
+        return BU, BD
+
+    def readback(self, BU, BD, th=2.0):
+        curv, asym = self.bend_to_curvature(BU, BD)
+        s2_rb = self.curvature_to_ellipse(curv, th)
+        defocus_mm = (s2_rb - self.s2) * 1000
+        bend_rad_m = 1/curv *1000
+        return {
+            "curvature": curv,
+            "bend_rad_m":  bend_rad_m, 
+            "asymmetry": asym,
+            "s2": s2_rb,
+            "defocus_mm": defocus_mm
+        }
+
+
+
+    
diff --git a/pxii_bec/macros/Undu_Helpers.py b/pxii_bec/macros/Undu_Helpers.py
index 12c5ead..eaf056c 100755
--- a/pxii_bec/macros/Undu_Helpers.py
+++ b/pxii_bec/macros/Undu_Helpers.py
@@ -227,11 +227,11 @@ def long_gscan(estart=7, end_en=20.5, g_low=4.5, g_high=9.0, nsteps=1500):
     )
     resol = (g_high - g_low) / nsteps
     print(f"nsteps = {nsteps}; resolution is {resol} mm")
-    dock_area = bec.gui.new("LongGapScan")
-    wr = dock_area.new(gui.available_widgets.Waveform)
+    dock_area = bec.gui.new("LongGapScan", geometry = [4000, 900, 1200, 700])
+    wr = dock_area.new(bec.gui.available_widgets.Waveform)
     mot = dev.id_gap
     det = dev.lu_bpmsum
-    wr.plot(x_name=mot.name, y_name=det.name)  ## names first !
+    wr.plot(device_x=mot, device_y=det)  ## names first !
     wr.x_label = mot.name
     wr.y_label = det.name
     g0 = dev.id_gap.readback.get()
@@ -304,11 +304,11 @@ def gscan(centre=0, gomax=0, detune=0):
     """
     import time
 
-    dock_area = bec.gui.new()
-    wr = dock_area.new(gui.available_widgets.Waveform)
+    dock_area = bec.gui.new(name="GapScan", geometry = [4000, 900, 700, 700])
+    wr = dock_area.new(bec.gui.available_widgets.Waveform)
     mot = dev.id_gap
     det = dev.lu_bpmsum
-    wr.plot(x_name=mot.name, y_name=det.name)  ## names first !
+    wr.plot(device_x=mot, device_y=det)  ## names first !
     # wr.plot(x=mot.name,y=det.name)           ### this comes later
     wr.x_label = mot.name
     wr.y_label = det.name
@@ -323,7 +323,7 @@ def gscan(centre=0, gomax=0, detune=0):
     # indmax = np.argmax(bpm_data)
     # gm = gap_data[indmax]
 
-    gcen, xm = fit_plot(gap_data, bpm_data, model="gauss")
+    gcen, xm = fit_plot(gap_data, bpm_data, model="voigt")
 
     if gomax:
         gm = xm
diff --git a/pxii_bec/macros/beamline_planner.py b/pxii_bec/macros/beamline_planner.py
index 217d589..aa99268 100755
--- a/pxii_bec/macros/beamline_planner.py
+++ b/pxii_bec/macros/beamline_planner.py
@@ -1,13 +1,15 @@
-"""Planner to move between beamline statesΩ"""
+"""Planner to move between beamline states"""
 
-import time
 from collections import defaultdict, deque
 from enum import Enum
+
 # from enums import BeamlineState, TemperatureMode
 # from matcher import DeviceMatcher, nonzero_is_on
 
+
 class BeamlineState(str, Enum):
     """List of beamline states"""
+
     ROBOT_SAMPLE_EXCHANGE = "robot_sample_exchange"
     SAMPLE_ALIGNMENT = "sample_alignment"
     DATA_COLLECTION = "data_collection"
@@ -22,6 +24,7 @@ class BeamlineState(str, Enum):
 
 class TemperatureMode(str, Enum):
     """List of temperature modes"""
+
     CRYO = "cryo"
     ROOM_TEMP = "room_temp"
 
@@ -59,7 +62,6 @@ class StateChangePlanner:
                 target.update(self.modifiers[modifier])
         return target
 
-
     def move_to(self, state_name, modifier=None):
         """Move devices to the correct positions to achieve a given state"""
         if isinstance(state_name, str):
@@ -124,12 +126,8 @@ class StateChangePlanner:
                 config = self._merged_state(state, modifier)
 
                 # Check if all devices match their expected positions
-                if all(self.devices[d].is_at(p) 
-                       for d, p in config.items()
-                       if d not in ignore_keys
-                       ):
-                    # print(f"Current state: {state.name}, Modifier: {modifier.name if modifier else 'None'}")
-                    matches.append((state.name, modifier.name if modifier else 'None'))
+                if all(self.devices[d].is_at(p) for d, p in config.items() if d not in ignore_keys):
+                    matches.append((state.name, modifier.name if modifier else "None"))
 
         return matches if matches else None
 
diff --git a/pxii_bec/macros/build_devices.py b/pxii_bec/macros/build_devices.py
index 3c8dd2e..12bb5fd 100755
--- a/pxii_bec/macros/build_devices.py
+++ b/pxii_bec/macros/build_devices.py
@@ -1,14 +1,15 @@
-""" Build the sample environment devices"""
+"""Build the sample environment devices"""
+
+import os
 import yaml
 
 # from position_device import PositionDevice
 
-def motor_resolver(bec_name):
 
-    candidates = [
-        bec_name,
-        bec_name.replace("_", "."),
-    ]
+def motor_resolver(bec_name):
+    """Used to handle aerotech and smargon motors"""
+
+    candidates = [bec_name, bec_name.replace("_", ".")]
 
     for path in candidates:
         try:
@@ -24,9 +25,9 @@ def motor_resolver(bec_name):
 
     raise ValueError(f"Cannot resolve motor for '{bec_name}'")
 
-def build_devices(yaml_file, mock_devices):
-    """ Build devices from the beamline states yaml"""
 
+def build_devices(yaml_file, mock_devices):
+    """Build devices from the beamline states yaml"""
 
     state_devices = {}
 
@@ -41,30 +42,103 @@ def build_devices(yaml_file, mock_devices):
         if not user:
             continue
 
+        if bec_name in ("aerotech", "smargon"):
 
-        tol = user.get("tol", 0.1)
+            tol = user.get("tol", 0.01)
 
-        positions = {
-            k: v for k, v in user.items()
-            if k not in ("type", "tol")
-        }
+            for axis in ["x", "y", "z", "u", "chi", "phi"]:
 
-        allow_arbitrary = (user["type"] == "continuous")
-        
-        
+                positions = user.get(axis)
 
-        pos_dev = PositionDevice(
-            bec_name=bec_name,
-            mot_device = motor_resolver(bec_name),
-            positions=positions,
-            tol=tol,
-            allow_arbitrary=allow_arbitrary,
-            use_mock=bec_name in mock_devices,
-        )
+                if positions is None:
+                    continue
+
+                component_name = f"{bec_name}_{axis}"
+
+                pos_dev = PositionDevice(
+                    bec_name=component_name,
+                    mot_device=motor_resolver(component_name),
+                    positions=positions,
+                    tol=tol,
+                    allow_arbitrary=True,
+                    use_mock=component_name in mock_devices,
+                )
+
+                state_devices[component_name] = pos_dev
+
+        else:
+
+            tol = user.get("tol", 0.1)
+            allow_arbitrary = user.get("type") == "continuous"
+
+            positions = {k: v for k, v in user.items() if k not in ("type", "tol")}
+
+            pos_dev = PositionDevice(
+                bec_name=bec_name,
+                mot_device=motor_resolver(bec_name),
+                positions=positions,
+                tol=tol,
+                allow_arbitrary=allow_arbitrary,
+                use_mock=bec_name in mock_devices,
+            )
+
+            state_devices[bec_name] = pos_dev
 
-        state_devices[bec_name] = pos_dev
     return state_devices
 
 
+# def update_position(device, position, value, axis=None):
+#     """Update the user parameter saved positions for a device"""
+#     params = device.user_parameter
+
+#     if axis is None:
+#         # Is this a nested structure?
+#         nested_keys = [k for k, v in params.items() if isinstance(v, dict)]
+
+#     if nested_keys:
+#         raise ValueError(
+#             f"{device.name} has nested parameters "
+#             f"({nested_keys}); specify axis=..."
+#         )
+
+#     device.update_user_parameter({position: value})
+#     return
+
+# axis_params = params[axis].copy()
+# axis_params[position] = value
+# device.update_user_parameter({axis: axis_params})
 
 
+# # Save the updated values to the device yaml file
+# # and re-initialise
+# beamline = os.environ["BEAMLINE"]
+# env = Environment(beamline = beamline)
+# bec.config.save_current_session(env.devices_file)
+# return init_beamline_environment()
+
+
+def update_position(device, position, value, axis=None):
+    """Update the user parameter saved positions for a device"""
+    params = device.user_parameter
+
+    if axis is None:
+        nested_keys = [k for k, v in params.items() if isinstance(v, dict)]
+
+        if nested_keys:
+            raise ValueError(
+                f"{device.name} has nested parameters " f"({nested_keys}); specify axis=..."
+            )
+
+        device.update_user_parameter({position: value})
+
+    else:
+        axis_params = params[axis].copy()
+        axis_params[position] = value
+        device.update_user_parameter({axis: axis_params})
+
+    # Save the updated values to the device yaml file
+    beamline = os.environ["BEAMLINE"]
+    env = Environment(beamline=beamline)
+    bec.config.save_current_session(env.devices_file)
+
+    return init_beamline_environment()
diff --git a/pxii_bec/macros/check.py b/pxii_bec/macros/check.py
index b5975f3..b37f88d 100755
--- a/pxii_bec/macros/check.py
+++ b/pxii_bec/macros/check.py
@@ -25,15 +25,12 @@ class Status(Enum):
             Status.ERROR: "red",
             Status.UNKNOWN: "blue",
         }[self]
-    
+
     @property
     def color_scilog(self):
-        return {
-            Status.OK: "green",
-            Status.WARNING: "",
-            Status.ERROR: "red",
-            Status.UNKNOWN: "",
-        }[self]
+        return {Status.OK: "green", Status.WARNING: "", Status.ERROR: "red", Status.UNKNOWN: ""}[
+            self
+        ]
 
 
 # -------------------------------------------------------------------
@@ -45,7 +42,7 @@ class Status(Enum):
 class HealthCheckResult:
 
     name: str
-    description: str 
+    description: str
     status: Status
 
     value: Any = None
@@ -59,50 +56,34 @@ class HealthCheckResult:
         if self.status == Status.OK:
             return f"[{self.status.name}] {self.description}"
 
-        return (
-            f"[{self.status.name}] "
-            f"{self.description}: {self.message}"
-        )
-    
+        return f"[{self.status.name}] " f"{self.description}: {self.message}"
+
     def formatted_message(self):
         if self.status == Status.OK:
             return f"[{self.status.name} {self.name}]"
-        
-        return (
-            f"[{self.status.name}] "
-            f"{self.description}: {self.message}"
-        )
+
+        return f"[{self.status.name}] " f"{self.description}: {self.message}"
+
 
 # -------------------------------------------------------------------
 # Send to SciLog
 # -------------------------------------------------------------------
 
+
 def send_to_scilog(results):
 
-    counts = {
-        Status.OK: 0,
-        Status.WARNING: 0,
-        Status.ERROR: 0,
-        Status.UNKNOWN: 0,
-    }
+    counts = {Status.OK: 0, Status.WARNING: 0, Status.ERROR: 0, Status.UNKNOWN: 0}
 
     for result in results:
         counts[result.status] += 1
 
-
     msg = bec.messaging.scilog.new()
 
-    msg.add_text(
-        "Beamline Health Summary",
-        bold = True
-    )
+    msg.add_text("Beamline Health Summary", bold=True)
 
     msg.add_text("\n")
     for status, count in counts.items():
-        msg.add_text(
-            f"{status.name:<10}: {count}",
-            bold=True,
-        )
+        msg.add_text(f"{status.name:<10}: {count}", bold=True)
 
     msg.add_text("\n")
 
@@ -110,7 +91,7 @@ def send_to_scilog(results):
         msg.add_text(
             result.formatted_message(),
             # bold=result.status != Status.OK,
-            color = result.status.color_scilog
+            color=result.status.color_scilog,
         )
         msg.add_text("\n")
     msg.add_tags(["beamline health check"])
@@ -121,14 +102,12 @@ def send_to_scilog(results):
 # Configuration
 # -------------------------------------------------------------------
 
+
 @dataclass
 class BeamlineHealthConfig:
 
     signal_rules: dict[str, Callable] = field(
-        default_factory=lambda: {
-            "cam": lambda x: x != 0,
-            "bpm": lambda x: x != 0,
-        }
+        default_factory=lambda: {"cam": lambda x: x != 0, "bpm": lambda x: x != 0}
     )
 
     motor_tolerances: dict[str, float] = field(
@@ -160,11 +139,7 @@ def check_signals(devices, config: BeamlineHealthConfig):
 
     results = []
 
-    signal_devices = [
-        (name, obj)
-        for name, obj in devices
-        if isinstance(obj, Signal)
-    ]
+    signal_devices = [(name, obj) for name, obj in devices if isinstance(obj, Signal)]
 
     for name, obj in signal_devices:
 
@@ -255,11 +230,7 @@ def check_motors(devices, config: BeamlineHealthConfig):
     results = []
     ignore = ["id_gap", "smargon"]
 
-    motor_devices = [
-        (name, obj)
-        for name, obj in devices
-        if isinstance(obj, Positioner)
-    ]
+    motor_devices = [(name, obj) for name, obj in devices if isinstance(obj, Positioner)]
 
     for name, obj in motor_devices:
 
@@ -342,10 +313,7 @@ def check_motors(devices, config: BeamlineHealthConfig):
 
             diff = abs(actual - setpoint)
 
-            tolerance = config.motor_tolerances.get(
-                name,
-                config.default_motor_tolerance,
-            )
+            tolerance = config.motor_tolerances.get(name, config.default_motor_tolerance)
 
             if diff > tolerance:
 
@@ -389,6 +357,8 @@ def check_motors(devices, config: BeamlineHealthConfig):
             )
 
     return results
+
+
 # -------------------------------------------------------------------
 # General Info
 # -------------------------------------------------------------------
@@ -397,12 +367,14 @@ def info():
     gap = dev.id_gap.position
     energy = get_current_energy()
     # state = get_state()
-    print(f"[INFO] Machine: {current:.4g} mA\n"
-          f"[INFO] Undulator gap: {gap:.4g}\n"
-          f"[INFO] Beamline energy: {energy:.6g} eV\n")
-        #   f"[INFO] Beamline state: {state}")
-    
-    
+    print(
+        f"[INFO] Machine: {current:.4g} mA\n"
+        f"[INFO] Undulator gap: {gap:.4g}\n"
+        f"[INFO] Beamline energy: {energy:.6g} eV\n"
+    )
+    #   f"[INFO] Beamline state: {state}")
+
+
 # def get_state():
 #     states = []
 #     res = planner.current_state()
@@ -431,9 +403,7 @@ def check2(config: BeamlineHealthConfig | None = None):
     # Sort by severity
     # ---------------------------------------------------------------
 
-    results.sort(
-        key=lambda r: r.status.value,
-    )
+    results.sort(key=lambda r: r.status.value)
 
     return results
 
@@ -447,7 +417,6 @@ def summary_text(results):
 
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
 
-
     n_ok = sum(r.status == Status.OK for r in results)
 
     n_warn = sum(r.status == Status.WARNING for r in results)
@@ -472,22 +441,19 @@ def summary_text(results):
 # -------------------------------------------------------------------
 # Filter results
 # -------------------------------------------------------------------
-def filter_results(results, statuses = None):
+def filter_results(results, statuses=None):
     if statuses is None:
         return results
-    
-    return [
-        r for r in results
-        if r.status in statuses
-    ]
+
+    return [r for r in results if r.status in statuses]
+
 
 # -------------------------------------------------------------------
 # CLI Entry Point
 # -------------------------------------------------------------------
 
 
-def run_check(show_all= False, scilog=False):
-
+def run_check(show_all=False, scilog=False):
 
     results = check2()
 
@@ -496,36 +462,22 @@ def run_check(show_all= False, scilog=False):
     info()
 
     problem_results = filter_results(
-        results,
-        statuses={
-            Status.WARNING,
-            Status.ERROR,
-            Status.UNKNOWN,
-        }
+        results, statuses={Status.WARNING, Status.ERROR, Status.UNKNOWN}
     )
     if scilog:
         send_to_scilog(problem_results)
-    
+
     if not show_all:
-        results = filter_results(
-            results,
-            statuses={
-                Status.WARNING,
-                Status.ERROR,
-                Status.UNKNOWN
-            }
-        )
+        results = filter_results(results, statuses={Status.WARNING, Status.ERROR, Status.UNKNOWN})
     for result in results:
         print(result)
-    
-    disclaimer = "\n======================================================\n" \
-    "This reports: \n    1. If motors are in error state, if moving, or if readback != setpoint" \
-    "\n    2. If camera or BPMs are reading 0 (may or may not be an error)" \
-    "\nN.B. The motor checks are only done if they exist as standard ophyd motors in BEC." \
-    "\nTo see which devices were checked use run_check(show_all=True)."
+
+    disclaimer = (
+        "\n======================================================\n"
+        "This reports: \n    1. If motors are in error state, if moving, or if readback != setpoint"
+        "\n    2. If camera or BPMs are reading 0 (may or may not be an error)"
+        "\nN.B. The motor checks are only done if they exist as standard ophyd motors in BEC."
+        "\nTo see which devices were checked use run_check(show_all=True)."
+    )
 
     print(disclaimer)
-
-
-
-
diff --git a/pxii_bec/macros/dependencies.py b/pxii_bec/macros/dependencies.py
index f83296c..6e9e522 100755
--- a/pxii_bec/macros/dependencies.py
+++ b/pxii_bec/macros/dependencies.py
@@ -1,30 +1,14 @@
 """Planner dependencies"""
+
+
 def planner_deps():
     """Define the dependencies between beamline positions"""
     return {
-        ("bs_z", "samp"): [
-            ("aerotech_x", "out"),
-            ("diag_y", "out"),
-            ("coll_y", "out"),
-        ],
-        ("aerotech_x", "in"): [
-            ("diag_y", "out"),
-            ("bs_z", "safe"),
-        ],
-        ("aerotech_x", "out"): [
-            ("diag_y", "out"),
-            ("bs_z", "safe"),
-        ],
-        ("diag_y", "scint"): [
-            ("aerotech_x", "out"),
-            ("bs_z", "safe"),
-            ("cryo_pos", "out"),
-        ],
-        ("diag_y", "i1"): [
-            ("aerotech_x", "out"),
-            ("bs_z", "safe"),
-            ("cryo_pos", "out"),
-        ],
+        ("bs_z", "samp"): [("aerotech_x", "out"), ("diag_y", "out"), ("coll_y", "out")],
+        ("aerotech_x", "in"): [("diag_y", "out"), ("bs_z", "safe")],
+        ("aerotech_x", "out"): [("diag_y", "out"), ("bs_z", "safe")],
+        ("diag_y", "scint"): [("aerotech_x", "out"), ("bs_z", "safe"), ("cryo_pos", "out")],
+        ("diag_y", "i1"): [("aerotech_x", "out"), ("bs_z", "safe"), ("cryo_pos", "out")],
         ("bs_pos", "out"): [("bs_z", "safe")],
         ("bs_pos", "in"): [("bs_z", "safe")],
         ("diag_y", "out"): [("bs_z", "safe")],
diff --git a/pxii_bec/macros/devices_manager.py b/pxii_bec/macros/devices_manager.py
index 64b5ab3..47dddaf 100755
--- a/pxii_bec/macros/devices_manager.py
+++ b/pxii_bec/macros/devices_manager.py
@@ -10,13 +10,14 @@ class DeviceManager:
     """Class for building devices and attaching safety guards and policies."""
 
     @staticmethod
-    def initialize_devices(state_devices_file, rest_devices_file, mock_devices):
+    # def initialize_devices(state_devices_file, rest_devices_file, mock_devices):
+    def initialize_devices(devices_file, mock_devices):
         """
         Initializes sample environment devices from the specified file.
         """
-        devices = build_devices(state_devices_file, mock_devices)
-        rest_devices = build_devices(rest_devices_file, mock_devices)
-        devices.update(rest_devices)
+        devices = build_devices(devices_file, mock_devices)
+        # rest_devices = build_devices(rest_devices_file, mock_devices)
+        # devices.update(rest_devices)
         attach_guards(devices)
         attach_policies(devices)
         return devices
diff --git a/pxii_bec/macros/guards.py b/pxii_bec/macros/guards.py
index 0446e61..1306af9 100755
--- a/pxii_bec/macros/guards.py
+++ b/pxii_bec/macros/guards.py
@@ -15,9 +15,7 @@ class AtPositionGuard:
     def check(self):
         """Check if the device is in the specified position."""
         if self.device.pos != self.pos:
-            raise GuardViolation(
-                f"{self.device.bec_name} must be in the '{self.pos}' position"
-            )
+            raise GuardViolation(f"{self.device.bec_name} must be in the '{self.pos}' position")
         # print("move allowed")
         return True
 
diff --git a/pxii_bec/macros/init_beamline.py b/pxii_bec/macros/init_beamline.py
index 6c3eb80..cae0630 100755
--- a/pxii_bec/macros/init_beamline.py
+++ b/pxii_bec/macros/init_beamline.py
@@ -8,8 +8,10 @@ from dataclasses import dataclass
 # from dependencies import planner_deps
 # from beamline_planner import StateChangePlanner
 
+
 @dataclass
 class Environment:
+    """Define the device and state yaml files for each beamline"""
 
     device_mocks: dict[str, bool] = None
     beamline: str = None
@@ -21,18 +23,17 @@ class Environment:
         #     "rest": "pxi-rest-devices.yaml",
         #     "states": "pxi-beamline-states.yaml",
         # },
-        "x10sa" : {
+        "x10sa": {
             "devdir": "/sls/x10sa/config/bec/production/pxii_bec/pxii_bec/device_configs/",
-            "state": "pxii-state-devices.yaml",
-            "rest": "pxii-rest-devices.yaml",
+            "devices": "pxii-devices.yaml",
             "states": "pxii-beamline-states.yaml",
         },
-        "x06da" : {
+        "x06da": {
             "devdir": "/sls/x06da/config/bec/production/pxiii_bec/pxiii_bec/device_configs/",
             "state": "pxiii-state-devices.yaml",
             "rest": "pxiii-rest-devices.yaml",
             "states": "pxiii-beamline-states.yaml",
-        }
+        },
     }
 
     def __post_init__(self):
@@ -60,34 +61,23 @@ class Environment:
                 "xrf_pos": "mock",
             }
 
-        mocks = sorted(
-            name
-            for name, backend in self.device_mocks.items()
-            if backend == "mock"
-        )
+        mocks = sorted(name for name, backend in self.device_mocks.items() if backend == "mock")
 
-        reals = sorted(
-            name
-            for name, backend in self.device_mocks.items()
-            if backend == "real"
-        )
+        reals = sorted(name for name, backend in self.device_mocks.items() if backend == "real")
 
-        print(f"Mock devices ({len(mocks)}): {mocks}")
-        print(f"Real devices ({len(reals)}): {reals}") 
+        # print(f"Mock devices ({len(mocks)}): {mocks}")
+        # print(f"Real devices ({len(reals)}): {reals}")
 
         try:
             cfg = self.beamline_configs[self.beamline]
         except KeyError:
-            raise ValueError(
-                f"Unknown beamline '{self.beamline}'"
-            )
+            raise ValueError(f"Unknown beamline '{self.beamline}'")
 
         devdir = cfg["devdir"]
 
-        self.state_devices_file = devdir + cfg["state"]
-        self.rest_devices_file = devdir + cfg["rest"]
+        self.devices_file = devdir + cfg["devices"]
         self.states_file = devdir + cfg["states"]
-    
+
     mock_start_positions = {
         "aerotech_x": "in",
         "aerotech_y": "mount",
@@ -107,7 +97,7 @@ class Environment:
         "smargon_z": "mount",
         "smargon_chi": "mount",
         "smargon_phi": "mount",
-        "xrf_pos": "out", 
+        "xrf_pos": "out",
     }
 
     @property
@@ -116,7 +106,8 @@ class Environment:
         for name, device in self.device_mocks.items():
             if device == "mock":
                 mock_names.add(name)
-        return mock_names        
+        return mock_names
+
 
 def init_beamline_environment():
     """
@@ -125,15 +116,11 @@ def init_beamline_environment():
 
     beamline = os.environ["BEAMLINE"]
 
-    env = Environment(beamline = beamline)
+    env = Environment(beamline=beamline)
 
     # Initialize devices
     device_manager = DeviceManager()
-    devices = device_manager.initialize_devices(
-        env.state_devices_file,
-        env.rest_devices_file,
-        env.mock_devices
-        )
+    devices = device_manager.initialize_devices(env.devices_file, env.mock_devices)
 
     # Initialize states
     state_manager = DefineStatesManager()
@@ -144,7 +131,7 @@ def init_beamline_environment():
 
     # Setup planner
     planner = StateChangePlanner(devices, states, allow_modifiers, deps)
-    print("Initializing beamline state planner")
+    print("Initializing beamline state planner and devices")
 
     # Set mock motor starting positions
 
@@ -155,9 +142,4 @@ def init_beamline_environment():
             except Exception as e:
                 print(f"{e} error when setting {mock_dev}")
 
-
     return devices, planner
-
-
-
-
diff --git a/pxii_bec/macros/katscripts.py b/pxii_bec/macros/katscripts.py
new file mode 100755
index 0000000..3d36c69
--- /dev/null
+++ b/pxii_bec/macros/katscripts.py
@@ -0,0 +1,1547 @@
+"""Some simple scripts for commissioning"""
+
+import time, os
+from datetime import datetime
+from dataclasses import dataclass
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.signal import find_peaks as fp
+import pandas as pd
+from scipy.optimize import linear_sum_assignment
+
+
+def goto1a():
+    """Set beamline to 1A position"""
+    bragg_angle = 160.117
+    perp_dist = 0.0389
+    gap = 5.319
+    umv(dev.dcm_bragg, bragg_angle)
+    umv(dev.dcm_perp, perp_dist)
+    umv(dev.id_gap, gap)
+
+
+def bragg_scan():
+    """Energy scans from 6 to 18 keV at various gap positions"""
+
+    start_bragg = 110.05  # 18 keV
+    end_bragg = 335.77  # 6 keV
+    steps = 1200
+    exp = 0.05
+    gap = 7.5
+    umv(dev.id_gap, gap)
+    time.sleep(10)
+    while gap < 9.6:
+        print(f"Scanning the dcm_bragg from {start_bragg} to {end_bragg} at a gap of {gap: .2f} mm")
+        umv(dev.id_gap, gap)
+        scans.line_scan(
+            dev.dcm_bragg, start_bragg, end_bragg, steps=steps, exp_time=exp, relative=False
+        )
+        gap += 0.5
+
+
+def move_xeye(direction):
+    """Move the xeye in or out"""
+    if direction == "in":
+        umv(dev.ss_xicam_x, 7.0)
+    else:
+        umv(dev.ss_xicam_x, -7)
+
+
+def close_fe_slits(close=True):
+    """Close FE slits to (0.3,0.3) or open the FE slits to (2.0,1.0)"""
+    if close:
+        umv(dev.fe_sl_xsize, 0.3, dev.fe_sl_ysize, 0.3)
+    else:
+        umv(dev.fe_sl_xsize, 1.5, dev.fe_sl_ysize, 1.0)
+
+
+def energy_checks(start_energy=8000, end_energy=20000):
+    """Check gap, pitch and intensities at different energies"""
+    f = open("luts/test.csv", "a", encoding="utf-8")
+
+    gaps = {
+        8000: 8.04,
+        9000: 9.55,
+        10000: 7.45,
+        11000: 8.46,
+        12000: 7.09,
+        13000: 7.77,
+        14000: 8.61,
+        15000: 9.57,
+        16000: 8.09,
+        17000: 7.18,
+        18000: 7.67,
+        19000: 8.24,
+        20000: 7.52,
+    }
+    for energy in range(start_energy, end_energy, 1000):
+        f = open("luts/test.csv", "a", encoding="utf-8")
+        print(f"Moving to {energy} eV")
+        umv(dev.id_gap, gaps[energy])
+        move_and_set_dcm(energy)
+        if energy < 16000:
+            close_fe_slits(True)
+            go_to_peak(
+                dev.id_gap, dev.lu_bpmsum, -0.3, 0.3, 40, relative=True, confirm=False, gomax=True
+            )
+            scan_fe()
+            close_fe_slits(True)
+            go_to_peak(
+                dev.id_gap, dev.lu_bpmsum, -0.1, 0.1, 15, relative=True, confirm=False, gomax=True
+            )
+            go_to_peak(
+                dev.id_gap,
+                dev.lu_bpmsum,
+                -0.025,
+                0.025,
+                15,
+                relative=True,
+                confirm=False,
+                gomax=True,
+            )
+            close_fe_slits(False)
+
+        else:
+            umv(dev.s1_xsize, 0.5)
+            go_to_peak(
+                dev.id_gap, dev.bcu_bpmsum, -0.3, 0.3, 40, relative=True, confirm=False, gomax=True
+            )
+            scan_fe()
+            go_to_peak(
+                dev.id_gap, dev.bcu_bpmsum, -0.1, 0.1, 15, relative=True, confirm=False, gomax=True
+            )
+            umv(dev.s1_xsize, 2.5)
+        mono_pitch_scan()
+        gap = dev.id_gap.read()["id_gap"]["value"]
+        pitch = dev.dcm_pitch.read()["dcm_pitch"]["value"]
+        fe_x = dev.fe_sxcen.read()["fe_sxcen"]["value"]
+        fe_y = dev.fe_sycen.read()["fe_sycen"]["value"]
+        lu_read = dev.lu_bpmsum.read()["lu_bpmsum"]["value"]
+        bsc_read = dev.bsc_bpmsum.read()["bsc_bpmsum"]["value"]
+        bcu_read = dev.bcu_bpmsum.read()["bcu_bpmsum"]["value"]
+        f.write(
+            f"{energy}, {gap: .5g}, {pitch: .5g}, {lu_read: .5g}, "
+            f"{bsc_read: .5g}, {bcu_read: .5g}, "
+            f"{fe_x: .5g}, {fe_y: .5g}\n"
+        )
+
+        f.close()
+
+
+def scan_fe():
+    """Scan the FE slits in X and Y"""
+    print("Scanning FE slits in X")
+    umv(dev.fe_sxsize, 0.05, dev.fe_sysize, 2)
+    go_to_peak(dev.fe_sxcen, dev.lu_bpmsum, -1.5, 1.5, 20, confirm=False, relative=True)
+    print("Scanning FE slits in Y")
+    umv(dev.fe_sxsize, 0.3, dev.fe_sysize, 0.05)
+    go_to_peak(dev.fe_sycen, dev.lu_bpmsum, -1.2, 1.2, 15, confirm=False, relative=True)
+    close_fe_slits(False)
+
+
+def scan_gap():
+    """Scan the gap and monitor on lu_bpmsum or bcu_bpmsum"""
+    # close_fe_slits(True)
+    current_gap = dev.id_gap.read()["id_gap"]["value"]
+    if current_gap > 4.6:
+        go_to_peak(
+            dev.id_gap, dev.lu_bpmsum, -0.1, 0.1, 25, relative=True, confirm=False, gomax=False
+        )
+    else:
+        go_to_peak(
+            dev.id_gap, dev.lu_bpmsum, 4.5, 4.75, 25, relative=False, confirm=False, gomax=False
+        )
+    # close_fe_slits(False)
+
+
+def record_pitch():
+    """Record the pitch and perp distance to file"""
+    with open("luts/pitch_record.csv", "a", encoding="utf-8") as f:
+        current_energy = get_current_energy()
+        pitch = dev.dcm_pitch.read()["dcm_pitch"]["value"]
+        gap = dev.id_gap.read()["id_gap"]["value"]
+        f.write(f"{current_energy: .0f}, {pitch: .5g}, {gap: .4g}\n")
+        f.close()
+
+
+def record_roll():
+    """Record the roll and perp distance to file"""
+    with open("luts/roll_record.csv", "a", encoding="utf-8") as f:
+        current_energy = get_current_energy()
+        roll = dev.dcm_froll.read()["dcm_froll"]["value"]
+        f.write(f"{current_energy:.0f}, {roll:.5g}\n")
+        f.close()
+
+
+def record_perp():
+    """Check perp calibrations at various energies"""
+    with open("luts/perp_record.csv", "a", encoding="utf-8") as f:
+        current_energy = get_current_energy()
+        perp = dev.dcm_perp.read()["dcm_perp"]["value"]
+        ss_xicam_x = dev.ss_xicam_x.read()["ss_xicam_x"]["value"]
+        ss_xicam_y = dev.ss_xicam_y.read()["ss_xicam_y"]["value"]
+        f.write(f"{current_energy:.0f},{perp:.5g},{ss_xicam_x:.5g},{ss_xicam_y:.5g}\n")
+        f.close()
+
+
+def beam_centre_from_bsc():
+    """Compute the beam centre from the bsc_cam"""
+    y = dev.ss_xicam_x.read()["ss_xicam_x"]["value"]
+    x = dev.ss_xicam_y.read()["ss_xicam_y"]["value"]
+    beampos = {"xpos": x, "ypos": y}
+    print(f"X is {x: .4g}, Y is {y: .4g}")
+    return beampos
+
+
+def generate_dcm_lut(start_energy=26500, end_energy=30500, step=500):
+    """Generate a lookup table for the dcm from start_energy to end_energy in steps of step"""
+    now = datetime.now()
+    fnow = now.strftime("%d%m%H%M")
+    filename = f"luts/{fnow}_lut.csv"
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write("energy,harmonic,gap,pitch,roll,perp,ss_xicam_x,ss_xicam_y\n")
+
+    for energy in range(start_energy, end_energy, step):
+        print(f"Moving to {energy: .0f}eV")
+        bl_energy(energy, mono_scan=False)
+        scan_gap()
+        mono_pitch_scan()
+        gap = dev.id_gap.read()["id_gap"]["value"]
+        harm = Gap()
+        h = harm.get_harmonic_by_energy(energy)
+        pitch = dev.dcm_pitch.read()["dcm_pitch"]["value"]
+        roll = dev.dcm_froll.read()["dcm_froll"]["value"]
+        perp = dev.dcm_perp.read()["dcm_perp"]["value"]
+        auto_exposure(cam="ss_xicam", max_iter=25)
+        x = dev.ss_xicam_x.read()["ss_xicam_x"]["value"]
+        y = dev.ss_xicam_y.read()["ss_xicam_y"]["value"]
+        with open(filename, "a", encoding="utf-8") as f:
+            f.write(
+                f"{energy:.0f},{h},{gap:.5g},{pitch:.5g},{roll:.4g},{perp:.5g},{x:.4g},{y:.4g}\n"
+            )
+    umv(dev.id_gap, 20.0)
+
+
+def write_lut():
+    """Write DCM parameters to file"""
+    filename = "luts/manual_big.csv"
+    energy = get_current_energy()
+    mono_pitch_scan()
+    roll_scan_to_target()
+    gap = dev.id_gap.read()["id_gap"]["value"]
+    pitch = dev.dcm_pitch.read()["dcm_pitch"]["value"]
+    roll = dev.dcm_froll.read()["dcm_froll"]["value"]
+    perp = dev.dcm_perp.read()["dcm_perp"]["value"]
+    x = dev.ss_xicam_x.read()["ss_xicam_x"]["value"]
+    y = dev.ss_xicam_y.read()["ss_xicam_y"]["value"]
+    with open(filename, "a", encoding="utf-8") as f:
+        f.write(f"{energy:.0f},{gap:.5g},{pitch:.5g},{roll:.4g},{perp:.5g},{x:.4g},{y:.4g}\n")
+
+
+def measure_beamsize(cam="samcam"):
+    auto_exposure("samcam", max_iter=20)
+    a = dev.samcam_xsig.read()["samcam_xsig"]["value"]
+    b = dev.samcam_ysig.read()["samcam_ysig"]["value"]
+    zoom = dev.scam_zoom.read()["scam_zoom"]["value"]
+    sx = calc_scam_microns(a, zoom=zoom) * 2.35
+    sy = calc_scam_microns(b, zoom=zoom) * 2.35
+    print(f"FWHM in um : {sx, sy}")
+    return sx, sy
+
+
+def write_beamsize():
+    """Write beam size and flux to file"""
+    filename = "luts/beamsizes.csv"
+    with open(filename, "a", encoding="utf-8") as f:
+        f.write("lens_config,size_x,size_y,i1\n")
+    lens_config = input("Which lenses are in?")
+    if SE.scin.checkpos:
+        filters("out")
+        sx, sy = measure_beamsize()
+    else:
+        scin("in")
+        filters("out")
+        sx, sy = measure_beamsize()
+    i1_reading = i1()
+    with open(filename, "a", encoding="utf-8") as f:
+        f.write(f"{lens_config},{sx:.4g},{sy:.4g},{i1_reading:.4g}\n")
+
+
+def beamsize(size):
+    """WIP to dial up different beam sizes"""
+    # Set mirror trans and pitch to default settings for 12.4 keV
+    # vlaues from a 2025
+    # umv(dev.vfm_vert,2.136)
+    # umv(dev.vfm_pitch, 2.695)
+    # umv(dev.hfm_lat, 1.64)
+    # umv(dev.hfm_pitch, 2.9844)
+    umv(dev.vfm_vert, 2.5301)
+    umv(dev.vfm_pitch, 2.60)
+    umv(dev.hfm_lat, 1.6586)
+    umv(dev.hfm_pitch, 2.9964)
+    print(f"changing beam size to {size}")
+
+    # values = {"xs": {"vbu": -0.9095, "vbd": -1.246, "hbu": -2.9375, "hbd": -5.698},
+    #           "s": {"vbu": -0.8365, "vbd": -1.22, "hbu": -2.804, "hbd": -5.473},
+    #           "m": {"vbu": -0.7865, "vbd": -1.17, "hbu": -2.604, "hbd": -5.273},
+    #           "l": {"vbu": -0.7459, "vbd": -1.13, "hbu": -2.504, "hbd": -5.173}}
+    # values = {"xs": {"vbu": -0.9095, "vbd": -1.246, "hbu": -2.8075, "hbd": -5.668},
+    #           "s": {"vbu": -0.8606, "vbd": -1.195, "hbu": -2.6975, "hbd": -5.5585},
+    #           "m": {"vbu": -0.8410, "vbd": -1.465, "hbu": -2.5575, "hbd": -5.418},
+    #           "l": {"vbu": -0.762, "vbd": -1.094, "hbu": -2.4582, "hbd": -5.3187}}
+    values = {
+        "xs": {"vbu": -0.741, "vbd": -1.206, "hbu": -2.869, "hbd": -5.819},
+        "s": {"vbu": -0.7101, "vbd": -1.176, "hbu": -2.7133, "hbd": -5.5535},
+        "m": {"vbu": -0.6601, "vbd": -1.126, "hbu": -2.5133, "hbd": -5.3535},
+        "l": {"vbu": -0.6196, "vbd": -1.086, "hbu": -2.4133, "hbd": -5.2535},
+    }
+    umv(
+        dev.vfm_bu,
+        values[size]["vbu"],
+        dev.vfm_bd,
+        values[size]["vbd"],
+        dev.hfm_bu,
+        values[size]["hbu"],
+        dev.hfm_bd,
+        values[size]["hbd"],
+    )
+    print("Setting camera exposure time")
+    auto_exposure()
+    xsig = dev.samcam_xsig.read()["samcam_xsig"]["value"]
+    ysig = dev.samcam_ysig.read()["samcam_ysig"]["value"]
+    print(f"Beam has Xsigma = {xsig:.3g}, Ysigma = {ysig:.3g}")
+
+    # if size == 'm':
+    #     move_to_x()
+    #     print(f"Beam has Xsigma = {xsig:.3g}, Ysigma = {ysig:.3g}")
+    #     return
+    # if size == 'l':
+    #     move_to_x()
+    #     move_to_y()
+    #     umv(dev.hfm_pitch, 2.9684)
+    #     print(f"Beam has Xsigma = {xsig:.3g}, Ysigma = {ysig:.3g}")
+    #     return
+    # else:
+    #     move_to_x()
+    #     move_to_y()
+    #     print(f"Beam has Xsigma = {xsig:.3g}, Ysigma = {ysig:.3g}")
+
+
+def scan_Ge():
+    scanbefore = 30  # eV
+    scanafter = 30  # eV
+    stepsize = 0.5  # eV
+    edge_Ge = 11103.1  # eV
+
+    scanstart = edge_Ge + scanafter
+    scanend = edge_Ge - scanbefore
+    bragg_start = convert_from_energy(scanstart)["bragg_angle_mrad"]
+    bragg_end = convert_from_energy(scanend)["bragg_angle_mrad"]
+    stepnumber = abs(int((scanend - scanstart) / stepsize))
+
+    print(f"Changing energy to {scanstart}")
+    # bl_energy(scanstart)
+    # scan_gap()
+    umv(dev.bsc_f4_x, 6)  # Put Ge filter in place
+    print(f"scanning from {bragg_start} to {bragg_end} with {stepnumber} steps")
+    s = scans.line_scan(dev.dcm_bragg, bragg_start, bragg_end, steps=stepnumber, relative=False)
+    print(s)
+    umv(dev.bsc_f4_x, 2)
+
+
+def cal_samcam_fixed_x():
+    lat = dev.hfm_lat.read()["hfm_lat"]["value"]
+    pitch = dev.hfm_pitch.read()["hfm_pitch"]["value"]
+    scanpoints = np.linspace(lat - 0.1, lat + 0.1, 7)
+    zoom_high = 800
+    zoom_low = 200
+    highs, lows = [], []
+    high_lat, low_lat = [], []
+
+    # high zoom
+    umv(dev.scam_zoom, zoom_high)
+    auto_exposure("samcam")
+    for i in scanpoints:
+        umv(dev.hfm_lat, i)
+        umv(dev.hfm_pitch, pitch)
+        time.sleep(0.2)
+        high_y = dev.samcam_x.read()["samcam_x"]["value"]
+        high_x = dev.hfm_lat.read()["hfm_lat"]["value"]
+        print(f"Xpos at zoom {zoom_high} is {high_y}")
+        highs.append(high_y)
+        high_lat.append(high_x)
+
+    umv(dev.scam_zoom, zoom_low)
+    auto_exposure("samcam")
+    for i in scanpoints:
+        umv(dev.hfm_lat, i)
+        umv(dev.hfm_pitch, pitch)
+        time.sleep(0.2)
+        low_y = dev.samcam_x.read()["samcam_x"]["value"]
+        low_x = dev.hfm_lat.read()["hfm_lat"]["value"]
+        print(f"Xpos at zoom {zoom_low} is {low_y}")
+        lows.append(low_y)
+        low_lat.append(low_x)
+
+    umv(dev.hfm_lat, lat)
+    umv(dev.hfm_pitch, 2.9844)
+
+    # Convert to numpy arrays
+    x_high = np.array(high_lat)
+    x_low = np.array(low_lat)
+    y_high = np.array(highs)
+    y_low = np.array(lows)
+
+    # Fit linear models: y = m*x + b
+    m_high, b_high = np.polyfit(x_high, y_high, 1)
+    m_low, b_low = np.polyfit(x_low, y_low, 1)
+
+    # Intersection point
+    x_intersect = (b_low - b_high) / (m_high - m_low)
+    y_intersect = m_high * x_intersect + b_high
+
+    print(f"\nIntersection at:")
+    print(f"  HFM_lat = {x_intersect:.5f}")
+    print(f"  SamCam_x = {y_intersect:.2f}")
+
+    # --- Plot ---
+    plt.figure(figsize=(7, 5))
+    plt.scatter(x_high, y_high, color="red", label=f"Zoom = {zoom_high} data")
+    plt.scatter(x_low, y_low, color="blue", label=f"Zoom = {zoom_low} data")
+
+    x_fit = np.linspace(min(x_high), max(x_high), 100)
+    plt.plot(x_fit, m_high * x_fit + b_high, "r--", label=f"Fit: Zoom {zoom_high}")
+    plt.plot(x_fit, m_low * x_fit + b_low, "b--", label=f"Fit: Zoom {zoom_low}")
+
+    plt.scatter(x_intersect, y_intersect, color="green", s=80, zorder=5, label="Intersection")
+
+    plt.xlabel("HFM Lat Position")
+    plt.ylabel("SamCam X")
+    plt.title("Zoom Calibration")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+
+def cal_samcam_fixed_y():
+    vert = dev.vfm_vert.read()["vfm_vert"]["value"]
+    pitch = dev.vfm_pitch.read()["vfm_pitch"]["value"]
+    scanpoints = np.linspace(vert - 0.1, vert + 0.1, 7)
+    zoom_high = 800
+    zoom_low = 200
+    highs, lows = [], []
+    high_vert, low_vert = [], []
+
+    # high zoom
+    umv(dev.scam_zoom, zoom_high)
+    auto_exposure("samcam")
+    for i in scanpoints:
+        umv(dev.vfm_vert, i)
+        umv(dev.vfm_pitch, pitch)
+        time.sleep(0.2)
+        high_y = dev.samcam_y.read()["samcam_y"]["value"]
+        high_x = dev.vfm_vert.read()["vfm_vert"]["value"]
+        print(f"Ypos at zoom {zoom_high} is {high_y}")
+        highs.append(high_y)
+        high_vert.append(high_x)
+
+    umv(dev.scam_zoom, zoom_low)
+    auto_exposure("samcam")
+    for i in scanpoints:
+        umv(dev.vfm_vert, i)
+        umv(dev.vfm_pitch, pitch)
+        time.sleep(0.2)
+        low_y = dev.samcam_y.read()["samcam_y"]["value"]
+        low_x = dev.vfm_vert.read()["vfm_vert"]["value"]
+        print(f"Ypos at zoom {zoom_low} is {low_y}")
+        lows.append(low_y)
+        low_vert.append(low_x)
+
+    umv(dev.vfm_vert, vert)
+    umv(dev.vfm_pitch, pitch)
+
+    # Convert to numpy arrays
+    x_high = np.array(high_vert)
+    x_low = np.array(low_vert)
+    y_high = np.array(highs)
+    y_low = np.array(lows)
+
+    # Fit linear models: y = m*x + b
+    m_high, b_high = np.polyfit(x_high, y_high, 1)
+    m_low, b_low = np.polyfit(x_low, y_low, 1)
+
+    # Intersection point
+    x_intersect = (b_low - b_high) / (m_high - m_low)
+    y_intersect = m_high * x_intersect + b_high
+
+    print(f"\nIntersection at:")
+    print(f"  VFM_vert = {x_intersect:.5f}")
+    print(f"  SamCam_y = {y_intersect:.2f}")
+
+    # --- Plot ---
+    plt.figure(figsize=(7, 5))
+    plt.scatter(x_high, y_high, color="red", label=f"Zoom = {zoom_high} data")
+    plt.scatter(x_low, y_low, color="blue", label=f"Zoom = {zoom_low} data")
+
+    x_fit = np.linspace(min(x_high), max(x_high), 100)
+    plt.plot(x_fit, m_high * x_fit + b_high, "r--", label=f"Fit: Zoom {zoom_high}")
+    plt.plot(x_fit, m_low * x_fit + b_low, "b--", label=f"Fit: Zoom {zoom_low}")
+
+    plt.scatter(x_intersect, y_intersect, color="green", s=80, zorder=5, label="Intersection")
+
+    plt.xlabel("VFM Vert Position")
+    plt.ylabel("SamCam Y")
+    plt.title("Zoom Calibration")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+
+def correlate_froll():
+    x_correlation = []
+    y_correlation = []
+    scanpoints = np.linspace(0, 0.2, 10)
+    for pos in scanpoints:
+        umv(dev.dcm_froll, pos)
+        xpos, ypos = compute_pos()
+        x_correlation.append(xpos)
+        y_correlation.append(ypos)
+
+    x = np.array(scanpoints)
+    y1 = np.array(x_correlation)
+    y2 = np.array(y_correlation)
+
+    xslope, xint = np.polyfit(x, y1, 1)
+    yslope, yint = np.polyfit(x, y2, 1)
+
+    print(f"Fit for xpos is: y = {xslope}.x + {xint}")
+    print(f"Fit for ypos is: y = {yslope}.x + {yint}")
+
+    plt.figure(figsize=(7, 5))
+    # plt.scatter(x, y1, label='xpos')
+    plt.scatter(x, y2, label="beam y position", color="rebeccapurple")
+
+    x_fit = np.linspace(min(x), max(x), 100)
+    # plt.plot(x_fit, xslope*x_fit + xint, 'r--', label=f'y = {xslope}*x + {xint}')
+    plt.plot(
+        x_fit,
+        yslope * x_fit + yint,
+        "r--",
+        label=f"y = {yslope:.3g}*x + ({yint:.3g})",
+        color="lightcoral",
+    )
+    plt.xlabel("dcm fine roll (V)")
+    plt.ylabel("beam Y (from BCU BPM)")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+
+def correlate_fpitch():
+    x_correlation = []
+    y_correlation = []
+    scanpoints = np.linspace(0, 0.2, 10)
+    for pos in scanpoints:
+        umv(dev.dcm_fpitch, pos)
+        xpos, ypos = compute_pos()
+        x_correlation.append(xpos)
+        y_correlation.append(ypos)
+
+    x = np.array(scanpoints)
+    y1 = np.array(x_correlation)
+    y2 = np.array(y_correlation)
+
+    xslope, xint = np.polyfit(x, y1, 1)
+    yslope, yint = np.polyfit(x, y2, 1)
+
+    print(f"Fit for xpos is: y = {xslope}.x + {xint}")
+    print(f"Fit for ypos is: y = {yslope}.x + {yint}")
+
+    plt.figure(figsize=(7, 5))
+    # plt.scatter(x, y1, label='xpos')
+    plt.scatter(x, y1, label="beam x position", color="rebeccapurple")
+
+    x_fit = np.linspace(min(x), max(x), 100)
+    # plt.plot(x_fit, xslope*x_fit + xint, 'r--', label=f'y = {xslope}*x + {xint}')
+    plt.plot(
+        x_fit, xslope * x_fit + xint, label=f"y = {xslope:.3g}*x + ({xint:.3g})", color="lightcoral"
+    )
+    plt.xlabel("dcm fine pitch (V)")
+    plt.ylabel("beam X (from BCU BPM)")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+
+def correlate_hfm_lat():
+    x_correlation = []
+    lat = dev.hfm_lat.read()["hfm_lat"]["value"]
+    scanpoints = np.linspace(lat - 0.1, lat + 0.1, 10)
+    for pos in scanpoints:
+        umv(dev.hfm_lat, pos)
+        xpos, ypos = compute_pos()
+        x_correlation.append(xpos)
+    umv(dev.hfm_lat, lat)
+
+    x = np.array(scanpoints)
+    y1 = np.array(x_correlation)
+
+    xslope, xint = np.polyfit(x, y1, 1)
+
+    print(f"Fit for xpos is: y = {xslope}.x + {xint}")
+    plt.figure(figsize=(7, 5))
+    # plt.scatter(x, y1, label='xpos')
+    plt.scatter(x, y1, label="beam x position", color="rebeccapurple")
+
+    x_fit = np.linspace(min(x), max(x), 100)
+    # plt.plot(x_fit, xslope*x_fit + xint, 'r--', label=f'y = {xslope}*x + {xint}')
+    plt.plot(
+        x_fit, xslope * x_fit + xint, label=f"y = {xslope:.5g}*x + ({xint:.5g})", color="lightcoral"
+    )
+    plt.xlabel("HFM lateral (mm)")
+    plt.ylabel("beam X (from BCU BPM)")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+
+def correlate_vfm_vert():
+    y_correlation = []
+    vert = dev.vfm_vert.read()["vfm_vert"]["value"]
+    scanpoints = np.linspace(vert - 0.06, vert + 0.06, 10)
+    for pos in scanpoints:
+        umv(dev.vfm_vert, pos)
+        xpos, ypos = compute_pos()
+        y_correlation.append(ypos)
+    umv(dev.vfm_vert, vert)
+
+    x = np.array(scanpoints)
+    y1 = np.array(y_correlation)
+
+    yslope, yint = np.polyfit(x, y1, 1)
+
+    print(f"Fit for xpos is: y = {yslope}.x + {yint}")
+    plt.figure(figsize=(7, 5))
+    # plt.scatter(x, y1, label='xpos')
+    plt.scatter(x, y1, label="beam y position", color="rebeccapurple")
+
+    x_fit = np.linspace(min(x), max(x), 100)
+    # plt.plot(x_fit, xslope*x_fit + xint, 'r--', label=f'y = {xslope}*x + {xint}')
+    plt.plot(
+        x_fit, yslope * x_fit + yint, label=f"y = {yslope:.5g}*x + ({yint:.5g})", color="lightcoral"
+    )
+    plt.xlabel("VFM vertical (mm)")
+    plt.ylabel("beam Y(from BCU BPM)")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+
+def correlate_hfm_pitch():
+    x_correlation = []
+    pitch = dev.hfm_pitch.read()["hfm_pitch"]["value"]
+    scanpoints = np.linspace(pitch - 0.05, pitch + 0.05, 10)
+    for pos in scanpoints:
+        umv(dev.hfm_pitch, pos)
+        xpos, ypos = compute_pos()
+        x_correlation.append(xpos)
+    umv(dev.hfm_pitch, pitch)
+
+    x = np.array(scanpoints)
+    y1 = np.array(x_correlation)
+
+    xslope, xint = np.polyfit(x, y1, 1)
+
+    print(f"Fit for xpos is: y = {xslope}.x + {xint}")
+    plt.figure(figsize=(7, 5))
+    # plt.scatter(x, y1, label='xpos')
+    plt.scatter(x, y1, label="beam x position", color="rebeccapurple")
+
+    x_fit = np.linspace(min(x), max(x), 100)
+    # plt.plot(x_fit, xslope*x_fit + xint, 'r--', label=f'y = {xslope}*x + {xint}')
+    plt.plot(
+        x_fit, xslope * x_fit + xint, label=f"y = {xslope:.5g}*x + ({xint:.5g})", color="lightcoral"
+    )
+    plt.xlabel("HFM Pitch (mm)")
+    plt.ylabel("beam X (from BCU BPM)")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+
+def move_to_x(targetx=0.13):
+    # Calibration and drift compensation
+    # target from previous run was 0.1465
+    slope = -1.004
+    intercept = 1.793
+
+    xpos, ypos = compute_pos()
+
+    beam_drift = xpos - targetx  # beam moved +0.1 mm (100 µm)
+    mot_current = dev.hfm_lat.read()["hfm_lat"]["value"]  # current motor position (example)
+
+    # Compute correction
+    delta = -beam_drift / slope
+    mot_new = mot_current + delta
+    umv(dev.hfm_lat, mot_new)
+
+
+def move_to_y(targety=-0.033):
+    # Calibration and drift compensation
+    # target from previous run = -0.283
+    slope = -1.2779
+    intercept = 2.4374
+
+    xpos, ypos = compute_pos()
+
+    beam_drift = ypos - targety  # beam moved +0.1 mm (100 µm)
+    mot_current = dev.vfm_vert.read()["vfm_vert"]["value"]  # current motor position (example)
+
+    # Compute correction
+    delta = -beam_drift / slope
+    mot_new = mot_current + delta
+    umv(dev.vfm_vert, mot_new)
+
+
+from epics import caget, caput
+import time
+
+
+def auto_exposure(
+    cam="samcam", target=200, tol=5, gain=0.9, min_exp=0.00001, max_exp=0.2, max_iter=10
+):
+    """
+    Adjust camera exposure time to reach a target max pixel value.
+
+    Parameters
+    ----------
+    target : float
+        Desired MaxValue (counts)
+    tol : float
+        Acceptable deviation from target
+    min_exp, max_exp : float
+        Exposure time limits (s)
+    max_iter : int
+        Maximum number of adjustment iterations
+    """
+    if cam == "samcam":
+        exposure = dev.samcam_exp.read()["samcam_exp"]["value"]
+    else:
+        exposure = dev.ss_xicam_exp.read()["ss_xicam_exp"]["value"]
+
+    print(f"Starting exposure = {exposure:.4f} s")
+
+    for i in range(max_iter):
+        time.sleep(0.1)  # allow a frame or two to update
+        if cam == "samcam":
+            maxval = dev.samcam_max.read()["samcam_max"]["value"]
+            if maxval is None:
+                print("No reading — check camera.")
+                break
+        if cam == "ss_xicam":
+            maxval = dev.ss_xicam_max.read()["ss_xicam_max"]["value"]
+            if maxval is None:
+                print("No reading — check camera.")
+                break
+
+        error = target - maxval
+        # print(f"Iter {i+1}: MaxValue = {maxval:.1f}, error = {error:.1f}")
+
+        # stop if within tolerance
+        if abs(error) <= tol:
+            # print(f"Target reached (MaxValue={maxval:.1f}) after {i+1} iterations.")
+            break
+
+        # proportional correction (simple gain control)
+        gain_setting = gain  # moderate response
+        new_exp = exposure * (1 + gain_setting * error / target)
+
+        # limit exposure bounds
+        new_exp = max(min_exp, min(max_exp, new_exp))
+
+        # update camera        perp = dev.dcm_perp.read()["dcm_perp"]["value"]
+        y = dev.ss_xicam_x.read()["ss_xicam_x"]["value"]
+        x = dev.ss_xicam_y.read()["ss_xicam_y"]["value"]
+        if cam == "samcam":
+            dev.samcam_exp.put(new_exp)
+            print(f" → Adjusting exposure to {new_exp:.4f} s")
+        else:
+            dev.ss_xicam_exp.put(new_exp)
+            print(f" → Adjusting exposure to {new_exp:.4f} s")
+
+        exposure = new_exp
+
+    print(f"New exposure time is {exposure:.3g}")
+    return exposure
+
+
+def get_new_beamsizes(mirror):
+    filename = f"luts/{mirror}_size.csv"
+    if mirror == "hfm":
+        bu = dev.hfm_bu
+        bd = dev.hfm_bd
+        step = 0.2
+    else:
+        bu = dev.vfm_bu
+        bd = dev.vfm_bd
+        step = 0.05
+    beamsize("xs")
+    move_targetx_with_hfm_lat()
+    move_targety_with_vfm_vert()
+    with open(filename, "w") as f:
+        for _ in range(4):
+            curr_bu = bu.user_readback.get()
+            curr_bd = bd.user_readback.get()
+            auto_exposure()
+            umv(bu, curr_bu + step)
+            umv(bd, curr_bd + step)
+            move_targetx_with_hfm_lat()
+            move_targety_with_vfm_vert()
+            xpos = dev.samcam_x.read()["samcam_x"]["value"]
+            ypos = dev.samcam_y.read()["samcam_y"]["value"]
+            xsig = dev.samcam_xsig.read()["samcam_xsig"]["value"]
+            ysig = dev.samcam_ysig.read()["samcam_ysig"]["value"]
+            f.write(f"{curr_bu}, {curr_bd}, {xpos}, {ypos}, {xsig}, {ysig}\n")
+            print(f"{curr_bu}, {curr_bd}, {xpos}, {ypos}, {xsig}, {ysig}")
+
+
+def filters(pos="out"):
+    if pos == "out":
+        umv(dev.bsc_f1_x, 2.0, dev.bsc_f2_x, 2.0, dev.bsc_f3_x, 12.0, dev.bsc_f4_x, 8.0)
+        if SE.scin.checkpos():
+            auto_exposure(cam="samcam", max_iter=20)
+    else:
+        umv(dev.bsc_f1_x, 2.0, dev.bsc_f2_x, 2.0, dev.bsc_f3_x, 8.0, dev.bsc_f4_x, 8.0)
+        if SE.scin.checkpos():
+            auto_exposure(cam="samcam", max_iter=20)
+
+
+def energy_vs_height(start_energy=11000, end_energy=25000, step=1000):
+    """Correlate beam height with energy from start_energy to end_energy in steps of step"""
+    now = datetime.now()
+    # fnow = now.strftime("%d%m%H%M_")
+    fnow = now.strftime("%Y-%m-%d-%H%M")
+    filename = f"luts/{fnow}_energy-height-ss.csv"
+    with open(filename, "w", encoding="utf-8") as f:
+        # f.write("energy,bcu_norm_y,bcu_y,samcam_ypix,samcam_y\n")
+        f.write("energy,y_px,diffy_mic\n")
+
+    for energy in range(start_energy, end_energy, step):
+        print(f"Moving to {energy: .0f}eV")
+        bl_energy(energy)
+        # scan_gap()
+        # mono_pitch_scan()
+        # scan_slits("s3",x=False,y=True)
+        # height = dev.s3_ycen.read()["s3_ycen"]["value"]
+        # bcu_norm_y = compute_norm()[1]
+        # bcu_y = compute_pos()[1]
+        # auto_exposure(cam="samcam", target=200)
+        # samcam_ypix, samcam_y = calc_from_centre()
+        # with open(filename, "a", encoding="utf-8") as f:
+        #     f.write(f"{energy:.0f},{bcu_norm_y:.4g},{bcu_y:.4g},{samcam_ypix:.5g},{samcam_y:.4g}\n")
+
+        auto_exposure(cam="ss_xicam", target=200, max_iter=25)
+        time.sleep(0.5)
+        ypx, diffm = calc_from_centre("ss_xicam")
+        # pitch = dev.dcm_pitch.read()['dcm_pitch']['value']
+
+        with open(filename, "a", encoding="utf-8") as f:
+            f.write(f"{energy:.0f},{ypx:.4g},{diffm:.4g}\n")
+    # umv(dev.id_gap, 20.0)
+
+
+@dataclass
+class SlitParameters:
+    small: float
+    large: float
+    scanwidth: float
+    steps: any
+    x_size: any
+    x_cen: any
+    y_size: any
+    y_cen: any
+    mon: any
+
+
+# Generic scan function
+def scan_slits(name="s1", x=True, y=True):
+    # Define parameters for all slits
+    s1_params = SlitParameters(
+        small=0.075,
+        large=2.5,
+        scanwidth=2.5,
+        steps=40,
+        x_size=dev.s1_xsize,
+        y_size=dev.s1_ysize,
+        x_cen=dev.s1_xcen,
+        y_cen=dev.s1_ycen,
+        mon=dev.lu_bpmsum,
+    )
+    s2_params = SlitParameters(
+        small=0.075,
+        large=3.0,
+        scanwidth=2.5,
+        steps=50,
+        x_size=dev.s2_xsize,
+        y_size=dev.s2_ysize,
+        x_cen=dev.s2_xcen,
+        y_cen=dev.s2_ycen,
+        mon=dev.bcu_bpmsum,
+    )
+    s3_params = SlitParameters(
+        small=0.05,
+        large=0.5,
+        scanwidth=0.7,
+        steps=50,
+        x_size=dev.s3_xsize,
+        y_size=dev.s3_ysize,
+        x_cen=dev.s3_xcen,
+        y_cen=dev.s3_ycen,
+        mon=dev.i1,
+    )
+
+    # Map slit names to their parameters
+    slit_parameters = {"s1": s1_params, "s2": s2_params, "s3": s3_params}
+
+    if name not in slit_parameters:
+        raise ValueError(f"Unknown slit name: {name}")
+
+    params = slit_parameters[name]
+    print("Moving filters out")
+    filters("out")
+
+    print("Moving i1 diode into position")
+    SE.i1.mvin()
+
+    if x and y:
+        scan_in_x(
+            xsize=params.x_size,
+            xcen=params.x_cen,
+            mon=params.mon,
+            small=params.small,
+            large=params.large,
+            width=params.scanwidth,
+            steps=params.steps,
+        )
+        scan_in_y(
+            ysize=params.y_size,
+            ycen=params.y_cen,
+            mon=params.mon,
+            small=params.small,
+            large=params.large,
+            width=params.scanwidth,
+            steps=params.steps,
+        )
+    if x and not y:
+        scan_in_x(
+            xsize=params.x_size,
+            xcen=params.x_cen,
+            mon=params.mon,
+            small=params.small,
+            large=params.large,
+            width=params.scanwidth,
+            steps=params.steps,
+        )
+    else:
+        scan_in_y(
+            ysize=params.y_size,
+            ycen=params.y_cen,
+            mon=params.mon,
+            small=params.small,
+            large=params.large,
+            width=params.scanwidth,
+            steps=params.steps,
+        )
+
+    filters("in")
+
+
+def scan_in_x(xsize, xcen, mon, small, large, width, steps):
+    umv(xsize, small)
+    go_to_peak(xcen, mon, -(width * 0.5), (width * 0.5), steps=steps, relative=False)
+    umv(xsize, large)
+
+
+def scan_in_y(ysize, ycen, mon, small, large, width, steps):
+    umv(ysize, small)
+    go_to_peak(ycen, mon, -(width * 0.5), (width * 0.5), steps=steps, relative=True, confirm=False)
+    umv(ysize, large)
+
+
+def trans_fils(inc):
+    x1 = dev.bsc_f1_x.read()["bsc_f1_x"]["value"]
+    x2 = dev.bsc_f2_x.read()["bsc_f2_x"]["value"]
+    x3 = dev.bsc_f3_x.read()["bsc_f3_x"]["value"]
+    x4 = dev.bsc_f4_x.read()["bsc_f4_x"]["value"]
+    umv(
+        dev.bsc_f1_x,
+        x1 + inc,
+        dev.bsc_f2_x,
+        x2 + inc,
+        dev.bsc_f3_x,
+        x3 + inc,
+        dev.bsc_f4_x,
+        x4 + inc,
+    )
+
+
+def calc_from_centre(cam="samcam"):
+    if cam == "samcam":
+        read = dev.samcam_y.read()["samcam_y"]["value"]
+        diff = 1092 - read
+        diff_px = calc_scam_microns(diff, zoom=1000)
+        return read, float(diff_px)
+    else:
+        read = dev.ss_xicam_y.read()["ss_xicam_y"]["value"]
+        diff = 140 - read
+        diff_px = calc_ss_xicam_microns(diff)
+        return read, diff_px
+
+
+def get_cam():
+    umv(dev.scam_zoom, 100)
+    x = dev.samcam_x.read()["samcam_x"]["value"]
+    y = dev.samcam_y.read()["samcam_y"]["value"]
+    print(f"Low zoom: x = {x}, y = {y}")
+    umv(dev.scam_zoom, 500)
+    x = dev.samcam_x.read()["samcam_x"]["value"]
+    y = dev.samcam_y.read()["samcam_y"]["value"]
+    print(f"High zoom: x = {x}, y = {y}")
+
+
+def read_currents():
+    """Read the individual bpm channels"""
+    bpm1 = dev.bcu_bpm1.read()["bcu_bpm1"]["value"]
+    bpm2 = dev.bcu_bpm2.read()["bcu_bpm2"]["value"]
+    bpm3 = dev.bcu_bpm3.read()["bcu_bpm3"]["value"]
+    bpm4 = dev.bcu_bpm4.read()["bcu_bpm4"]["value"]
+    # print(f"bpm1 = {bpm1:.3f}, bpm2 = {bpm2:.3f}, bpm3 = {bpm3:.3f}, bpm4 = {bpm4:.3f}")
+    return {"bpm1": bpm1, "bpm2": bpm2, "bpm3": bpm3, "bpm4": bpm4}
+
+
+def compute_norm():
+    """Compute normalised x and y positions"""
+    readings = read_currents()
+    total = readings["bpm1"] + readings["bpm2"] + readings["bpm3"] + readings["bpm4"]
+    # print(f"Sum is {total:.2f}")
+    xn = ((readings["bpm1"] + readings["bpm2"]) - (readings["bpm3"] + readings["bpm4"])) / total
+    yn = ((readings["bpm1"] + readings["bpm3"]) - (readings["bpm2"] + readings["bpm4"])) / total
+    return xn, yn
+
+
+# def vfm_pscan():
+#     start_pitch = 3.0
+#     scan_width = 0.03
+#     start_vfm_y = -0.7
+#     vfm_y = dev.vfm_y.read()['vfm_y']['value']
+#     name = f"VFM-{vfm_y:.3g}"
+#     bpmsum, y = [], []
+
+# scanpoints = np.linspace((start_pitch-scan_width), (start_pitch+scan_width), 20)
+# umv(dev.vfm_y, start_vfm_y)
+# for repeat in range(0,8):
+#     filename = f"./luts/pitch{name}.csv"
+#     with open(filename, "w") as f:
+#         f.write("BCUsum, BCU-Y\n")
+#         for i in scanpoints:
+#             umv(dev.vfm_pitch,i)
+#             time.sleep(0.2)
+#             bcu = dev.bcu_bpmsum.read()['bcu_bpmsum']['value']
+#             xn, yn = compute_norm()
+#             bpmsum.append(bcu)
+#             ypos = y.append(yn)
+#             with open(filename, "a") as f:
+#                 f.write(f"{i:.4g},{bcu:.4g},{yn:.4g}\n")
+#     umv(dev.vfm_pitch,start_pitch)
+#     sum_array = np.array(bpmsum)
+#     y_array = np.array(y)
+# # --- Plot ---
+# plt.figure(figsize=(7,5))
+# plt.plot(scanpoints, sum_array, color='red', label=f'BCU bpmsum')
+# plt.xlabel('VFM pitch')
+# plt.ylabel('BCU')
+# plt.title(f"{name}")
+# plt.legend()
+# plt.grid(True)
+# plt.tight_layout()
+# plt.savefig(f"luts/{name}_sum.png")
+# # plt.show()
+# plt.figure(figsize=(7,5))
+# plt.plot(scanpoints, y_array, color='blue', label=f'BCU Y')
+# plt.xlabel('VFM pitch')
+# plt.ylabel('BCU')
+# plt.title(f"{name}")
+# plt.legend()
+# plt.grid(True)
+# plt.tight_layout()
+# plt.savefig(f"luts/{name}_y.png")
+# # plt.show()
+
+
+def hfm_pscan2():
+
+    # -----------------------
+    # Settings
+    # -----------------------
+    start_pitch = 3.0
+    pitch_width = 0.03
+    n_pitch = 15
+
+    start_hfm_x = 1.5
+    hfm_x_width = 0.2
+    n_hfm_x = 7
+
+    settle = 0.2
+
+    output_dir = "./luts"
+    os.makedirs(output_dir, exist_ok=True)
+
+    # -----------------------
+    # Save initial positions
+    # -----------------------
+    initial_pitch = dev.hfm_pitch.read()["hfm_pitch"]["value"]
+    initial_hfmx = dev.hfm_x.read()["hfm_x"]["value"]
+
+    # -----------------------
+    # Scan points
+    # -----------------------
+    pitch_points = np.linspace(start_pitch - pitch_width, start_pitch + pitch_width, n_pitch)
+
+    hfmx_points = np.linspace(start_hfm_x - hfm_x_width, start_hfm_x + hfm_x_width, n_hfm_x)
+
+    summary = []
+
+    # -----------------------
+    # Loop over hFM X
+    # -----------------------
+    for hfmx in hfmx_points:
+
+        print(f"\nScanning HFM X = {hfmx:.4f}")
+
+        umv(dev.hfm_x, hfmx)
+        time.sleep(settle)
+
+        bpmsum = []
+
+        name = f"HFMX_{hfmx:.4f}"
+
+        csvfile = os.path.join(output_dir, f"{name}.csv")
+
+        with open(csvfile, "w") as f:
+
+            f.write("pitch,bpmsum,bpmsum_std\n")
+
+            for pitch in pitch_points:
+
+                umv(dev.hfm_pitch, pitch)
+                time.sleep(settle)
+
+                # Average several BPM readings
+                vals = []
+                for _ in range(5):
+                    vals.append(dev.bcu_bpmsum.read()["bcu_bpmsum"]["value"])
+                    time.sleep(0.1)
+
+                bcu = np.mean(vals)
+                bcu_std = np.std(vals)
+
+                bpmsum.append(bcu)
+
+                f.write(f"{pitch:.6f},{bcu:.6f}, {bcu_std:.6f}\n")
+
+        # Return pitch to nominal
+        umv(dev.hfm_pitch, start_pitch)
+
+        bpmsum = np.array(bpmsum)
+
+        # Find maximum transmission
+        imax = np.argmax(bpmsum)
+
+        pitch_peak = pitch_points[imax]
+        sum_peak = bpmsum[imax]
+
+        summary.append([hfmx, pitch_peak, sum_peak])
+
+        print(f"Peak pitch = {pitch_peak:.5f}, " f"Max BPM sum = {sum_peak:.1f}")
+
+        # Plot this pitch scan
+        plt.figure(figsize=(7, 5))
+
+        plt.plot(pitch_points, bpmsum, marker="o")
+
+        plt.axvline(pitch_peak, linestyle="--", label=f"Peak = {pitch_peak:.5f}")
+
+        plt.xlabel("HFM pitch")
+        plt.ylabel("BPM sum")
+        plt.title(name)
+
+        plt.grid(True)
+        plt.legend()
+        plt.tight_layout()
+
+        plt.savefig(os.path.join(output_dir, f"{name}.png"))
+
+        plt.close()
+
+    # -----------------------
+    # Summary analysis
+    # -----------------------
+    summary = np.array(summary)
+
+    hfmx = summary[:, 0]
+    pitch_peak = summary[:, 1]
+    sum_peak = summary[:, 2]
+
+    # Save summary CSV
+    summary_file = os.path.join(output_dir, "hfm_summary.csv")
+
+    with open(summary_file, "w") as f:
+
+        f.write("hfmx,pitch_peak,sum_peak\n")
+
+        for row in summary:
+            f.write(",".join(f"{x:.6f}" for x in row) + "\n")
+
+    # -----------------------
+    # Summary plots
+    # -----------------------
+
+    plt.figure(figsize=(7, 5))
+
+    plt.plot(hfmx, sum_peak, marker="o")
+
+    plt.xlabel("HFM X")
+    plt.ylabel("Maximum BPM sum")
+    plt.title("Transmission vs HFM X")
+
+    plt.grid(True)
+    plt.tight_layout()
+
+    plt.savefig(os.path.join(output_dir, "summary_sum_vs_hfmx.png"))
+
+    plt.close()
+
+    plt.figure(figsize=(7, 5))
+
+    plt.plot(hfmx, pitch_peak, marker="o")
+
+    plt.xlabel("HFM X")
+    plt.ylabel("Pitch at maximum transmission")
+    plt.title("Optimum pitch vs HFM X")
+
+    plt.grid(True)
+    plt.tight_layout()
+
+    plt.savefig(os.path.join(output_dir, "summary_pitch_vs_hfmx.png"))
+
+    plt.close()
+
+    # -----------------------
+    # Find best HFM X
+    # -----------------------
+    ibest = np.argmax(sum_peak)
+
+    best_vfmy = hfmx[ibest]
+    best_pitch = pitch_peak[ibest]
+
+    print("\nBest alignment:")
+    print(f"HFM X     = {best_hfmx:.5f}")
+    print(f"HFM pitch = {best_pitch:.5f}")
+
+    # Move to optimum
+    umv(dev.hfm_x, best_hfmx)
+    umv(dev.hfm_pitch, best_pitch)
+
+    print("\nMoved mirrors to optimum values.")
+
+    return summary
+
+
+def vfm_pscan():
+
+    # -------------------------------
+    # User settings
+    # -------------------------------
+    start_pitch = 3.0  # nominal pitch
+    pitch_width = 0.03  # +/- pitch scan range
+    n_pitch = 20
+
+    start_vfm_y = -0.900  # nominal VFM Y
+    vfm_y_width = 0.05  # +/- VFM Y scan range
+    n_vfm_y = 8
+
+    settle_time = 0.2
+
+    output_dir = "./luts"
+    os.makedirs(output_dir, exist_ok=True)
+
+    # -------------------------------
+    # Save initial positions
+    # -------------------------------
+    initial_pitch = dev.vfm_pitch.read()["vfm_pitch"]["value"]
+    initial_vfm_y = dev.vfm_y.read()["vfm_y"]["value"]
+
+    # -------------------------------
+    # Generate scan points
+    # -------------------------------
+    pitch_points = np.linspace(start_pitch - pitch_width, start_pitch + pitch_width, n_pitch)
+
+    vfm_y_points = np.linspace(start_vfm_y - vfm_y_width, start_vfm_y + vfm_y_width, n_vfm_y)
+
+    summary = []
+
+    # -------------------------------
+    # Loop over VFM Y
+    # -------------------------------
+    for vfm_y in vfm_y_points:
+
+        print(f"\nScanning VFM Y = {vfm_y:.4f}")
+
+        umv(dev.vfm_y, vfm_y)
+        time.sleep(settle_time)
+
+        bpmsum = []
+        bpm_y = []
+
+        name = f"VFMY_{vfm_y:.4f}"
+
+        csvfile = os.path.join(output_dir, f"{name}.csv")
+
+        with open(csvfile, "w") as f:
+
+            f.write("pitch,bpmsum,bpm_y\n")
+
+            # -------------------------------
+            # Pitch scan
+            # -------------------------------
+            for pitch in pitch_points:
+
+                umv(dev.vfm_pitch, pitch)
+                time.sleep(settle_time)
+
+                bcu = dev.bcu_bpmsum.read()["bcu_bpmsum"]["value"]
+
+                xn, yn = compute_norm()
+
+                bpmsum.append(bcu)
+                bpm_y.append(yn)
+
+                f.write(f"{pitch:.6f},{bcu:.6f},{yn:.6f}\n")
+
+        # Return pitch to nominal
+        umv(dev.vfm_pitch, start_pitch)
+
+        # Convert to arrays
+        bpmsum = np.array(bpmsum)
+        bpm_y = np.array(bpm_y)
+
+        # -------------------------------
+        # Find optimum pitch
+        # -------------------------------
+        imax = np.argmax(bpmsum)
+
+        pitch_peak = pitch_points[imax]
+        sum_peak = bpmsum[imax]
+        y_peak = bpm_y[imax]
+
+        summary.append([vfm_y, pitch_peak, sum_peak, y_peak])
+
+        print(f"Peak at pitch={pitch_peak:.5f}, " f"BPM sum={sum_peak:.1f}, " f"BPM Y={y_peak:.4f}")
+
+        # -------------------------------
+        # Plot BPM sum
+        # -------------------------------
+        plt.figure(figsize=(7, 5))
+
+        plt.plot(pitch_points, bpmsum, marker="o")
+
+        plt.axvline(pitch_peak, linestyle="--")
+
+        plt.xlabel("VFM pitch")
+        plt.ylabel("BCU BPM sum")
+        plt.title(name)
+
+        plt.grid(True)
+        plt.tight_layout()
+
+        plt.savefig(os.path.join(output_dir, f"{name}_sum.png"))
+
+        plt.close()
+
+        # -------------------------------
+        # Plot BPM Y
+        # -------------------------------
+        plt.figure(figsize=(7, 5))
+
+        plt.plot(pitch_points, bpm_y, marker="o")
+
+        plt.axvline(pitch_peak, linestyle="--")
+
+        plt.xlabel("VFM pitch")
+        plt.ylabel("BCU BPM Y")
+        plt.title(name)
+
+        plt.grid(True)
+        plt.tight_layout()
+
+        plt.savefig(os.path.join(output_dir, f"{name}_y.png"))
+
+        plt.close()
+
+    # -------------------------------
+    # Summary arrays
+    # -------------------------------
+    summary = np.array(summary)
+
+    vfm_y_vals = summary[:, 0]
+    pitch_peaks = summary[:, 1]
+    sum_peaks = summary[:, 2]
+    y_peaks = summary[:, 3]
+
+    # Save summary CSV
+    summary_file = os.path.join(output_dir, "vfm_summary.csv")
+
+    with open(summary_file, "w") as f:
+
+        f.write("vfm_y,pitch_peak,sum_peak,bpm_y_peak\n")
+
+        for row in summary:
+            f.write(",".join(f"{x:.6f}" for x in row) + "\n")
+
+    # -------------------------------
+    # Summary plots
+    # -------------------------------
+
+    plt.figure(figsize=(7, 5))
+    plt.plot(vfm_y_vals, pitch_peaks, marker="o")
+
+    plt.xlabel("VFM Y")
+    plt.ylabel("Pitch at max BPM sum")
+    plt.title("Optimum pitch vs VFM Y")
+
+    plt.grid(True)
+    plt.tight_layout()
+
+    plt.savefig(os.path.join(output_dir, "summary_pitch_vs_vfmy.png"))
+
+    plt.close()
+
+    plt.figure(figsize=(7, 5))
+    plt.plot(vfm_y_vals, sum_peaks, marker="o")
+
+    plt.xlabel("VFM Y")
+    plt.ylabel("Maximum BPM sum")
+    plt.title("Maximum transmission vs VFM Y")
+
+    plt.grid(True)
+    plt.tight_layout()
+
+    plt.savefig(os.path.join(output_dir, "summary_sum_vs_vfmy.png"))
+
+    plt.close()
+
+    plt.figure(figsize=(7, 5))
+    plt.plot(vfm_y_vals, y_peaks, marker="o")
+
+    plt.xlabel("VFM Y")
+    plt.ylabel("BPM Y at optimum pitch")
+    plt.title("Beam position vs VFM Y")
+
+    plt.grid(True)
+    plt.tight_layout()
+
+    plt.savefig(os.path.join(output_dir, "summary_bpmy_vs_vfmy.png"))
+
+    plt.close()
+
+    # -------------------------------
+    # Restore original positions
+    # -------------------------------
+    umv(dev.vfm_pitch, initial_pitch)
+    umv(dev.vfm_y, initial_vfm_y)
+
+    print("\nScan complete.")
+    print(f"Summary written to {summary_file}")
+
+    return summary
+
+
+def find_best_roll(low=6000, high=20000):
+    low_scanpoints = np.linspace(0.5, 5.5, 11)
+    high_scanpoints = np.linspace(1.0, 9.0, 9)
+    highs_y, lows_y = [], []
+
+    # low energy
+    bl_energy(low)
+    energy = get_current_energy()
+    filename = f"./luts/roll_{energy:.0f}.csv"
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write("Roll, Y pos\n")
+    auto_exposure("bsccam", max_iter=25)
+    for i in low_scanpoints:
+        umv(dev.dcm_froll, i)
+        time.sleep(0.2)
+        low_y = dev.bsccam_y.read()["bsccam_y"]["value"]
+        print(f"Ypos at BSC cam is {low_y}")
+        lows_y.append(low_y)
+        with open(filename, "a", encoding="utf-8") as f:
+            f.write(f"{i:.4g},{low_y:.4g} \n")
+
+    # high energy
+    bl_energy(high)
+    energy = get_current_energy()
+    if 19999 < energy < 200001:
+        umv(dev.id_gap, 4.718)
+    filename = f"./luts/roll_{energy:.0f}.csv"
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write("Roll, Y pos\n")
+    auto_exposure("bsccam", max_iter=25)
+    for i in high_scanpoints:
+        umv(dev.dcm_froll, i)
+        time.sleep(0.2)
+        high_y = dev.bsccam_y.read()["bsccam_y"]["value"]
+        print(f"Ypos at BSC cam is {high_y}")
+        highs_y.append(high_y)
+        with open(filename, "a", encoding="utf-8") as f:
+            f.write(f"{i:.4g},{low_y:4g.} \n")
+
+    y_high = np.array(highs_y)
+    y_low = np.array(lows_y)
+
+    # # Fit linear models: y = m*x + b
+    m_high, b_high = np.polyfit(high_scanpoints, y_high, 1)
+    m_low, b_low = np.polyfit(low_scanpoints, y_low, 1)
+
+    # # Intersection point
+    x_intersect = (b_low - b_high) / (m_high - m_low)
+    y_intersect = m_high * x_intersect + b_high
+
+    print(f"\nIntersection at:")
+    print(f"  DCM Roll = {x_intersect:.5f}")
+    print(f"  BSCcam Y = {y_intersect:.2f}")
+
+    # # --- Plot ---
+    plt.figure(figsize=(7, 5))
+    plt.scatter(high_scanpoints, y_high, color="red", label=f"High energy")
+    plt.scatter(low_scanpoints, y_low, color="blue", label=f"Low energy")
+
+    x_fit = np.linspace(min(high_scanpoints), max(high_scanpoints), 100)
+    plt.plot(x_fit, m_high * x_fit + b_high, "r--", label=f"High energy")
+    plt.plot(x_fit, m_low * x_fit + b_low, "b--", label=f"Low energy")
+
+    plt.scatter(x_intersect, y_intersect, color="green", s=80, zorder=5, label="Intersection")
+
+    plt.xlabel("DCM fine roll")
+    plt.ylabel("BSCcam Y pos")
+    plt.title("Roll Calibration")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
diff --git a/pxii_bec/macros/policies.py b/pxii_bec/macros/policies.py
index 576edae..cea388c 100755
--- a/pxii_bec/macros/policies.py
+++ b/pxii_bec/macros/policies.py
@@ -58,15 +58,16 @@ def make_diag_y_policy(d):
     def diag_y_policy(target):
         cfg = d["diag_y"].positions
         # Don't move in if the goniometer is in
-        if d["aerotech_x"].actual >= d['aerotech_x'].positions['in'] and target > cfg["out"]:
+        if d["aerotech_x"].actual >= d["aerotech_x"].positions["in"] and target > cfg["out"]:
             raise GuardViolation(
                 f"Diagnostic device cannot move beyond {cfg['out']} mm when goniometer is not OUT"
             )
         # Don't move if cryocooler is in
-        if d['cryo_pos'].pos == 'in' and target > cfg['out']:
+        if d["cryo_pos"].pos == "in" and target > cfg["out"]:
             raise GuardViolation(
                 f"Diagnostic device cannot move beyond {cfg['out']} mm when cryocooler is IN"
             )
+
     return diag_y_policy
 
 
diff --git a/pxii_bec/macros/pxii_energy.py b/pxii_bec/macros/pxii_energy.py
index f72d25c..3b40325 100755
--- a/pxii_bec/macros/pxii_energy.py
+++ b/pxii_bec/macros/pxii_energy.py
@@ -85,7 +85,7 @@ def mono_pitch_scan(plot=True):
     energy = get_current_energy()
     pos = get_dcm_motors_positions(energy)
     print(f"Setting DCM Pitch to default value of {pos['dcm_pitch']}")
-    scans.umv(EnergyDefaults.mono_pitch, pos["dcm_pitch"], relative=False)
+    # scans.umv(EnergyDefaults.mono_pitch, pos["dcm_pitch"], relative=False)
     # Go to peak using default parameters from EnergyDefaults
     if plot:
         print("Scanning monochromator pitch and moving to peak, with plotting.")
@@ -118,7 +118,7 @@ def mono_pitch_scan(plot=True):
 # Specific functions - need to be edited for each beamline
 
 
-def move_gap_if_needed(energy_ev, move_gap=False):
+def move_gap_if_needed(energy_ev, move_gap=True):
     """
     Move the gap position based on energy if the move_gap flag is set.
 
@@ -163,7 +163,7 @@ def get_dcm_motors_positions(energy_ev):
     # dcm_motor_values = get_value_from_lut(energy_ev)
     dcm_motor_values = {}
     # pitch = float(np.poly1d(Calibration.pitch)(energy_ev))
-    pitch = -5.304
+    pitch = -5.5
     roll = EnergyDefaults.mono_roll_value
     perp = calc_perp_position(energy_ev, print_result=False)
     bragg_angle = convert_from_energy(energy_ev, print_result=False)["bragg_angle_mrad"]
@@ -183,8 +183,8 @@ def move_dcm_motors(energy_ev):
     print(
         f"Moving DCM bragg: {dcm_pos['bragg_angle']: .5g} mrad, "
         f"DCM perp: {dcm_pos['perp']: .3g} mm, "
-        f"DCM pitch fixed at -5.304 mrad, "
-        # f"DCM pitch: {dcm_pos['dcm_pitch']: .5g} mrad, "
+        # f"DCM pitch fixed at -5.304 mrad, "
+        f"DCM pitch: {dcm_pos['dcm_pitch']: .5g} mrad, "
         f"DCM Roll: {dcm_pos['dcm_roll']:.5g} V"
     )
     # umv(EnergyDefaults.energy, dcm_pos["bragg_angle"])
@@ -205,7 +205,7 @@ def move_dcm_motors(energy_ev):
     )
 
 
-def bl_energy(energy_ev, move_gap=False, mono_scan=True, plot=True):
+def bl_energy(energy_ev, move_gap=True, mono_scan=True, plot=True):
     """
     Adjusts the beamline's energy to the specified energy in electron volts (eV).
     The function validates the target energy, checks the current energy, and makes
diff --git a/pxii_bec/macros/pxii_parameters.py b/pxii_bec/macros/pxii_parameters.py
index 856b685..5a1f2d7 100755
--- a/pxii_bec/macros/pxii_parameters.py
+++ b/pxii_bec/macros/pxii_parameters.py
@@ -4,7 +4,6 @@ from dataclasses import dataclass
 import numpy as np
 
 
-
 @dataclass(frozen=True)
 class EnergyDefaults:
     """Parameters for PXII energy changes"""
@@ -37,13 +36,15 @@ class Gap:
     """Fit parameters to calculate gap from harmonics"""
 
     harmonics = {
-        "H3": np.array([9.15e-04, 4.49e-01]),
-        "H5": np.array([5.19e-04, 7.149e-01]),
-        "H7": np.array([3.57694643e-04, 8.73775476e-01]),
-        "H9": np.array([2.76335714e-04, 8.98471905e-01]),
-        "H11": np.array([2.2225e-04, 9.582e-01]),
-        "H13": np.array([1.9e-4, 9.262e-01]),
-        "H15": np.array([1.67e-4, 8.83e-01]),
+        "H3": np.array([9.409e-04, 2.797e-01]),
+        "H5": np.array([5.097e-04, 8.065e-01]),
+        "H7": np.array([3.623e-04, 8.252e-01]),
+        "H9": np.array([2.795e-04, 8.595e-01]),
+        "H11": np.array([2.309e-04, 8.167e-01]),
+        "H13": np.array([1.928e-04, 8.748e-01]),
+        "H15": np.array([1.67e-04, 8.743e-01]),
+        "H17": np.array([1.484e-04, 8.546e-01]),
+        "H19": np.array([1.275e-04, 1.0085]),
     }
     # Define harmonic ranges as a constant
     harmonic_ranges = {
@@ -53,7 +54,9 @@ class Gap:
         "H9": (13000, 16000),
         "H11": (16000, 19000),
         "H13": (19000, 22000),
-        "H15": (22000, float("inf")),
+        "H15": (22000, 25000),
+        "H17": (25000, 27500),
+        "H19": (27500, float("inf")),
     }
 
     @staticmethod
@@ -122,17 +125,17 @@ class CamConversion:
 class BPMScans:
     """Define the names of the motors and bpm channels"""
 
-    fe = {
-        "x_name": dev.fe_bpm_x.name,
-        "y_name": dev.fe_bpm_y.name,
-        "z1_name": dev.fe_bpm1.name,
-        "z2_name": dev.fe_bpm2.name,
-        "z3_name": dev.fe_bpm3.name,
-        "z4_name": dev.fe_bpm3.name,
-        "z5_name": dev.fe_bpmsum.name,
-        "x_device": dev.fe_bpm_x,
-        "y_device": dev.fe_bpm_y,
-    }
+    # fe = {
+    #     "x_name": dev.fe_bpm_x.name,
+    #     "y_name": dev.fe_bpm_y.name,
+    #     "z1_name": dev.fe_bpm1.name,
+    #     "z2_name": dev.fe_bpm2.name,
+    #     "z3_name": dev.fe_bpm3.name,
+    #     "z4_name": dev.fe_bpm3.name,
+    #     "z5_name": dev.fe_bpmsum.name,
+    #     "x_device": dev.fe_bpm_x,
+    #     "y_device": dev.fe_bpm_y,
+    # }
     lu = {
         "x_name": dev.lu_bpm_x.name,
         "y_name": dev.lu_bpm_y.name,
@@ -186,5 +189,3 @@ class BPMScans:
 #         "x_device": dev.vfm_bu,
 #         "y_device": dev.vfm_bd,
 #     }
-
-
diff --git a/pxii_bec/macros/pxii_parameters_version_120526.txt b/pxii_bec/macros/pxii_parameters_version_120526.txt
deleted file mode 100755
index 7f3f761..0000000
--- a/pxii_bec/macros/pxii_parameters_version_120526.txt
+++ /dev/null
@@ -1,338 +0,0 @@
-"""File to store beamline parameters and defaults"""
-
-from dataclasses import dataclass
-from typing import Callable
-import numpy as np
-import yaml
-
-
-
-
-@dataclass(frozen=True)
-class EnergyDefaults:
-    """Parameters for PXII energy changes"""
-
-    min_energy_change = 1
-    min_energy_ev = 4800
-    max_energy_ev = 30002
-    beam_offset = 6
-    signals = {"sig1": dev.lu_bpmsum, "sig2": dev.bsc_bpmsum, "sig3": dev.bcu_bpmsum}
-    energy = dev.dcm_bragg
-    mono_pitch = dev.dcm_pitch
-    mono_perp = dev.dcm_perp
-    mono_roll = dev.dcm_froll
-    mono_roll_value = 4.65
-    LUT_table = "luts/energy_lut.csv"
-    stripe_thresholds = {"silicon": 9000, "rhodium": 20000, "platinum": 40000}
-    pitch_scan = {"halfwidth": 0.075, "steps": 20}
-
-
-@dataclass(frozen=True)
-class Calibration:
-    """Calibration parameters for PXII optics"""
-
-    pitch = np.array([4.61823701e-14, -1.97330772e-09, 2.89694543e-05, -5.34468669e00])
-    roll = np.array([2.28291039e-03, -2.41928101e01])
-
-
-@dataclass(frozen=True)
-class Gap:
-    """Fit parameters to calculate gap from harmonics"""
-
-    harmonics = {
-        "H3": np.array([9.15e-04, 4.49e-01]),
-        "H5": np.array([5.19e-04, 7.149e-01]),
-        "H7": np.array([3.57694643e-04, 8.73775476e-01]),
-        "H9": np.array([2.76335714e-04, 8.98471905e-01]),
-        "H11": np.array([2.2225e-04, 9.582e-01]),
-        "H13": np.array([1.9e-4, 9.262e-01]),
-        "H15": np.array([1.67e-4, 8.83e-01]),
-    }
-    # Define harmonic ranges as a constant
-    harmonic_ranges = {
-        "H3": (4900, 7000),
-        "H5": (7000, 10000),
-        "H7": (10000, 13000),
-        "H9": (13000, 16000),
-        "H11": (16000, 19000),
-        "H13": (19000, 22000),
-        "H15": (22000, float("inf")),
-    }
-
-    @staticmethod
-    def get_harmonic_by_energy(energy_ev: float):
-        """
-        Determines the harmonic key based on the provided energy.
-
-        Args:
-            energy_ev (float): The energy value (eV).
-
-        Returns:
-            Optional[str]: The harmonic name (e.g., 'H3', 'H7')
-            if the range matches, None otherwise.
-        """
-        for harmonic, (low, high) in Gap.harmonic_ranges.items():
-            if low < energy_ev <= high:
-                return harmonic
-        return None
-
-    def get_harmonic_values(self, energy_ev: float):
-        """
-        Retrieves the harmonic array based on the energy value.
-
-        Args:
-            energy_ev (float): The energy value (eV).
-
-        Returns:
-            Optional[np.array]: The corresponding array of harmonic values
-            if the range matches, None otherwise.
-        """
-        harmonic = self.get_harmonic_by_energy(energy_ev)
-        return self.harmonics.get(harmonic) if harmonic else None
-
-
-@dataclass(frozen=True)
-class Harmonics:
-    """Anuschka's harmonics data for PXII U19 Undulator"""
-
-    min_gap_value = 4.5
-    map = {
-        3: np.array([1.07141725, -0.52834258]),
-        4: np.array([0.007111, -0.13678409, 1.52295567, -1.06882785]),
-        5: np.array([0.00315051, -0.0766359, 1.13107469, -0.86442062]),
-        6: np.array([0.00162862, -0.04452336, 0.82948259, -0.37329674]),
-        7: np.array([0.00080764, -0.02418882, 0.59212947, 0.15702886]),
-        8: np.array([1.16699242e-03, -4.68207543e-02, 9.43972396e-01, -1.94201019e00]),
-        9: np.array([0.00048419, -0.02010648, 0.55514114, -0.38180067]),
-        10: np.array([2.11583333e-04, -8.03503571e-03, 3.43141595e-01, 6.02318000e-01]),
-        11: np.array([0.00334392, -0.18405336, 3.58338994, -19.3640241]),
-        12: np.array([3.20520798e-05, 2.39253145e-03, 8.09198503e-02, 2.22897377e00]),
-        13: np.array([0.00278744, 0.07979874, 2.05143916]),
-    }
-    energy_ranges = {3: (0, 7), 5: (7, 10), 7: (10, 13), 9: (13, 16), 11: (16, 19), 13: (19, 22)}
-    high_energy = [(15, (23, 25)), (17, (25, 29)), (19, (29, float("inf")))]
-
-
-@dataclass(frozen=True)
-class CamConversion:
-    """Convert pixels to microns for sam cam"""
-
-    a = 0.5208
-    b = 0.002586
-
-
-@dataclass(frozen=True)
-class BPMScans:
-    """Define the names of the motors and bpm channels"""
-
-    fe = {
-        "x_name": dev.fe_bpm_x.name,
-        "y_name": dev.fe_bpm_y.name,
-        "z1_name": dev.fe_bpm1.name,
-        "z2_name": dev.fe_bpm2.name,
-        "z3_name": dev.fe_bpm3.name,
-        "z4_name": dev.fe_bpm3.name,
-        "z5_name": dev.fe_bpmsum.name,
-        "x_device": dev.fe_bpm_x,
-        "y_device": dev.fe_bpm_y,
-    }
-    lu = {
-        "x_name": dev.lu_bpm_x.name,
-        "y_name": dev.lu_bpm_y.name,
-        "z1_name": dev.lu_bpm1.name,
-        "z2_name": dev.lu_bpm2.name,
-        "z3_name": dev.lu_bpm3.name,
-        "z4_name": dev.lu_bpm4.name,
-        "z5_name": dev.lu_bpmsum.name,
-        "x_device": dev.lu_bpm_x,
-        "y_device": dev.lu_bpm_y,
-    }
-    bsc = {
-        "x_name": dev.bsc_bpm_x.name,
-        "y_name": dev.bsc_bpm_y.name,
-        "z1_name": dev.bsc_bpm1.name,
-        "z2_name": dev.bsc_bpm2.name,
-        "z3_name": dev.bsc_bpm3.name,
-        "z4_name": dev.bsc_bpm4.name,
-        "z5_name": dev.bsc_bpmsum.name,
-        "x_device": dev.bsc_bpm_x,
-        "y_device": dev.bsc_bpm_y,
-    }
-    bcu = {
-        "x_name": dev.bcu_bpm_x.name,
-        "y_name": dev.bcu_bpm_y.name,
-        "z1_name": dev.bcu_bpm1.name,
-        "z2_name": dev.bcu_bpm2.name,
-        "z3_name": dev.bcu_bpm3.name,
-        "z4_name": dev.bcu_bpm4.name,
-        "z5_name": dev.bcu_bpmsum.name,
-        "x_device": dev.bcu_bpm_x,
-        "y_device": dev.bcu_bpm_y,
-    }
-
-
-@dataclass(frozen=True)
-class MirrorConfig:
-    """Define the names of the mirror channels"""
-
-    hfm = {
-        "bu_name": dev.hfm_bu.name,
-        "bd_name": dev.hfm_bd.name,
-        "z_name": dev.samcam_xsig.name,
-        "x_device": dev.hfm_bu,
-        "y_device": dev.hfm_bd,
-    }
-    vfm = {
-        "bu_name": dev.vfm_bu.name,
-        "bd_name": dev.vfm_bd.name,
-        "z_name": dev.samcam_ysig.name,
-        "x_device": dev.vfm_bu,
-        "y_device": dev.vfm_bd,
-    }
-
-
-@dataclass
-class PositionedDevice:
-    """Class for devices with defined in and out positions"""
-
-    device_name: str
-    type: str
-    name: str
-    inpos: float
-    outpos: float
-    tol: float
-    mot: str
-    reader: Callable[[], float]
-
-    @property
-    def actual(self):
-        """Returns current motor position"""
-        return self.reader()
-
-    def checkin(self):
-        """Returns True if motor in in the 'in' position"""
-        return abs(self.actual - self.inpos) <= self.tol
-
-    def mvin(self):
-        """Moves motor to the 'in' position"""
-        scans.umv(self.mot, self.inpos, relative=False)
-
-    def mvout(self):
-        """Moves motor to the 'out' position"""
-        scans.umv(self.mot, self.outpos, relative=False)
-    
-    def status(self):
-        """ Check if device is in or out or moving"""
-        positions = ("in", "out", "moving", "undefined")
-        target_in = self.inpos
-        target_out = self.outpos
-        actual = self.actual
-        delta_in = actual - target_in
-        delta_out = actual - target_out
-        # Check if motor is moving
-        if "Signal" in self.type:
-            moving = 0
-        elif "Motor" in self.type:
-            d = getattr(dev, self.device_name)
-            moving = d.motor_is_moving.get()
-            if moving:
-                pos = positions[2]
-                return {"position": pos.upper(),
-                        "name": self.name,
-                        "moving": moving}
-
-        if abs(delta_in) > self.tol and abs(delta_out) > self.tol:
-            pos = positions[3]
-            return {"position": pos.upper(),
-                    "name": self.name,
-                    "actual": actual,
-                    "moving": moving}
- 
-        elif abs(delta_in) <= self.tol:
-            target = self.inpos
-            pos = positions[0]
-            delta = delta_in
-        elif abs(delta_out) <= self.tol:
-            target = self.outpos
-            pos = positions[1]
-            delta = delta_out
-
-        return {
-            "name": self.name,
-            "position": pos.upper(),
-            "target": target,
-            "actual": actual,
-            "delta": delta,
-            "tol": self.tol,
-            "moving": moving,
-        }
-    
-    def report(self):
-        """ Print status of motor """
-        s = self.status()
-
-        if s['position'] == "UNDEFINED":
-            return (f"{s['name']:15s}: "
-                f"{s['position']} "
-                f"position {s['actual']:.3f}")
-        elif s['position'] == "MOVING":
-                return (f"{s['name']:15s}: "
-                f"{s['position']} ") 
-        else:
-            return (
-                f"{s['name']:15s}: "
-                f"[{s['position']}] "
-                f"actual = {s['actual']:.3f} "
-                f"target = {s['target']:.3f} "
-                f"delta = {s['delta']:.3f}"
-            )
-
-
-
-@dataclass(frozen=True)
-class PD:
-    """Class for positioned device positions"""
-
-
-def build_pd(yaml_file):
-    """Takes the in and out values from the yaml file
-    and adds them to the PD class
-    """
-    with open(yaml_file, encoding="utf-8") as f:
-        data = yaml.safe_load(f)
-    for device_name, cfg in data.items():
-        # Skip devices without userParameter
-        user = cfg.get("userParameter")
-        if not user:
-            continue
-        # Set tolerance
-        if "tol" not in user:
-            user["tol"] = 0.01
-
-        try:
-            dev_obj = getattr(dev, device_name)
-        except:
-            raise KeyError(f"Device {device_name} not found in device list")
-        desc = cfg.get("description")
-        type = cfg.get("deviceClass")
-        target = PositionedDevice(
-            device_name=device_name,
-            type = type,
-            name=desc,
-            inpos=user["in"],
-            outpos=user["out"],
-            tol=user["tol"],
-            mot=dev_obj,
-            reader=lambda d=dev_obj, n=device_name: d.read()[n]["value"],
-        )
-
-        setattr(PD, device_name, target)
-
-
-def init_positioned_devices():
-    """Initialises the positioned devices"""
-    file = (
-        "/sls/x10sa/config/bec/production/pxii_bec/pxii_bec/device_configs/pxii-autogenerated.yaml"
-    )
-    build_pd(file)
-    print("Defined positions for devices have been updated from pxii-autogenerated.yaml")
diff --git a/pxii_bec/macros/test.py b/pxii_bec/macros/test.py
index 6461395..cc368dc 100755
--- a/pxii_bec/macros/test.py
+++ b/pxii_bec/macros/test.py
@@ -22,7 +22,7 @@ def state_test():
         current = random.choice(choices)
         print(f"Testing {current}")
         planner.move_to(current)
-        time.sleep(5)
+        time.sleep(2)
         tested_states.append(current.name)
         previous = current
     planner.move_to(BeamlineState.MANUAL_SAMPLE_EXCHANGE)