Add beamline states

2026-04-21 10:46:29 +02:00
parent a11fe91998
commit 7147bc1c84
20 changed files with 2634 additions and 2652 deletions
@@ -34,4 +34,8 @@ 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()
+# init_positioned_devices()
+d = init_se_devices()
+states, allow_modifiers = get_states()
+deps = planner_deps()
+planner = StateManager(d, states, allow_modifiers, deps)
@@ -15,7 +15,7 @@ def extend_command_line_args(parser):
    Extend the command line arguments of the BEC client.
    """

-    # parser.add_argument("--session", help="Session name", type=str, default="cSAXS")
+    # parser.add_argument("--session", help="Session name", type=str, default="MX")

    return parser

@@ -0,0 +1,151 @@
+states:
+  robot_sample_exchange:
+    allow_modifiers: true
+    bl_pos: in
+    bl_bright: 'off'
+    bs_pos: in
+    bs_z: safe
+    coll_y: out
+    cryo_pos: in
+#    det_cov: no requirement
+    diag_y: out
+    fl_bright: 'off'
+    gon_x: in
+#    smargon: not implemented
+    xrf_pos: out
+
+  sample_alignment:
+    allow_modifiers: true
+    bl_pos: in
+    bl_bright: 'on'
+    bs_pos: in
+    bs_z: safe
+    coll_y: out
+    cryo_pos: in
+    #    det_cov: no requirement
+    diag_y: out
+    fl_bright: 'on'
+    gon_x: in
+  #    smargon: not implemented
+    xrf_pos: out
+
+  data_collection:
+    allow_modifiers: true
+    bl_pos: out
+    bl_bright: 'off'
+    bs_pos: in
+    bs_z: safe
+    coll_y: in
+    cryo_pos: in
+    det_cov: 'open'
+    diag_y: out
+    fl_bright: 'on'
+    gon_x: in
+  #    smargon: not implemented
+    xrf_pos: out
+
+  DC_XRF:
+    allow_modifiers: true
+#    bl_pos: out
+    bl_bright: 'off'
+    bs_pos: in
+    bs_z: safe
+    coll_y: in
+    cryo_pos: in
+#    det_cov: open
+    diag_y: out
+    fl_bright: 'on'
+    gon_x: in
+    #    smargon: not implemented
+    xrf_pos: in
+
+  manual_sample_exchange:
+    allow_modifiers: true
+    bl_pos: out
+    bl_bright: 'off'
+    bs_pos: out
+    bs_z: safe
+    coll_y: park
+    cryo_pos: in
+    det_cov: 'close'
+    diag_y: park
+    fl_bright: 'off'
+    gon_x: in
+    #    smargon: not implemented
+    xrf_pos: out
+
+  beam_visualisation:
+    bl_pos: out
+    bl_bright: 'off'
+    bs_pos: in
+    bs_z: safe
+    coll_y: out
+    cryo_pos: out
+    det_cov: 'close'
+    diag_y: scint
+    fl_bright: 'off'
+    gon_x: out
+  #    smargon: not implemented
+    xrf_pos: out
+
+  flux_measurement:
+    bl_pos: in
+    bl_bright: 'off'
+    bs_pos: in
+    bs_z: safe
+    coll_y: out
+    cryo_pos: out
+    det_cov: 'close'
+    diag_y: i1
+    fl_bright: 'off'
+    gon_x: out
+    #    smargon: not implemented
+    xrf_pos: out
+
+  beamstop_alignment:
+    bl_pos: out
+    bl_bright: 'off'
+    bs_pos: in
+    bs_z: samp
+    coll_y: out
+    cryo_pos: out
+#    det_cov: open
+    diag_y: out
+    fl_bright: 'on'
+    gon_x: out
+    #    smargon: not implemented
+    xrf_pos: out
+
+  maintenance:
+    allow_modifiers: true
+    bl_pos: out
+    bl_bright: 'off'
+    bs_pos: out
+    bs_z: safe
+    coll_y: park
+    cryo_pos: in
+    det_cov: 'close'
+    diag_y: park
+    fl_bright: 'off'
+    gon_x: out
+    #    smargon: not implemented
+    xrf_pos: out
+
+  xtal_snapshot:
+    allow_modifiers: true
+    bl_pos: in
+    bl_bright: 'on'
+    bs_pos: in
+    bs_z: safe
+    coll_y: intermediate
+    cryo_pos: in
+#    det_cov: open
+    diag_y: out
+    fl_bright: 'on'
+    gon_x: in
+    #    smargon: not implemented
+    xrf_pos: out
+
+
+
+
@@ -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
@@ -0,0 +1,169 @@
+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,Motor,X10SA-FE-SL1:TRXR,baseline,fe,no,yes,,
+fe_sl_yt,FE Slit Y top,Motor,X10SA-FE-SL1:TRYT,baseline,fe,no,yes,,
+fe_sl_xw,FE Slit X Wall,Motor,X10SA-FE-SL1:TRXW,baseline,fe,no,yes,,
+fe_sl_yb,FE SlitY Bottom,Motor,X10SA-FE-SL1:TRYB,baseline,fe,no,yes,,
+fe_sl_xcen,FE Slit X Centre,Motor,X10SA-FE-SL1:CENTERX,baseline,fe,no,yes,,
+fe_sl_xsize,FE Slit X Size,Motor,X10SA-FE-SL1:SIZEX,baseline,fe,no,yes,,
+fe_sl_ycen,FE Slit Y Centre,Motor,X10SA-FE-SL1:CENTERY,baseline,fe,no,yes,,
+fe_sl_ysize,FE Slit Y Size,Motor,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,Motor,X10SA-OP-BSFSLH:TRXW,baseline,bsf,no,yes,,
+bsf_sl_xr,BSF slit inboard,Motor,X10SA-OP-BSFSLH:TRXR,baseline,bsf,no,yes,,
+bsf_sl_yt,BSF slit top,Motor,X10SA-OP-BSFSLV:TRYT,baseline,bsf,no,yes,,
+bsf_sl_yb,BSF slit bottom,Motor,X10SA-OP-BSFSLV:TRYB,baseline,bsf,no,yes,,
+bsf_sl_xcen,BSF X centre,Motor,X10SA-OP-BSFSLH:CENTER,baseline,bsf,no,yes,,
+bsf_sl_xsize,BSF X size,Motor,X10SA-OP-BSFSLH:SIZE,baseline,bsf,no,yes,,
+bsf_sl_ycen,BSF Y centre,Motor,X10SA-OP-BSFSLV:CENTER,baseline,bsf,no,yes,,
+bsf_sl_ysize,BSF Y size,Motor,X10SA-OP-BSFSLV:SIZE,baseline,bsf,no,yes,,
+bsf_f1_y,BSF Filter 1 Y,Motor,X10SA-OP-BSFFI1:TRY,baseline,bsf,no,yes,,
+bsf_f2_y,BSF Filter 2 Y,Motor,X10SA-OP-BSFFI2:TRY,baseline,bsf,no,yes,,
+dcm_bragg,DCM Bragg angle,Motor,X10SA-OP-DCM:ROTY,baseline,dcm,no,yes,,
+dcm_x,DCM lateral,Motor,X10SA-OP-DCM:TRX,baseline,dcm,no,yes,,
+dcm_perp,DCM Perp,Motor,X10SA-OP-DCM:TRX-CR2,baseline,dcm,no,yes,,
+dcm_pitch,DCM 2nd crystal pitch,Motor,X10SA-OP-DCM:ROTY-CR2-PITCH,baseline,dcm,no,yes,,
+dcm_fpitch,DCM 2nd crystal fine pitch,Motor,X10SA-OP-DCM:ROTY-CR2-FINEPITCH,baseline,dcm,no,yes,,
+dcm_froll,DCM 2nd crystal fine roll,Motor,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,yes,,
+ss_xicam_y,ss cam Y,SignalRO,X10SA-ES-SSXI:cam1:Stats5:CentroidY_RBV,baseline,ss,yes,yes,,
+ss_xicam_max,ss cam max value,SignalRO,X10SA-ES-SSXI:cam1:Stats5:MaxValue_RBV,monitored,ss,yes,yes,,
+ss_xicam_exp,ss camera exposure,Signal,X10SA-ES-SSXI:cam1:AcquireTime,baseline,ss,no,yes,,
+ss_xicam_gain,ss camera gain,Signal,X10SA-ES-SSXI:cam1:cam1:Gain,baseline,ss,no,yes,,
+ss_xicam_xsig,ss camera  x sigma,Signal,X10SA-ES-SSXI:cam1:Stats5:SigmaX_RBV,baseline,ss,yes,yes,,
+ss_xicam_ysig,ss camera y sigma,Signal,X10SA-ES-SSXI:cam1:Stats5:SigmaY_RBV,baseline,ss,yes,yes,,
+vfm_xu,VFM Upstream X,Motor,X10SA-ES-KBV:TRXU,baseline,vfm,no,no,,
+vfm_xd,VFM Downstream X,Motor,X10SA-ES-KBV:TRXD,baseline,vfm,no,no,,
+vfm_yur,VFM Upstream Ring Y,Motor,X10SA-ES-KBV:TRYUR,baseline,vfm,no,no,,
+vfm_yw,VFM Wall Y,Motor,X10SA-ES-KBV:TRYW,baseline,vfm,no,no,,
+vfm_ydr,VFM Downstream Ring Y,Motor,X10SA-ES-KBV:TRYDR,baseline,vfm,no,no,,
+vfm_bu,VFM Upstream Bender,Motor,X10SA-ES-KBV:BNDU,baseline,vfm,no,no,,
+vfm_bd,VFM Downstream Bender,Motor,X10SA-ES-KBV:BNDD,baseline,vfm,no,no,,
+vfm_yaw,VFM Virtual Yaw,Motor,X10SA-ES-KBV:YAW,baseline,vfm,no,no,,
+vfm_roll,VFM Virtual Roll,Motor,X10SA-ES-KBV:ROLL,baseline,vfm,no,no,,
+vfm_pitch,VFM Virtual Pitch,Motor,X10SA-ES-KBV:PITCH,baseline,vfm,no,no,,
+vfm_x,VFM Virtual X,Motor,X10SA-ES-KBV:TRX,baseline,vfm,no,no,,
+vfm_y,VFM Virtual Y ,Motor,X10SA-ES-KBV:TRY,baseline,vfm,no,no,,
+hfm_xu,HFM Upstream X,Motor,X10SA-ES-KBH:TRXU,baseline,hfm,no,no,,
+hfm_xd,HFM Downstream X,Motor,X10SA-ES-KBH:TRXD,baseline,hfm,no,no,,
+hfm_yuw,HFM Upstream Wall Y,Motor,X10SA-ES-KBH:TRYUW,baseline,hfm,no,no,,
+hfm_yr,HFM Ring Y,Motor,X10SA-ES-KBH:TRYR,baseline,hfm,no,no,,
+hfm_ydw,HFM Downstream Wall Y,Motor,X10SA-ES-KBH:TRYDW,baseline,hfm,no,no,,
+hfm_bu,HFM Upstream Bender,Motor,X10SA-ES-KBH:BNDU,baseline,hfm,no,no,,
+hfm_bd,HFM Downstream Bender,Motor,X10SA-ES-KBH:BNDD,baseline,hfm,no,no,,
+hfm_yaw,HFM Virtual Yaw,Motor,X10SA-ES-KBH:YAW,baseline,hfm,no,no,,
+hfm_roll,HFM Virtual Roll,Motor,X10SA-ES-KBH:ROLL,baseline,hfm,no,no,,
+hfm_pitch,HFM Virtual Pitch,Motor,X10SA-ES-KBH:PITCH,baseline,hfm,no,no,,
+hfm_x,HFM Virtual X,Motor,X10SA-ES-KBH:TRX,baseline,hfm,no,no,,
+hfm_y,HFM Virtual Y ,Motor,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,yes,"{""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,yes,,
+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,yes,"{""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,yes,"{""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,yes,"{""type"":positioner}",
+bl_bright,Backlight brightness,Signal,X10SA-ES-BL:SET,baseline,se,no,yes,,
+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,yes,"{""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,yes,"{""type"":positioner}",
+gon_x,Goniometer X,Motor,X10SA-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,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,yes,"{""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,yes,"{""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,,
@@ -0,0 +1,190 @@
+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: 0
+    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: 0
+    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
+
@@ -1,5 +1,7 @@
 base_config:
  - !include ./pxii-autogenerated.yaml
+sample_env:
+  - !include ./se_devices.yaml
 id_gap:
  readoutPriority: baseline
  description: undulator gap
@@ -10,39 +12,6 @@ id_gap:
  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

 smargon:
  description: REST-based device which connects to Smargopolo
@@ -55,4 +24,4 @@ smargon:
    - smargon
    - motors
  readOnly: false 
-  softwareTrigger: false
+  softwareTrigger: false
@@ -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
-
-  
-
-
@@ -45,12 +45,7 @@ def a2e(a, *hkl):
    if "deg" in hkl:
        ideg = 1

-    d0 = (
-        2
-        * 5.43102
-        * (1 - 2.4e-4 * iln)
-        / np.sqrt(h[0] ** 2.0 + h[1] ** 2.0 + h[2] ** 2.0)
-    )
+    d0 = 2 * 5.43102 * (1 - 2.4e-4 * iln) / np.sqrt(h[0] ** 2.0 + h[1] ** 2.0 + h[2] ** 2.0)

    if ideg or (a > 1):
        a = math.radians(a)  #  *math.pi/180.
@@ -91,12 +86,7 @@ def angle(e, *hkl):
    if "deg" in hkl:
        ideg = 1

-    d0 = (
-        2
-        * 5.43102
-        * (1 - 2.4e-4 * iln)
-        / np.sqrt(h[0] ** 2.0 + h[1] ** 2.0 + h[2] ** 2.0)
-    )
+    d0 = 2 * 5.43102 * (1 - 2.4e-4 * iln) / np.sqrt(h[0] ** 2.0 + h[1] ** 2.0 + h[2] ** 2.0)
    a = math.asin(12.39842 / d0 / e)

    if ideg:
@@ -149,7 +139,7 @@ def rock(**kwargs):
    import matplotlib.pyplot as plt

    dock_area = bec.gui.new()
-    wr = dock_area.new(bec.gui.available_widgets.Waveform)
+    wr = dock_area.new().new(bec.gui.available_widgets.Waveform)

    # width of rocking curve of perfect xtal: at 20 keV: 14 urad == 0.0008 deg

@@ -206,7 +196,7 @@ def rock(**kwargs):
    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(device_x=mot.name, device_y=det.name)  ##set names/axes first !
+    wr.plot(x_name=mot.name, y_name=det.name)  ##set names/axes first !
    wr.x_label = mot.name
    wr.y_label = det.name
    if ax == 0:
@@ -263,13 +253,7 @@ def justfit(data_x, data_y, model="gauss", ibg=0):
    gfit, xmax =  justfit(data_x, data_y, model = "lorentz", ibg =0) : Lorentzian, no BG
    """

-    from lmfit.models import (
-        LinearModel,
-        GaussianModel,
-        VoigtModel,
-        QuadraticModel,
-        LorentzianModel,
-    )
+    from lmfit.models import LinearModel, GaussianModel, VoigtModel, QuadraticModel, LorentzianModel
    import matplotlib.pyplot as plt

    peak = GaussianModel()
@@ -338,20 +322,12 @@ def fit_plothist(hindex: int, signal_name: str, model="gauss", ibg=0):

    """

-    from lmfit.models import (
-        LinearModel,
-        GaussianModel,
-        VoigtModel,
-        QuadraticModel,
-        LorentzianModel,
-    )
+    from lmfit.models import LinearModel, GaussianModel, VoigtModel, QuadraticModel, LorentzianModel
    import matplotlib.pyplot as plt

    h = bec.history[hindex]
    md = h.metadata["bec"]
-    scanvar = list(md["args"].keys())[
-        0
-    ]  # string, returns the variable of the last performed scan
+    scanvar = list(md["args"].keys())[0]  # string, returns the variable of the last performed scan
    # data = h.devices[device_name][signal].read()["value"]
    # data_x = h.devices.dcm_pitch.dcm_pitch.read()["value"]
    # data_y = h.devices.lu_bpmsum.lu_bpmsum.read()["value"]
@@ -442,9 +418,9 @@ def fit_plot(data_x, data_y, model="gauss", ibg=1, fitrange=0, fitclick=0):
    sigma = 1.0
    gamma = 0.2  # blurring/widening of the sigma ; the larger, the more of a Lorentzian profile
    print("maxy, indmax, xm = ", maxy, indmax, xm)
-    #p = model.make_params(
+    # p = model.make_params(
    #    amplitude=max(data_y), center=xm, slope=0, intercept=min(data_y)
-    #)
+    # )
    p = model.make_params(amplitude=maxy, center=xm)
    p["center"].set(min=min(data_x), max=max(data_x))
    p["sigma"].set(min=0, max=(max(data_x) - min(data_x)) / 2.0)
@@ -541,7 +517,7 @@ def save_data(hindex: int, device_name: str, signal_name: str):
    ans = "n"
    ans = input("Store data in csv file? y/n ")
    if ans == "y":
-        dirname = "/home/gac-x10sa/Data/"
+        dirname = "/sls/x10sa/config/commissioning/Data/"
        # writing output to simple data file for later analysis:
        combined = np.column_stack((data_x, data_y))
        filename = dirname + "Scan" + str(hindex) + device_name + ".txt"
@@ -552,7 +528,7 @@ def save_data(hindex: int, device_name: str, signal_name: str):


 #########################################
-### just retried the saved data from csv
+### just retrieve the saved data from csv
 ########################################
 def read_data(filename: str):
    """
@@ -560,6 +536,7 @@ def read_data(filename: str):

    Args:
        filename (str): the csv file, eg, of a Scan
+        e.g., dat = read_data("/home/e18747/SLS2/Data/gaps/gaps10.txt")
    """

    # dirname = '/home/gac-x10sa/Data/'
@@ -572,6 +549,8 @@ def read_data(filename: str):

    print("No of Rows =", rows)
    print("No of Colums =", cols)
+    ind1 = 0
+    ind2 = 1
    if cols > 2:
        print(
            "only first 2 colums (data[:, 0] and  data[:, 1]) are plotted, please consider the other columns as well!"
@@ -645,7 +624,7 @@ def save_plot_gaps(hindex: int, device_name: str, signal_name: str):

    plt.show()

-    dirname = "/home/gac-x10sa/Data/"
+    dirname = "/sls/x10sa/config/commissioning/Data/"
    # writing output to simple data file for later analysis:
    combined = np.column_stack((en_vec, data_y))
    filename = dirname + "EnScan" + str(hindex) + ".txt"
@@ -668,8 +647,9 @@ def getdiodepos(diode="i1"):
    """

    diode_in = 1
-    dpos = 44  # mm
-    measdev = dev.scin_y
+    dpos = dev.diag_y.user_parameter["i1"]  # 44  # mm
+
+    measdev = dev.diag_y
    diodepos_rb = measdev.user_readback.get()
    if abs(dpos - diodepos_rb) > 0.1:
        print("Diode not in, please move")
@@ -679,7 +659,7 @@ def getdiodepos(diode="i1"):
        detpos_diode = 214.5
        detpos_rb = dev.det_z.user_readback.get()
        print("using Det diode requires det up and close and beamstop out")
-        if abs(detpos - detpos_rb) > 0.5:
+        if abs(detpos_diode - detpos_rb) > 0.5:
            print("Diode not in, please move Det up")
            diode_in = 0  # sys.exit(0)

@@ -692,7 +672,7 @@ def read_mon():
    e = getenergy()
    fesum = dev.fe_bpmsum.read()["fe_bpmsum"]["value"]
    lusum = dev.lu_bpmsum.read()["lu_bpmsum"]["value"]
-    bscsum = dev.bsc_bpmsum.read()["bsc_bpmsum"]["value"]
+    sssum = dev.ss_bpmsum.read()["ss_bpmsum"]["value"]

    # Mono
    bragg = dev.dcm_bragg.read()["dcm_bragg"]["value"]
@@ -727,24 +707,24 @@ def read_mon():
    fe_sy_size = dev.fe_sysize.read()["fe_sysize"]["value"]

    ## BSF slits centre and size
-    s1_xcen = dev.s1_xcen.read()["s1_xcen"]["value"]
-    s1_xsize = dev.s1_xsize.read()["s1_xsize"]["value"]
-    s1_ycen = dev.s1_ycen.read()["s1_ycen"]["value"]
-    s1_ysize = dev.s1_ysize.read()["s1_ysize"]["value"]
+    bsf_xcen = dev.bsf_sl_xcen.read()["bsf_sl_xcen"]["value"]
+    bsf_xsize = dev.bsf_sl_xsize.read()["bsf_sl_xsize"]["value"]
+    bsf_ycen = dev.bsf_sl_ycen.read()["bsf_sl_ycen"]["value"]
+    bsf_ysize = dev.bsf_sl_ysize.read()["bsf_sl_ysize"]["value"]

-    ## BSC slits centre and size
-    s2_xcen = dev.s2_xcen.read()["s2_xcen"]["value"]
-    s2_xsize = dev.s2_xsize.read()["s2_xsize"]["value"]
-    s2_ycen = dev.s2_ycen.read()["s2_ycen"]["value"]
-    s2_ysize = dev.s2_ysize.read()["s2_ysize"]["value"]
+    ## SS slits centre and size
+    ss_sl_xcen = dev.ss_sl_xcen.read()["ss_sl_xcen"]["value"]
+    ss_sl_xsize = dev.ss_sl_xsize.read()["ss_sl_xsize"]["value"]
+    ss_sl_ycen = dev.ss_sl_ycen.read()["ss_sl_ycen"]["value"]
+    ss_sl_ysize = dev.ss_sl_ysize.read()["ss_sl_ysize"]["value"]

    ## BCU slits centre and size
-    s3_xcen = dev.s3_xcen.read()["s3_xcen"]["value"]
-    s3_xsize = dev.s3_xsize.read()["s3_xsize"]["value"]
-    s3_ycen = dev.s3_ycen.read()["s3_ycen"]["value"]
-    s3_ysize = dev.s3_ysize.read()["s3_ysize"]["value"]
+    bcu_sl_xcen = dev.bcu_sl_xcen.read()["bcu_sl_xcen"]["value"]
+    bcu_sl_xsize = dev.bcu_sl_xsize.read()["bcu_sl_xsize"]["value"]
+    bcu_sl_ycen = dev.bcu_sl_ycen.read()["bcu_sl_ycen"]["value"]
+    bcu_sl_ysize = dev.bcu_sl_ysize.read()["bcu_sl_ysize"]["value"]

-    ## move in screen in BSC chamber and get size and position
+    ## move in screen in SS chamber and get size and position
    ## move out again

    # umv(dev.samcam_xmot, 1)
@@ -767,12 +747,10 @@ def read_mon():
        bcusum = dev.bcu_bpmsum.read()["bcu_bpmsum"]["value"]
        i1signal = dev.i1.read()["i1"]["value"]
    print("Energy = ", e, " keV")
-    print(f"fesum,lusum,bscsum,bcusum,i1signal =  {fesum,lusum,bscsum,bcusum,i1signal}")
+    print(f"fesum,lusum,sssum,bcusum,i1signal =  {fesum,lusum,sssum,bcusum,i1signal}")

-    print(
-        f"bragg, pitch, perp, fpitch, froll, gap =  {bragg, pitch,perp, fpitch, froll, gap}"
-    )
-    # return e, fesum,lusum,bscsum,bcusum,i1signal
+    print(f"bragg, pitch, perp, fpitch, froll, gap =  {bragg, pitch,perp, fpitch, froll, gap}")
+    # return e, fesum,lusum,sssum,bcusum,i1signal
    print("KB VERT")
    print(
        f"vbu, vbd, vbpitch,vbyaw,vbroll,vblat,vbvert =  {vbu, vbd, vbpitch,vbyaw,vbroll,vblat,vbvert}"
@@ -786,7 +764,7 @@ def read_mon():
    ## dump status in CSV

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    dirname = "/home/gac-x10sa/Data/"
+    dirname = "/sls/x10sa/config/commissioning/Data/"
    filename = dirname + f"BLstatus_{timestamp}.txt"
    with open(filename, "w") as f:
        combined = np.column_stack((e, gap))
@@ -810,19 +788,19 @@ def read_mon():
        np.savetxt(f, combined, delimiter=",", fmt="%5f")

        f.write("BSF slits\n")
-        combined = np.column_stack((s1_xcen, s1_xsize, s1_ycen, s1_ysize))
+        combined = np.column_stack((bsf_sl_xcen, bsf_sl_xsize, bsf_sl_ycen, bsf_sl_ysize))
        np.savetxt(f, combined, delimiter=",", fmt="%5f")

-        f.write("BSC slits\n")
-        combined = np.column_stack((s2_xcen, s2_xsize, s2_ycen, s2_ysize))
+        f.write("SS slits\n")
+        combined = np.column_stack((ss_sl_xcen, ss_sl_xsize, ss_sl_ycen, ss_sl_ysize))
        np.savetxt(f, combined, delimiter=",", fmt="%5f")

        f.write("BCU slits\n")
-        combined = np.column_stack((s3_xcen, s3_xsize, s3_ycen, s3_ysize))
+        combined = np.column_stack((bcu_sl_xcen, bcu_sl_xsize, bcu_sl_ycen, bcu_sl_ysize))
        np.savetxt(f, combined, delimiter=",", fmt="%5f")

-        f.write("fesum,lusum,bscsum,bcusum,i1signal\n")
-        combined = np.column_stack((fesum, lusum, bscsum, bcusum, i1signal))
+        f.write("fesum,lusum,sssum,bcusum,i1signal\n")
+        combined = np.column_stack((fesum, lusum, sssum, bcusum, i1signal))
        np.savetxt(f, combined, delimiter=",", fmt="%5f")

        return
@@ -840,33 +818,23 @@ def longscan():

    umv(dev.id_gap, 4.5)
    time.sleep(0.2)
-    s = scans.line_scan(
-        dev.dcm_bragg, 406.5, 65.9, steps=1500, exp_time=0.05, relative=False
-    )
+    s = scans.line_scan(dev.dcm_bragg, 406.5, 65.9, steps=1500, exp_time=0.05, relative=False)
    time.sleep(2)
    umv(dev.id_gap, 5.0)
    time.sleep(0.2)
-    s = scans.line_scan(
-        dev.dcm_bragg, 65.9, 406.5, steps=1500, exp_time=0.05, relative=False
-    )
+    s = scans.line_scan(dev.dcm_bragg, 65.9, 406.5, steps=1500, exp_time=0.05, relative=False)
    time.sleep(2)
    umv(dev.id_gap, 5.5)
    time.sleep(0.2)
-    s = scans.line_scan(
-        dev.dcm_bragg, 406.5, 65.9, steps=1500, exp_time=0.05, relative=False
-    )
+    s = scans.line_scan(dev.dcm_bragg, 406.5, 65.9, steps=1500, exp_time=0.05, relative=False)
    time.sleep(2)
    umv(dev.id_gap, 6.0)
    time.sleep(0.2)
-    s = scans.line_scan(
-        dev.dcm_bragg, 65.9, 406.5, steps=1500, exp_time=0.05, relative=False
-    )
+    s = scans.line_scan(dev.dcm_bragg, 65.9, 406.5, steps=1500, exp_time=0.05, relative=False)
    time.sleep(2)
    umv(dev.id_gap, 6.5)
    time.sleep(0.2)
-    s = scans.line_scan(
-        dev.dcm_bragg, 406.5, 65.9, steps=1500, exp_time=0.05, relative=False
-    )
+    s = scans.line_scan(dev.dcm_bragg, 406.5, 65.9, steps=1500, exp_time=0.05, relative=False)


 #####################
@@ -890,15 +858,15 @@ 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(bec.gui.available_widgets.Waveform)
+    wr = dock_area.new().new(bec.gui.available_widgets.Waveform)

    # check if i1 DIODE is IN
    # if not, aks to be moved

-    diodeinpos = 44  # mm
-    colli_up = 41  # mm
+    diodeinpos = dev.diag_y.user_parameter["i1"]  # 44  # mm
+    colli_up = dev.coll_y.user_parameter["in"]  # 41.5  # mm

-    measdev = dev.scin_y
+    measdev = dev.diag_y
    diodepos_rb = measdev.user_readback.get()
    if abs(diodeinpos - diodepos_rb) > 0.1:
        print("Diode not in, please move")
@@ -999,32 +967,32 @@ def slitscan(device_location: str, direction: str, range: 1, nsteps=50, centre=0
        default_h = 3.0  # 8125
        default_v = 3.0  # ??? close more ???? # 8149.8
        det = dev.lu_bpmsum
-        # det = dev.bsc_bpmsum or #det = dev.bcu_bpmsum would also work
+        # det = dev.ss_bpmsum or #det = dev.bcu_bpmsum would also work
        if direction == "h":
-            mot = dev.s1_xcen
-            size = dev.s1_xsize
+            mot = dev.bsf_sl_xcen
+            size = dev.bsf_sl_xsize
            s_closed = 0.1
            s_open = default_h
        else:
-            mot = dev.s1_ycen
-            size = dev.s1_ysize
+            mot = dev.bsf_sl_ycen
+            size = dev.bsf_sl_ysize
            s_closed = 0.1
            s_open = default_v

-    # BSC slits ================================
+    # SS slits ================================

-    if device_location in ["bsc", "s2", "ss"]:
+    if device_location in ["ss", "ss_sl", "ss"]:
        default_h = 6.0  # ???
        default_v = 5.0  # ??? close more ???? # 8149.8
        det = dev.bcu_bpmsum
        if direction == "h":
-            mot = dev.s2_xcen
-            size = dev.s2_xsize
+            mot = dev.ss_sl_xcen
+            size = dev.ss_sl_xsize
            s_closed = 0.1
            s_open = default_h
        else:
-            mot = dev.s2_ycen
-            size = dev.s2_ysize
+            mot = dev.ss_sl_ycen
+            size = dev.ss_sl_ysize
            s_closed = 0.1
            s_open = default_v

@@ -1035,20 +1003,20 @@ def slitscan(device_location: str, direction: str, range: 1, nsteps=50, centre=0
        default_v = 2.0  # ??? close more ???? # 8149.8
        # change to i0 later ??
        det = dev.i1
-        dposm = 43.8
+        dposm = dev.diag_y.user_parameter["i1"]
        # dpos0 = dev.scin_y.user_readback.get()
        # if abs(dposm - dpos0) > 1:
        #    print("moving diode i1 in")
        #    umv(dev.scin_y, dposm)

        if direction == "h":
-            mot = dev.s3_xcen
-            size = dev.s3_xsize
+            mot = dev.bcu_sl_xcen
+            size = dev.bcu_sl_xsize
            s_closed = 3.0  ## very large, else does not work !
            s_open = default_h
        else:
-            mot = dev.s3_ycen
-            size = dev.s3_ysize
+            mot = dev.bcu_sl_ycen
+            size = dev.bcu_sl_ysize
            s_closed = 3.0  ## very large !
            s_open = default_v

@@ -1064,14 +1032,14 @@ def slitscan(device_location: str, direction: str, range: 1, nsteps=50, centre=0
        return

    dock_area = bec.gui.new()
-    wr = dock_area.new(bec.gui.available_widgets.Waveform)
+    wr = dock_area.new().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(device_x=mot.name, device_y=det.name)
+    wr.plot(x_name=mot.name, y_name=det.name)
    wr.x_label = mot.name
    wr.y_label = det.name

@@ -1088,25 +1056,25 @@ def slitscan(device_location: str, direction: str, range: 1, nsteps=50, centre=0
    if mot.name == "fe_sycen":
        data_x = s.scan.live_data.fe_sycen.fe_sycen.val
    # BSF slits ================================
-    if mot.name == "s1_xcen":
-        data_x = s.scan.live_data.s1_xcen.s1_xcen.val
-    if mot.name == "s1_ycen":
-        data_x = s.scan.live_data.s1_ycen.s1_ycen.val
+    if mot.name == "bsf_sl_xcen":
+        data_x = s.scan.live_data.bsf_sl_xcen.bsf_sl_xcen.val
+    if mot.name == "bsf_ycen":
+        data_x = s.scan.live_data.bsf_sl_ycen.bsf_sl_ycen.val

-    # BSC slits ================================
-    if mot.name == "s2_xcen":
-        data_x = s.scan.live_data.s2_xcen.s2_xcen.val
+    # SS slits ================================
+    if mot.name == "ss_sl_xcen":
+        data_x = s.scan.live_data.ss_sl_xcen.ss_sl_xcen.val
        data_y = s.scan.live_data.bcu_bpmsum.bcu_bpmsum.val
-    if mot.name == "s2_ycen":
-        data_x = s.scan.live_data.s2_ycen.s2_ycen.val
+    if mot.name == "ss_sl_ycen":
+        data_x = s.scan.live_data.ss_sl_ycen.ss_sl_ycen.val
        data_y = s.scan.live_data.bcu_bpmsum.bcu_bpmsum.val

    # BCU slits ================================
-    if mot.name == "s3_xcen":
-        data_x = s.scan.live_data.s3_xcen.s3_xcen.val
+    if mot.name == "bcu_sl_xcen":
+        data_x = s.scan.live_data.bcu_sl_xcen.bcu_sl_xcen.val
        data_y = s.scan.live_data.i1.i1.val
-    if mot.name == "s3_ycen":
-        data_x = s.scan.live_data.s3_ycen.s3_ycen.val
+    if mot.name == "bcu_sl_ycen":
+        data_x = s.scan.live_data.bcu_sl_ycen.bcu_sl_ycen.val
        data_y = s.scan.live_data.i1.i1.val

    # change to i0 later ??
@@ -1161,9 +1129,7 @@ def kbfocus(sizex, sizey):

    en = getenergy()
    print(f"Energy is {en} keV")
-    print(
-        "Currently only 2 sizes supported, small approx.(2 x 2.7) and medium approx.(40 x 40)"
-    )
+    print("Currently only 2 sizes supported, small approx.(2 x 2.7) and medium approx.(40 x 40)")

    ## is the pitch ok ?
    vpitch = 2.695
@@ -1261,11 +1227,9 @@ def bstatus():
    #
    dock_area = bec.gui.new()

-    dbrowser = dock_area.new(
-        bec.gui.available_widgets.DeviceBrowser, object_name="device_browser"
-    )
+    dbrowser = dock_area.new("device_browser").new(bec.gui.available_widgets.DeviceBrowser)

-    dock_area.new(bec.gui.available_widgets.BECQueue, object_name="queue")
+    dock_area.new("queue").new(bec.gui.available_widgets.BECQueue)
    # queue = dock_area.queue.BECQueue # give it a name
    # text_box = dock_area.new().new(widget=bec.gui.available_widgets.TextBox)
    # text_box.set_plain_text("Hello, World!")
@@ -1307,15 +1271,15 @@ def detxeye_in():

    print("moving X-ray eye below Eiger in")

-    xrpos = dev.xeye2_x.user_readback.get()
+    xrpos = dev.det_xi_x.user_readback.get()
    if abs(setxrpos - xrpos) > 1:
-        umv(dev.xeye2_x, setxrpos)
-    zoompos = dev.xeye2_zoom.user_readback.get()
+        umv(dev.det_xi_x, setxrpos)
+    zoompos = dev.det_xi_zoom.user_readback.get()
    if abs(setzoom - zoompos) > 1:
-        umv(dev.xeye2_zoom, setzoom)
-    focpos = dev.xeye2_focus.user_readback.get()
+        umv(dev.det_xi_zoom, setzoom)
+    focpos = dev.det_xi_focus.user_readback.get()
    if abs(setfoc - focpos) > 1:
-        umv(dev.xeye2_focus, setfoc)
+        umv(dev.det_xi_focus, setfoc)


 def detxeye_out():
@@ -1337,7 +1301,7 @@ def detxeye_out():

 def measure_samcam(zoom=1000):
    scinti_inpos = 38.6  # mm
-    sc_rb = dev.scin_y.user_readback.get()
+    sc_rb = dev.diag_y.user_readback.get()
    if abs(scinti_inpos - sc_rb) > 0.3:
        print("Scinti not in, please move")
        sys.exit(0)
@@ -1352,20 +1316,20 @@ def measure_samcam(zoom=1000):
    return sx, sy


-def measure_bsccam():
-    x_inpos = 7  # mm
+def measure_sscam():
+    x_inpos = dev.ss_xi_x.user_parameter["in"]  # 7  # mm
    px2mum = 20
-    scpos_rb = dev.xeye_x.user_readback.get()
+    scpos_rb = dev.ss_xi_x.user_readback.get()
    if abs(x_inpos - scpos_rb) > 0.3:
        print("Scinti not in, please move")
        sys.exit(0)

-    auto_exposure(cam="bsccam", target=200)
-    a = dev.bsccam_xsig.read()["bsccam_xsig"]["value"]
-    b = dev.bsccam_ysig.read()["bsccam_ysig"]["value"]
+    auto_exposure(cam="sscam", target=200)
+    a = dev.ss_xicam_xsig.read()["ss_xicam_xsig"]["value"]
+    b = dev.ss_xicam_ysig.read()["ss_xicam_ysig"]["value"]
    sx = a * px2mum * 2.35
    sy = b * px2mum * 2.35
-    print(f"FWHM at BSC cam in um : {sx, sy}")
+    print(f"FWHM at SS cam in um : {sx, sy}")

    return sx, sy

@@ -1381,9 +1345,7 @@ def knife_edge(dir="hor", range=0.05, steps=100):
    if dir == "vert":
        mot = dev.gon_y

-    s = scans.line_scan(
-        dev.gon_x, -range, range, steps=steps, exp_time=1, relative=True
-    )
+    s = scans.line_scan(dev.gon_x, -range, range, steps=steps, exp_time=1, relative=True)
    return


@@ -1472,9 +1434,7 @@ def scan_eg(erange, nsteps=50, fit=True):

    print(f"Scanning Bragg from {a_start} to {a_end} mrad")

-    s = scans.line_scan(
-        mot_scan, a_start, a_end, steps=nsteps, exp_time=exptime, relative=False
-    )
+    s = scans.line_scan(mot_scan, a_start, a_end, steps=nsteps, exp_time=exptime, relative=False)

    ## plot and fit the scan
    bragg_data = (
@@ -1520,3 +1480,27 @@ def scan_eg(erange, nsteps=50, fit=True):
 ### compute a signal
 ###########################
 # see in config file
+
+
+################################################
+### open window/doch 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]
+    # Add signals to the WaveformWidget
+    plt1.plot(device_x='id_gap', device_y='bpm')
+
+    dock2 = dock_area.new(name="motor_dock", widget="MotorMap",relative_to=nam, position="right")
+    ###do stuff
+
+    
+    ### if done, remove 
+    dock2.remove()
@@ -10,12 +10,9 @@ from scipy.optimize import curve_fit
 from scipy.ndimage import gaussian_filter1d


-
 def fit_harm(harm, n, order):
    x = harm[0, :].astype(float)
-    y = harm[1, :].astype(
-        float
-    )  ## else funny object that might contain funny strings ...
+    y = harm[1, :].astype(float)  ## else funny object that might contain funny strings ...
    coeff = np.polyfit(x, y, order)  # 3 in general i.e., 4 params
    polynomial = np.poly1d(coeff)
    x_fit = np.linspace(min(x), max(x), 100)
@@ -23,30 +20,27 @@ def fit_harm(harm, n, order):
    print("Polynomial coefficients of the harmonic: ", n, coeff)
    plot(x_fit, y_fit, color="blue")

-    return (
-        x / n,
-        y,
-    )  # get the normalized energy gap relation for fitting the Halbach coeff
+    return (x / n, y)  # get the normalized energy gap relation for fitting the Halbach coeff


 ######### simple exp fit ############
 def exponential_func0(x, a, b, c):
    # fit 3 params a,b,c

-    return a * np.exp(b * x + c * x ** 2)
+    return a * np.exp(b * x + c * x**2)


 ######### inverse exp fit ############
 def exponential_func1(x, a, b, c):
    # fit 3 params a,b,c

-    return 1 / (1 + (a * np.exp(b * x + c * x ** 2)))
+    return 1 / (1 + (a * np.exp(b * x + c * x**2)))


 ######### inverse exp fit plus E_max ############
 def exponential_func2(x, a, b, c, d):
    # fit 4 params a,b,c, e.g.,  fit energy of storage ring as well
-    return d / (1 + (a * np.exp(b * x + c * x ** 2)))
+    return d / (1 + (a * np.exp(b * x + c * x**2)))


 ##################################
@@ -79,36 +73,38 @@ def return_harmon():

    return h

-def plot_harmon(e_start, e_end, h_no, pr_out = False):

-    enarr=  np.arange(e_start, e_end+1, 0.5)
+def plot_harmon(e_start, e_end, h_no, pr_out=False):
+
+    enarr = np.arange(e_start, e_end + 1, 0.5)

    h_all = return_harmon()
-    h=h_all[h_no] 
+    h = h_all[h_no]
    polynomial = np.poly1d(h)
    gaps = polynomial(enarr)

-    if (pr_out):
-        print("en =", enarr )
-        print("gaps =", gaps ) 
-    
+    if pr_out:
+        print("en =", enarr)
+        print("gaps =", gaps)
+
    plt.ion()
    plt.figure()
-    
-    plt.plot(enarr,gaps,'*')
+
+    plt.plot(enarr, gaps, "*")
    plt.title(f"harmonic no {h_no}")
    plt.xlabel("E / keV")
    plt.ylabel("Gap / mm")
    plt.show()

+
 def setu19(en, *harm_no, detune=0):
    """
    set the U19 to the gaps defined in Jul2025, or the "theoretical" ones for higher
    harmonics
    USAGE:
    setu19(en, *harm_no, detune=0)
-    en in keV, possibly select a special harmonics, or detune [0/1] to a value 
-    with a nicer beam shape but less flux 
+    en in keV, possibly select a special harmonics, or detune [0/1] to a value
+    with a nicer beam shape but less flux
    """
    g0 = dev.id_gap.readback.get()

@@ -168,30 +164,31 @@ def setu19(en, *harm_no, detune=0):
        print("Moving Undulator gap to ", g, " mm")
    else:
        print("not a valid gap, do nothing")
-         
+
    if detune:
-        g =g *0.996
+        g = g * 0.996
        print("moving to detuned gap value, slightly below max, about 0.15 % ")
-    #print("move disabled!!")
-    res =  scans.umv(dev.id_gap, g, relative=False)
+    # print("move disabled!!")
+    res = scans.umv(dev.id_gap, g, relative=False)

    return

+
 ##################################
 def harmon_walk(estart=7.5, end_en=13):
    import time

    en = estart
-    ans ='y'
-    while en < end_en+0.5 and ans == 'y':
-        print(en) 
+    ans = "y"
+    while en < end_en + 0.5 and ans == "y":
+        print(en)
        setu19(en, 5)
        time.sleep(2)
-        sete(en)  
-        en = en+0.5
+        sete(en)
+        en = en + 0.5
        ans = input("Next energy? y/n: ")
-        
-    
+
+
 ##################################
 def gap_harm(e=12.4):
    fitpar_u19 = np.array([2.17078531, 0.519452, -0.00720255])
@@ -217,7 +214,7 @@ def long_gscan(estart=7, end_en=20.5, g_low=4.5, g_high=9.0, nsteps=1500):
    import time
    import numpy as np

-    dirname = "/home/gac-x10sa/Data/"
+    dirname = "/sls/x10sa/config/commissioning/Data/"

    print(
        f"scanning the U19 gap from {estart} keV to {end_en} keV, for a gapsize from {g_low} to {g_high}"
@@ -225,29 +222,30 @@ def long_gscan(estart=7, end_en=20.5, g_low=4.5, g_high=9.0, nsteps=1500):
    resol = (g_high - g_low) / nsteps
    print(f"nsteps = {nsteps}; resolution is {resol} mm")
    dock_area = bec.gui.new("LongGapScan")
-    wr = dock_area.new(bec.gui.available_widgets.Waveform)
+    wr = dock_area.new().new(bec.gui.available_widgets.Waveform)
    mot = dev.id_gap
    det = dev.lu_bpmsum
-    wr.plot(device_x=mot.name, device_y=det.name)  ## names first !
+    wr.plot(x_name=mot.name, y_name=det.name)  ## names first !
    wr.x_label = mot.name
    wr.y_label = det.name
    g0 = dev.id_gap.readback.get()

+    ### parameters
    # g_low = 4.5  # 4.5
    # g_high = 9.0  # 9.0
    # nsteps = 1500 # res = 3 um

+    ## now: probably do from 5 keV to ?? 30 keV ???
+
    en = estart

    while en < end_en:
        sete(en)
-        time.sleep(1)
+        time.sleep(0.2)
        rock()
        print(f"setting energy to {en}")
-        time.sleep(2)
-        ds = scans.line_scan(
-            dev.id_gap, g_low, g_high, steps=nsteps, exp_time=0.8, relative=False
-        )
+        time.sleep(0.2)
+        ds = scans.line_scan(dev.id_gap, g_low, g_high, 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)
@@ -270,30 +268,28 @@ def gscan(centre=0, gomax=0, detune=0):
    gscan(centre=1): go to centre of fit max
    gscan(centre=1, gomax=1): go to max of intensity
    gscan(centre=1,detune=1): position of slightly less flux with nicer beam shape
-         
-    """ 
+
+    """
    import time

    dock_area = bec.gui.new()
-    wr = dock_area.new(bec.gui.available_widgets.Waveform)
+    wr = dock_area.new().new(bec.gui.available_widgets.Waveform)
    mot = dev.id_gap
    det = dev.lu_bpmsum
-    wr.plot(device_x=mot.name, device_y=det.name)  ## names first !
+    wr.plot(x_name=mot.name, y_name=det.name)  ## names first !
    # wr.plot(x=mot.name,y=det.name)           ### this comes later
    wr.x_label = mot.name
    wr.y_label = det.name

    g0 = dev.id_gap.readback.get()
    deltag = 0.05
-    ds = scans.line_scan(
-        dev.id_gap, -deltag, deltag, steps=30, exp_time=0.5, relative=True
-    )
+    ds = scans.line_scan(dev.id_gap, -deltag, deltag, steps=30, exp_time=0.5, relative=True)
    gap_data = ds.scan.live_data.id_gap.id_gap.val
    bpm_data = ds.scan.live_data.lu_bpmsum.lu_bpmsum.val

-    #maxy = max(bpm_data)
-    #indmax = np.argmax(bpm_data)
-    #gm = gap_data[indmax]
+    # maxy = max(bpm_data)
+    # indmax = np.argmax(bpm_data)
+    # gm = gap_data[indmax]

    gcen, xm = fit_plot(gap_data, bpm_data, model="gauss")

@@ -304,16 +300,15 @@ def gscan(centre=0, gomax=0, detune=0):

    print("gap off by ", g0 - gm, " mm")
    if detune:
-        gm=gm*0.996 
+        gm = gm * 0.996
        print("moving to detuned gap value, slightly (0.15 %) below max")
-    
+
    if centre:
        time.sleep(0.2)
-        if min(gap_data) <= gm <= max(gap_data): 
+        if min(gap_data) <= gm <= max(gap_data):
            scans.umv(dev.id_gap, gm, relative=False)
            print("moving to ", gm, " mm")
        else:
            print("Fit too far off, try using option gomax=1")
-            
-    return

+    return
@@ -0,0 +1,24 @@
+""" "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
+
+
+
@@ -0,0 +1,167 @@
+"""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
@@ -0,0 +1,95 @@
+"""Setup guards for devices."""
+
+
+class GuardViolation(Exception):
+    """Raised when a guarded move is not allowed."""
+
+
+class AtPositionGuard:
+    """Guard that checks if a device is in a specific position."""
+
+    def __init__(self, device, position):
+        self.device = device
+        self.pos = position
+
+    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"
+            )
+        # print("move allowed")
+        return True
+
+    def requirement(self):
+        """Return the requirement for the guard."""
+        return (self.device.bec_name, self.pos)
+
+
+class MinMaxGuard:
+    """Guard that checks if a device is within a specific range."""
+
+    def __init__(self, device, limit_value, direction):
+        self.device = device
+        self.limit_value = limit_value
+        self.direction = direction  # direction: 'max' or 'min'
+
+    def check(self):
+        """Check if the device is within the specified range."""
+        if self.direction == "less_than":
+            if not (self.device.actual - self.device.tol) <= self.limit_value:
+                raise GuardViolation(
+                    f"{self.device.bec_name} must be less than or equal to {self.limit_value} mm"
+                )
+        elif self.direction == "more_than":
+            if not (self.device.actual + self.device.tol) >= self.limit_value:
+                raise GuardViolation(
+                    f"{self.device.bec_name} must be greater than or equal to {self.limit_value} mm"
+                )
+        else:
+            raise ValueError(
+                f"Invalid direction '{self.direction}'. Use 'less_than' or 'more_than'."
+            )
+
+        # print("move allowed")
+        return True
+
+    def requirement(self):
+        """Return the requirement for the guard."""
+        # planner cannot handle numeric constraints directly
+        # return None -> planner ignores
+        return None
+
+
+def guards_setup(d):
+    """Define guards for devices."""
+    guards = {}
+    guards["bs_safe"] = AtPositionGuard(d["bs_z"], position="safe")
+    guards["bs_max_blin"] = MinMaxGuard(
+        d["bs_z"], direction="less_than", limit_value=d["bs_z"].positions["max_blin"]
+    )
+    guards["bs_work_min"] = MinMaxGuard(
+        d["bs_z"], direction="more_than", limit_value=d["bs_z"].positions["work_min"]
+    )
+    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"]
+    )
+    guards["gonx_safe"] = AtPositionGuard(d["gon_x"], position="safe")
+    guards["diag_y_out"] = MinMaxGuard(
+        d["diag_y"], direction="less_than", limit_value=d["diag_y"].positions["out"]
+    )
+    guards["coll_y_out"] = MinMaxGuard(
+        d["coll_y"], direction="less_than", limit_value=d["diag_y"].positions["out"]
+    )
+    return guards
+
+
+def attach_guards(d):
+    """Attach guards to devices."""
+    g = guards_setup(d)
+    d["diag_y"].guards.append(g["bs_work_min"].check)
+    d["bl_pos"].guards.append(g["bs_max_blin"].check)
+    d["bs_pos"].guards.append(g["bs_safe"].check)
+    d["bs_z"].guards.append(g["bs_pos_in"].check)
+    d["coll_y"].guards.append(g["bs_work_min"].check)
@@ -1,14 +1,23 @@
 """Get data from an h5 file or BEC history and perform fitting."""

 import numpy as np
-from lmfit.models import GaussianModel, LorentzianModel, VoigtModel, ConstantModel, LinearModel
+from lmfit.models import (
+    GaussianModel,
+    LorentzianModel,
+    VoigtModel,
+    ConstantModel,
+    LinearModel,
+)
 from scipy.ndimage import gaussian_filter1d
 import h5py
 import matplotlib.pyplot as plt


 def create_fit_parameters(
-    deriv: bool = False, model: str = "Voigt", baseline: str = "Linear", smoothing: None = None
+    deriv: bool = False,
+    model: str = "Voigt",
+    baseline: str = "Linear",
+    smoothing: None = None,
 ):
    """Store the fit parameters in a dictionary."""
    # map input model to lmfit model name
@@ -45,7 +54,10 @@ def get_data_from_h5(signal_name: str = "lu_bpmsum"):
    }


-def get_data_from_history(history_index: int, signal_name: str = "lu_bpmsum"):
+def get_data_from_history(
+    history_index: int,
+    signal_name: str = "lu_bpmsum",
+):
    """Read data from the BEC history and return the X and Y data as arrays."""
    scan = bec.history[history_index]
    md = scan.metadata["bec"]
@@ -84,7 +96,10 @@ def process_data(data, fit_params):
    else:
        fitting_data = y_data

-    updated_data = {"y_to_fit": fitting_data, "signal_name": signal_name}
+    updated_data = {
+        "y_to_fit": fitting_data,
+        "signal_name": signal_name,
+    }
    data.update(updated_data)
    return data

@@ -109,15 +124,23 @@ def fit(data, fit_params):
        params["base_slope"].set(value=0)

    # Add peak-specific parameters
-    params.update(peak_model.guess(processed_data["y_to_fit"], x=processed_data["x_data"]))
+    params.update(
+        peak_model.guess(processed_data["y_to_fit"], x=processed_data["x_data"])
+    )

    # Perform the fitting
-    lmfit_result = full_model.fit(processed_data["y_to_fit"], params, x=processed_data["x_data"])
+    lmfit_result = full_model.fit(
+        processed_data["y_to_fit"], params, x=processed_data["x_data"]
+    )

    # Find the X that gives the max Y
    max_index = np.argmax(processed_data["y_to_fit"])
    x_max = processed_data["x_data"][max_index]

+    # Generate data for a smoothed fit curve
+    fit_xdata = np.linspace(np.min(data["x_data"]), np.max(data["x_data"]), 500)
+    fit_ydata = lmfit_result.eval(x=fit_xdata, params=lmfit_result.params)
+
    # Collect results
    return {
        "model": fit_params["model"].__name__,
@@ -127,20 +150,15 @@ def fit(data, fit_params):
        "chi_sq": lmfit_result.chisqr,
        "lmfit_result": lmfit_result,
        "x_max": x_max,
+        "fit_xdata": fit_xdata,
+        "fit_ydata": fit_ydata,
    }


 def plot_fitted_data(data, fit_result):
    """Plot the original data and the fitted model."""
    plt.plot(data["x_data"], data["y_to_fit"], label="Data")
-    plt.plot(
-        data["x_data"],
-        fit_result["lmfit_result"].best_fit,
-        "-",
-        label=f"FWHM = {fit_result['fwhm']:.3f},"
-        f"Centre = {fit_result['centre']:.3f}, "
-        f"Height = {fit_result['height']:.3f}",
-    )
+    plt.plot(fit_result['fit_xdata'], fit_result['fit_ydata'], label="Fit")
    plt.xlabel(data["motor_name"])
    plt.ylabel(data["signal_name"])
    plt.title(f"Scan {data['scan_number']}, fitted with {fit_result['model']}")
@@ -154,17 +172,20 @@ def select_bec_window(dock_area_name="Fitting"):
    open_docks = bec.gui.windows
    if open_docks.get(dock_area_name) is None:
        dock_area = bec.gui.new(dock_area_name)
-        wf = dock_area.new(bec.gui.available_widgets.Waveform, object_name="Plot")
-        text_box = dock_area.new(
-            bec.gui.available_widgets.TextBox, object_name="Results", where="bottom"
-        )
+        # wf = dock_area.new("Plot").new(bec.gui.available_widgets.Waveform)
+        wf = dock_area.new(widget='Waveform', object_name='Plot')
+        text_box = dock_area.new(widget='TextBox', object_name="Results", where="bottom")
    else:
-        wf = bec.gui.Fitting.Plot.Waveform
-        text_box = bec.gui.Fitting.Results.TextBox
+        wf = bec.gui.Fitting.Plot
+        text_box = bec.gui.Fitting.Results
    return wf, text_box


-def plot_live_data_bec(motor_name, signal_name, window_name="Fitting"):
+def plot_live_data_bec(
+    motor_name,
+    signal_name,
+    window_name="Fitting"
+):
    """
    Plotting live data for motor and signal using BEC.

@@ -189,7 +210,10 @@ def plot_live_data_bec(motor_name, signal_name, window_name="Fitting"):
    wf.plot(device_x=motor_name, device_y=signal_name)


-def plot_fitted_data_bec(data, fit_result):
+def plot_fitted_data_bec(
+    data,
+    fit_result,
+):
    """
    Plot fitted data and display fitting parameters in the specified window.

@@ -221,5 +245,8 @@ def plot_fitted_data_bec(data, fit_result):
    wf.title = f"Scan: {data['scan_number']}"
    wf.x_label = data["motor_name"]
    wf.y_label = data["signal_name"]
-    wf.plot(x=data["x_data"], y=data["y_to_fit"], label="data")
-    wf.plot(x=data["x_data"], y=fit_result["lmfit_result"].best_fit, label="Fit to data")
+    wf.plot(x=data["x_data"], y=data["y_to_fit"], label="Data")
+    wf.plot(x=fit_result["fit_xdata"], y=fit_result["fit_ydata"], label="Fit")
+    # wf.Fit.set(symbol_size = 0)
+    wf.get_curve('Fit').set(symbol_size=0)
+
@@ -74,7 +74,7 @@ def move_to_position(motor_device, motor_name: str, position: float, data: dict)
        scans.umv(motor_device, motor_centre, relative=False)
        msg = (
            f"Position {position: .2f} is outside the scan range of "
-            f"{motor_min: .2f}to {motor_max: .2f}. "
+            f"{motor_min: .2f} to {motor_max: .2f}. "
            f"Returning to centre of scan range {motor_centre: .3f}."
        )
        raise ValueError(msg)
@@ -249,79 +249,42 @@ def scan_bpm(bpmname):

    # Open a dock area and set up the heatmaps
    dock_area = bec.gui.new("XBPM_Scan")
-    wf5 = dock_area.new(bec.gui.available_widgets.Heatmap, object_name="Sum")
-    wf1 = dock_area.new(
-        bec.gui.available_widgets.Heatmap,
-        object_name="Ch1",
-        relative_to="Sum",
-        where="bottom",
+    wf5 = dock_area.new("Sum").new(bec.gui.available_widgets.Heatmap)
+    wf1 = dock_area.new("Ch1", relative_to="Sum", position="bottom").new(
+        bec.gui.available_widgets.Heatmap
    )
-    wf3 = dock_area.new(
-        bec.gui.available_widgets.Heatmap,
-        object_name="Ch3",
-        relative_to="Ch1",
-        where="right",
+    wf3 = dock_area.new("Ch3", relative_to="Ch1", position="right").new(
+        bec.gui.available_widgets.Heatmap
    )
-    wf4 = dock_area.new(
-        bec.gui.available_widgets.Heatmap,
-        object_name="Ch4",
-        relative_to="Ch3",
-        where="bottom",
+    wf4 = dock_area.new("Ch4", relative_to="Ch3", position="bottom").new(
+        bec.gui.available_widgets.Heatmap
    )
-    wf2 = dock_area.new(
-        bec.gui.available_widgets.Heatmap,
-        object_name="Ch2",
-        relative_to="Ch1",
-        where="bottom",
+    wf2 = dock_area.new("Ch2", relative_to="Ch1", position="bottom").new(
+        bec.gui.available_widgets.Heatmap
    )
-    wfscan = dock_area.new(bec.gui.available_widgets.ScanControl, object_name="ScanControl")
+    wfscan = dock_area.new("ScanControl").new(bec.gui.available_widgets.ScanControl)

    cfg = getattr(BPMScans, bpmname)

    wf1.x_label = cfg["x_name"]
    wf1.y_label = cfg["y_name"]
-    wf1.plot(
-        device_x=cfg["x_name"],
-        device_y=cfg["y_name"],
-        device_z=cfg["z1_name"],
-        color_map="plasma",
-    )
+    wf1.plot(x_name=cfg["x_name"], y_name=cfg["y_name"], z_name=cfg["z1_name"], color_map="plasma")

    wf2.x_label = cfg["x_name"]
    wf2.y_label = cfg["y_name"]
-    wf2.plot(
-        device_x=cfg["x_name"],
-        device_y=cfg["y_name"],
-        device_z=cfg["z2_name"],
-        color_map="plasma",
-    )
+    wf2.plot(x_name=cfg["x_name"], y_name=cfg["y_name"], z_name=cfg["z2_name"], color_map="plasma")

    wf3.x_label = cfg["x_name"]
    wf3.y_label = cfg["y_name"]
-    wf3.plot(
-        device_x=cfg["x_name"],
-        device_y=cfg["y_name"],
-        device_z=cfg["z3_name"],
-        color_map="plasma",
-    )
+    wf3.plot(x_name=cfg["x_name"], y_name=cfg["y_name"], z_name=cfg["z3_name"], color_map="plasma")

    wf4.x_label = cfg["x_name"]
    wf4.y_label = cfg["y_name"]
-    wf4.plot(
-        device_x=cfg["x_name"],
-        device_y=cfg["y_name"],
-        device_z=cfg["z4_name"],
-        color_map="plasma",
-    )
+    wf4.plot(x_name=cfg["x_name"], y_name=cfg["y_name"], z_name=cfg["z4_name"], color_map="plasma")

    wf5.x_label = cfg["x_name"]
    wf5.y_label = cfg["y_name"]
-    wf5.plot(
-        device_x=cfg["x_name"],
-        device_y=cfg["y_name"],
-        device_z=cfg["z5_name"],
-        color_map="plasma",
-    )
+    wf5.plot(x_name=cfg["x_name"], y_name=cfg["y_name"], z_name=cfg["z5_name"], color_map="plasma")
    # Run the scan
    x_mot = cfg["x_device"]
    y_mot = cfg["y_device"]
@@ -341,20 +304,15 @@ def optimise_kb(mirror):

    # Open a dock area and set up the heatmaps
    dock_area = bec.gui.new(mirror)
-    wf1 = dock_area.new(bec.gui.available_widgets.Heatmap, object_name="Heatmap")
+    wf1 = dock_area.new("Heatmap").new(bec.gui.available_widgets.Heatmap)

-    wfscan = dock_area.new(bec.gui.available_widgets.ScanControl, object_name="ScanControl")
+    wfscan = dock_area.new("ScanControl").new(bec.gui.available_widgets.ScanControl)

    cfg = getattr(MirrorConfig, mirror)

    wf1.x_label = cfg["bu_name"]
    wf1.y_label = cfg["bd_name"]
-    wf1.plot(
-        device_x=cfg["bu_name"],
-        device_y=cfg["bd_name"],
-        device_z=cfg["z_name"],
-        color_map="plasma",
-    )
+    wf1.plot(x_name=cfg["bu_name"], y_name=cfg["bd_name"], z_name=cfg["z_name"], color_map="plasma")

    # Run the scan
    x_mot = cfg["x_device"]
@@ -0,0 +1,234 @@
+"""Planner to move between beamline states"""
+from enum import Enum
+import yaml
+from collections import defaultdict, deque
+
+
+class BeamlineState(str, Enum):
+    ROBOT_SAMPLE_EXCHANGE = "robot_sample_exchange"
+    SAMPLE_ALIGNMENT = "sample_alignment"
+    DATA_COLLECTION = "data_collection"
+    DC_XRF = "DC_XRF"
+    MANUAL_SAMPLE_EXCHANGE = "manual_sample_exchange"
+    BEAM_VISUALISATION = "beam_visualisation"
+    FLUX_MEASUREMENT = "flux_measurement"
+    BEAMSTOP_ALIGNMENT = "beamstop_alignment"
+    MAINTENANCE = "maintenance"
+    XTAL_SNAPSHOT = "xtal_snapshot"
+
+class TemperatureMode(str, Enum):
+    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:
+    """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,
+                 ):
+        self.devices = devices
+        self.states = states
+        self.allow_modifiers = allow_modifiers or {}
+        self.deps = deps
+        self.debug = debug
+
+        self.modifiers = {
+            TemperatureMode.CRYO: {"cryo_pos": "in"},
+            TemperatureMode.ROOM_TEMP: {"cryo_pos": "out"},
+        }
+
+    def _merged_state(self, state, modifier):
+        target = dict(self.states[state])
+
+        if modifier:
+            if isinstance(modifier, str):
+                modifier = TemperatureMode(modifier)
+
+            if self.allow_modifiers.get(state, False):
+                target.update(self.modifiers[modifier])
+        return target
+
+    def move_to(self, state_name, modifier=None):
+        """Move devices to the correct positions to achieve a given state"""
+        if isinstance(state_name, str):
+            state_name = BeamlineState(state_name)
+        target = self._merged_state(state_name, modifier)
+
+        plan = self._plan(target)
+
+        print("PLAN:")
+        for i, stage in enumerate(plan):
+            print(f"Stage {i + 1}: {stage}")
+
+        for stage in plan:
+            for dev, pos in stage:
+                d = self.devices[dev]
+                if not d.is_at(pos):
+
+                    if self.debug:
+                        print(f"→ Moving {dev} -> {pos}")
+                        # print("  Before:", self.get_states())
+
+                    try:
+                        d.move(pos)
+
+                    except Exception as e:
+                        print(f"Exception occurred: {e}")
+                        print(f"\nFAILED MOVE: {dev} -> {pos}")
+                        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())
+
+    def get_positions(self):
+        """Return current positions of all SE devices"""
+        return {name: dev.pos for name, dev in self.devices.items()}
+
+    def print_positions(self):
+        """Return current state of all devices"""
+        for name, device in self.devices.items():
+            print(f"{name:10s} : {device.pos}")
+
+    def diff_states(self, before):
+        """Return a dict of {device: (before, after)} pairs for devices that changed state"""
+        after = self.get_positions()
+        return {k: (before[k], after[k]) for k in before if before[k] != after[k]}
+
+    def current_state(self):
+        """Return all current matching BeamlineState and TemperatureMode combinations,
+        prioritizing non-None modifiers first."""
+        matches = []  # Store all matching (state, modifier) pairs
+        for state in self.states:
+            # Start with prioritized modifiers: Non-None first, then None.
+            modifiers = list(self.modifiers.keys())
+            modifiers.append(None)  # Add `None` as a fallback after real modifiers.
+
+            for modifier in modifiers:
+                # Combine state and modifier to get full configuration
+                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()):
+                    # print(f"Current state: {state.name}, Modifier: {modifier.name if modifier else 'None'}")
+                    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()
+        if not actual:
+            return False
+
+        if modifier is None:
+            # match any modifier
+            return any(s == state.name for s, _ in actual)
+
+        return (state.name, modifier.name) in actual
+
+    def _plan(self, target):
+
+            graph = defaultdict(set)
+            indeg = defaultdict(int)
+            nodes = set()
+
+            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)
+
+            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")],
+        ("diag_y", "i1"): [("gon_x", "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")]
+    }
+
+
@@ -0,0 +1,69 @@
+'''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'''
+    g = guards_setup(d)
+    if g["diag_y_out"].check() and g["coll_y_out"].check() and g["gonx_out"].check():
+        return True
+    return False
+
+
+def is_sample_area_clear_for_gonx(d):
+    '''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
+        if target >= cfg["out"] and not is_sample_area_clear_for_gonx(d):
+            raise GuardViolation("Sample area is not clear")
+
+    return gon_x_policy
+
+
+def make_bs_z_policy(d):
+    '''Create the policy for bs_z'''
+    def bs_z_policy(target):
+        """Checks that the target position is within limits"""
+        cfg = d["bs_z"].positions
+        # Lower bound
+        if target < cfg["work_min"] and not is_sample_area_clear_for_beamstop(d):
+            raise GuardViolation("Sample area is not clear")
+        if target < cfg["min"]:
+            raise GuardViolation(
+                f"Requested beamstop Z {target} is below recommended minimum {cfg['min']}"
+            )
+        # Upper bound
+        if d["bl_pos"].pos == "in" and target > cfg["max_blin"]:
+            raise GuardViolation(
+                f"Beamstop Z cannot move beyond {cfg['max_blin']} when backlight is IN"
+            )
+
+    return bs_z_policy
+
+
+def make_diag_y_policy(d):
+    '''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"].pos == "in" and target > cfg["out"]:
+            raise GuardViolation(
+                f"Diagnostic device cannot move beyond {cfg['out']} when goniometer is IN"
+            )
+
+    return diag_y_policy
+
+
+def attach_policies(d):
+    '''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["diag_y"].policy = make_diag_y_policy(d)
@@ -81,6 +81,7 @@ def set_mirror_stripe(energy_ev):
 def mono_pitch_scan(plot=True):
    """Scan the monochromator pitch and move to the peak."""
    # Move to the calculated pitch value for the current energy
+    print("Starting Mono Pitch Scan.")
    energy = get_current_energy()
    pos = get_dcm_motors_positions(energy)
    print(f"Setting DCM Pitch to default value of {pos['dcm_pitch']}")
@@ -1,10 +1,7 @@
 """File to store beamline parameters and defaults"""

 from dataclasses import dataclass
-from typing import Callable
 import numpy as np
-import yaml
-



@@ -16,7 +13,7 @@ class EnergyDefaults:
    min_energy_ev = 4800
    max_energy_ev = 30002
    beam_offset = 6
-    signals = {"sig1": dev.lu_bpmsum, "sig2": dev.bsc_bpmsum, "sig3": dev.bcu_bpmsum}
+    signals = {"sig1": dev.lu_bpmsum, "sig2": dev.ss_bpmsum, "sig3": dev.bcu_bpmsum}
    energy = dev.dcm_bragg
    mono_pitch = dev.dcm_pitch
    mono_perp = dev.dcm_perp
@@ -148,15 +145,15 @@ class BPMScans:
        "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,
+        "x_name": dev.ss_bpm_x.name,
+        "y_name": dev.ss_bpm_y.name,
+        "z1_name": dev.ss_bpm1.name,
+        "z2_name": dev.ss_bpm2.name,
+        "z3_name": dev.ss_bpm3.name,
+        "z4_name": dev.ss_bpm4.name,
+        "z5_name": dev.ss_bpmsum.name,
+        "x_device": dev.ss_bpm_x,
+        "y_device": dev.ss_bpm_y,
    }
    bcu = {
        "x_name": dev.bcu_bpm_x.name,
@@ -191,148 +188,3 @@ class MirrorConfig:
    }


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