WIP: Trexafs

startup/30-scaler.py

@@ -154,6 +154,58 @@ def export_sis_data(ion, filepath, zebra):
         f.close()
 
 
+def export_sis_data_laser(ion, filepath, zebra):
+    N = ion.nuse_all.get()
+    t = ion.mca1.get(timeout=5.0)
+    i = ion.mca2.get(timeout=5.0)
+    im = ion.mca3.get(timeout=5.0)
+    it = ion.mca4.get(timeout=5.0)
+    while len(t) == 0 and len(t) != len(i):
+        t = ion.mca1.get(timeout=5.0)
+        i = ion.mca2.get(timeout=5.0)
+        im = ion.mca3.get(timeout=5.0)
+        it = ion.mca4.get(timeout=5.0)
+
+    if len(i) != N:
+        print(f'Scaler did not receive collect enough points.')
+        ## Try one more time
+        t = ion.mca1.get(timeout=5.0)
+        i = ion.mca2.get(timeout=5.0)
+        im = ion.mca3.get(timeout=5.0)
+        it = ion.mca4.get(timeout=5.0)
+        if len(i) != N:
+            print(f'Nope. Only received {len(i)}/{N} points.')
+
+    correct_length = N
+    # correct_length = zebra.pc.data.num_down.get()
+    # Only consider even points
+    with h5py.File(filepath, "w") as f:
+        if len(t) != correct_length:
+            correction_factor = correct_length - len(t)
+            print(f"Adding {correction_factor} points to scaler!")
+            print(f"t is not the correct length. {t} != {correct_length}")
+            correction_list = [1e10 for _ in range(0, int(correction_factor))]
+            new_t = [k for k in t] + correction_list
+            new_i = [k for k in i] + correction_list
+            new_im = [k for k in im] + correction_list
+            new_it = [k for k in it] + correction_list
+        else:
+            correction_factor = 0
+            new_t = t
+            new_i = i
+            new_im = im
+            new_it = it
+        dset0 = f.create_dataset("time", (correct_length,), dtype="f")
+        dset0[...] = np.array(new_t)
+        dset1 = f.create_dataset("i0", (correct_length,), dtype="f")
+        dset1[...] = np.array(new_i)
+        dset2 = f.create_dataset("im", (correct_length,), dtype="f")
+        dset2[...] = np.array(new_im)
+        dset3 = f.create_dataset("it", (correct_length,), dtype="f")
+        dset3[...] = np.array(new_it)
+        f.close()
+
+
 class SISHDF5Handler(HandlerBase):
     HANDLER_NAME = "SIS_HDF51"
 

startup/31-xspress3.py

@@ -333,6 +333,10 @@ class SrxXspress3Detector(SRXXspressTrigger, Xspress3Detector):
     # replace HDF5:FileCreateDir with HDF1:FileCreateDir
     create_dir = Cpt(EpicsSignal, "HDF5:FileCreateDir")
 
+    # deadtime correction on/off attribute, added by YY
+    # dt_correction = Cpt(EpicsSignal, "det1:CTRL_DTC")
+
+
     hdf5 = Cpt(
         Xspress3FileStoreFlyable,
         "HDF5:",

startup/32-zebra.py

@@ -183,7 +183,7 @@ def unstage(self):
         super().unstage()
 
 
-class SRXZebraOR(Device):
+class SRXZebraANDOR(Device):
     # I really appreciate the different indexing for input source
     # Thank you for that
     use1 = Cpt(EpicsSignal, '_ENA:B0')
@@ -206,28 +206,44 @@ def unstage(self):
         super().unstage()
 
 
-class SRXZebraAND(Device):
-    # I really appreciate the different indexing for input source
-    # Thank you for that
-    use1 = Cpt(EpicsSignal, '_ENA:B0')
-    use2 = Cpt(EpicsSignal, '_ENA:B1')
-    use3 = Cpt(EpicsSignal, '_ENA:B2')
-    use4 = Cpt(EpicsSignal, '_ENA:B3')
-    input_source1 = Cpt(EpicsSignal, '_INP1')
-    input_source2 = Cpt(EpicsSignal, '_INP2')
-    input_source3 = Cpt(EpicsSignal, '_INP3')
-    input_source4 = Cpt(EpicsSignal, '_INP4')
-    invert1 = Cpt(EpicsSignal, '_INV:B0')
-    invert2 = Cpt(EpicsSignal, '_INV:B1')
-    invert3 = Cpt(EpicsSignal, '_INV:B2')
-    invert4 = Cpt(EpicsSignal, '_INV:B3')
+class SRXZebraDIV(Device):
+    input_source = Cpt(EpicsSignal, 'INP')
+    div = Cpt(EpicsSignal, 'DIV')
+    first_pulse = FC(EpicsSignal, '{self._zebra_prefix}DIV_FIRST:{self._div_addr}')
+    trigger_on = FC(EpicsSignal, '{self._zebra_prefix}POLARITY:{self._edge_addr}')
+
+    _edge_addrs = {1: 'B8',
+                   2: 'B9',
+                   3: 'BA',
+                   4: 'BB',
+                   }
+    _div_addrs = {1: 'B0',
+                  2: 'B1',
+                  3: 'B2',
+                  4: 'B3',
+                 }
 
     def stage(self):
         super().stage()
 
     def unstage(self):
         super().unstage()
 
+    def __init__(self, prefix, *, index=None, parent=None,
+                 configuration_attrs=None, read_attrs=None, **kwargs):
+        if read_attrs is None:
+            read_attrs = ['input_source', 'div', 'first_pulse', 'trigger_on']
+        if configuration_attrs is None:
+            configuration_attrs = []
+
+        zebra = parent
+        self.index = index
+        self._zebra_prefix = zebra.prefix
+        self._edge_addr = self._edge_addrs[index]
+        self._div_addr = self._div_addrs[index]
+
+        super().__init__(prefix, configuration_attrs=configuration_attrs,
+                         read_attrs=read_attrs, parent=parent, **kwargs)
 
 
 class ZebraPulse(Device):
@@ -240,8 +256,7 @@ class ZebraPulse(Device):
     time_units = Cpt(EpicsSignalWithRBV, 'PRE', string=True)
     output = Cpt(EpicsSignal, 'OUT')
 
-    input_edge = FC(EpicsSignal,
-                    '{self._zebra_prefix}POLARITY:{self._edge_addr}')
+    input_edge = FC(EpicsSignal, '{self._zebra_prefix}POLARITY:{self._edge_addr}')
 
     _edge_addrs = {1: 'BC',
                    2: 'BD',
@@ -278,18 +293,22 @@ class SRXZebra(Zebra):
     """
 
     pc = Cpt(ZebraPositionCapture, "")
-    or1 = Cpt(SRXZebraOR, "OR1")  # XF:05IDD-ES:1{Dev:Zebra2}:OR1_INV:B0
-    or2 = Cpt(SRXZebraOR, "OR2")
-    or3 = Cpt(SRXZebraOR, "OR3")
-    or4 = Cpt(SRXZebraOR, "OR4")
-    and1 = Cpt(SRXZebraAND, "AND1")  # XF:05IDD-ES:1{Dev:Zebra2}:AND1_ENA:B0
-    and2 = Cpt(SRXZebraAND, "AND2")
-    and3 = Cpt(SRXZebraAND, "AND3")
-    and4 = Cpt(SRXZebraAND, "AND4")
+    and1 = Cpt(SRXZebraANDOR, "AND1")
+    and2 = Cpt(SRXZebraANDOR, "AND2")
+    and3 = Cpt(SRXZebraANDOR, "AND3")
+    and4 = Cpt(SRXZebraANDOR, "AND4")
+    or1 = Cpt(SRXZebraANDOR, "OR1")  # XF:05IDD-ES:1{Dev:Zebra2}:OR1_INV:B0
+    or2 = Cpt(SRXZebraANDOR, "OR2")
+    or3 = Cpt(SRXZebraANDOR, "OR3")
+    or4 = Cpt(SRXZebraANDOR, "OR4")
     pulse1 = Cpt(ZebraPulse, "PULSE1_", index=1)  # XF:05IDD-ES:1{Dev:Zebra2}:PULSE1_INP
     pulse2 = Cpt(ZebraPulse, "PULSE2_", index=2)
     pulse3 = Cpt(ZebraPulse, "PULSE3_", index=3)
     pulse4 = Cpt(ZebraPulse, "PULSE4_", index=4)
+    div1 = Cpt(SRXZebraDIV, "DIV1_", index=1)
+    div2 = Cpt(SRXZebraDIV, "DIV2_", index=2)
+    div3 = Cpt(SRXZebraDIV, "DIV3_", index=3)
+    div4 = Cpt(SRXZebraDIV, "DIV4_", index=4)
 
     def stage(self):
         super().stage()
@@ -386,7 +405,7 @@ def set_flyer_zebra_stage_sigs(flyer, method):
         # flyer.stage_sigs[flyer._encoder.pulse1.delay] = 0.2
         # flyer.stage_sigs[flyer._encoder.pulse1.width] = 0.1
         # flyer.stage_sigs[flyer._encoder.pulse1.time_units] = 0
-        flyer.stage_sigs[flyer._encoder.pulse2.input_addr] = 30
+        flyer.stage_sigs[flyer._encoder.pulse2.input_addr] = 31
         flyer.stage_sigs[flyer._encoder.pulse2.input_edge] = 0  # 0 = rising, 1 = falling
         flyer.stage_sigs[flyer._encoder.pulse2.delay] = 0
         flyer.stage_sigs[flyer._encoder.pulse2.width] = 0.1
@@ -438,11 +457,11 @@ def set_flyer_zebra_stage_sigs(flyer, method):
         # flyer.stage_sigs[flyer._encoder.pulse1.delay] = 0.2
         # flyer.stage_sigs[flyer._encoder.pulse1.width] = 0.1
         # flyer.stage_sigs[flyer._encoder.pulse1.time_units] = 0
-        # flyer.stage_sigs[flyer._encoder.pulse2.input_addr] = 30
-        # flyer.stage_sigs[flyer._encoder.pulse2.input_edge] = 0  # 0 = rising, 1 = falling
-        # flyer.stage_sigs[flyer._encoder.pulse2.delay] = 0
-        # flyer.stage_sigs[flyer._encoder.pulse2.width] = 0.1
-        # flyer.stage_sigs[flyer._encoder.pulse2.time_units] = 0
+        flyer.stage_sigs[flyer._encoder.pulse2.input_addr] = 30
+        flyer.stage_sigs[flyer._encoder.pulse2.input_edge] = 0  # 0 = rising, 1 = falling
+        flyer.stage_sigs[flyer._encoder.pulse2.delay] = 0
+        flyer.stage_sigs[flyer._encoder.pulse2.width] = 0.45
+        flyer.stage_sigs[flyer._encoder.pulse2.time_units] = 1
         flyer.stage_sigs[flyer._encoder.pulse3.input_addr] = 31
         flyer.stage_sigs[flyer._encoder.pulse3.input_edge] = 0  # 0 = rising, 1 = falling
         flyer.stage_sigs[flyer._encoder.pulse3.delay] = 0.0
@@ -826,10 +845,11 @@ def complete(self):
             ttime.sleep(0.01)
             if (ttime.monotonic() - t0) > 60:
                 print(f"{self.name} is behaving badly!")
-                self._encoder.pc.disarm.put(1)
-                ttime.sleep(0.100)
-                if self._encoder.pc.data_in_progress.get() == 1:
-                    raise TimeoutError
+                #self._encoder.pc.disarm.put(1)
+                #ttime.sleep(0.100)
+                #if self._encoder.pc.data_in_progress.get() == 1:
+                    #raise TimeoutError
+                break
 
         # ttime.sleep(.1)
         self._mode = "complete"
@@ -920,7 +940,12 @@ def get_sis_data():
 
         if amk_debug_flag:
             t_sisdata = tic()
-        get_sis_data()
+        if 'laser' in self.name:
+            export_sis_data_laser(
+                self._sis, self.__write_filepath_sis, self._encoder
+            )
+        else:
+            get_sis_data()
         if amk_debug_flag:
             toc(t_sisdata, str='Get SIS data')
 
@@ -1096,19 +1121,29 @@ def resume(self):
 
 def export_nano_zebra_data(zebra, filepath, fastaxis):
     j = 0
+    flag_bad_zebra = False
     while zebra.pc.data_in_progress.get() == 1:
         print("Waiting for zebra...")
         ttime.sleep(0.1)
         j += 1
         if j > 10:
             print("THE ZEBRA IS BEHAVING BADLY CARRYING ON")
+            flag_bad_zebra = True
+            zebra.pc.reset_block_state.put(1)
             break
 
     time_d = zebra.pc.data.time.get()
     enc1_d = zebra.pc.data.enc1.get()
     enc2_d = zebra.pc.data.enc2.get()
     enc3_d = zebra.pc.data.enc3.get()
 
+    # Drop the first point if Zebra is behaving badly
+    if flag_bad_zebra:
+        time_d = time_d[1:]
+        enc1_d = enc1_d[1:]
+        enc2_d = enc2_d[1:]
+        enc3_d = enc3_d[1:]
+
     px = zebra.pc.pulse_step.get()
     if fastaxis == 'NANOHOR':
         # Add half pixelsize to correct encoder