pxii_bec/bec_ipython_client/startup/post_startup.py

@@ -34,4 +34,4 @@ to setup the prompts.
 """
 
 # pylint: disable=invalid-name, unused-import, import-error, undefined-variable, unused-variable, unused-argument, no-name-in-module
-init_positioned_devices()
+d, planner = init_beamline_environment()

pxii_bec/device_configs/device_config.yaml

@@ -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

pxii_bec/device_configs/pxii-beamline-states.yaml

@@ -10,8 +10,14 @@ states:
     det_cov: 'close'
     diag_y: out
     fl_bright: 'off'
-    gon_x: in
-#    smargon: not implemented
+    aerotech_x: in
+    aerotech_y: mount
+    aerotech_z: mount
+    aerotech_u: mount
+    smargon_x: mount
+    smargon_y: mount
+    smargon_chi: mount
+    smargon_phi: mount
     xrf_pos: out
 
   sample_alignment:
@@ -25,8 +31,14 @@ states:
     det_cov: 'close'
     diag_y: out
     fl_bright: 'on'
-    gon_x: in
-  #    smargon: not implemented
+    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
 
   data_collection:
@@ -40,8 +52,14 @@ states:
     det_cov: 'open'
     diag_y: out
     fl_bright: 'on'
-    gon_x: in
-  #  smargon: not implemented
+    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
 
   DC_XRF:
@@ -55,9 +73,15 @@ states:
     det_cov: 'close'
     diag_y: out
     fl_bright: 'on'
-    gon_x: in
-    #    smargon: not implemented
-    xrf_pos: in
+    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
 
   manual_sample_exchange:
     allow_modifiers: true
@@ -70,8 +94,14 @@ states:
     det_cov: 'close'
     diag_y: park
     fl_bright: 'off'
-    gon_x: in
-    #    smargon: not implemented
+    aerotech_x: in
+    aerotech_y: mount
+    aerotech_z: mount
+    aerotech_u: mount
+    smargon_x: mount
+    smargon_y: mount
+    smargon_chi: mount
+    smargon_phi: mount
     xrf_pos: out
 
   beam_visualisation:
@@ -84,8 +114,14 @@ states:
     det_cov: 'close'
     diag_y: scint
     fl_bright: 'off'
-    gon_x: out
-  #    smargon: not implemented
+    aerotech_x: out
+    aerotech_y: mount
+    aerotech_z: mount
+    aerotech_u: mount
+    smargon_x: mount
+    smargon_y: mount
+    smargon_chi: mount
+    smargon_phi: mount    
     xrf_pos: out
 
   flux_measurement:
@@ -98,8 +134,14 @@ states:
     det_cov: 'close'
     diag_y: i1
     fl_bright: 'off'
-    gon_x: out
-    #    smargon: not implemented
+    aerotech_x: out
+    aerotech_y: mount
+    aerotech_z: mount
+    aerotech_u: mount
+    smargon_x: mount
+    smargon_y: mount
+    smargon_chi: mount
+    smargon_phi: mount
     xrf_pos: out
 
   beamstop_alignment:
@@ -112,8 +154,14 @@ states:
     det_cov: 'close'
     diag_y: out
     fl_bright: 'on'
-    gon_x: out
-    #    smargon: not implemented
+    aerotech_x: out
+    aerotech_y: mount
+    aerotech_z: mount
+    aerotech_u: mount
+    smargon_x: mount
+    smargon_y: mount
+    smargon_chi: mount
+    smargon_phi: mount
     xrf_pos: out
 
   maintenance:
@@ -127,8 +175,14 @@ states:
     det_cov: 'close'
     diag_y: park
     fl_bright: 'off'
-    gon_x: out
-    #    smargon: not implemented
+    aerotech_x: out
+    aerotech_y: mount
+    aerotech_z: mount
+    aerotech_u: mount
+    smargon_x: mount
+    smargon_y: mount
+    smargon_chi: mount
+    smargon_phi: mount
     xrf_pos: out
 
   xtal_snapshot:
@@ -142,8 +196,14 @@ states:
     det_cov: 'close'
     diag_y: out
     fl_bright: 'on'
-    gon_x: in
-    #    smargon: not implemented
+    # 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
 
 

pxii_bec/device_configs/pxii-devices-new.csv

@@ -1,169 +0,0 @@
-name,description,deviceClass,PV,readoutPriority,tag,readOnly,include,userParameter,
-sls_current,SLS current,SignalRO,ARS07-DPCT-0100:CURR,monitored,SLS,yes,yes,,
-fe_bpm1,FE XBPM Signal 1,SignalRO,X10SA-FE-XBPM1:Current1:MeanValue_RBV,monitored,bpm,yes,yes,,
-fe_bpm2,FE XBPM Signal 2,SignalRO,X10SA-FE-XBPM1:Current2:MeanValue_RBV,monitored,bpm,yes,yes,,
-fe_bpm3,FE XBPM Signal 3,SignalRO,X10SA-FE-XBPM1:Current3:MeanValue_RBV,monitored,bpm,yes,yes,,
-fe_bpm4,FE XBPM Signal 4,SignalRO,X10SA-FE-XBPM1:Current4:MeanValue_RBV,monitored,bpm,yes,yes,,
-fe_bpmsum,FE XBPM Summed,SignalRO,X10SA-FE-XBPM1:SumAll:MeanValue_RBV,monitored,bpm,yes,yes,,
-fe_bpm_x,FE BPM X,Motor,X10SA-FE-XBPM1:TRX,baseline,fe,no,yes,,
-fe_bpm_y,FE BPM Y,Motor,X10SA-FE-XBPM1:TRY,baseline,fe,no,yes,,
-fe_sl_xr,FE Slit X Ring,MotorEC,X10SA-FE-SL1:TRXR,baseline,fe,no,yes,,
-fe_sl_yt,FE Slit Y top,MotorEC,X10SA-FE-SL1:TRYT,baseline,fe,no,yes,,
-fe_sl_xw,FE Slit X Wall,MotorEC,X10SA-FE-SL1:TRXW,baseline,fe,no,yes,,
-fe_sl_yb,FE SlitY Bottom,MotorEC,X10SA-FE-SL1:TRYB,baseline,fe,no,yes,,
-fe_sl_xcen,FE Slit X Centre,MotorEC,X10SA-FE-SL1:CENTERX,baseline,fe,no,yes,,
-fe_sl_xsize,FE Slit X Size,MotorEC,X10SA-FE-SL1:SIZEX,baseline,fe,no,yes,,
-fe_sl_ycen,FE Slit Y Centre,MotorEC,X10SA-FE-SL1:CENTERY,baseline,fe,no,yes,,
-fe_sl_ysize,FE Slit Y Size,MotorEC,X10SA-FE-SL1:SIZEY,baseline,fe,no,yes,,
-bsf_bpm1,BSF BPM Signal 1,SignalRO,X10SA-OP-BSFBPM:SIGNAL1,monitored,bpm,yes,no,,
-bsf_bpm2,BSF BPM Signal 2,SignalRO,X10SA-OP-BSFBPM:SIGNAL2,monitored,bpm,yes,no,,
-bsf_bpm3,BSF BPM Signal 3,SignalRO,X10SA-OP-BSFBPM:SIGNAL3,monitored,bpm,yes,no,,
-bsf_bpm4,BSF BPM Signal 4,SignalRO,X10SA-OP-BSFBPM:SIGNAL4,monitored,bpm,yes,no,,
-bsf_bpmsum,BSF BPM Summed,SignalRO,X10SA-OP-BSFBPM:SUM,monitored,bpm,yes,no,,
-bsf_sl_xw,BSF slit outboard,MotorEC,X10SA-OP-BSFSLH:TRXW,baseline,bsf,no,yes,,
-bsf_sl_xr,BSF slit inboard,MotorEC,X10SA-OP-BSFSLH:TRXR,baseline,bsf,no,yes,,
-bsf_sl_yt,BSF slit top,MotorEC,X10SA-OP-BSFSLV:TRYT,baseline,bsf,no,yes,,
-bsf_sl_yb,BSF slit bottom,MotorEC,X10SA-OP-BSFSLV:TRYB,baseline,bsf,no,yes,,
-bsf_sl_xcen,BSF X centre,MotorEC,X10SA-OP-BSFSLH:CENTER,baseline,bsf,no,yes,,
-bsf_sl_xsize,BSF X size,MotorEC,X10SA-OP-BSFSLH:SIZE,baseline,bsf,no,yes,,
-bsf_sl_ycen,BSF Y centre,MotorEC,X10SA-OP-BSFSLV:CENTER,baseline,bsf,no,yes,,
-bsf_sl_ysize,BSF Y size,MotorEC,X10SA-OP-BSFSLV:SIZE,baseline,bsf,no,yes,,
-bsf_f1_y,BSF Filter 1 Y,MotorEC,X10SA-OP-BSFFI1:TRY,baseline,bsf,no,yes,,
-bsf_f2_y,BSF Filter 2 Y,MotorEC,X10SA-OP-BSFFI2:TRY,baseline,bsf,no,yes,,
-dcm_bragg,DCM Bragg angle,MotorEC,X10SA-OP-DCM:ROTY,baseline,dcm,no,yes,,
-dcm_x,DCM lateral,MotorEC,X10SA-OP-DCM:TRX,baseline,dcm,no,yes,,
-dcm_perp,DCM Perp,MotorEC,X10SA-OP-DCM:TRX-CR2,baseline,dcm,no,yes,,
-dcm_pitch,DCM 2nd crystal pitch,MotorEC,X10SA-OP-DCM:ROTY-CR2-PITCH,baseline,dcm,no,yes,,
-dcm_fpitch,DCM 2nd crystal fine pitch,MotorEC,X10SA-OP-DCM:ROTY-CR2-FINEPITCH,baseline,dcm,no,yes,,
-dcm_froll,DCM 2nd crystal fine roll,MotorEC,X10SA-OP-DCM:ROTZ-CR2-FINEROLL,baseline,dcm,no,yes,,
-lu_bpm1,LU BPM Signal 1,SignalRO,X10SA-OP-LUBPM:Current1:MeanValue_RBV,monitored,bpm,yes,yes,,
-lu_bpm2,LU BPM Signal 2,SignalRO,X10SA-OP-LUBPM:Current2:MeanValue_RBV,monitored,bpm,yes,yes,,
-lu_bpm3,LU BPM Signal 3,SignalRO,X10SA-OP-LUBPM:Current3:MeanValue_RBV,monitored,bpm,yes,yes,,
-lu_bpm4,LU BPM Signal 4,SignalRO,X10SA-OP-LUBPM:Current4:MeanValue_RBV,monitored,bpm,yes,yes,,
-lu_bpmsum,LU BPM Summed,SignalRO,X10SA-OP-LUBPM:SumAll:MeanValue_RBV,monitored,bpm,yes,yes,,
-lu_bpm_x,BPM2 X translation,Motor,X10SA-OP-LUBPM:TRX,baseline,lu,no,yes,,
-lu_bpm_y,BPM2 Y translation,Motor,X10SA-OP-LUBPM:TRY,baseline,lu,no,yes,,
-lu_z1,Lens Z1 Motion,Motor,X10SA-OP-LUTRZ1:TRZ,baseline,lu,no,yes,,
-lu_z2,Lens Z2 Motion,Motor,X10SA-OP-LUTRZ2:TRZ,baseline,lu,no,yes,,
-lu_pod1_x,SmarPod1 X,Motor,X10SA-OP-LUPOD1:TRX1,baseline,lu,no,no,,
-lu_lens1_x2,Lenses1 X,Motor,X10SA-OP-LUPOD1:TRX2,baseline,lu,no,no,,
-lu_pod1_y,SmarPod1 Y,Motor,X10SA-OP-LUPOD1:TRY,baseline,lu,no,yes,,
-lu_pod1_z,SmarPod1 Z,Motor,X10SA-OP-LUPOD1:TRZ,baseline,lu,no,yes,,
-lu_pod1_rotx,SmarPod1 RX,Motor,X10SA-OP-LUPOD1:ROTX,baseline,lu,no,yes,,
-lu_pod1_roty,SmarPod1 RY,Motor,X10SA-OP-LUPOD1:ROTY,baseline,lu,no,yes,,
-lu_pod1_rotz,SmarPod1 RZ,Motor,X10SA-OP-LUPOD1:ROTZ,baseline,lu,no,yes,,
-lu_pod2_x,SmarPod2 X,Motor,X10SA-OP-LUPOD2:TRX1,baseline,lu,no,no,,
-lu_lens2_x2,Lenses2 X,Motor,X10SA-OP-LUPOD2:TRX2,baseline,lu,no,no,,
-lu_pod2_y,SmarPod2 Y,Motor,X10SA-OP-LUPOD2:TRY,baseline,lu,no,yes,,
-lu_pod2_z,SmarPod2 Z,Motor,X10SA-OP-LUPOD2:TRZ,baseline,lu,no,yes,,
-lu_pod2_rotx,SmarPod2 RX,Motor,X10SA-OP-LUPOD2:ROTX,baseline,lu,no,yes,,
-lu_pod2_roty,SmarPod2 RY,Motor,X10SA-OP-LUPOD2:ROTY,baseline,lu,no,yes,,
-lu_pod2_rotz,SmarPod2 RZ,Motor,X10SA-OP-LUPOD2:ROTZ,baseline,lu,no,yes,,
-ss_bpm1,SS BPM Signal 1,SignalRO,X10SA-ES-SSBPM:Current1:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpm2,SS BPM Signal 2,SignalRO,X10SA-ES-SSBPM:Current2:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpm3,SS BPM Signal 3,SignalRO,X10SA-ES-SSBPM:Current3:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpm4,SS BPM Signal 4,SignalRO,X10SA-ES-SSBPM:Current4:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpmsum,SS BPM Summed,SignalRO,X10SA-ES-SSBPM:SumAll:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpm_x,SS BPM X,Motor,X10SA-ES-SSBPM:TRX,baseline,ss,no,yes,,
-ss_bpm_y,SS BPM Y,Motor,X10SA-ES-SSBPM:TRY,baseline,ss,no,yes,,
-ss_f1_x,SS Filter 1 X,Motor,X10SA-ES-SSFI1:TRX,baseline,ss,no,yes,,
-ss_f2_x,SS Filter 2 X,Motor,X10SA-ES-SSFI2:TRX,baseline,ss,no,yes,,
-ss_f3_x,SS Filter 2 X,Motor,X10SA-ES-SSFI3:TRX,baseline,ss,no,yes,,
-ss_f4_x,SS Filter 4 X,Motor,X10SA-ES-SSFI4:TRX,baseline,ss,no,yes,,
-ss_sl_xw,SS slit wall,Motor,X10SA-ES-SSSLH:TRXW,baseline,ss,no,yes,,
-ss_sl_xr,SS slit ring,Motor,X10SA-ES-SSSLH:TRXR,baseline,ss,no,yes,,
-ss_sl_xcen,SS slit X centre,Motor,X10SA-ES-SSSLH:CENTER,baseline,ss,no,yes,,
-ss_sl_xsize,SS slit X size,Motor,X10SA-ES-SSSLH:SIZE,baseline,ss,no,yes,,
-ss_sl_yt,SS slit top,Motor,X10SA-ES-SSSLV:TRYT,baseline,ss,no,yes,,
-ss_sl_yb,SS slit bottom,Motor,X10SA-ES-SSSLV:TRYB,baseline,ss,no,yes,,
-ss_sl_ycen,SS slit Y centre,Motor,X10SA-ES-SSSLV:CENTER,baseline,ss,no,yes,,
-ss_sl_ysize,SS slit Y size,Motor,X10SA-ES-SSSLV:SIZE,baseline,ss,no,yes,,
-ss_xi_x,SS X-ray eye X,Motor,X10SA-ES-SSXI:TRX,baseline,ss,no,yes,"{""type"": multi-position,""in"": 7.5, ""out"": -2.1}",
-ss_xi_y,SS X-ray eye Y,Motor,X10SA-ES-SSXI:TRY,baseline,ss,no,yes,,
-ss_xicam_x,ss cam X,SignalRO,X10SA-ES-SSXI:cam1:Stats5:CentroidX_RBV,baseline,ss,yes,no,,
-ss_xicam_y,ss cam Y,SignalRO,X10SA-ES-SSXI:cam1:Stats5:CentroidY_RBV,baseline,ss,yes,no,,
-ss_xicam_max,ss cam max value,SignalRO,X10SA-ES-SSXI:cam1:Stats5:MaxValue_RBV,monitored,ss,yes,no,,
-ss_xicam_exp,ss camera exposure,Signal,X10SA-ES-SSXI:cam1:AcquireTime,baseline,ss,no,no,,
-ss_xicam_gain,ss camera gain,Signal,X10SA-ES-SSXI:cam1:cam1:Gain,baseline,ss,no,no,,
-ss_xicam_xsig,ss camera  x sigma,Signal,X10SA-ES-SSXI:cam1:Stats5:SigmaX_RBV,baseline,ss,yes,no,,
-ss_xicam_ysig,ss camera y sigma,Signal,X10SA-ES-SSXI:cam1:Stats5:SigmaY_RBV,baseline,ss,yes,no,,
-vfm_xu,VFM Upstream X,MotorEC,X10SA-ES-KBV:TRXU,baseline,vfm,no,no,,
-vfm_xd,VFM Downstream X,MotorEC,X10SA-ES-KBV:TRXD,baseline,vfm,no,no,,
-vfm_yur,VFM Upstream Ring Y,MotorEC,X10SA-ES-KBV:TRYUR,baseline,vfm,no,no,,
-vfm_yw,VFM Wall Y,MotorEC,X10SA-ES-KBV:TRYW,baseline,vfm,no,no,,
-vfm_ydr,VFM Downstream Ring Y,MotorEC,X10SA-ES-KBV:TRYDR,baseline,vfm,no,no,,
-vfm_bu,VFM Upstream Bender,MotorEC,X10SA-ES-KBV:BNDU,baseline,vfm,no,no,,
-vfm_bd,VFM Downstream Bender,MotorEC,X10SA-ES-KBV:BNDD,baseline,vfm,no,no,,
-vfm_yaw,VFM Virtual Yaw,MotorEC,X10SA-ES-KBV:YAW,baseline,vfm,no,no,,
-vfm_roll,VFM Virtual Roll,MotorEC,X10SA-ES-KBV:ROLL,baseline,vfm,no,no,,
-vfm_pitch,VFM Virtual Pitch,MotorEC,X10SA-ES-KBV:PITCH,baseline,vfm,no,no,,
-vfm_x,VFM Virtual X,MotorEC,X10SA-ES-KBV:TRX,baseline,vfm,no,no,,
-vfm_y,VFM Virtual Y ,MotorEC,X10SA-ES-KBV:TRY,baseline,vfm,no,no,,
-hfm_xu,HFM Upstream X,MotorEC,X10SA-ES-KBH:TRXU,baseline,hfm,no,no,,
-hfm_xd,HFM Downstream X,MotorEC,X10SA-ES-KBH:TRXD,baseline,hfm,no,no,,
-hfm_yuw,HFM Upstream Wall Y,MotorEC,X10SA-ES-KBH:TRYUW,baseline,hfm,no,no,,
-hfm_yr,HFM Ring Y,MotorEC,X10SA-ES-KBH:TRYR,baseline,hfm,no,no,,
-hfm_ydw,HFM Downstream Wall Y,MotorEC,X10SA-ES-KBH:TRYDW,baseline,hfm,no,no,,
-hfm_bu,HFM Upstream Bender,MotorEC,X10SA-ES-KBH:BNDU,baseline,hfm,no,no,,
-hfm_bd,HFM Downstream Bender,MotorEC,X10SA-ES-KBH:BNDD,baseline,hfm,no,no,,
-hfm_yaw,HFM Virtual Yaw,MotorEC,X10SA-ES-KBH:YAW,baseline,hfm,no,no,,
-hfm_roll,HFM Virtual Roll,MotorEC,X10SA-ES-KBH:ROLL,baseline,hfm,no,no,,
-hfm_pitch,HFM Virtual Pitch,MotorEC,X10SA-ES-KBH:PITCH,baseline,hfm,no,no,,
-hfm_x,HFM Virtual X,MotorEC,X10SA-ES-KBH:TRX,baseline,hfm,no,no,,
-hfm_y,HFM Virtual Y ,MotorEC,X10SA-ES-KBH:TRY,baseline,hfm,no,no,,
-bcu_bpm1,BCU BPM Signal 1 ,SignalRO,X10SA-ES-BCBPM:Current1:MeanValue_RBV,monitored,bpm,yes,yes,,
-bcu_bpm2,BCU BPM Signal 2,SignalRO,X10SA-ES-BCBPM:Current2:MeanValue_RBV,monitored,bpm,yes,yes,,
-bcu_bpm3,BCU BPM Signal 3,SignalRO,X10SA-ES-BCBPM:Current3:MeanValue_RBV,monitored,bpm,yes,yes,,
-bcu_bpm4,BCU BPM Signal 4,SignalRO,X10SA-ES-BCBPM:Current4:MeanValue_RBV,monitored,bpm,yes,yes,,
-bcu_bpmsum,BCU BPM Summed,SignalRO,X10SA-ES-BCBPM:SumAll:MeanValue_RBV,monitored,bpm,yes,yes,,
-bcu_bpm_x,BCU BPM X,Motor,X10SA-ES-BCBPM:TRX,baseline,bcu,no,yes,,
-bcu_bpm_y,BCU BPM Y ,Motor,X10SA-ES-BCBPM:TRY,baseline,bcu,no,yes,,
-bcu_sl_xw,BCU slit wall,Motor,X10SA-ES-BCSLH:TRXW,baseline,bcu,no,no,,
-bcu_sl_xr,BCU slit ring,Motor,X10SA-ES-BCSLH:TRXR,baseline,bcu,no,no,,
-bcu_sl_xcen,BCU slit X centre,Motor,X10SA-ES-BCSLH:CENTER,baseline,bcu,no,no,,
-bcu_sl_xsize,BCU slit X size,Motor,X10SA-ES-BCSLH:SIZEX,baseline,bcu,no,no,,
-bcu_sl_yt,BCU slit top,Motor,X10SA-ES-BCSLV:TRYT,baseline,bcu,no,no,,
-bcu_sl_yb,BCU slit bottom,Motor,X10SA-ES-BCSLV:TRYB,baseline,bcu,no,no,,
-bcu_sl_ycen,BCU slit Y centre,Motor,X10SA-ES-BCSLV:CENTER,baseline,bcu,no,no,,
-bcu_sl_ysize,BCU slit Y size,Motor,X10SA-ES-BCSLV:SIZE,baseline,bcu,no,no,,
-xrf_pos,XRF det in/out,Signal,X10SA-ES-XRF:POS-SET,baseline,se,no,no,"{""type"":positioner}",
-samcam_x,sample cam X ,SignalRO,X10SA-ES-MS:Stats5:CentroidX_RBV,baseline,scam,yes,yes,,
-samcam_xsig,sample cam X sigma,SignalRO,X10SA-ES-MS:Stats5:SigmaX_RBV,monitored,scam,yes,yes,,
-samcam_y,sample cam Y ,SignalRO,X10SA-ES-MS:Stats5:CentroidY_RBV,baseline,scam,yes,yes,,
-samcam_ysig,sample cam Y sigma,SignalRO,X10SA-ES-MS:Stats5:SigmaY_RBV,monitored,scam,yes,yes,,
-samcam_max,sample cam max value,SignalRO,X10SA-ES-MS:Stats5:MaxValue_RBV,monitored,scam,yes,yes,,
-samcam_exp,sample cam exp time,Signal,X10SA-ES-MS:cam1:AcquireTime,baseline,scam,no,yes,,
-samcam_gain,sample cam gain,Signal,X10SA-ES-MS:cam1:Gain,baseline,scam,no,yes,,
-scam_zoom,Sample cam zoom,Motor,X10SA-ES-MS:ZOOM,baseline,scam,no,yes,,
-fl_bright,Frontlight brightness,Signal,X10SA-ES-FL:SET,baseline,se,no,no,,
-coll_x,Collimator X,Motor,X10SA-ES-COL:TRX,baseline,se,no,yes,, 
-coll_y,Collimator Y,Motor,X10SA-ES-COL:TRY,baseline,se,no,no,"{""type"": multi-position, ""in"": 41.5, ""out"": 20.0, ""park"": 0,""tol"":0.05}",
-diag_y,Scintillator/diode Y,Motor,X10SA-ES-SCL:TRY,baseline,se,no,no,"{""type"": multi-position, ""scint"": 38.62, ""i1"": 44.0, ""out"": 20.0,""park"": 0,""tol"":0.3}",
-diag_z,Scintillator/diode Z,Motor,X10SA-ES-SCL:TRZ,baseline,se,no,yes,,
-i1,i1 diode reading,SignalRO,X10SA-ES-SCLDI:READOUT,monitored,bpm,yes,yes,,
-bl_pos,Backlight positioner,Signal,X10SA-ES-BL:POS-SET,baseline,se,no,no,"{""type"":positioner}",
-bl_bright,Backlight brightness,Signal,X10SA-ES-BL:SET,baseline,se,no,no,,
-bs_x,Beamstop X,Motor,X10SA-ES-BS:TRX,baseline,se,no,yes,,
-bs_y,Beamstop Y,Motor,X10SA-ES-BS:TRY,baseline,se,no,yes,,
-bs_z,Beamstop Z,Motor,X10SA-ES-BS:TRZ,baseline,se,no,no,"{""type"": guarded, ""min"": 13, ""samp"": 15, ""work_min"": 20, ""safe"": 41, ""max_blin"": 42, ""max_blout"": 70}",
-bs_pos,Beamstop positioner,Signal,X10SA-ES-BS:POS-SET,baseline,se,no,no,"{""type"":positioner}",
-gon_x,Goniometer X,Motor,X10SA-ES-DF1:TRX1,baseline,det,no,no,"{""type"": guarded, ""in"": 18.0, ""out"": -10.0, ""safe"": -100,""tol"":0.5}",
-gon_y,Goniometer Y,Motor,X10SA-ES-DF1:TRY1,baseline,det,no,yes,,
-gon_z,Goniometer X,Motor,X10SA-ES-DF1:TRZ1,baseline,det,no,yes,,
-omega,Omega,Motor,X10SA-ES-DF1:ROTU,baseline,det,no,yes,,
-cryo_pos,Cryo positioner,Signal,X10SA-ES-CS:POS-SET,baseline,se,no,no,"{""type"":positioner}",
-cryo_x,Cryojet X ,Motor,X10SA-ES-CS:TRX,baseline,se,no,yes,,
-det_xi_focus,X-ray eye 2 Focus,Motor,X10SA-ES-XEYE:FOCUS,baseline,det,no,yes,,
-det_xi_zoom,X-ray eye 2 Zoom,Motor,X10SA-ES-XEYE:ZOOM,baseline,det,no,yes,,
-det_xi_x,X-ray eye X,Motor,X10SA-ES-XEYE:TRX,baseline,det,no,yes,,
-i2,i2,SignalRO,X10SA-ES-XEYEDI:READOUT,monitored,bpm,yes,yes,,
-det_xicam_x,sample cam X ,SignalRO,X10SA-ES-XEYE:cam1:Stats5:CentroidX_RBV,baseline,scam,yes,no,,
-det_xicam_xsig,sample cam X sigma,SignalRO,X10SA-ES-XEYE:cam1:Stats5:SigmaX_RBV,monitored,scam,yes,no,,
-det_xicam_y,sample cam Y ,SignalRO,X10SA-ES-XEYE:cam1:Stats5:CentroidY_RBV,baseline,scam,yes,no,,
-det_xicam_ysig,sample cam Y sigma,SignalRO,X10SA-ES-XEYE:cam1:Stats5:SigmaY_RBV,monitored,scam,yes,no,,
-det_xicam_max,sample cam max value,SignalRO,X10SA-ES-XEYE:cam1:Stats5:MaxValue_RBV,monitored,scam,yes,no,,
-det_xicam_exp,sample cam exp time,Signal,X10SA-ES-XEYE:cam1:cam1:AcquireTime,baseline,scam,no,no,,
-det_xicam_gain,sample cam gain,Signal,X10SA-ES-XEYE:cam1:cam1:Gain,baseline,scam,no,no,,
-det_cov,Detector cover,Signal,X10SA-ES-DETCOV:SET,baseline,det,no,no,"{""type"":positioner}",
-det_y,Detector Y,Motor,X10SA-ES-DET:TRY,baseline,det,no,yes,,
-det_z,Detector Z,Motor,X10SA-ES-DET:TRZ,baseline,det,no,yes,,

pxii_bec/device_configs/pxiii-devices-new.csv

@@ -1,146 +0,0 @@
-name,description,deviceClass,PV,readoutPriority,tag,readOnly,include,userParameter,
-sls_current,SLS current,SignalRO,ARS07-DPCT-0100:CURR,monitored,SLS,yes,yes,,
-fe_sl_xr,FE Slit X Ring,Motor,X06DA-FE-SLDI:TRXR,baseline,fe,no,yes,,
-fe_sl_yt,FE Slit Y top,Motor,X06DA-FE-SLDI:TRYT,baseline,fe,no,yes,,
-fe_sl_xw,FE Slit X Wall,Motor,X06DA-FE-SLDI:TRXW,baseline,fe,no,yes,,
-fe_sl_yb,FE SlitY Bottom,Motor,X06DA-FE-SLDI:TRYB,baseline,fe,no,yes,,
-fe_sl_xcen,FE Slit X Centre,Motor,X06DA-FE-SLDI:CENTERX,baseline,fe,no,yes,,
-fe_sl_xsize,FE Slit X Size,Motor,X06DA-FE-SLDI:SIZEX,baseline,fe,no,yes,,
-fe_sl_ycen,FE Slit Y Centre,Motor,X06DA-FE-SLDI:CENTERY,baseline,fe,no,yes,,
-fe_sl_ysize,FE Slit Y Size,Motor,X06DA-FE-SLDI:SIZEY,baseline,fe,no,yes,,
-fe_cm_xu,FE Coll Mirror Upstream X,Motor,X06DA-ES-MI1:TRXU,baseline,fe_cm,no,yes,,
-fe_cm_xd,FE Coll Mirror Downstream X,Motor,X06DA-ES-MI1:TRXD,baseline,fe_cm,no,yes,,
-fe_cm_yur,FE Coll Mirror Upstream Ring Y,Motor,X06DA-ES-MI1:TRYUR,baseline,fe_cm,no,yes,,
-fe_cm_yw,FE Coll Mirror Wall Y,Motor,X06DA-ES-MI1:TRYW,baseline,fe_cm,no,yes,,
-fe_cm_ydr,FE Coll Mirror Downstream Ring Y,Motor,X06DA-ES-MI1:TRYDR,baseline,fe_cm,no,yes,,
-fe_cm_b1,FE Coll Mirror Bender,Motor,X06DA-ES-MI1:BND1,baseline,fe_cm,no,yes,,
-fe_cm_yaw,FE Coll Mirror Yaw,Motor,X06DA-ES-MI1:YAW,baseline,fe_cm,no,yes,,
-fe_cm_roll,FE Coll Mirror Roll,Motor,X06DA-ES-MI1:ROLL,baseline,fe_cm,no,yes,,
-fe_cm_pitch,FE Coll Mirror Pitch,Motor,X06DA-ES-MI1:PITCH,baseline,fe_cm,no,yes,,
-fe_cm_x,FE Coll Mirror X,Motor,X06DA-ES-MI1:TRX,baseline,fe_cm,no,yes,,
-fe_cm_y,FE Coll Mirror Y ,Motor,X06DA-ES-MI1:TRY,baseline,fe_cm,no,yes,,
-bsf_bpm1,BSF BPM Signal 1,SignalRO,X06DA-OP-BSFBPM:SIGNAL1,monitored,bpm,yes,no,,
-bsf_bpm2,BSF BPM Signal 2,SignalRO,X06DA-OP-BSFBPM:SIGNAL2,monitored,bpm,yes,no,,
-bsf_bpm3,BSF BPM Signal 3,SignalRO,X06DA-OP-BSFBPM:SIGNAL3,monitored,bpm,yes,no,,
-bsf_bpm4,BSF BPM Signal 4,SignalRO,X06DA-OP-BSFBPM:SIGNAL4,monitored,bpm,yes,no,,
-bsf_bpmsum,BSF BPM Summed,SignalRO,X06DA-OP-BSFBPM:SUM,monitored,bpm,yes,no,,
-bsf_sl_xw,BSF slit outboard,Motor,X06DA-OP-BSFSLH:TRXW,baseline,bsf,no,yes,,
-bsf_sl_xr,BSF slit inboard,Motor,X06DA-OP-BSFSLH:TRXR,baseline,bsf,no,yes,,
-bsf_sl_yt,BSF slit top,Motor,X06DA-OP-BSFSLV:TRYT,baseline,bsf,no,yes,,
-bsf_sl_yb,BSF slit bottom,Motor,X06DA-OP-BSFSLV:TRYB,baseline,bsf,no,yes,,
-bsf_sl_xcen,BSF X centre,Motor,X06DA-OP-BSFSLH:CENTER,baseline,bsf,no,yes,,
-bsf_sl_xsize,BSF X size,Motor,X06DA-OP-BSFSLH:SIZE,baseline,bsf,no,yes,,
-bsf_sl_ycen,BSF Y centre,Motor,X06DA-OP-BSFSLV:CENTER,baseline,bsf,no,yes,,
-bsf_sl_ysize,BSF Y size,Motor,X06DA-OP-BSFSLV:SIZE,baseline,bsf,no,yes,,
-bsf_f1_y,BSF Filter 1 Y,Motor,X06DA-OP-BSFFI1:TRY,baseline,bsf,no,yes,,
-bsf_f2_y,BSF Filter 2 Y,Motor,X06DA-OP-BSFFI2:TRY,baseline,bsf,no,yes,,
-dccm_theta1,DCCM theta1,Motor,X06DA-OP-DCCM:ROTX-CR1,baseline,dccm,no,yes,,
-dccm_theta2,DCCM theta2,Motor,X06DA-OP-DCCM:ROTX-CR2,baseline,dccm,no,yes,,
-dccm_rotz,DCCM Crystal 2 rotz ,Motor,X06DA-OP-DCCM:ROTZ-CR2,baseline,dccm,no,yes,,
-dccm_energy,DCCM energy,Motor,X06DA-OP-DCCM:ENERGY,baseline,dccm,no,yes,,
-dccm_diode_t,Top diode between mono crystals,SignalRO,X06DA-OP-XPM1:TOP:READOUT,baseline,dccm,no,yes,,
-dccm_diode_b,Bottom diode between mono crystals,SignalRO,X06DA-OP-XPM1:BOT:READOUT,baseline,dccm,no,yes,,
-dccm_xbpm1,XBPM after mono ch1,SignalRO,X06DA-OP-XBPM1:Current1:MeanValue_RBV,baseline,dccm,no,yes,,
-dccm_xbpm2,XBPM after mono ch2,SignalRO,X06DA-OP-XBPM1:Current2:MeanValue_RBV,baseline,dccm,no,yes,,
-dccm_xbpm3,XBPM after mono ch3,SignalRO,X06DA-OP-XBPM1:Current3:MeanValue_RBV,baseline,dccm,no,yes,,
-dccm_xbpm4,XBPM after mono ch4,SignalRO,X06DA-OP-XBPM1:Current4:MeanValue_RBV,baseline,dccm,no,yes,,
-dccm_xbpmsum,XBPM after mono summed,SignalRO,X06DA-OP-XBPM1:SumAll:MeanValue_RBV,baseline,dccm,no,yes,,
-ss_bpm1,SS BPM Signal 1,SignalRO,X06DA-ES-SSBPM:Current1:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpm2,SS BPM Signal 2,SignalRO,X06DA-ES-SSBPM:Current2:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpm3,SS BPM Signal 3,SignalRO,X06DA-ES-SSBPM:Current3:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpm4,SS BPM Signal 4,SignalRO,X06DA-ES-SSBPM:Current4:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpmsum,SS BPM Summed,SignalRO,X06DA-ES-SSBPM:SumAll:MeanValue_RBV,monitored,bpm,yes,yes,,
-ss_bpm_x,SS BPM X,Motor,X06DA-ES-SSBPM:TRX,baseline,ss,no,yes,,
-ss_bpm_y,SS BPM Y,Motor,X06DA-ES-SSBPM:TRY,baseline,ss,no,yes,,
-ss_sl_xw,SS slit wall,Motor,X06DA-ES-SSSLH:TRXW,baseline,ss,no,yes,,
-ss_sl_xr,SS slit ring,Motor,X06DA-ES-SSSLH:TRXR,baseline,ss,no,yes,,
-ss_sl_xcen,SS slit X centre,Motor,X06DA-ES-SSSLH:CENTER,baseline,ss,no,yes,,
-ss_sl_xsize,SS slit X size,Motor,X06DA-ES-SSSLH:SIZE,baseline,ss,no,yes,,
-ss_sl_yt,SS slit top,Motor,X06DA-ES-SSSLV:TRYT,baseline,ss,no,yes,,
-ss_sl_yb,SS slit bottom,Motor,X06DA-ES-SSSLV:TRYB,baseline,ss,no,yes,,
-ss_sl_ycen,SS slit Y centre,Motor,X06DA-ES-SSSLV:CENTER,baseline,ss,no,yes,,
-ss_sl_ysize,SS slit Y size,Motor,X06DA-ES-SSSLV:SIZE,baseline,ss,no,yes,,
-ss_xi_x,SS X-ray eye X,Motor,X06DA-ES-SSXI:TRX,baseline,ss,no,yes,,
-ss_xi_y,SS X-ray eye Y,Motor,X06DA-ES-SSXI:TRY,baseline,ss,no,yes,,
-ss_xicam_x,ss cam X,SignalRO,X06DA-ES-SSXI:cam1:Stats5:CentroidX_RBV,baseline,ss,yes,yes,,
-ss_xicam_y,ss cam Y,SignalRO,X06DA-ES-SSXI:cam1:Stats5:CentroidY_RBV,baseline,ss,yes,yes,,
-ss_xicam_max,ss cam max value,SignalRO,X06DA-ES-SSXI:cam1:Stats5:MaxValue_RBV,monitored,ss,yes,yes,,
-ss_xicam_exp,ss camera exposure,Signal,X06DA-ES-SSXI:cam1:AcquireTime,baseline,ss,no,yes,,
-ss_xicam_gain,ss camera gain,Signal,X06DA-ES-SSXI:cam1:cam1:Gain,baseline,ss,no,yes,,
-ss_xicam_xsig,ss camera  x sigma,Signal,X06DA-ES-SSXI:cam1:Stats5:SigmaX_RBV,baseline,ss,yes,yes,,
-ss_xicam_ysig,ss camera y sigma,Signal,X06DA-ES-SSXI:cam1:Stats5:SigmaY_RBV,baseline,ss,yes,yes,,
-vfm_xu,VFM Upstream X,Motor,X06DA-ES-KBV:TRXU,baseline,vfm,no,no,,
-vfm_xd,VFM Downstream X,Motor,X06DA-ES-KBV:TRXD,baseline,vfm,no,no,,
-vfm_yur,VFM Upstream Ring Y,Motor,X06DA-ES-KBV:TRYUR,baseline,vfm,no,no,,
-vfm_yw,VFM Wall Y,Motor,X06DA-ES-KBV:TRYW,baseline,vfm,no,no,,
-vfm_ydr,VFM Downstream Ring Y,Motor,X06DA-ES-KBV:TRYDR,baseline,vfm,no,no,,
-vfm_bu,VFM Upstream Bender,Motor,X06DA-ES-KBV:BNDU,baseline,vfm,no,no,,
-vfm_bd,VFM Downstream Bender,Motor,X06DA-ES-KBV:BNDD,baseline,vfm,no,no,,
-vfm_yaw,VFM Virtual Yaw,Motor,X06DA-ES-KBV:YAW,baseline,vfm,no,no,,
-vfm_roll,VFM Virtual Roll,Motor,X06DA-ES-KBV:ROLL,baseline,vfm,no,no,,
-vfm_pitch,VFM Virtual Pitch,Motor,X06DA-ES-KBV:PITCH,baseline,vfm,no,no,,
-vfm_x,VFM Virtual X,Motor,X06DA-ES-KBV:TRX,baseline,vfm,no,no,,
-vfm_y,VFM Virtual Y ,Motor,X06DA-ES-KBV:TRY,baseline,vfm,no,no,,
-hfm_xu,HFM Upstream X,Motor,X06DA-ES-KBH:TRXU,baseline,hfm,no,no,,
-hfm_xd,HFM Downstream X,Motor,X06DA-ES-KBH:TRXD,baseline,hfm,no,no,,
-hfm_yuw,HFM Upstream Wall Y,Motor,X06DA-ES-KBH:TRYUW,baseline,hfm,no,no,,
-hfm_yr,HFM Ring Y,Motor,X06DA-ES-KBH:TRYR,baseline,hfm,no,no,,
-hfm_ydw,HFM Downstream Wall Y,Motor,X06DA-ES-KBH:TRYDW,baseline,hfm,no,no,,
-hfm_bu,HFM Upstream Bender,Motor,X06DA-ES-KBH:BNDU,baseline,hfm,no,no,,
-hfm_bd,HFM Downstream Bender,Motor,X06DA-ES-KBH:BNDD,baseline,hfm,no,no,,
-hfm_yaw,HFM Virtual Yaw,Motor,X06DA-ES-KBH:YAW,baseline,hfm,no,no,,
-hfm_roll,HFM Virtual Roll,Motor,X06DA-ES-KBH:ROLL,baseline,hfm,no,no,,
-hfm_pitch,HFM Virtual Pitch,Motor,X06DA-ES-KBH:PITCH,baseline,hfm,no,no,,
-hfm_x,HFM Virtual X,Motor,X06DA-ES-KBH:TRX,baseline,hfm,no,no,,
-hfm_y,HFM Virtual Y ,Motor,X06DA-ES-KBH:TRY,baseline,hfm,no,no,,
-bcu_bpm1,BCU BPM Signal 1 ,SignalRO,X06DA-ES-BCBPM:Current1:MeanValue_RBV,monitored,bpm,yes,no,,
-bcu_bpm2,BCU BPM Signal 2,SignalRO,X06DA-ES-BCBPM:Current2:MeanValue_RBV,monitored,bpm,yes,no,,
-bcu_bpm3,BCU BPM Signal 3,SignalRO,X06DA-ES-BCBPM:Current3:MeanValue_RBV,monitored,bpm,yes,no,,
-bcu_bpm4,BCU BPM Signal 4,SignalRO,X06DA-ES-BCBPM:Current4:MeanValue_RBV,monitored,bpm,yes,no,,
-bcu_bpmsum,BCU BPM Summed,SignalRO,X06DA-ES-BCBPM:SumAll:MeanValue_RBV,monitored,bpm,yes,no,,
-bcu_bpm_x,BCU BPM X,Motor,X06DA-ES-BCBPM:TRX,baseline,bcu,no,no,,
-bcu_bpm_y,BCU BPM Y ,Motor,X06DA-ES-BCBPM:TRY,baseline,bcu,no,no,,
-bcu_sl_xw,BCU slit wall,Motor,X06DA-ES-BCSLH:TRXW,baseline,bcu,no,no,,
-bcu_sl_xr,BCU slit ring,Motor,X06DA-ES-BCSLH:TRXR,baseline,bcu,no,no,,
-bcu_sl_xcen,BCU slit X centre,Motor,X06DA-ES-BCSLH:CENTER,baseline,bcu,no,no,,
-bcu_sl_xsize,BCU slit X size,Motor,X06DA-ES-BCSLH:SIZEX,baseline,bcu,no,no,,
-bcu_sl_yt,BCU slit top,Motor,X06DA-ES-BCSLV:TRYT,baseline,bcu,no,no,,
-bcu_sl_yb,BCU slit bottom,Motor,X06DA-ES-BCSLV:TRYB,baseline,bcu,no,no,,
-bcu_sl_ycen,BCU slit Y centre,Motor,X06DA-ES-BCSLV:CENTER,baseline,bcu,no,no,,
-bcu_sl_ysize,BCU slit Y size,Motor,X06DA-ES-BCSLV:SIZE,baseline,bcu,no,no,,
-bcu_f1_x,BCU filter 1 X,Motor,X06DA-ES-BCFI1:TRX,baseline,bcu,no,no,,
-bcu_f2_x,BCU filter 2 X,Motor,X06DA-ES-BCFI2:TRX,baseline,bcu,no,no,,
-bcu_f3_x,BCU filter 3 X,Motor,X06DA-ES-BCFI3:TRX,baseline,bcu,no,no,,
-bcu_f4_x,BCU filter 4 X,Motor,X06DA-ES-BCFI4:TRX,baseline,bcu,no,no,,
-xrf_pos,XRF det in/out,Signal,X06DA-ES-XRF:POS-SET,baseline,se,no,yes,"{""type"":positioner}",
-samcam_x,sample cam X ,SignalRO,X06DA-ES-MS:Stats5:CentroidX_RBV,baseline,scam,yes,yes,,
-samcam_xsig,sample cam X sigma,SignalRO,X06DA-ES-MS:Stats5:SigmaX_RBV,monitored,scam,yes,yes,,
-samcam_y,sample cam Y ,SignalRO,X06DA-ES-MS:Stats5:CentroidY_RBV,baseline,scam,yes,yes,,
-samcam_ysig,sample cam Y sigma,SignalRO,X06DA-ES-MS:Stats5:SigmaY_RBV,monitored,scam,yes,yes,,
-samcam_max,sample cam max value,SignalRO,X06DA-ES-MS:Stats5:MaxValue_RBV,monitored,scam,yes,yes,,
-samcam_exp,sample cam exp time,Signal,X06DA-ES-MS:cam1:AcquireTime,baseline,scam,no,yes,,
-samcam_gain,sample cam gain,Signal,X06DA-ES-MS:cam1:Gain,baseline,scam,no,yes,,
-scam_zoom,Sample cam zoom,Motor,X06DA-ES-MS:ZOOM,baseline,scam,no,yes,,
-fl_bright,Frontlight brightness,Signal,X06DA-ES-FL:SET,baseline,se,no,yes,,
-coll_x,Collimator X,Motor,X06DA-ES-COL:TRX,baseline,se,no,yes,, 
-coll_y,Collimator Y,Motor,X06DA-ES-COL:TRY,baseline,se,no,yes,"{""type"": multi-position, ""in"": 41.5, ""out"": 20.0, ""park"": 0,""tol"":0.05}",
-diag_y,Scintillator/diode Y,Motor,X06DA-ES-SCL:TRY,baseline,se,no,yes,"{""type"": multi-position, ""scint"": 38.62, ""i1"": 44.0, ""out"": 20.0,""park"": 0,""tol"":0.3}",
-diag_z,Scintillator/diode Z,Motor,X06DA-ES-SCL:TRZ,baseline,se,no,yes,,
-i1,i1 diode reading,SignalRO,X06DA-ES-SCLDI:READOUT,monitored,bpm,yes,yes,,
-bl_pos,Backlight positioner,Signal,X06DA-ES-BL:POS-SET,baseline,se,no,yes,"{""type"":positioner}",
-bl_bright,Backlight brightness,Signal,X06DA-ES-BL:SET,baseline,se,no,yes,,
-bs_x,Beamstop X,Motor,X06DA-ES-BS:TRX,baseline,se,no,yes,,
-bs_y,Beamstop Y,Motor,X06DA-ES-BS:TRY,baseline,se,no,yes,,
-bs_z,Beamstop Z,Motor,X06DA-ES-BS:TRZ,baseline,se,no,yes,"{""type"": guarded, ""min"": 13, ""samp"": 15, ""work_min"": 20, ""safe"": 41, ""max_blin"": 42, ""max_blout"": 70}",
-bs_pos,Beamstop positioner,Signal,X06DA-ES-BS:POS-SET,baseline,se,no,yes,"{""type"":positioner}",
-gon_x,Goniometer X,Motor,X06DA-ES-DF1:TRX1,baseline,det,no,yes,"{""type"": guarded, ""in"": 18.0, ""out"": -10.0, ""safe"": -100,""tol"":0.5}",
-gon_y,Goniometer Y,Motor,X06DA-ES-DF1:TRY1,baseline,det,no,yes,,
-gon_z,Goniometer X,Motor,X06DA-ES-DF1:TRZ1,baseline,det,no,yes,,
-omega,Omega,Motor,X06DA-ES-DF1:ROTU,baseline,det,no,yes,,
-cryo_pos,Cryo positioner,Signal,X06DA-ES-CS:POS-SET,baseline,se,no,yes,"{""type"":positioner}",
-cryo_x,Cryojet X ,Motor,X06DA-ES-CS:TRX,baseline,se,no,yes,,
-det_cov,Detector cover,Signal,X06DA-ES-DETCOV:SET,baseline,det,no,yes,"{""type"":positioner}",
-det_y,Detector Y,Motor,X06DA-ES-DET:TRY,baseline,det,no,yes,,
-det_z,Detector Z,Motor,X06DA-ES-DET:TRZ,baseline,det,no,yes,,
-gonpos,Sample sensor distance,SignalRO,X06DA-ES-DF1:CBOX-USER1,baseline,se,no,yes,,
-gonvalid,Sample in valid distance,SignalRO,X06DA-ES-DF1:CBOX-CMP1,baseline,se,no,yes,,

pxii_bec/device_configs/se_devices.yaml

@@ -1,206 +0,0 @@
-ss_sl_xw:
-  description: SS slit wall
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SSSLH:TRXW'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - ss
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: continuous
-    in: 1.0
-    out: 2.0
-
-bs_z:
-  description: Beamstop Z
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-BS:TRZ'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: continuous
-    min: 13
-    samp: 15
-    work_min: 20
-    safe: 41
-    max_blin: 42
-    max_blout: 70
-
-gon_x:
-  description: Goniometer X
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-DF1:TRX1'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - det
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: continuous
-    in: 0.0
-    out: -10.0
-    safe: -100
-    tol: 0.5
-
-diag_y:
-  description: Scintillator/diode Y
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-SCL:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: continuous
-    scint: 38.62
-    i1: 44.0
-    out: 20.0
-    park: 1
-    tol: 0.3
-
-coll_y:
-  description: Collimator Y
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-COL:TRY'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: continuous
-    in: 41.5
-    intermediate: 32
-    out: 20.0
-    park: 1
-    tol: 0.05
-
-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:
-    - se
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: discrete
-    in: 1.0
-    out: 0.0
-
-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:
-    - se
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: discrete
-    in: 1.0
-    out: 0.0
-
-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:
-    - se
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: discrete
-    in: 1.0
-    out: 0.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:
-    - det
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: discrete
-    'open': 2.0
-    'close': 1.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:
-    - se
-  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:
-    - se
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: discrete
-    in: 1.0
-    out: 0.0
-
-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:
-    - se
-  readOnly: False
-  softwareTrigger: false
-  userParameter:
-    type: continuous
-    'on': 3.0
-    'off': 0.0
-

pxii_bec/device_configs/smargopolo_smargon.yaml

@@ -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

pxii_bec/device_configs/x10sa_device_config.yaml

@@ -1,27 +1,40 @@
 base_config:
-  - !include ./pxii-devices-new.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

pxii_bec/device_configs/x10sa_device_config_testing.yaml

@@ -1,99 +0,0 @@
-base_config:
-  - !include ./pxii-autogenerated.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
-coll_x:
-  description: Collimator X
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-ES-COL:TRX'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - se
-  readOnly: false 
-  softwareTrigger: false
-dcm_fpitch:
-  description: DCM 2nd crystal fine pitch
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-DCM:PITCH-C2'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-   - dcm
-  readOnly: false 
-  softwareTrigger: false
-dcm_froll:
-  description: DCM 2nd crystal fine roll
-  deviceClass: ophyd.EpicsMotor
-  deviceConfig: {prefix: 'X10SA-OP-DCM:ROLL-C2'}
-  onFailure: buffer
-  enabled: True
-  readoutPriority: baseline
-  deviceTags:
-    - dcm
-  readOnly: false 
-  softwareTrigger: false
-
-bcu_xasym:
-  description: horizontal asymmetry 
-  deviceClass: ophyd_devices.ComputedSignal
-  deviceConfig:
-    compute_method: "def compute_xasym(signal1, signal2, signal3, signal4):\n    return (signal3.get()+signal4.get() - signal1.get()- signal2.get())/(sum((signal1.get(), signal2.get(), signal3.get(), signal4.get())))"
-    input_signals: 
-      - "bcu_bpm1"
-      - "bcu_bpm2"
-      - "bcu_bpm3"
-      - "bcu_bpm4"
-  enabled: true
-  readOnly: false
-  readoutPriority: baseline
-
-bcu_yasym:
-  description: vertical asymmetry 
-  deviceClass: ophyd_devices.ComputedSignal
-  deviceConfig:
-    compute_method: "def compute_xasym(signal1, signal2, signal3, signal4):\n    return (signal1.get()+signal2.get() - signal3.get()- signal4.get())/(sum((signal1.get(), signal2.get(), signal3.get(), signal4.get())))"
-    input_signals: 
-      - "bcu_bpm1"
-      - "bcu_bpm2"
-      - "bcu_bpm3"
-      - "bcu_bpm4"
-  enabled: true
-  readOnly: false
-  readoutPriority: baseline
-
-bcu_xpos:
-  description: horizontal position
-  deviceClass: ophyd_devices.ComputedSignal
-  deviceConfig:
-    compute_method: "def compute_xpos(signal1):\n    import numpy as np\n    return  0.131786+  np.arctanh((signal1.get()-0.007105) /0.99342) / 9.5597 "
-    input_signals: 
-      - "bcu_xasym"
-  enabled: true
-  readOnly: false
-  readoutPriority: baseline
-
-bcu_ypos:
-  description: vertical position
-  deviceClass: ophyd_devices.ComputedSignal
-  deviceConfig:
-    compute_method: "def compute_ypos(signal1):\n    import numpy as np\n    return -0.20283 +  np.arctanh((signal1.get()- (-0.19936)) /0.80653) / (-13.18539)"
-    input_signals: 
-      - "bcu_yasym"
-  enabled: true
-  readOnly: false
-  readoutPriority: baseline
-
-  
-
-

pxii_bec/devices/aerotech.py

@@ -4,8 +4,8 @@ from .http import TIMESTAMP_ID, HttpDeviceController, HttpDeviceSignal, HttpOphy
 
 
 class AerotechController(HttpDeviceController):
-    _readback_endpoint = "status"
-    _target_endpoint = "position"
+    _readback_endpoint = "/status"
+    _target_endpoint = "/position"
 
     def __init__(self, *, prefix, **kwargs):
         self._readbacks: dict[str, dict[str, float | bool]] = {}

pxii_bec/macros/APscripts.py

@@ -138,8 +138,9 @@ def rock(**kwargs):
     from lmfit.models import LinearModel, GaussianModel  # LorentzianModel
     import matplotlib.pyplot as plt
 
-    dock_area = bec.gui.new()
-    wr = dock_area.new().new(bec.gui.available_widgets.Waveform)
+    ## create a dock area: 
+    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
 
@@ -193,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:
@@ -236,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
 
@@ -485,7 +505,7 @@ def fit_plot(data_x, data_y, model="gauss", ibg=1, fitrange=0, fitclick=0):
 
 
 ####################################
-### just save data
+### just SAVE DATA
 ####################################
 def save_data(hindex: int, device_name: str, signal_name: str):
     """
@@ -494,8 +514,8 @@ def save_data(hindex: int, device_name: str, signal_name: str):
 
     Args:
         history_index (int): scan to fetch, e.g. -1 for the most recent scan
-        device_name (str): the device for which to get the monitoring data
-        signal_name (str): the monitor
+        device_name (str): the device for which to get the monitoring data, eg, device_name='dcm_pitch'
+        signal_name (str): the monitor, eg, signal_name='lu_bpmsum' 
     """
 
     h = bec.history[hindex]
@@ -591,6 +611,7 @@ def save_plot_gaps(hindex: int, device_name: str, signal_name: str):
     """
     Get data for a completed scan from the BEC history,
     and plot all the results, store in a CSV file
+    For a certain gap size, scan through energy (Bragg angle) 
 
     Args:
         history_index (int): scan to fetch, e.g. -1 for the most recent scan
@@ -857,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
@@ -923,7 +944,7 @@ def colliscan(direction: str, range=0.3, nsteps=30, stime=0.5, centre=1):
 
 
 #####################
-### slitscans
+### SLITSCANS
 #####################
 def slitscan(device_location: str, direction: str, range: 1, nsteps=50, centre=0):
     """
@@ -1031,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().new(bec.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
@@ -1483,24 +1505,31 @@ def scan_eg(erange, nsteps=50, fit=True):
 
 
 ################################################
-### open window/doch for long gap scan
+### open window/dock for long gap scan
 ################################################
 #
 ### Note: all deprecated !!!! 
 def scan_window(wname="Scan", fit=True):
-    dock_area = bec.gui.new()
     # Add a new dock with a Waveform to the BECDockArea
     nam = "waveform_dock_"+wname
-    dock_area.new(name=nam, widget="Waveform")
-    #  dock_area.panels
-    #  dock_area.panel_list 
-    plt1 = dock_area.panels[nam]
+    dock_area = bec.gui.new(name=wname, geometry = [4000, 900, 700, 700])
+
+    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
-    plt1.plot(device_x='id_gap', device_y='bpm')
+    w1.plot(device_x = dev.id_gap, device_y = dev.lu_bpmsum) 
+
+    ###w1.plot(device_x='id_gap', device_y='bpm')
+    ###dock2 = dock_area.new(name="motor_dock", widget="MotorMap",relative_to=nam, position="right")
 
-    dock2 = dock_area.new(name="motor_dock", widget="MotorMap",relative_to=nam, position="right")
     ###do stuff
 
+    gstart = 4.5
+    gend = 5.0
+    resol = 0.003 # 3 um resol for gap scan
+    nsteps = round(gend-gstart)/resol 
+    s = scans.line_scan(dev.id_gap, gstart, gend, steps = nsteps, exp_time = 0.1, relative = False)  
     
     ### if done, remove 
-    dock2.remove()
+    #w2.remove()

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
+        }
+
+
+
+    

pxii_bec/macros/Undu_Helpers.py

@@ -178,11 +178,12 @@ def setu19(en, *harm_no, detune=0):
 def harmon_walk(estart=7.5, end_en=13):
     import time
 
+    harmon = 5 
     en = estart
     ans = "y"
     while en < end_en + 0.5 and ans == "y":
         print(en)
-        setu19(en, 5)
+        setu19(en, harmon)
         time.sleep(2)
         sete(en)
         en = en + 0.5
@@ -209,6 +210,9 @@ def gap_harm(e=12.4):
 
 ##################################
 
+# use with estart = 6, end_en = 30.5
+
+# test with estart = 6, end_en = 7.5 # should be 3 files , estimated time: 90 min 
 
 def long_gscan(estart=7, end_en=20.5, g_low=4.5, g_high=9.0, nsteps=1500):
     import time
@@ -216,16 +220,18 @@ def long_gscan(estart=7, end_en=20.5, g_low=4.5, g_high=9.0, nsteps=1500):
 
     dirname = "/sls/x10sa/config/commissioning/Data/"
 
+    enstep = 0.5 
+
     print(
-        f"scanning the U19 gap from {estart} keV to {end_en} keV, for a gapsize from {g_low} to {g_high}"
+        f"scanning the U19 gap from {estart} keV to {end_en} keV, for a gapsize from {g_low} to {g_high} in {enstep} keV energy intervals"
     )
     resol = (g_high - g_low) / nsteps
     print(f"nsteps = {nsteps}; resolution is {resol} mm")
-    dock_area = bec.gui.new("LongGapScan")
-    wr = dock_area.new().new(bec.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()
@@ -237,12 +243,17 @@ def long_gscan(estart=7, end_en=20.5, g_low=4.5, g_high=9.0, nsteps=1500):
 
     ## now: probably do from 5 keV to ?? 30 keV ???
 
+    tstart = time.perf_counter() # time logging
+    
     en = estart
 
     while en < end_en:
-        sete(en)
-        time.sleep(0.2)
-        rock()
+        #sete(en)
+        #time.sleep(0.2)
+        #rock()
+        # maybe use
+        bl_energy(en, move_gap = False, plot = False)
+        
         print(f"setting energy to {en}")
         time.sleep(0.2)
         ds = scans.line_scan(dev.id_gap, g_low, g_high, steps=nsteps, exp_time=0.1, relative=False)
@@ -255,7 +266,28 @@ def long_gscan(estart=7, end_en=20.5, g_low=4.5, g_high=9.0, nsteps=1500):
         with open(filename, "w") as f:
             np.savetxt(f, combined, delimiter=",", fmt="%5f")
 
-        en += 1
+        en += enstep 
+
+        # SNAKING ###
+        bl_energy(en, move_gap = False, plot = False)
+        
+        print(f"setting energy to {en}")
+        time.sleep(0.2)
+        ds = scans.line_scan(dev.id_gap, g_high, g_low, steps=nsteps, exp_time=0.1, relative=False)
+        gap_data = ds.scan.live_data.id_gap.id_gap.val
+        bpm_data = ds.scan.live_data.lu_bpmsum.lu_bpmsum.val
+        wr.plot(x=gap_data, y=bpm_data)
+        # writing output to simple data file for later analysis:
+        combined = np.column_stack((gap_data, bpm_data))
+        filename = dirname + "gaps" + str(en) + ".txt"
+        with open(filename, "w") as f:
+            np.savetxt(f, combined, delimiter=",", fmt="%5f")
+
+        en += enstep 
+
+    elapsed_time = time.perf_counter()-tstart
+    print(f"Runtime: {elapsed_time: .6f} seconds, i.e., {elapsed_time: .6f}/60 min")
+
     return
 
 
@@ -272,11 +304,11 @@ def gscan(centre=0, gomax=0, detune=0):
     """
     import time
 
-    dock_area = bec.gui.new()
-    wr = dock_area.new().new(bec.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
@@ -291,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

pxii_bec/macros/beamline_planner.py

@@ -1,10 +1,15 @@
 """Planner to move between beamline states"""
-from enum import Enum
-import yaml
+
 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"
@@ -16,47 +21,25 @@ class BeamlineState(str, Enum):
     MAINTENANCE = "maintenance"
     XTAL_SNAPSHOT = "xtal_snapshot"
 
+
 class TemperatureMode(str, Enum):
+    """List of temperature modes"""
+
     CRYO = "cryo"
     ROOM_TEMP = "room_temp"
 
-def get_states():
-    """Returns the states defined in beamline_states.yaml"""
-    directory = "/sls/x10sa/config/bec/production/pxii_bec/pxii_bec/device_configs/"
-    # directory = "./"
-    filename = "beamline_states.yaml"
-    file = directory + filename
-    with open(file, "r", encoding="utf-8") as f:
-        cfg = yaml.safe_load(f)
-        states = {}
-        allow_modifiers = {}
 
-        for name, config in cfg["states"].items():
-            state = BeamlineState(name)
-
-            allow_modifiers[state] = config.pop("allow_modifiers", False)
-
-            states[state] = config
-
-        return states, allow_modifiers
-
-        # cfg = yaml.safe_load(f)
-        # return {
-        #     BeamlineState(name): config
-        #     for name, config in cfg["states"].items()
-        # }
-    
-
-class StateManager:
+class StateChangePlanner:
     """Moves devices to the correct positions to achieve a given state"""
 
-    def __init__(self,
-                 devices,
-                 states: dict[BeamlineState, dict[str, str]],
-                 allow_modifiers=None,
-                 deps=None,
-                 debug=False,
-                 ):
+    def __init__(
+        self,
+        devices,
+        states: dict[BeamlineState, dict[str, str]],
+        allow_modifiers=None,
+        deps=None,
+        debug=False,
+    ):
         self.devices = devices
         self.states = states
         self.allow_modifiers = allow_modifiers or {}
@@ -109,18 +92,6 @@ class StateManager:
                         print("States at failure:", self.get_positions())
                         raise
 
-                    # if self.debug:
-                    #     print("  After :", self.get_states())
-                # if not d.is_at(pos):
-                #     d.move(pos)
-
-    # def reset(self, state):
-    #     """Reset all devices to the given state"""
-    #     if isinstance(state, str):
-    #         state = BeamlineState(state)
-    #     for dev, pos in self.states[state].items():
-    #         self.devices[dev].set_pos(pos)
-
     def available_states(self):
         """Return a list of available states"""
         return list(self.states.keys())
@@ -132,7 +103,7 @@ class StateManager:
     def print_positions(self):
         """Return current state of all devices"""
         for name, device in self.devices.items():
-            print(f"{name:10s} : {device.pos}")
+            print(f"{name:10s} : {device.pos:10s} value: {device.actual}")
 
     def diff_states(self, before):
         """Return a dict of {device: (before, after)} pairs for devices that changed state"""
@@ -155,17 +126,11 @@ class StateManager:
                 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
 
-
-
     def is_state(self, state, modifier=None):
         """Check if the current state matches the given state and modifier."""
         actual = self.current_state()
@@ -180,65 +145,33 @@ class StateManager:
 
     def _plan(self, target):
 
-            graph = defaultdict(set)
-            indeg = defaultdict(int)
-            nodes = set()
+        graph = defaultdict(set)
+        indeg = defaultdict(int)
+        nodes = set()
 
-            for dev, pos in target.items():
-                node = (dev, pos)
-                nodes.add(node)
+        for dev, pos in target.items():
+            node = (dev, pos)
+            nodes.add(node)
 
-                for dep in self.deps.get(node, []):
-                    graph[dep].add(node)
-                    indeg[node] += 1
-                    nodes.add(dep)
+            for dep in self.deps.get(node, []):
+                graph[dep].add(node)
+                indeg[node] += 1
+                nodes.add(dep)
 
-            q = deque(n for n in nodes if indeg[n] == 0)
-            stages = []
+        q = deque(n for n in nodes if indeg[n] == 0)
+        stages = []
 
-            while q:
-                stage = list(q)
-                stages.append(stage)
-                q.clear()
-
-                for n in stage:
-                    for m in graph[n]:
-                        indeg[m] -= 1
-                        if indeg[m] == 0:
-                            q.append(m)
-
-            if sum(len(s) for s in stages) != len(nodes):
-                raise RuntimeError("Circular dependency in state dependencies")
-            return stages
-
-
-def planner_deps():
-    """Define the dependencies between beamline positions"""
-    return {
-        ("bs_z", "samp"): [
-            ("gon_x", "out"),
-            ("diag_y", "out"),
-            ("coll_y", "out"),
-        ],
-        ("gon_x", "in"): [
-            ("diag_y", "out"),
-            ("bs_z", "safe"),
-        ],
-        ("diag_y", "scint"): [
-            ("gon_x", "out"),
-            ("cryo_pos", "out")
-            ],
-        ("diag_y", "i1"): [
-            ("gon_x", "out"),
-            ("cryo_pos", "out")],
-        ("bs_pos", "out"): [("bs_z", "safe")],
-        ("bs_pos", "in"): [("bs_z", "safe")],
-        ("diag_y", "out"): [("bs_z", "safe")],
-        ("diag_y", "park"): [("bs_z", "safe")],
-        ("coll_y", "out"): [("bs_z", "safe")],
-        ("coll_y", "park"): [("bs_z", "safe")],
-        ("coll_y", "in"): [("bs_z", "safe")],
-        ("coll_y", "intermediate"): [("bs_z", "safe")]
-    }
+        while q:
+            stage = list(q)
+            stages.append(stage)
+            q.clear()
 
+            for n in stage:
+                for m in graph[n]:
+                    indeg[m] -= 1
+                    if indeg[m] == 0:
+                        q.append(m)
 
+        if sum(len(s) for s in stages) != len(nodes):
+            raise RuntimeError("Circular dependency in state dependencies")
+        return stages

pxii_bec/macros/beamline_state_manager.py

@@ -0,0 +1,21 @@
+# from enums import BeamlineState
+import yaml
+
+
+class DefineStatesManager:
+    @staticmethod
+    def initialize_states(states_file):
+        """
+        Returns the states and modifiers defined in the specified states file.
+        """
+        with open(states_file, "r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f)
+            states = {}
+            allow_modifiers = {}
+
+            for name, config in cfg["states"].items():
+                state = BeamlineState(name)
+                allow_modifiers[state] = config.pop("allow_modifiers", False)
+                states[state] = config
+
+            return states, allow_modifiers

pxii_bec/macros/build_devices.py

@@ -0,0 +1,144 @@
+"""Build the sample environment devices"""
+
+import os
+import yaml
+
+# from position_device import PositionDevice
+
+
+def motor_resolver(bec_name):
+    """Used to handle aerotech and smargon motors"""
+
+    candidates = [bec_name, bec_name.replace("_", ".")]
+
+    for path in candidates:
+        try:
+            obj = dev
+
+            for part in path.split("."):
+                obj = getattr(obj, part)
+
+            return obj
+
+        except Exception:
+            pass
+
+    raise ValueError(f"Cannot resolve motor for '{bec_name}'")
+
+
+def build_devices(yaml_file, mock_devices):
+    """Build devices from the beamline states yaml"""
+
+    state_devices = {}
+
+    with open(yaml_file, encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    for bec_name, cfg in data.items():
+
+        user = cfg.get("userParameter")
+
+        # Skip devices without user parameters
+        if not user:
+            continue
+
+        if bec_name in ("aerotech", "smargon"):
+
+            tol = user.get("tol", 0.01)
+
+            for axis in ["x", "y", "z", "u", "chi", "phi"]:
+
+                positions = user.get(axis)
+
+                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
+
+    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()

pxii_bec/macros/check.py

@@ -1,62 +1,483 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable
+from datetime import datetime
+
 from bec_lib.device import Signal, Positioner
 
-def check():
-    check_devices(tolerance = 0.02)
 
-    
+# -------------------------------------------------------------------
+# Status Enum
+# -------------------------------------------------------------------
 
-def check_devices(tolerance):
-    devices = list(dev.items())
-    for name, obj in devices:
+
+class Status(Enum):
+    OK = 0
+    WARNING = 1
+    ERROR = 2
+    UNKNOWN = 3
+
+    @property
+    def color(self):
+        return {
+            Status.OK: "green",
+            Status.WARNING: "yellow",
+            Status.ERROR: "red",
+            Status.UNKNOWN: "blue",
+        }[self]
+
+    @property
+    def color_scilog(self):
+        return {Status.OK: "green", Status.WARNING: "", Status.ERROR: "red", Status.UNKNOWN: ""}[
+            self
+        ]
+
+
+# -------------------------------------------------------------------
+# Health Result Object
+# -------------------------------------------------------------------
+
+
+@dataclass
+class HealthCheckResult:
+
+    name: str
+    description: str
+    status: Status
+
+    value: Any = None
+
+    message: str = ""
+
+    category: str = "general"
+
+    def __str__(self):
+
+        if self.status == Status.OK:
+            return f"[{self.status.name}] {self.description}"
+
+        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}"
+
+
+# -------------------------------------------------------------------
+# Send to SciLog
+# -------------------------------------------------------------------
+
+
+def send_to_scilog(results):
+
+    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("\n")
+    for status, count in counts.items():
+        msg.add_text(f"{status.name:<10}: {count}", bold=True)
+
+    msg.add_text("\n")
+
+    for result in results:
+        msg.add_text(
+            result.formatted_message(),
+            # bold=result.status != Status.OK,
+            color=result.status.color_scilog,
+        )
+        msg.add_text("\n")
+    msg.add_tags(["beamline health check"])
+    msg.send()
+
+
+# -------------------------------------------------------------------
+# Configuration
+# -------------------------------------------------------------------
+
+
+@dataclass
+class BeamlineHealthConfig:
+
+    signal_rules: dict[str, Callable] = field(
+        default_factory=lambda: {"cam": lambda x: x != 0, "bpm": lambda x: x != 0}
+    )
+
+    motor_tolerances: dict[str, float] = field(
+        default_factory=lambda: {
+            # examples
+            # "mono_theta": 0.001,
+            # "detector_z": 0.1,
+        }
+    )
+
+    default_motor_tolerance: float = 0.02
+
+
+# -------------------------------------------------------------------
+# Device Collection
+# -------------------------------------------------------------------
+
+
+def get_devices():
+    return list(dev.items())
+
+
+# -------------------------------------------------------------------
+# Signal Checks
+# -------------------------------------------------------------------
+
+
+def check_signals(devices, config: BeamlineHealthConfig):
+
+    results = []
+
+    signal_devices = [(name, obj) for name, obj in devices if isinstance(obj, Signal)]
+
+    for name, obj in signal_devices:
 
         try:
             data = obj.read()
-            # deal with smargon
-            if "smargon" in name:
-                continue
-            
+            actual = data[name]["value"]
+            description = obj.description
+
+        except Exception as e:
+
+            results.append(
+                HealthCheckResult(
+                    name=name,
+                    description=name,
+                    status=Status.UNKNOWN,
+                    message=f"Failed to read signal: {e}",
+                    category="signals",
+                )
+            )
+
+            continue
+
+        matched = False
+
+        for keyword, rule in config.signal_rules.items():
+
+            if keyword in name:
+
+                matched = True
+
+                try:
+                    passed = rule(actual)
+
+                except Exception as e:
+
+                    results.append(
+                        HealthCheckResult(
+                            name=name,
+                            description=name,
+                            status=Status.UNKNOWN,
+                            value=actual,
+                            message=f"Rule evaluation failed: {e}",
+                            category="signals",
+                        )
+                    )
+
+                    break
+
+                if passed:
+
+                    results.append(
+                        HealthCheckResult(
+                            name=name,
+                            description=description,
+                            status=Status.OK,
+                            value=actual,
+                            category="signals",
+                        )
+                    )
+
+                else:
+
+                    results.append(
+                        HealthCheckResult(
+                            name=name,
+                            description=description,
+                            status=Status.ERROR,
+                            value=actual,
+                            message=f"Signal value = {actual}, failed validation",
+                            category="signals",
+                        )
+                    )
+                break
+
+        if not matched:
+            continue
+
+    return results
+
+
+# -------------------------------------------------------------------
+# Motor Checks
+# -------------------------------------------------------------------
+
+
+def check_motors(devices, config: BeamlineHealthConfig):
+
+    results = []
+    ignore = ["id_gap", "smargon"]
+
+    motor_devices = [(name, obj) for name, obj in devices if isinstance(obj, Positioner)]
+
+    for name, obj in motor_devices:
+
+        if name in ignore:
+            continue
+
+        try:
+
+            data = obj.read()
+
+            description = obj.description
+
             actual = data[name]["value"]
 
-            # If signal and a camera or bpm, check reading is not 0
-            if isinstance(obj, Signal):
-                if 'cam' in name or 'bpm' in name:
-                    if actual == 0.0:
-                        print(f"{name} is reading 0")    
+            error_code = obj.motor_status.get()
 
-            # if signal is a motor, check in position, error, moving
-            if isinstance(obj, Positioner):
-                # Check set position = real position
+            move_state = obj.motor_is_moving.get()
 
-                sp_key = f"{name}_user_setpoint"
+        except Exception as e:
 
-                if sp_key not in data:
-                    continue
+            results.append(
+                HealthCheckResult(
+                    name=name,
+                    description=name,
+                    status=Status.UNKNOWN,
+                    message=f"Failed to read motor: {e}",
+                    category="motors",
+                )
+            )
 
-                setpoint = data[sp_key]["value"]
+            continue
 
-                diff = abs(actual - setpoint)
-                inpos = diff <= tolerance
-                if not inpos:
-                    print(
-                        f"{name}: "
-                        # f"actual={actual:.4f}, "
-                        # f"setpoint={setpoint:.4f}, "
-                        # f"diff={diff:.4f}, "
-                        f"in position = {inpos}"
+        # -----------------------------------------------------------
+        # Error state
+        # -----------------------------------------------------------
+
+        if error_code != 0:
+
+            results.append(
+                HealthCheckResult(
+                    name=name,
+                    description=description,
+                    status=Status.ERROR,
+                    value=error_code,
+                    message=f"motor error code: {error_code}",
+                    category="motors",
+                )
+            )
+
+            continue
+
+        # -----------------------------------------------------------
+        # Moving state
+        # -----------------------------------------------------------
+
+        if move_state != 0:
+
+            results.append(
+                HealthCheckResult(
+                    name=name,
+                    description=description,
+                    status=Status.WARNING,
+                    value=move_state,
+                    message="motor is currently moving",
+                    category="motors",
+                )
+            )
+
+            continue
+
+        # -----------------------------------------------------------
+        # Setpoint comparison
+        # -----------------------------------------------------------
+
+        sp_key = f"{name}_user_setpoint"
+
+        if sp_key in data:
+
+            setpoint = data[sp_key]["value"]
+
+            diff = abs(actual - setpoint)
+
+            tolerance = config.motor_tolerances.get(name, config.default_motor_tolerance)
+
+            if diff > tolerance:
+
+                results.append(
+                    HealthCheckResult(
+                        name=name,
+                        description=description,
+                        status=Status.WARNING,
+                        value=diff,
+                        message=(
+                            f"Setpoint {setpoint:.5g} differs "
+                            f"from readback {actual:.5g} "
+                            f"by {diff:.4g}"
+                        ),
+                        category="motors",
                     )
-                # check if motor is in error state    
-                error_status = obj.motor_status.get()
+                )
 
-                if error_status != 0:
-                    print(f"{name}: error_state = {error_status}")
-                
-                # check if motor is moving
-                move_status = obj.motor_is_moving.get()
-                if move_status != 0:
-                    print(f"{name} is moving")
+            else:
 
-        
-        except Exception as exc:
+                results.append(
+                    HealthCheckResult(
+                        name=name,
+                        description=description,
+                        status=Status.OK,
+                        value=actual,
+                        category="motors",
+                    )
+                )
 
-            print(f"{name}: ERROR -> {exc}")   
+        else:
 
+            results.append(
+                HealthCheckResult(
+                    name=name,
+                    description=description,
+                    status=Status.UNKNOWN,
+                    message="No setpoint available",
+                    category="motors",
+                )
+            )
+
+    return results
+
+
+# -------------------------------------------------------------------
+# General Info
+# -------------------------------------------------------------------
+def info():
+    current = dev.sls_current.get()
+    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}")
+
+
+# def get_state():
+#     states = []
+#     res = planner.current_state()
+#     for state in res:
+#         states.append(state[0])
+#     return list(set(states))
+
+# -------------------------------------------------------------------
+# Main Check Entry Point
+# -------------------------------------------------------------------
+
+
+def check2(config: BeamlineHealthConfig | None = None):
+    if config is None:
+        config = BeamlineHealthConfig()
+
+    devices = get_devices()
+
+    results = []
+
+    results.extend(check_signals(devices, config))
+
+    results.extend(check_motors(devices, config))
+
+    # ---------------------------------------------------------------
+    # Sort by severity
+    # ---------------------------------------------------------------
+
+    results.sort(key=lambda r: r.status.value)
+
+    return results
+
+
+# -------------------------------------------------------------------
+# Summary Printer
+# -------------------------------------------------------------------
+
+
+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)
+
+    n_err = sum(r.status == Status.ERROR for r in results)
+
+    n_unknown = sum(r.status == Status.UNKNOWN for r in results)
+
+    return (
+        f"==========================================\n"
+        f"Beamline Health Check at {timestamp}\n"
+        f"==========================================\n"
+        f"OK       : {n_ok}\n"
+        f"WARNING  : {n_warn}\n"
+        f"ERROR    : {n_err}\n"
+        f"UNKNOWN  : {n_unknown}\n"
+        "==========================================\n"
+    )
+    # return "\n".join(lines)
+
+
+# -------------------------------------------------------------------
+# Filter results
+# -------------------------------------------------------------------
+def filter_results(results, statuses=None):
+    if statuses is None:
+        return results
+
+    return [r for r in results if r.status in statuses]
+
+
+# -------------------------------------------------------------------
+# CLI Entry Point
+# -------------------------------------------------------------------
+
+
+def run_check(show_all=False, scilog=False):
+
+    results = check2()
+
+    print(summary_text(results))
+
+    info()
+
+    problem_results = filter_results(
+        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})
+    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)."
+    )
+
+    print(disclaimer)

pxii_bec/macros/config.py

@@ -1,24 +0,0 @@
-""" "Initialises the sample environment devices, guards, 
-dependencies and planner"""
-
-# import yaml
-# from devices import build_devices
-# from guards import attach_guards
-# from policies import attach_policies
-
-
-def init_se_devices():
-    """Initialises the sample environment devices"""
-    directory = "/sls/x10sa/config/bec/production/pxii_bec/pxii_bec/device_configs/"
-    # directory = "./"
-    filename = "se_devices.yaml"
-    file = directory + filename
-    print(f"Loading devices from {file}")
-    se_devices = build_devices(file)
-    attach_guards(se_devices)
-    attach_policies(se_devices)
-
-    return se_devices
-
-
-

pxii_bec/macros/dependencies.py

@@ -0,0 +1,20 @@
+"""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_pos", "out"): [("bs_z", "safe")],
+        ("bs_pos", "in"): [("bs_z", "safe")],
+        ("diag_y", "out"): [("bs_z", "safe")],
+        ("diag_y", "park"): [("bs_z", "safe")],
+        ("coll_y", "out"): [("bs_z", "safe")],
+        ("coll_y", "park"): [("bs_z", "safe")],
+        ("coll_y", "in"): [("bs_z", "safe")],
+        ("coll_y", "intermediate"): [("bs_z", "safe")],
+    }

pxii_bec/macros/devices.py

@@ -1,167 +0,0 @@
-"""Set up the positioned devices"""
-
-from dataclasses import dataclass, field
-from typing import Callable, List, Dict, Optional, Union
-
-import yaml
-
-
-@dataclass
-class PositionDevice:
-    """Generic device that moves between named or numeric positions"""
-
-    bec_name: str
-    positions: Dict[str, float] = field(default_factory=dict)
-    tol: float = 0.1
-
-    guards: List[Callable[[], None]] = field(default_factory=list)
-    policy: Optional[Callable[[float], None]] = None
-
-    # line below defines if the device is permitted to move to any arbitrary position or not
-    allow_arbitrary: bool = False
-
-    def __post_init__(self):
-        # Use this for BEC
-        self.mot = getattr(dev, self.bec_name)
-
-        # Use this for testing
-        # self.mot = self.MockMotor()
-
-        # Normalize position names
-        self.positions = {k.lower(): v for k, v in self.positions.items()}
-
-    # -------------------------
-    # internal helpers
-    # -------------------------
-
-    def _check_guards(self):
-        for g in self.guards:
-            g()
-
-    def _resolve_target(self, target: Union[str, float]) -> float:
-        """Convert target into a motor position"""
-
-        if isinstance(target, str):
-            name = target.lower()
-
-            if name not in self.positions:
-                raise ValueError(f"Unknown position '{target}'")
-
-            return self.positions[name]
-
-        if isinstance(target, (float, int)):
-            if not self.allow_arbitrary:
-                raise ValueError(f"{self.bec_name} only accepts named positions")
-            return float(target)
-
-        raise TypeError("Target must be str or float")
-
-    # -------------------------
-    # motion
-    # -------------------------
-
-    def move(self, target: Union[str, float]):
-        """Unified move interface"""
-
-        pos = self._resolve_target(target)
-
-        self._check_guards()
-
-        if self.policy:
-            self.policy(pos)
-
-        # Use for testing
-        # self.mot.move(pos)
-
-        # Use in BEC
-        scans.umv(self.mot, pos, relative=False)
-        # s = scans.mv(self.mot, pos, relative=False)
-        # s.wait(timeout=5)
-
-    # def set_position(self, target: Union[str, float]):
-    #     """Only to be used for testing purposes"""
-    #     pos = self._resolve_target(target)
-    #     self.mot.move(pos)
-
-    # -------------------------
-    # readback
-    # -------------------------
-
-    @property
-    def actual(self) -> float:
-        """Return the actual position of the device."""
-        return self.mot.read()[self.bec_name]["value"]
-        # return self.mot.position
-
-    @property
-    def pos(self) -> str:
-        """Return the closest matching position"""
-
-        for name, pos in self.positions.items():
-            if abs(self.actual - pos) <= self.tol:
-                return name
-
-        return "unknown"
-
-    def is_at(self, position: str) -> bool:
-        """Return True if the device is at the given position."""
-        position = position.lower()
-
-        if position not in self.positions:
-            raise ValueError(f"Unknown position '{position}'")
-
-        return abs(self.actual - self.positions[position]) <= self.tol
-
-    # -------------------------
-    # Mock Motor Implementation
-    # -------------------------
-
-    class MockMotor:
-        """Mock implementation of MotorLike for testing and initialization."""
-
-        def __init__(self):
-            self.position = 0.0
-
-        def move(self, value: float):
-            """Move the motor to the given position."""
-            self.position = value
-
-        def read(self):
-            """Read the current position of the motor."""
-            return {"value": self.position}
-
-
-def build_devices(yaml_file):
-    """Takes the defined positions from the device yaml file
-    and adds them to the PositionDevice class.
-    """
-    # discrete_devs = []
-    # continuous_devs = []
-    se_devices = {}
-
-    with open(yaml_file, encoding="utf-8") as f:
-        data = yaml.safe_load(f)
-
-    for bec_name, cfg in data.items():
-        # Skip devices without userParameter
-        user = cfg.get("userParameter")
-
-        if not user:
-            continue
-
-        tol = user.get("tol", 0.1)
-
-        positions = {k: v for k, v in user.items() if k not in ("type", "tol")}
-
-        if user["type"] == "discrete":
-            dev = PositionDevice(bec_name, positions, tol=tol, allow_arbitrary=False)
-            # discrete_devs.append(bec_name)
-            se_devices[bec_name] = dev
-        elif user["type"] == "continuous":
-            dev = PositionDevice(bec_name, positions, tol=tol, allow_arbitrary=True)
-            # continuous_devs.append(bec_name)
-            se_devices[bec_name] = dev
-
-    # print(f"Discrete devices: {discrete_devs}")
-    # print(f"Continuous: {continuous_devs}")
-    return se_devices

pxii_bec/macros/devices_manager.py

@@ -0,0 +1,23 @@
+"""
+This module manages the initialization of devices."""
+
+# from guards import attach_guards
+# from policies import attach_policies
+# from build_devices import build_devices
+
+
+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(devices_file, mock_devices):
+        """
+        Initializes sample environment devices from the specified file.
+        """
+        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

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
 
@@ -73,9 +71,9 @@ def guards_setup(d):
     )
     guards["bs_pos_in"] = AtPositionGuard(d["bs_pos"], position="in")
     guards["gonx_out"] = MinMaxGuard(
-        d["gon_x"], direction="less_than", limit_value=d["gon_x"].positions["out"]
+        d["aerotech_x"], direction="less_than", limit_value=d["aerotech_x"].positions["out"]
     )
-    guards["gonx_safe"] = AtPositionGuard(d["gon_x"], position="safe")
+    guards["gonx_safe"] = AtPositionGuard(d["aerotech_x"], position="safe")
     guards["diag_y_out"] = MinMaxGuard(
         d["diag_y"], direction="less_than", limit_value=d["diag_y"].positions["out"]
     )

pxii_bec/macros/init_beamline.py

@@ -0,0 +1,145 @@
+"""Initialise sample environment devices and beamline states"""
+
+import os
+from dataclasses import dataclass
+
+# from devices_manager import DeviceManager
+# from beamline_state_manager import DefineStatesManager
+# 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
+
+    beamline_configs = {
+        # "x06sa" : {
+        #     "devdir": "/sls/x10sa/config/bec/production/pxi_bec/pxi_bec/device_configs/",
+        #     "state": "pxi-state-devices.yaml",
+        #     "rest": "pxi-rest-devices.yaml",
+        #     "states": "pxi-beamline-states.yaml",
+        # },
+        "x10sa": {
+            "devdir": "/sls/x10sa/config/bec/production/pxii_bec/pxii_bec/device_configs/",
+            "devices": "pxii-devices.yaml",
+            "states": "pxii-beamline-states.yaml",
+        },
+        "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):
+
+        if self.device_mocks is None:
+            self.device_mocks = {
+                "aerotech_x": "real",
+                "aerotech_y": "real",
+                "aerotech_z": "real",
+                "aerotech_u": "real",
+                "bl_bright": "real",
+                "bl_pos": "real",
+                "bs_pos": "real",
+                "bs_z": "real",
+                "coll_y": "real",
+                "cryo_pos": "real",
+                "det_cov": "real",
+                "diag_y": "real",
+                "fl_bright": "real",
+                "smargon_x": "real",
+                "smargon_y": "real",
+                "smargon_z": "real",
+                "smargon_chi": "real",
+                "smargon_phi": "real",
+                "xrf_pos": "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")
+
+        # 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}'")
+
+        devdir = cfg["devdir"]
+
+        self.devices_file = devdir + cfg["devices"]
+        self.states_file = devdir + cfg["states"]
+
+    mock_start_positions = {
+        "aerotech_x": "in",
+        "aerotech_y": "mount",
+        "aerotech_z": "mount",
+        "aerotech_u": "mount",
+        "bl_bright": "off",
+        "bl_pos": "out",
+        "bs_pos": "out",
+        "bs_z": "safe",
+        "coll_y": "park",
+        "cryo_pos": "in",
+        "det_cov": "close",
+        "diag_y": "park",
+        "fl_bright": "off",
+        "smargon_x": "mount",
+        "smargon_y": "mount",
+        "smargon_z": "mount",
+        "smargon_chi": "mount",
+        "smargon_phi": "mount",
+        "xrf_pos": "out",
+    }
+
+    @property
+    def mock_devices(self):
+        mock_names = set()
+        for name, device in self.device_mocks.items():
+            if device == "mock":
+                mock_names.add(name)
+        return mock_names
+
+
+def init_beamline_environment():
+    """
+    Initializes the beamline with real or mock devices.
+    """
+
+    beamline = os.environ["BEAMLINE"]
+
+    env = Environment(beamline=beamline)
+
+    # Initialize devices
+    device_manager = DeviceManager()
+    devices = device_manager.initialize_devices(env.devices_file, env.mock_devices)
+
+    # Initialize states
+    state_manager = DefineStatesManager()
+    states, allow_modifiers = state_manager.initialize_states(env.states_file)
+
+    # Setup dependencies
+    deps = planner_deps()
+
+    # Setup planner
+    planner = StateChangePlanner(devices, states, allow_modifiers, deps)
+    print("Initializing beamline state planner and devices")
+
+    # Set mock motor starting positions
+
+    for mock_dev, pos in env.mock_start_positions.items():
+        if mock_dev in env.mock_devices:
+            try:
+                devices[mock_dev].set_position(pos)
+            except Exception as e:
+                print(f"{e} error when setting {mock_dev}")
+
+    return devices, planner

pxii_bec/macros/policies.py

@@ -1,9 +1,10 @@
-'''Define guard policies for devices in the beamline.'''
+"""Define guard policies for devices in the beamline."""
+
 # from guards import GuardViolation, guards_setup
 
 
 def is_sample_area_clear_for_beamstop(d):
-    '''Check if the sample area is clear of diag_y, coll_y, and gonx'''
+    """Check if the sample area is clear of diag_y, coll_y, and gonx"""
     g = guards_setup(d)
     if g["diag_y_out"].check() and g["coll_y_out"].check() and g["gonx_out"].check():
         return True
@@ -11,25 +12,27 @@ def is_sample_area_clear_for_beamstop(d):
 
 
 def is_sample_area_clear_for_gonx(d):
-    '''Check if the sample area is clear of diag_y and bs_z'''
+    """Check if the sample area is clear of diag_y and bs_z"""
     g = guards_setup(d)
     if g["diag_y_out"].check() and g["bs_work_min"].check():
         return True
     return False
 
 
-def make_gon_x_policy(d):
-    '''Create the policy for gon_x'''
-    def gon_x_policy(target):
-        cfg = d["gon_x"].positions
+def make_aerotech_x_policy(d):
+    """Create the policy for aerotech_x"""
+
+    def aerotech_x_policy(target):
+        cfg = d["aerotech_x"].positions
         if target >= cfg["out"] and not is_sample_area_clear_for_gonx(d):
             raise GuardViolation("Sample area is not clear")
 
-    return gon_x_policy
+    return aerotech_x_policy
 
 
 def make_bs_z_policy(d):
-    '''Create the policy for bs_z'''
+    """Create the policy for bs_z"""
+
     def bs_z_policy(target):
         """Checks that the target position is within limits"""
         cfg = d["bs_z"].positions
@@ -50,24 +53,26 @@ def make_bs_z_policy(d):
 
 
 def make_diag_y_policy(d):
-    '''Create the policy for diag_y'''
+    """Create the policy for diag_y"""
+
     def diag_y_policy(target):
         cfg = d["diag_y"].positions
-        # Don't move in if the goniometer is >= 'in'
-        if d["gon_x"].actual >= d["gon_x"].positions["in"] and target > cfg['out']:
+        # Don't move in if the goniometer is in
+        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"
             )
-        if d['cryo_pos'].pos == "in" and target > cfg["out"]:
+        # Don't move if cryocooler is in
+        if d["cryo_pos"].pos == "in" and target > cfg["out"]:
             raise GuardViolation(
-                f"Diagnostic device cannot move beyond {cfg['out']} mm when cryo is IN"
+                f"Diagnostic device cannot move beyond {cfg['out']} mm when cryocooler is IN"
             )
 
     return diag_y_policy
 
 
 def attach_policies(d):
-    '''Attach the policies to the devices'''
+    """Attach the policies to the devices"""
     d["bs_z"].policy = make_bs_z_policy(d)
-    d["gon_x"].policy = make_gon_x_policy(d)
+    d["aerotech_x"].policy = make_aerotech_x_policy(d)
     d["diag_y"].policy = make_diag_y_policy(d)

pxii_bec/macros/position_device.py

@@ -0,0 +1,254 @@
+"""Set up the positioned devices for mock or real motors"""
+
+from dataclasses import dataclass, field
+from typing import Callable, List, Dict, Optional, Union
+
+import time
+
+
+class SimpleStatus:
+    """Makes a mock motor return a status"""
+
+    def __init__(self, motor, target, delay=0.0, success=True, name=""):
+        self.motor = motor
+        self.target = target
+        self.delay = delay
+        self._success = success
+        self.name = name
+        self._done = False
+
+    def wait(self, timeout=None):
+        start = time.time()
+
+        while True:
+            # simulate motion completion
+            if not self._done:
+                if time.time() - start >= self.delay:
+                    if self._success:
+                        self.motor.position = self.target
+                    self._done = True
+
+            if self._done:
+                if not self._success:
+                    raise RuntimeError(f"Motor {self.name} failed")
+                return True
+
+            if timeout is not None and (time.time() - start) > timeout:
+                raise TimeoutError(f"Timeout waiting for {self.name}")
+
+            time.sleep(0.01)
+
+
+class MotorAdapter:
+    """Motor adapter for setting up mock/real motors"""
+
+    def move(self, pos: float):
+        """Move the motor to the given position"""
+        raise NotImplementedError
+
+    def move_with_status(self, pos: float):
+        """Move the motor to the given position with a status"""
+        raise NotImplementedError
+
+    def set_fail(self, value: bool):
+        """Put the motor into a failure state"""
+        raise NotImplementedError
+
+    @property
+    def actual(self) -> float:
+        """The actual position of the motor"""
+        raise NotImplementedError
+
+
+class MockMotorAdapter(MotorAdapter):
+    """Motor adapter for mock motors"""
+
+    def __init__(self, name: str):
+        self._motor = PositionDevice.MockMotor(name)
+
+    def move(self, pos: float):
+        """Move the motor to the given position"""
+        self._motor.move(pos)
+
+    def move_with_status(self, pos: float):
+        """Move the motor to the given position with a status"""
+        if self._motor.fail:
+            return SimpleStatus(
+                motor=self._motor,
+                target=pos,
+                delay=self._motor.delay,
+                success=False,
+                name=self._motor.name,
+            )
+
+        # don't update position immediately
+        return SimpleStatus(
+            motor=self._motor,
+            target=pos,
+            delay=self._motor.delay,
+            success=True,
+            name=self._motor.name,
+        )
+
+    def set_fail(self, value: bool):
+        """Put the motor into a failure state"""
+        self._motor.fail = value
+
+    def set_delay(self, value: float):
+        self._motor.delay = value
+
+    @property
+    def actual(self) -> float:
+        """The actual position of the motor"""
+        return self._motor.position
+
+
+class RealMotorAdapter(MotorAdapter):
+    """Motor adapter for real motors"""
+
+    def __init__(self, mot, name):
+        self._motor = mot
+        self._name = name
+
+    def move(self, pos: float):
+        """Move the motor to the given position"""
+        scans.umv(self._motor, pos, relative=False)
+
+    def move_with_status(self, pos: float):
+        """Move the motor to the given position with a status"""
+        return scans.mv(self._motor, pos, relative=False)
+        # scans.mv(self._motor, pos, relative=False)
+
+    def set_fail(self, value: bool):
+        """Put the motor into a failure state"""
+        raise NotImplementedError
+
+    @property
+    def actual(self) -> float:
+        """The actual position of the motor"""
+        return self._motor.read()[self._name]["value"]
+
+
+@dataclass
+class PositionDevice:
+    """Generic device that moves between named or numeric positions"""
+
+    bec_name: str
+    mot_device: any = None
+    positions: Dict[str, float] = field(default_factory=dict)
+    tol: float = 0.1
+    # device_timeout = 3
+    guards: List[Callable[[], None]] = field(default_factory=list)
+    policy: Optional[Callable[[float], None]] = None
+    allow_arbitrary: bool = False
+    use_mock: bool = True
+
+    def __post_init__(self):
+        if self.use_mock:
+            self.mot = MockMotorAdapter(self.bec_name)
+        else:
+            self.mot = RealMotorAdapter(self.mot_device, self.bec_name)
+            # self.mot = getattr(dev, self.bec_name)
+
+        # Normalize position names
+        self.positions = {k.lower(): v for k, v in self.positions.items()}
+
+    def _check_guards(self):
+        """Check if guards exist"""
+        for g in self.guards:
+            g()
+
+    def _resolve_target(self, target: Union[str, float]) -> float:
+        """Convert target into a motor position"""
+
+        if isinstance(target, str):
+            name = target.lower()
+
+            if name not in self.positions:
+                raise ValueError(f"Unknown position '{target}'")
+
+            return self.positions[name]
+
+        if isinstance(target, (float, int)):
+            if not self.allow_arbitrary:
+                raise ValueError(f"{self.bec_name} only accepts named positions")
+            return float(target)
+
+        raise TypeError("Target must be str or float")
+
+    def move(self, target: Union[str, float]):
+        """Move devices"""
+        pos = self._resolve_target(target)
+
+        self._check_guards()
+
+        if self.policy:
+            self.policy(pos)
+
+        self.mot.move(pos)
+
+    def mv(self, target: Union[str, float]):
+        """move devices with a timeout"""
+
+        pos = self._resolve_target(target)
+
+        self._check_guards()
+
+        if self.policy:
+            self.policy(pos)
+
+        # status.wait(self.device_timeout)
+        return self.mot.move_with_status(pos)
+        # self.mot.move_with_status(pos)
+
+    def set_position(self, target: Union[str, float]):
+        """Only to be used for testing purposes, bypasses guards"""
+        pos = self._resolve_target(target)
+        self.mot.move(pos)
+
+    @property
+    def actual(self) -> float:
+        """Return the actual position of the device."""
+        # return self.mot.read()[self.bec_name]["value"]
+        return self.mot.actual
+
+    @property
+    def pos(self) -> str:
+        """Return the closest matching position"""
+
+        for name, pos in self.positions.items():
+            if abs(self.actual - pos) <= self.tol:
+                return name
+
+        return "unknown"
+
+    #
+
+    def is_at(self, target: Union[str, float]) -> bool:
+        """Return True if the device is at the given position."""
+
+        pos = self._resolve_target(target)
+        return abs(self.actual - pos) <= self.tol
+
+    # -------------------------
+    # Mock Motor Implementation
+    # -------------------------
+
+    class MockMotor:
+        """Mock motor implementation"""
+
+        def __init__(self, name: str):
+            self.name = name
+            self.position = 0.0
+            self._target = self.position
+            self.fail = False
+            self.delay = 0
+
+        #
+        def move(self, pos: float):
+            """Move the motor to the given position."""
+            if self.fail:
+                return
+                # raise RuntimeError(f"Motor {self.name} failed")
+            time.sleep(self.delay)
+            self.position = pos

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

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,
@@ -168,23 +171,21 @@ class BPMScans:
     }
 
 
-@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(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,
+#     }

pxii_bec/macros/pxii_parameters_version_120526.txt

@@ -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")

pxii_bec/macros/test.py

@@ -1,38 +1,31 @@
+"""Test state changes"""
+
 import random
 import time
 
-def test_mv():
-    tol = 0.1
-    if abs(dev.coll_y.position) < tol:
-        value = 40
-    else:
-        value = 0
-    print(f"Moving coll_y to {value}")
-    s = scans.mv(dev.coll_y, value, relative=False)
-    s.wait(timeout = 3)
-
-def test_states():
-    d = init_se_devices()
-    states, allow_modifiers = get_states()
-    deps = planner_deps()
-    planner = StateManager(d, states, allow_modifiers, deps)
-    states_to_test = [
-        BeamlineState.ROBOT_SAMPLE_EXCHANGE,
-        BeamlineState.DATA_COLLECTION,
-        BeamlineState.MANUAL_SAMPLE_EXCHANGE,
-        BeamlineState.XTAL_SNAPSHOT,
-
-    ]
-    previous = None
+def state_test():
+    d, planner = init_beamline_environment()
     tested_states = []
-    for i in range(10):        
-        choices = [ s for s in states_to_test if s != previous]
+    states_to_test = [BeamlineState.BEAMSTOP_ALIGNMENT,
+                      BeamlineState.DATA_COLLECTION,
+                      BeamlineState.MAINTENANCE,
+                      BeamlineState.ROBOT_SAMPLE_EXCHANGE,
+                      BeamlineState.SAMPLE_ALIGNMENT,
+                    #   BeamlineState.DC_XRF,
+                      BeamlineState.FLUX_MEASUREMENT,
+                      BeamlineState.XTAL_SNAPSHOT,
+                      BeamlineState.MANUAL_SAMPLE_EXCHANGE,
+                      BeamlineState.BEAM_VISUALISATION]
+    previous = None
+    for i in range(20):
+        choices = [s for s in states_to_test if s != previous]
         current = random.choice(choices)
-        print(f"Moving to state {current}")
+        print(f"Testing {current}")
         planner.move_to(current)
-        tested_states.append(current)
-        time.sleep(5)
+        time.sleep(2)
+        tested_states.append(current.name)
         previous = current
-    print(f"Tested states: {tested_states}")
+    planner.move_to(BeamlineState.MANUAL_SAMPLE_EXCHANGE)
+
+    print("\n".join(tested_states))
 
-