amor-eos 3.3.4__tar.gz → 3.3.5__tar.gz

{amor_eos-3.3.4 → amor_eos-3.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amor_eos
-Version: 3.3.4
+Version: 3.3.5
 Summary: EOS reflectometry reduction for AMOR instrument
 Author: Jochen Stahn - Paul Scherrer Institut
 Author-email: jochen.stahn@psi.ch

{amor_eos-3.3.4 → amor_eos-3.3.5}/amor_eos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amor_eos
-Version: 3.3.4
+Version: 3.3.5
 Summary: EOS reflectometry reduction for AMOR instrument
 Author: Jochen Stahn - Paul Scherrer Institut
 Author-email: jochen.stahn@psi.ch

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/__init__.py

@@ -2,5 +2,5 @@
 Package to handle data redction at the AMOR instrument to be used by __main__.py script.
 """
 
-__version__ = '3.3.4'
-__date__    = '2026-08-27'
+__version__ = '3.3.5'
+__date__    = '2026-11-06'

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/event_analysis.py

@@ -19,7 +19,7 @@ class ExtractWalltime(EventDataAction):
         wallTime = extract_walltime(dataset.data.events.tof,
                                     dataset.data.packets.start_index,
                                     dataset.data.packets.time)
-        logging.debug(f'        expending event stream by wallTime')
+        logging.debug(f'          expending event stream by wallTime')
         new_events = append_fields(dataset.data.events, [('wallTime', wallTime.dtype)])
         new_events.wallTime = wallTime
         dataset.data.events = new_events
@@ -156,12 +156,14 @@ class FilterQzRange(EventDataAction):
 
 class FilterByLog(EventDataAction):
 
-    def __init__(self, filter_string, remove_switchpulse=False):
+    def __init__(self, filter_string, remove_switchpulse=False, pre_switch=0, post_switch=0):
         if filter_string.startswith('!'):
             filter_string = filter_string[1:]
             remove_switchpulse = True
         self.filter_string = filter_string
         self.remove_switchpulse = remove_switchpulse
+        self.pre_switch = pre_switch
+        self.post_switch = post_switch
 
     def perform_action(self, dataset: EventDatasetProtocol) -> None:
         filter_variable = None
@@ -184,8 +186,13 @@ class FilterByLog(EventDataAction):
             add_log_to_pulses(filter_variable, dataset)
         fltr_pulses = eval(self.filter_string, {filter_variable: dataset.data.pulses[filter_variable]})
         if self.remove_switchpulse:
-            switched = fltr_pulses[:-1] & ~fltr_pulses[1:]
-            fltr_pulses[:-1] &= ~switched
+            switched = np.logical_xor(fltr_pulses[:-1], fltr_pulses[1:])
+            fltr_pulses[:-1] &= np.logical_not(switched)
+            for i in range(self.pre_switch):
+                fltr_pulses[:-2-i] &= np.logical_not(switched[1+i:])
+            for i in range(self.post_switch):
+                fltr_pulses[1+i:-1] &= np.logical_not(switched[:-1-i])
+        dataset.data.pulses.mask += EVENT_BITMASKS[filter_variable]*np.logical_not(fltr_pulses)
         goodTimeS = dataset.data.pulses.time[fltr_pulses]
         filter_e = np.logical_not(np.isin(dataset.data.events.wallTime, goodTimeS))
         dataset.data.events.mask += EVENT_BITMASKS[filter_variable]*filter_e

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/event_data_types.py

@@ -37,7 +37,7 @@ class DA00EventBuffer:
 # Structured datatypes used for event streams
 EVENT_TYPE = np.dtype([('tof', np.float64), ('pixelID', np.uint32), ('mask', np.int32)])
 PACKET_TYPE = np.dtype([('start_index', np.uint32), ('time', np.int64)])
-PULSE_TYPE = np.dtype([('time', np.int64), ('monitor', np.float32)])
+PULSE_TYPE = np.dtype([('time', np.int64), ('monitor', np.float32), ('mask', np.int32)])
 PC_TYPE = np.dtype([('current', np.float32), ('time', np.int64)])
 BM_TYPE = np.dtype([('value', np.int32), ('time', np.int64)])
 LOG_TYPE = np.dtype([('value', np.float32), ('time', np.int64)])

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/event_handling.py

@@ -134,6 +134,7 @@ class FilterMonitorThreshold(EventDataAction):
             raise ValueError(
                     "FilterMonitorThreshold requires walltTime to be extracted, please run ExtractWalltime first")
         low_current_filter = dataset.data.pulses.monitor>2*dataset.timing.tau*self.lowCurrentThreshold*1e-3
+        dataset.data.pulses.mask[np.logical_not(low_current_filter)] = EVENT_BITMASKS['MonitorThreshold']
         dataset.data.pulses.monitor[np.logical_not(low_current_filter)] = 0.
         goodTimeS = dataset.data.pulses.time[low_current_filter]
         filter_e = np.logical_not(np.isin(dataset.data.events.wallTime, goodTimeS))
@@ -197,19 +198,25 @@ class ApplyMask(EventDataAction):
         logging.info(f'      number of events: total = {pre_filter:7d}, after filtering = {post_filter:7d}')
         if d.device_logs == {} or not hasattr(dataset, 'update_info_from_logs'):
             return
-        if 'wallTime' in d.events.dtype.names:
-            # filter pulses and logs to allow update of header information
-            from .helpers import add_log_to_pulses
-            times = np.unique(d.events.wallTime)
-            # make sure all log variables are associated with pulses
-            for key, log in d.device_logs.items():
-                if not key in d.pulses.dtype.names:
-                    # interpolate the parameter values for all existing pulses
-                    add_log_to_pulses(key, dataset)
-            # remove all pulses that have no more events
-            d.pulses = d.pulses[np.isin(d.pulses.time, times)]
-            for key, log in d.device_logs.items():
-                d.device_logs[key] = np.recarray(d.pulses.shape, dtype = log.dtype)
-                d.device_logs[key].time = d.pulses.time
-                d.device_logs[key].value = d.pulses[key]
-            dataset.update_info_from_logs()
+        # filter pulses, not all masks apply to pulses
+        pre_filter_pulses = d.pulses.shape[0]
+        # make sure all log variables are associated with pulses
+        for key, log in d.device_logs.items():
+            if not key in d.pulses.dtype.names:
+                from .helpers import add_log_to_pulses
+                # interpolate the parameter values for all existing pulses
+                add_log_to_pulses(key, dataset)
+        if self.bitmask_filter is None:
+            d.pulses = d.pulses[d.pulses.mask==0]
+        else:
+            # remove the provided bitmask_filter bits from the events
+            # this means that all bits that are set in bitmask_filter will NOT be used to filter events
+            fltr = (d.pulses.mask & (~self.bitmask_filter)) == 0
+            d.pulses = d.pulses[fltr]
+        post_filter_pulses = d.pulses.shape[0]
+        logging.info(f'      number of pulses: total = {pre_filter_pulses:7d}, after filtering = {post_filter_pulses:7d}')
+        for key, log in d.device_logs.items():
+            d.device_logs[key] = np.recarray(d.pulses.shape, dtype = log.dtype)
+            d.device_logs[key].time = d.pulses.time
+            d.device_logs[key].value = d.pulses[key]
+        dataset.update_info_from_logs()

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/file_reader.py

@@ -527,11 +527,11 @@ class AmorEventData(AmorHeader):
             pulseTimeS = self._beam_monitor.time
         elif self.correctTimeFallback:
             logging.critical(
-                '      No chopper trigger data or monitor time available, using event stearm and packet times instead!')
+                '      No chopper trigger data or monitor time available, using event stream and packet times instead!')
             data_group = self.hdf[self.hdf_paths['data'][0]]
             startTime = np.array(data_group['event_time_zero'][0], dtype=np.int64)
             stopTime = np.array(data_group['event_time_zero'][-1], dtype=np.int64)
-            pulseTimeS = np.arange(startTime, stopTime, self.timing.tau*1e9, dtype=np.int64)
+            pulseTimeS = np.arange(startTime, stopTime+self.timing.tau*1e9, self.timing.tau*1e9, dtype=np.int64)
             # find times that are closest to the next packet time and correct them to fit exactly
             all_times = np.unique(packets.time)
             all_times.sort()
@@ -549,6 +549,7 @@ class AmorEventData(AmorHeader):
         pulses = np.recarray(pulseTimeS.shape, dtype=PULSE_TYPE)
         pulses.time = pulseTimeS
         pulses.monitor = 1. # default is monitor pulses as it requires no calculation
+        pulses.mask = 0
         # apply filter in case the events were filtered
         if (self.first_index>0 or not self.EOF):
             pulses = pulses[(pulses.time>=packets.time[0])&(pulses.time<=packets.time[-1])]
@@ -604,8 +605,9 @@ class AmorEventData(AmorHeader):
             output = np.recarray(a1.shape[0]+a2.shape[0], dtype=new_fields)
             for field in new_fields.fields.keys():
                 output[field] = np.concatenate([a1[field], a2[field]])
-            logging.warning("Missing data when combining datasets, "
-                            f"{tuple(a1.dtype.fields.keys())} != {tuple(a2.dtype.fields.keys())}")
+            logging.warning("      Missing data when combining datasets,\n"
+                            f"          {tuple(a1.dtype.fields.keys())} \n"
+                            f"        !={tuple(a2.dtype.fields.keys())}")
             return output
 
     def append(self, other):
@@ -625,7 +627,15 @@ class AmorEventData(AmorHeader):
         else:
             new_device_logs = {}
             for key, slog in self.data.device_logs.items():
-                olog = other.data.device_logs[key]
+                try:
+                    olog = other.data.device_logs[key]
+                except KeyError:
+                    if getattr(other.experiment, 'end_date', None) is None:
+                        logging.warning(f"      Device logs for '{key}' not found in dataset to be added, "
+                                        f"ignoring key as file is not finalized")
+                        continue
+                    else:
+                        raise KeyError(f"Device logs for '{key}' not found in dataset to be added")
                 new_device_logs[key] = np.recarray(slog.shape[0]+olog.shape[0],
                                                    dtype = slog.dtype)
                 new_device_logs[key].time = np.concatenate([slog.time, olog.time])
@@ -664,4 +674,7 @@ class AmorEventData(AmorHeader):
         output.data = AmorEventStream(self.data.events[event_filter], self.data.packets,
                                       self.data.pulses[pulse_filter], self.data.proton_current,
                                       self.data.beam_monitor)
+        for key, value in self.data.device_logs.items():
+            output.data.device_logs[key] = value[pulse_filter]
+        output.update_info_from_logs()
         return output

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/options.py

@@ -499,6 +499,15 @@ class ReflectivityReductionConfig(ArgParsable):
                 },
             )
 
+    flipperMaxDelay: int = field(
+            default=4,
+            metadata={
+                'short': 'fmd',
+                'group': 'data manicure',
+                'help':  'Remove all neutron pulses that are within flipperMaxDelay of a change in spin state',
+                },
+            )
+
 class OutputFomatOption(StrEnum):
     Rqz_ort = "Rqz.ort"
     Rqz_orb = "Rqz.orb"
@@ -640,6 +649,7 @@ class E2HPlotSelection(StrEnum):
     YZ = 'Iyz'
     LT = 'Ilt'
     YT = 'Iyt'
+    Z = 'Iz'
     TZ = 'Itz'
     Q = 'Iq'
     L = 'Il'

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/projection.py

@@ -237,7 +237,7 @@ class LZProjection(ProjectionInterface):
 
     def normalize_no_footprint(self, norm: LZNormalisation):
         norm_lz = norm.norm
-        ref_lz = (self.data.I/norm_lz)
+        ref_lz = (self.data.I/np.where(norm_lz>0, norm_lz, np.nan))
         ref_lz *= norm.monitor/self.monitor
         ref_lz[np.logical_not(self.data.mask)] = np.nan
         self.data.norm = norm_lz
@@ -249,8 +249,8 @@ class LZProjection(ProjectionInterface):
     def scale(self, factor: float):
         if not self.is_normalized:
             raise ValueError("Dataset needs to be normalized, first")
-        self.data.ref /= factor
-        self.data.err /= factor
+        self.data.ref *= factor
+        self.data.err *= factor
         self.norm_monitor *= factor
 
     def project_on_qz(self):
@@ -636,6 +636,77 @@ class TofZProjection(ProjectionInterface):
                 art.remove()
             plt.draw()
 
+class FltrZProjection(ProjectionInterface):
+    z: np.ndarray
+    tau: float
+    foldback: bool
+    l_range: Tuple[float, float]
+
+    data: np.recarray
+    _dtype = np.dtype([
+            ('cts', np.float64),
+            ('I', np.float64),
+            ('err', np.float64),
+            ])
+
+    def __init__(self, tau, foldback=False, l_range=(0., 15.0)):
+        self.l_range = l_range
+        self.tau = tau
+        self.z = np.arange(Detector.nBlades*Detector.nWires+1)-0.5
+        self.foldback = foldback
+        self.data = np.zeros(self.z.shape[0]-1, dtype=self._dtype).view(np.recarray)
+        self.monitor = 0.
+
+    def project(self, dataset: EventDatasetProtocol, monitor: float):
+        detYi, detZi, detX, delta = Detector.pixelLookUp[dataset.data.events.pixelID-1].T
+
+        fltr = dataset.data.events.lamda>=self.l_range[0]
+        fltr &= dataset.data.events.lamda<=self.l_range[1]
+
+        cts , *_ = np.histogram(detZi[fltr], bins=self.z)
+        self.data.cts += cts
+        self.monitor += monitor
+
+        self.data.I = self.data.cts / self.monitor
+        self.data.err = np.sqrt(self.data.cts) / self.monitor
+
+    def clear(self):
+        self.data[:] = 0
+        self.monitor = 0.
+
+    def plot(self, **kwargs):
+        from matplotlib import pyplot as plt
+
+        Z = (self.z[1:]+self.z[:-1])/2.
+        self._graph = plt.errorbar(Z, self.data.I, yerr=self.data.err, **kwargs)
+        ez, eI = self.find_lower_edge()
+        plt.plot([ez], [eI], 'ro')
+        plt.text(ez, 0., f'{ez:.1f}', ha='center', va='bottom')
+
+        plt.xlabel('Z')
+        plt.xlim(self.z[-1], self.z[0])
+        plt.title('Vertical Pixel w/ filter')
+
+    def update_plot(self):
+        """
+        Inline update of previous plot by just updating the data.
+        """
+        from matplotlib.colors import LogNorm
+        self._graph.set_array(self.data.I)
+
+    def find_lower_edge(self):
+        Imax = self.data.I.max()
+        next_pix = np.where(self.data.I>Imax/2.)[0][-1]
+        I_next = self.data.I[next_pix]
+        I_prev = self.data.I[next_pix+1]
+
+        Z = (self.z[1:]+self.z[:-1])/2.
+        nxt_prev_ratio = (Imax/2.-I_prev)/(I_next - Imax/2.)
+        z = Z[next_pix+1] + nxt_prev_ratio*(Z[next_pix]-Z[next_pix+1])
+        print(I_next - Imax/2., Imax/2.-I_prev, )
+        return z, Imax/2.
+
+
 class TofProjection(ProjectionInterface):
     tof: np.ndarray
 

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/reduction_e2h.py

@@ -19,10 +19,11 @@ from .normalization import LZNormalisation
 from .options import E2HConfig, E2HPlotArguments, IncidentAngle, MonitorType, E2HPlotSelection
 from . import event_handling as eh
 from .path_handling import PathResolver
-from .projection import CombinedProjection, LProjection, LZProjection, ProjectionInterface, ReflectivityProjector, \
-    TofProjection,  TofZProjection,  TProjection, YTProjection, YZProjection
+from .projection import CombinedProjection, FltrZProjection, LProjection, LZProjection, ProjectionInterface, \
+    ReflectivityProjector, \
+    TofProjection, TofZProjection, TProjection, YTProjection, YZProjection
 
-NEEDS_LAMDA = (E2HPlotSelection.All, E2HPlotSelection.LT, E2HPlotSelection.Q, E2HPlotSelection.L)
+NEEDS_LAMDA = (E2HPlotSelection.All, E2HPlotSelection.LT, E2HPlotSelection.Q, E2HPlotSelection.L, E2HPlotSelection.Z)
 
 class E2HReduction:
     config: E2HConfig
@@ -97,7 +98,8 @@ class E2HReduction:
         self.event_actions |= eh.ApplyMask()
 
         # plot dependant options
-        if self.config.reduction.plot in [E2HPlotSelection.All, E2HPlotSelection.LT, E2HPlotSelection.Q]:
+        if self.config.reduction.plot in [E2HPlotSelection.All, E2HPlotSelection.LT,
+                                          E2HPlotSelection.Q, E2HPlotSelection.Z]:
             self.grid = LZGrid(0.05, [0.0, 0.25], lambda_overwrite=self.config.experiment.lambdaRange)
             self.grid.dldl = 0.01
 
@@ -195,6 +197,11 @@ class E2HReduction:
         if self.config.reduction.plot==E2HPlotSelection.TZ:
             self.projection = TofZProjection(last_file_header.timing.tau, foldback=not self.config.reduction.fast)
 
+        if self.config.reduction.plot==E2HPlotSelection.Z:
+            self.projection = FltrZProjection(last_file_header.timing.tau,
+                                              foldback=not self.config.reduction.fast,
+                                              l_range=self.config.experiment.lambdaRange)
+
         if self.config.reduction.plot==E2HPlotSelection.ToF:
             self.projection = TofProjection(last_file_header.timing.tau, foldback=not self.config.reduction.fast)
 

{amor_eos-3.3.4 → amor_eos-3.3.5}/eos/reduction_reflectivity.py

@@ -125,6 +125,8 @@ class ReflectivityReduction:
                 _sampleName = 'unknown'
             _mu = int(self.dataset.geometry.mu * 3)
             self.config.output.outputName = f'{_sampleName}_{_mu:03}_{_date}'
+        elif self.config.output.outputName.endswith('.Rqz.ort'):
+            self.config.output.outputName = self.config.output.outputName[:-len('.Rqz.ort')]
 
         logging.warning('output:')
 
@@ -145,9 +147,10 @@ class ReflectivityReduction:
         logging.warning('input:')
         file_list = self.path_resolver.resolve(short_notation)
 
-        self.header.measurement_data_files = []
 
         self.dataset = AmorEventData(file_list[0])
+        self.header.measurement_data_files = [
+            fileio.File( file=os.path.basename(file_list[0]), timestamp=self.dataset.fileDate)]
         if self.config.experiment.monitorType==MonitorType.auto:
             if self.dataset.data.proton_current.current.sum()>1:
                 self.config.experiment.monitorType = MonitorType.proton_charge
@@ -169,10 +172,8 @@ class ReflectivityReduction:
             di = AmorEventData(fi)
             self.dataevent_actions(di)
             self.dataset.append(di)
-
-        for fileName in file_list:
-            self.header.measurement_data_files.append(fileio.File( file=os.path.basename(fileName),
-                                                                   timestamp=self.dataset.fileDate))
+            self.header.measurement_data_files.append(fileio.File( file=os.path.basename(fi),
+                                                                   timestamp=di.fileDate))
 
         if 'polarization_config_label' in self.dataset.data.device_logs:
             pols = np.unique(self.dataset.data.device_logs['polarization_config_label'].value)
@@ -185,7 +186,9 @@ class ReflectivityReduction:
                 for pi in pols:
                     plabel = const.polarizationLabels[pi]
                     pol_filter = FilterByLog(f'polarization_config_label=={pi}',
-                                             remove_switchpulse=True) | ApplyMask()
+                                             remove_switchpulse=True,
+                                             pre_switch=self.config.reduction.flipperMaxDelay
+                                             ) | ApplyMask()
                     logging.info(f'    filter {plabel} using polarization_config_label=={pi}')
                     pol_filter(self.dataset)
                     self.dataset.update_header(self.header)
@@ -238,7 +241,7 @@ class ReflectivityReduction:
                     logging.warning(
                             f'backgroung file {self.sFileName} not compatible with q_z scale ({len(self.sq_q)} vs. {len(result.Q)})')
 
-            if not self.config.reduction.is_default('scale'):
+            if self.config.reduction.autoscale and not self.config.reduction.is_default('scale'):
                 try:
                     scale = self.config.reduction.scale[i]
                 except IndexError:
@@ -366,7 +369,7 @@ class ReflectivityReduction:
         self.last_result = result
         # reset normal logging behavior
         #logging.StreamHandler.terminator = "\n"
-        logging.info(f'      done  {min(time+interval, pulseTimeS[-1]):5.0f}')
+        logging.info(f'      done   {min(time+interval, pulseTimeS[-1]):5.0f}')
 
     def save_Rqz(self):
         fname = os.path.join(self.config.output.outputPath, f'{self.config.output.outputName}.Rqz.ort')

{amor_eos-3.3.4 → amor_eos-3.3.5}/tests/test_event_handling.py

@@ -53,6 +53,7 @@ class MockEventData:
         pulses = np.recarray((packets.shape[0],), dtype=PULSE_TYPE)
         pulses.monitor = 1.0
         pulses.time = packets.time
+        pulses.mask = 0
 
         # proton current information with independent timing
         proton_current = np.recarray((50,), dtype=PC_TYPE)
@@ -552,27 +553,65 @@ class TestSimpleActions(TestCase):
 
         self._extract_walltime()
 
-        test_log = np.recarray(shape=(2,), dtype=np.dtype([('value', np.int32),
-                                                           ('time', np.int64)]))
-        test_log.time = [-5, self.d.data.pulses.time[100]+123]
-        test_log.value = [0, 1]
+        test_log = np.recarray(shape=(self.d.data.pulses.shape[0],),
+                               dtype=np.dtype([('value', np.int32), ('time', np.int64)]))
+        test_log.time = self.d.data.pulses.time
+        test_log.value = 0
+        test_log.value[10:-10] = 1
         self.d.data.device_logs['test_log'] = test_log
         action.perform_action(self.d)
-        self.assertEqual(self.d.data.pulses.shape[0], 101)
+        self.assertEqual(20, self.d.data.pulses.shape[0])
 
     def test_filter_by_log_switchpulse(self):
         action = FilterByLog("!test_log==0") | ApplyMask()
         self._extract_walltime()
 
-        test_log = np.recarray(shape=(2,), dtype=np.dtype([('value', np.int32),
-                                                           ('time', np.int64)]))
-        test_log.time = [-5, self.d.data.pulses.time[100]+123]
-        test_log.value = [0, 1]
+        test_log = np.recarray(shape=(self.d.data.pulses.shape[0],),
+                               dtype=np.dtype([('value', np.int32), ('time', np.int64)]))
+        test_log.time = self.d.data.pulses.time
+        test_log.value = 0
+        test_log.value[10:-10] = 1
         self.d.data.device_logs['test_log'] = test_log
         self.d.data.device_logs['check_log'] = test_log.copy()
         action.perform_action(self.d)
-        self.assertEqual(self.d.data.pulses.shape[0], 100)
+        self.assertEqual(19, self.d.data.pulses.shape[0])
         np.testing.assert_array_equal(
                 self.d.data.device_logs['test_log'],
                 self.d.data.device_logs['check_log'],
-                )
+                )
+
+    def test_filter_by_log_preswitch(self):
+        action = FilterByLog("!test_log==0", pre_switch=2) | ApplyMask()
+        self._extract_walltime()
+
+        test_log = np.recarray(shape=(self.d.data.pulses.shape[0],),
+                               dtype=np.dtype([('value', np.int32), ('time', np.int64)]))
+        test_log.time = self.d.data.pulses.time
+        test_log.value = 0
+        test_log.value[10:-10] = 1
+        self.d.data.device_logs['test_log'] = test_log
+        self.d.data.device_logs['check_log'] = test_log.copy()
+        action.perform_action(self.d)
+        self.assertEqual(17, self.d.data.pulses.shape[0])
+        np.testing.assert_array_equal(
+                self.d.data.device_logs['test_log'],
+                self.d.data.device_logs['check_log'],
+                )
+
+    def test_filter_by_log_postswitch(self):
+        action = FilterByLog("!test_log==0", post_switch=2) | ApplyMask()
+        self._extract_walltime()
+
+        test_log = np.recarray(shape=(self.d.data.pulses.shape[0],),
+                               dtype=np.dtype([('value', np.int32), ('time', np.int64)]))
+        test_log.time = self.d.data.pulses.time
+        test_log.value = 0
+        test_log.value[10:-10] = 1
+        self.d.data.device_logs['test_log'] = test_log
+        self.d.data.device_logs['check_log'] = test_log.copy()
+        action.perform_action(self.d)
+        self.assertEqual(17, self.d.data.pulses.shape[0])
+        np.testing.assert_array_equal(
+                self.d.data.device_logs['test_log'],
+                self.d.data.device_logs['check_log'],
+                )