pytrms 0.9.6__tar.gz → 0.9.7__tar.gz

{pytrms-0.9.6 → pytrms-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pytrms
-Version: 0.9.6
+Version: 0.9.7
 Summary: Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS).
 License: GPL-2.0
 Author: Moritz Koenemann

{pytrms-0.9.6 → pytrms-0.9.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pytrms"
-version = "0.9.6"
+version = "0.9.7"
 description = "Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS)."
 authors = ["Moritz Koenemann <moritz.koenemann@ionicon.com>"]
 license = "GPL-2.0"

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/__init__.py

@@ -1,4 +1,4 @@
-_version = '0.9.6'
+_version = '0.9.7'
 
 __all__ = ['load', 'connect']
 
@@ -32,7 +32,7 @@ def connect(host='localhost', port=None, method='mqtt'):
     elif method.lower() == 'webapi':
         from .clients.ioniclient import IoniClient as _client
     elif method.lower() == 'modbus':
-        from .modbus import IoniconModbus as _client
+        from .clients.modbus import IoniconModbus as _client
     else:
         raise NotImplementedError(str(method))
 

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/_base/__init__.py

@@ -1,7 +1,7 @@
 from collections import namedtuple
 
-from .mqttclient import MqttClientBase
-from .ioniclient import IoniClientBase
+from .mqttclient import MqttClientBase as _MqttClientBase
+from .ioniclient import IoniClientBase as _IoniClientBase
 
 class itype:
 

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/_base/ioniclient.py

@@ -1,6 +1,10 @@
 from abc import ABC, abstractmethod
 
+
 class IoniClientBase(ABC):
+    '''Abstract base-class that defines the common interface for clients.
+
+    '''
 
     @property
     @abstractmethod
@@ -22,6 +26,22 @@ class IoniClientBase(ABC):
     def disconnect(self):
         pass
 
+    @abstractmethod
+    def start_measurement(self, path=None):
+        '''Start a new measurement and block until the change is confirmed.
+
+        If 'path' is not None, write to the given .h5 file.
+        '''
+        pass
+
+    @abstractmethod
+    def stop_measurement(self, future_cycle=None):
+        '''Stop the current measurement and block until the change is confirmed.
+
+        If 'future_cycle' is not None and in the future, schedule the stop command.
+        '''
+        pass
+
     def __init__(self, host, port):
         # Note: circumvent (potentially sluggish) Windows DNS lookup:
         self.host = '127.0.0.1' if host == 'localhost' else str(host)

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/_base/mqttclient.py

@@ -9,8 +9,6 @@ from datetime import datetime as dt
 
 import paho.mqtt.client
 
-from .ioniclient import IoniClientBase
-
 log = logging.getLogger(__name__)
 
 __all__ = ['MqttClientBase']
@@ -35,7 +33,11 @@ def _on_publish(client, self, mid):
     log.debug(f"[{self}] published {mid = }")
 
 
-class MqttClientBase(IoniClientBase):
+class MqttClientBase:
+    """Mix-in class that supplies basic MQTT-callback functions.
+
+    Implements part of the `IoniClientBase` interface.
+    """
 
     @property
     def is_connected(self):
@@ -50,8 +52,11 @@ class MqttClientBase(IoniClientBase):
     def __init__(self, host, port, subscriber_functions,
             on_connect, on_subscribe, on_publish, 
             connect_timeout_s=10):
+        # Note: circumvent (potentially sluggish) Windows DNS lookup:
+        self.host = '127.0.0.1' if host == 'localhost' else str(host)
+        self.port = int(port)
+
         assert len(subscriber_functions) > 0, "no subscribers: for some unknown reason this causes disconnects"
-        super().__init__(host, port)
 
         # Note: Version 2.0 of paho-mqtt introduced versioning of the user-callback to fix
         #  some inconsistency in callback arguments and to provide better support for MQTTv5.
@@ -90,7 +95,7 @@ class MqttClientBase(IoniClientBase):
         try:
             self.connect(connect_timeout_s)
         except TimeoutError as exc:
-            log.warn(f"{exc} (retry connecting when the Instrument is set up)")
+            log.warning(f"{exc} (retry connecting when the Instrument is set up)")
 
     def connect(self, timeout_s=10):
         log.info(f"[{self}] connecting to MQTT broker...")
@@ -117,3 +122,6 @@ class MqttClientBase(IoniClientBase):
         self.client.loop_stop()
         self.client.disconnect()
 
+    def __repr__(self):
+        return f"<{self.__class__.__name__} @ {self.host}[:{self.port}]>"
+

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/clients/__init__.py

@@ -11,23 +11,23 @@ _logging.TRACE = 5  # even more verbose than logging.DEBUG
 
 def enable_extended_logging(log_level=_logging.DEBUG):
     '''make output of http-requests more talkative.
-    
-    set 'log_level=logging.TRACE' (defined as 0 in pytrms.__init__) for highest verbosity!
+
+    set 'log_level=_logging.TRACE' for highest verbosity!
     '''
     if log_level <= _logging.DEBUG:
         # enable logging of http request urls on the library, that is
         #  underlying the 'requests'-package:
-        _logging.warn(f"enabling logging-output on 'urllib3' ({log_level = })")
+        _logging.warning(f"enabling logging-output on 'urllib3' ({log_level = })")
         requests_log = _logging.getLogger("urllib3")
         requests_log.setLevel(log_level)
         requests_log.propagate = True
-    
+
     if log_level <= _logging.TRACE:
         # Enabling debugging at http.client level (requests->urllib3->http.client)
         # you will see the REQUEST, including HEADERS and DATA, and RESPONSE with
         # HEADERS but without DATA. the only thing missing will be the response.body,
         # which is not logged.
-        _logging.warn(f"enabling logging-output on 'HTTPConnection' ({log_level = })")
+        _logging.warning(f"enabling logging-output on 'HTTPConnection' ({log_level = })")
         from http.client import HTTPConnection
         HTTPConnection.debuglevel = 1
 

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/clients/db_api.py

@@ -5,16 +5,12 @@ import requests
 
 from . import _logging
 from .ssevent import SSEventListener
-from .._base import IoniClientBase
+from .._base import _IoniClientBase
 
 log = _logging.getLogger(__name__)
 
-# TODO :: sowas waer auch ganz cool: die DBAPI bietes sich geradezu an,
-#  da mehr object-oriented zu arbeiten:
-#   currentVariable = get_component(currentComponentNameAction, ds)
-#   currentVariable.save_value({'value': currentValue})
 
-class IoniConnect(IoniClientBase):
+class IoniConnect(_IoniClientBase):
 
     @property
     def is_connected(self):
@@ -28,12 +24,31 @@ class IoniConnect(IoniClientBase):
     @property
     def is_running(self):
         '''Returns `True` if IoniTOF is currently acquiring data.'''
+        # TODO :: /api/meas/curretn {isRunning ?}
         raise NotImplementedError("is_running")
 
     def connect(self, timeout_s):
+        # TODO :: create session ?! (see __init__ ...)
         pass
 
     def disconnect(self):
+        # TODO :: del session ?!
+        pass
+
+    def start_measurement(self, path=None):
+        '''Start a new measurement and block until the change is confirmed.
+
+        If 'path' is not None, write to the given .h5 file.
+        '''
+        # TODO :: POST /api/measurement {recipeDirectory}  / path = ?
+        pass
+
+    def stop_measurement(self, future_cycle=None):
+        '''Stop the current measurement and block until the change is confirmed.
+
+        If 'future_cycle' is not None and in the future, schedule the stop command.
+        '''
+        # TODO :: PUT /api/meas/current {isRunning = False}
         pass
 
     def __init__(self, host='127.0.0.1', port=5066, session=None):
@@ -106,9 +121,9 @@ class IoniConnect(IoniClientBase):
         from pytrms.peaktable import Peak, PeakTable
         from operator import attrgetter
 
-        # Note: a `Peak` is a hashable object that serves as a key that
-        #  distinguishes between peaks as defined by PyTRMS:
-        make_key = lambda peak: Peak(center=peak['center'], label=peak['name'], shift=peak['shift'])
+        # Note: the DB-API distinguishes between peaks with 
+        #  different center *and* name, so this is our key:
+        make_key = lambda peak: (peak['center'], peak['name'])
 
         if isinstance(peaktable, str):
             log.info(f"loading peaktable '{peaktable}'...")
@@ -165,15 +180,12 @@ class IoniConnect(IoniClientBase):
         if len(peaktable.fitted):
             # Note: until now, we disregarded the peak-parent-relationship, so
             # make another request to the updated peak-table from the server...
-            db_peaks = {make_key(p): {
-                        'payload': {k: p[k] for k in conv.keys()},
-                        'self':   p['_links']['self'],
-                        'parent': p['_links'].get('parent'),
-                        } for p in self.get('/api/peaks')['_embedded']['peaks']}
+            peak2href = {Peak(center=p["center"], label=p["name"]): p["_links"]["self"]["href"]
+                            for p in self.get('/api/peaks')['_embedded']['peaks']}
 
             for fitted in peaktable.fitted:
-                fitted_href = db_peaks[fitted]["self"]["href"]
-                parent_href = db_peaks[fitted.parent]["self"]["href"]
+                fitted_href = peak2href[fitted]
+                parent_href = peak2href[fitted.parent]
                 r = self.session.request('link', self.url + parent_href, headers={"location": fitted_href})
                 if not r.ok:
                     log.error(f"LINK {parent_href} to Location: {fitted_href} failed\n\n[{r.status_code}]: {r.content}")

pytrms-0.9.7/pytrms/clients/dummy.py

@@ -0,0 +1,43 @@
+from . import _logging
+from .._base import _IoniClientBase
+
+log = _logging.getLogger(__name__)
+
+
+class IoniDummy(_IoniClientBase):
+    '''A mock for any 'IoniClient' (modbus, mqtt, ...) that can be used
+    in places where no connection to the instrument is possible or desirable.
+    '''
+
+    @property
+    def is_connected(self):
+        return self.__is_connected
+
+    __is_connected = False
+
+    @property
+    def is_running(self):
+        return self.__is_running
+
+    __is_running = False
+
+    def connect(self, timeout_s):
+        log.info(f'pretending to connect to server')
+        self.__is_connected = True
+
+    def disconnect(self):
+        log.info(f'pretending to disconnect to server')
+        self.__is_connected = False
+
+    def start_measurement(self, path=None):
+        log.info(f'pretending to start measurement ({path = })')
+        self.__is_running = True
+
+    def stop_measurement(self, future_cycle=None):
+        log.info(f'pretending to stop measurement ({future_cycle = })')
+        self.__is_running = False
+
+    def __init__(self, host='localhost', port=5687):
+        super().__init__(host, port)
+        self.connect()
+

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/clients/modbus.py

@@ -6,13 +6,13 @@ import struct
 import time
 import logging
 from collections import namedtuple
-from functools import lru_cache
+from functools import lru_cache, partial
 from itertools import tee
 
 import pyModbusTCP.client
 
 from . import _par_id_file
-from .._base.ioniclient import IoniClientBase
+from .._base import _IoniClientBase
 
 log = logging.getLogger(__name__)
 
@@ -32,7 +32,7 @@ def _patch_is_open():
     if int(minor) < 2:
         return lambda mc: mc.is_open()
     else:
-        return lambda mc: mc.is_open
+        return lambda mc: bool(mc.is_open)
 
 _is_open = _patch_is_open()
 
@@ -48,11 +48,11 @@ with open(_par_id_file) as f:
 #  some exceptions that are 'short' (alive_counter, n_parameters) or explicitly
 #  marked to be 'int' (AME_RunNumber, et.c.):
 _fmts = dict([
-    ('float', '>f'),
-    ('double', '>d'),
-    ('short', '>h'),
-    ('int', '>i'),
-    ('long', '>q'),
+    ('float',   '>f'),
+    ('double',  '>d'),
+    ('short',   '>h'),
+    ('int',     '>i'),
+    ('long',    '>q'),
 ])
 
 _register = namedtuple('register_info', ['n_registers', 'c_format', 'reg_format'])
@@ -106,40 +106,72 @@ def _pack(value, format='>f'):
 
     return struct.unpack(reg_format, struct.pack(c_format, value))
 
+_fast  = 0      # MPV direction enum
+_DO_ON = 0x3F80 # digital output magick number
 
-class IoniconModbus(IoniClientBase):
+
+class IoniconModbus(_IoniClientBase):
 
     address = dict([
-        ('server_state',     (    0, '>f', True)),  # 0: Not ready, 1: Ready, 2: Startup
-        ('measure_state',    (    2, '>f', True)),  # 0: Not running | 1: running | 2: Just Started | 3: Just Stopped
-        ('instrument_state', (    4, '>f', True)),  # 0: Not Ok, 1: Ok, 2: Error, 3: Warning
-        ('alive_counter',    (    6, '>H', True)),  # (updated every 500 ms)
-        ('n_parameters',     ( 2000, '>H', True)),
-        ('tc_raw',           ( 4000, '>f', True)),
-        ('tc_conc',          ( 6000, '>f', True)),
-        ('n_masses',         ( 8000, '>f', True)),
-        # ('n_corr',         ( 7000, '>i', True)),  # not implemented?
-        ('tc_components',    (10000, '>f', True)),
-        ('ame_alarms',       (12000, '>f', True)),
-        ('user_number',      (13900, '>i', True)),
-        ('step_number',      (13902, '>i', True)),
-        ('run_number',       (13904, '>i', True)),
-        ('use_mean',         (13906, '>i', True)),
-        ('action_number',    (13912, '>i', True)),
-        ('version_major',    (13918, '>h', True)),
-        ('version_minor',    (13919, '>h', True)),
-        ('version_patch',    (13920, '>h', True)),
-        ('ame_state',        (13914, '>i', True)),  # Running 0=Off; 1=On (not implemented!)
-        ('n_components',     (14000, '>f', True)),
-        ('component_names',  (14002, '>f', True)),
-        ('ame_mean_data',    (26000, '>f', True)),
-        ('n_ame_mean',       (26002, '>d', True)),
+        ('server_state',     (    0, '>f', False)),  # 0: Not ready, 1: Ready, 2: Startup
+        ('measure_state',    (    2, '>f', False)),  # 0: Not running | 1: running | 2: Just Started | 3: Just Stopped
+        ('instrument_state', (    4, '>f', False)),  # 0: Not Ok, 1: Ok, 2: Error, 3: Warning
+        ('alive_counter',    (    6, '>H', False)),  # (updated every 500 ms)
+        ('n_parameters',     ( 2000, '>H', False)),
+        ('tc_raw',           ( 4000, '>f', False)),
+        ('tc_conc',          ( 6000, '>f', False)),
+        ('n_masses',         ( 8000, '>f', False)),
+        # ('n_corr',         ( 7000, '>i', False)),  # not implemented?
+        ('tc_components',    (10000, '>f', False)),
+        ('ame_alarms',       (12000, '>f', False)),
+        ('user_number',      (13900, '>i', False)),
+        ('step_number',      (13902, '>i', False)),
+        ('run_number',       (13904, '>i', False)),
+        ('use_mean',         (13906, '>i', False)),
+        ('action_number',    (13912, '>i', False)),
+        ('version_major',    (13918, '>h', False)),
+        ('version_minor',    (13919, '>h', False)),
+        ('version_patch',    (13920, '>h', False)),
+        ('ame_state',        (13914, '>i', False)),  # Running 0=Off; 1=On (not implemented!)
+        ('n_components',     (14000, '>f', False)),
+        ('component_names',  (14002, '>f', False)),
+        ('ame_mean_data',    (26000, '>f', False)),
+        ('n_ame_mean',       (26002, '>d', False)),
+    ])
+
+    _lookup_offset = dict([
+        # parID  offset     name in Modbus manual   special procedure
+        ( 42,   (3 *  0,    'FC H2O',           partial(_pack, format='>f')         )),
+        (  1,   (3 *  1,    'PC',               partial(_pack, format='>f')         )),
+        (  2,   (3 *  2,    'FC inlet',         partial(_pack, format='>f')         )),
+        (  3,   (3 *  3,    'FC O2',            partial(_pack, format='>f')         )),
+        (  4,   (3 *  4,    'FC NO',            partial(_pack, format='>f')         )),
+        (  5,   (3 *  5,    'FC Dilution',      partial(_pack, format='>f')         )),
+        (  6,   (3 *  6,    'FC Krypton',       partial(_pack, format='>f')         )),
+        (  7,   (3 *  7,    'FC Xenon',         partial(_pack, format='>f')         )),
+        (  8,   (3 *  8,    'FC Purge',         partial(_pack, format='>f')         )),
+        (  9,   (3 *  9,    'FC FastGC',        partial(_pack, format='>f')         )),
+        ( 10,   (3 * 10,    'FC Custom 1',      partial(_pack, format='>f')         )),
+        ( 11,   (3 * 11,    'FC Custom 2',      partial(_pack, format='>f')         )),
+        ( 12,   (3 * 12,    'FC Custom 3',      partial(_pack, format='>f')         )),
+        ( 13,   (3 * 13,    'FC Custom 4',      partial(_pack, format='>f')         )),
+        ( 14,   (3 * 14,    'FC Custom 5',      partial(_pack, format='>f')         )),
+        ( 15,   (3 * 15,    'FC Custom 6',      partial(_pack, format='>f')         )),
+        ( 16,   (3 * 16,    'FC Custom 7',      partial(_pack, format='>f')         )),
+        ( 17,   (3 * 17,    'FC Custom 8',      partial(_pack, format='>f')         )),
+        ( 18,   (3 * 18,    'FC Custom 9',      partial(_pack, format='>f')         )),
+        (556,   (3 * 19,    'Measure Start',    partial(_pack, format='>f')         )),
+        (559,   (3 * 20,    'Measure Stop',     partial(_pack, format='>f')         )),
+        ( 70,   (3 * 21,    'Set MPV1',         lambda v: [_fast, *_pack(v, '>h')]  )),
+        ( 71,   (3 * 22,    'Set MPV2',         lambda v: [_fast, *_pack(v, '>h')]  )),
+        ( 72,   (3 * 23,    'Set MPV3',         lambda v: [_fast, *_pack(v, '>h')]  )),
+        (138,   (3 * 24,    'DO 1',             lambda v: [_DO_ON if v else 0x0, 0] )),
+        (139,   (3 * 25,    'DO 2',             lambda v: [_DO_ON if v else 0x0, 0] )),
     ])
 
     @classmethod
-    def use_legacy_input_registers(klaas, use_input_reg = True):
-        """Read from input- instead of holding-registers (legacy method to be compatible with AME1.0)."""
-        use_holding = not use_input_reg
+    def use_holding_registers(klaas, use_holding=True):
+        """Use Modbus HOLDING- instead of INPUT-registers (default: INPUT, compatible with AME1 and AME2)."""
         modded = dict()
         for key, vals in klaas.address.items():
             modded[key] = vals[0], vals[1], use_holding
@@ -154,16 +186,21 @@ class IoniconModbus(IoniClientBase):
         if not _is_open(self.mc):
             return False
 
-        # wait for the IoniTOF alive-counter to change (1 second max)...
-        initial_count = self._alive_counter
-        timeout_s = 3  # counter should increase every 500 ms, approximately
-        started_at = time.monotonic()
-        while time.monotonic() < started_at + timeout_s:
-            if initial_count != self._alive_counter:
-                return True
-
-            time.sleep(10e-3)
-        return False
+        try:
+            # wait for the IoniTOF alive-counter to change (1 second max)...
+            initial_count = self._alive_counter
+            timeout_s = 3  # counter should increase every 500 ms, approximately
+            started_at = time.monotonic()
+            while time.monotonic() < started_at + timeout_s:
+                if initial_count != self._alive_counter:
+                    return True
+
+                time.sleep(10e-3)
+            return False
+        except IOError:
+            # bug-fix: failing to read _alive_counter closed the connection,
+            #  even after checking .is_open! Don't let this property throw:
+            return False
 
     @property
     def is_running(self):
@@ -210,7 +247,7 @@ class IoniconModbus(IoniClientBase):
         try:
             self.connect()
         except TimeoutError as exc:
-            log.warn(f"{exc} (retry connecting when the Instrument is set up)")
+            log.warning(f"{exc} (retry connecting when the Instrument is set up)")
         self._addresses = {}
 
     def connect(self, timeout_s=10):
@@ -220,7 +257,7 @@ class IoniconModbus(IoniClientBase):
             self.mc.timeout(timeout_s)
         else:
             self.mc.timeout = timeout_s
-        if not self.mc.open():
+        if not (_is_open(self.mc) or self.mc.open()):
             raise TimeoutError(f"[{self}] no connection to modbus socket")
 
         started_at = time.monotonic()
@@ -237,6 +274,52 @@ class IoniconModbus(IoniClientBase):
         if _is_open(self.mc):
             self.mc.close()
 
+    def start_measurement(self, path=None):
+        '''Start a new measurement and block until the change is confirmed.
+
+        'path' is ignored!
+        '''
+        if path is not None:
+            log.warning(f'ignoring .h5-filepath in Modbus command and starting quick measurement')
+
+        # Note: let's assume one of them will be right and calling it twice don't hurt:
+        self.write_instrument_data('ACQ_SRV_Start_Meas_Quick', 1, oldschool=False, timeout_s=10)
+        self.write_instrument_data('ACQ_SRV_Start_Meas_Quick', 1, oldschool=True)
+
+        timeout_s = 10
+        started_at = time.monotonic()
+        while time.monotonic() < started_at + timeout_s:
+            if self.is_running:
+                break
+
+            time.sleep(10e-3)
+        else:
+            raise TimeoutError(f"[{self}] unable to start measurement after { timeout_s = }");
+
+    def stop_measurement(self, future_cycle=None):
+        '''Stop the current measurement and block until the change is confirmed.
+
+        'future_cycle' is ignored!
+        '''
+        if future_cycle is not None:
+            log.info(f'block until {future_cycle = } (current_cycle = {self.read_timecycle().abs_cycle})')
+            while self.read_timecycle().abs_cycle < int(future_cycle):
+                time.sleep(200e-3)
+
+        # Note: let's assume one of them will be right and calling it twice don't hurt:
+        self.write_instrument_data('ACQ_SRV_Stop_Meas', 1, oldschool=False, timeout_s=10)
+        self.write_instrument_data('ACQ_SRV_Stop_Meas', 1, oldschool=True)
+
+        timeout_s = 10
+        started_at = time.monotonic()
+        while time.monotonic() < started_at + timeout_s:
+            if not self.is_running:
+                break
+
+            time.sleep(10e-3)
+        else:
+            raise TimeoutError(f"[{self}] unable to stop measurement after { timeout_s = }");
+
     @property
     @lru_cache
     def n_parameters(self):
@@ -301,16 +384,16 @@ class IoniconModbus(IoniClientBase):
 
         return rv
 
-    def write_instrument_data(self, par_id, new_value, timeout_s=10):
+    def write_instrument_data(self, par_id, new_value, oldschool=False, timeout_s=10):
+        '''Send a write command via the Modbus protocol.
 
-        # This command-structure is written as an array:
-        # Register 0: number of command-blocks to write
-        # Each command-block consists of 3 registers:
-        # Register 1: Parameter ID
-        # Register 2-3: Parameter Set Value as float(real)
-        start_register = 41000
-        blocksize = 3
+        See the Modbus manual for implementation details.
 
+        'par_id' - (int or string) the parameter-ID or -descriptor from the parID-list
+        'new_value' - the value to write (will be converted to float32)
+        'oldschool' - use the legacy Modbus write procedure (Register 40000)
+        'timeout_s' - timeout in seconds
+        '''
         if isinstance(par_id, str):
             try:
                 par_id = next(k for k, v in _id_to_descr.items() if v == par_id)
@@ -320,11 +403,33 @@ class IoniconModbus(IoniClientBase):
         if par_id not in _id_to_descr:
             raise IndexError(str(par_id))
 
-        # Note: we use only the first command-block for writing:
+        # Each command-block consists of 3 registers:
+        #  Register 1: Parameter ID (newschool) / execute bit (oldschool)
+        #  Register 2-3: Parameter Set Value as float(real)
+        # Note: The newschool command-structure is written as an array:
+        #   Register 0: number of command-blocks to write
+        #  This coincides with the oldschool protocol, where
+        #   Register 0: ready to write (execute bit) ~> 1
+        #  We use only the first command-block for writing...
         n_blocks = 1
-        reg_values = list(_pack(n_blocks, '>h'))
-        # ...although we could add more command-blocks here:
-        reg_values += list(_pack(par_id, '>h')) + list(_pack(new_value, '>f'))
+        assert (n_blocks == 1 or not oldschool), "oldschool instrument protocol doesn't allow multiple writes"
+        reg_values = []
+        if oldschool:
+            offset, name, packer = IoniconModbus._lookup_offset[par_id]
+            start_register = 40_000 + offset
+            reg_values += list(_pack(1, '>h'))  # execute!
+            reg_values += list(packer(new_value))
+            log.debug(f'WRITE REG {start_register} ({name}) w/ oldschool protocol')
+        else:
+            start_register = 41_000
+            # ...although we could add more command-blocks here (newschool):
+            reg_values += list(_pack(n_blocks, '>h'))
+            # the parameter to write is written to the command block (newschool):
+            reg_values += list(_pack(par_id, '>h'))
+            reg_values += list(_pack(new_value, '>f'))
+            log.debug(f'WRITE REG {start_register} ({par_id = }) w/ newschool protocol')
+
+        assert len(reg_values) == (4 - bool(oldschool)), "invalid program: unexpected number of registers to write"
 
         # wait for instrument to receive...
         retry_time = 0
@@ -332,8 +437,8 @@ class IoniconModbus(IoniClientBase):
             # a value of 0 indicates ready-to-write:
             if self.mc.read_holding_registers(start_register) == [0]:
                 break
-            retry_time += 0.5
-            time.sleep(0.5)
+            retry_time += 0.2
+            time.sleep(0.2)
         else:
             raise TimeoutError(f'instrument not ready for writing after ({timeout_s}) seconds')
 
@@ -419,9 +524,9 @@ class IoniconModbus(IoniClientBase):
     def read_ame_alarms(self):
         start_reg, c_fmt, _is_holding = self.address['ame_alarms']
         n_alarms = int(self._read_reg(start_reg, c_fmt, _is_holding))
-        values = self._read_reg_multi(start_reg + 2, c_fmt, n_alarms, _is_holding)
+        alarm_levels = self._read_reg_multi(start_reg + 2, c_fmt, n_alarms, _is_holding)
 
-        return dict(zip(self.read_component_names(), map(bool, values)))
+        return dict(zip(self.read_component_names(), alarm_levels))
 
     def read_ame_timecycle(self):
         return self.read_timecycle(kind='components')
@@ -453,7 +558,7 @@ class IoniconModbus(IoniClientBase):
     ])
 
     def write_ame_action(self, action_number):
-        self.write_instrument_data(596, action_number, timeout_s=10)
+        self.write_instrument_data(596, action_number, oldschool=False, timeout_s=10)
 
     def read_ame_mean(self, step_number=None):
         start_reg, c_fmt, _is_holding = self.address['ame_mean_data']
@@ -485,14 +590,16 @@ class IoniconModbus(IoniClientBase):
         )
 
     def _read_reg(self, addr, c_format, is_holding_register=False):
-        n_bytes, c_format, reg_format = _get_fmt(c_format)
+        if not _is_open(self.mc):
+            raise IOError("trying to read from closed Modbus-connection")
+
         _read = self.mc.read_holding_registers if is_holding_register else self.mc.read_input_registers
-        
+
+        n_bytes, c_format, reg_format = _get_fmt(c_format)
+
         register = _read(addr, n_bytes)
-        if register is None and _is_open(self.mc):
+        if register is None:
             raise IOError(f"unable to read ({n_bytes}) registers at [{addr}] from connection")
-        elif register is None and not _is_open(self.mc):
-            raise IOError("trying to read from closed Modbus-connection")
 
         return _unpack(register, c_format)
 
@@ -501,6 +608,9 @@ class IoniconModbus(IoniClientBase):
         if not n_values > 0:
             return rv
 
+        if not _is_open(self.mc):
+            raise IOError("trying to read from closed Modbus-connection")
+
         _read = self.mc.read_holding_registers if is_holding_register else self.mc.read_input_registers
 
         n_bytes, c_format, reg_format = _get_fmt(c_format)
@@ -514,10 +624,8 @@ class IoniconModbus(IoniClientBase):
 
         for block in blocks:
             register = _read(*block)
-            if register is None and self.is_connected:
+            if register is None:
                 raise IOError(f"unable to read ({block[1]}) registers at [{block[0]}] from connection")
-            elif register is None and not self.is_connected:
-                raise IOError("trying to read from closed Modbus-connection")
 
             # group the register-values by n_bytes, e.g. [1,2,3,4,..] ~> [(1,2),(3,4),..]
             # this is a trick from the itertools-recipes, see

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/clients/mqtt.py

@@ -10,18 +10,18 @@ from threading import Condition, RLock
 
 from . import _logging
 from . import _par_id_file
-from .._base import itype, MqttClientBase
+from .._base import itype, _MqttClientBase, _IoniClientBase
 
 
 log = _logging.getLogger(__name__)
 
-__all__ = ['MqttClient', 'MqttClientBase']
+__all__ = ['MqttClient']
 
 
 with open(_par_id_file) as f:
     from pandas import read_csv, isna
 
-    _par_id_info = read_csv(f, sep='\t').drop(0).set_index('Name')
+    _par_id_info = read_csv(f, sep='\t').drop(0).set_index('Name').fillna('')
     if isna(_par_id_info.at['MPV_1', 'Access']):
         log.warning(f'filling in read-properties still missing in {os.path.basename(_par_id_file)}')
         _par_id_info.at['MPV_1', 'Access'] = 'RW'
@@ -34,9 +34,10 @@ with open(_par_id_file) as f:
 
 def _build_header():
     ts = datetime.now()
+    ts_isoformat = ts.astimezone().isoformat(timespec='milliseconds')
     header = {
         "TimeStamp": {
-            "Str": ts.isoformat(),
+            "Str": ts_isoformat[:-3] + ts_isoformat[-2:],  # TZ-info w/o the colon
             "sec": ts.timestamp() + 2082844800,  # convert to LabVIEW time
         },
     }
@@ -133,7 +134,7 @@ def _parse_fullcycle(byte_string, need_add_data=False):
     performance (on a Intel Core i5, 8th Gen Ubuntu Linux):
       < 2 ms  when `need_add_data=False` (default)
       6-7 ms  when needing to parse the AddData-cluster (else)
-    
+
     @returns a namedtuple ('timecycle', 'intensity', 'mass_cal', 'add_data')
     '''
     import numpy as np
@@ -152,7 +153,7 @@ def _parse_fullcycle(byte_string, need_add_data=False):
         _arr = np.frombuffer(byte_string, dtype=dtype, count=1, offset=offset)
         offset += _arr.nbytes
         return _arr[0]
-    
+
     def rd_arr1d(dtype=_f32, count=None):
         nonlocal offset
         if count is None:
@@ -160,7 +161,7 @@ def _parse_fullcycle(byte_string, need_add_data=False):
         arr = np.frombuffer(byte_string, dtype=dtype, count=count, offset=offset)
         offset += arr.nbytes
         return arr
-    
+
     def rd_arr2d(dtype=_f32):
         nonlocal offset
         n = rd_single()
@@ -172,14 +173,14 @@ def _parse_fullcycle(byte_string, need_add_data=False):
     def rd_string():
         nonlocal offset
         return rd_arr1d(dtype=_chr).tobytes().decode('latin-1').lstrip('\x00')
-    
+
     tc_cluster      = rd_arr1d(dtype=_f64, count=4)
     run__, cpx__    = rd_arr1d(dtype=_f64, count=2)  # (discarded)
     # SpecData #
     intensity       = rd_arr1d(dtype=_f32)
     sum_inty        = rd_arr1d(dtype=_f32)  # (discarded)
     mon_peaks       = rd_arr2d(dtype=_f32)  # (discarded)
-    
+
     if not need_add_data:
         # skip costly parsing of Trace- and Add-Data cluster:
         return itype.fullcycle_t(itype.timecycle_t(*tc_cluster), intensity, None, None)
@@ -283,7 +284,7 @@ def follow_schedule(client, self, msg):
 
         if msg.topic.endswith("SRV_Schedule"):
             if not msg.payload:
-                log.warn("empty ACQ_SRV_Schedule payload has cleared retained topic")
+                log.warning("empty ACQ_SRV_Schedule payload has cleared retained topic")
                 self._sched_cmds.clear()
                 return
 
@@ -413,7 +414,7 @@ _subscriber_functions = [fun for name, fun in list(vars().items())
 _NOT_INIT = object()
 
 
-class MqttClient(MqttClientBase):
+class MqttClient(_MqttClientBase, _IoniClientBase):
     """a simplified client for the Ionicon MQTT API.
 
     > mq = MqttClient()
@@ -433,7 +434,7 @@ class MqttClient(MqttClientBase):
     set_value_limit = {
         "TCP_MCP_B": 3200.0,
     }
-    
+
     @property
     def is_connected(self):
         '''Returns `True` if connection to IoniTOF could be established.'''
@@ -476,7 +477,7 @@ class MqttClient(MqttClientBase):
     @property
     def current_sourcefile(self):
         '''Returns the path to the hdf5-file that is currently being written.
-        
+
         Returns an empty string if no measurement is running.
         '''
         if not self.is_running:
@@ -492,7 +493,7 @@ class MqttClient(MqttClientBase):
         while time.monotonic() < started_at + timeout_s:
             if self._sf_filename[0] is not _NOT_INIT:
                 return self._sf_filename[0]
-    
+
             time.sleep(10e-3)
         else:
             raise TimeoutError(f"[{self}] unable to retrieve source-file after ({timeout_s = })");
@@ -531,6 +532,10 @@ class MqttClient(MqttClientBase):
         if not self.is_connected:
             raise Exception(f"[{self}] no connection to instrument");
 
+        if parID == "FC_inlet":
+            log.warning(f"mapping 'FC_inlet' ~> 'FC_FC inlet' (with whitespace)")
+            parID = "FC_FC inlet"
+
         _lut = self.act_values if kind.lower() == "act" else self.set_values
         is_read_only = ('W' not in _par_id_info.loc[parID].Access)  # may raise KeyError!
         if _lut is self.set_values and is_read_only:
@@ -561,7 +566,7 @@ class MqttClient(MqttClientBase):
                 # confirm change of state:
                 if not self._calcconzinfo[0] is _NOT_INIT:
                     return self._calcconzinfo[0].tables[table_name]
-    
+
                 time.sleep(10e-3)
             else:
                 raise TimeoutError(f"[{self}] unable to retrieve calc-conz-info from PTR server");
@@ -592,11 +597,15 @@ class MqttClient(MqttClientBase):
         if not self.is_connected:
             raise Exception(f"[{self}] no connection to instrument");
 
+        if parID == "FC_inlet":
+            log.warning(f"mapping 'FC_inlet' ~> 'FC_FC inlet' (with whitespace)")
+            parID = "FC_FC inlet"
+
         if not 'W' in _par_id_info.loc[parID].Access:  # may raise KeyError!
             raise ValueError(f"'{parID}' is read-only")
 
         if parID in __class__.set_value_limit and new_value > __class__.set_value_limit[parID]:
-            raise ValueError("set value limit of {__class__.set_value_limit[parID]} on '{parID}'")
+            raise ValueError(f"will not exceed set-value limit of {__class__.set_value_limit[parID]} on '{parID}'")
 
         topic, qos, retain = "IC_Command/Write/Direct", 1, False
         log.info(f"writing '{parID}' ~> [{new_value}]")
@@ -617,11 +626,15 @@ class MqttClient(MqttClientBase):
         if not self.is_connected:
             raise Exception(f"[{self}] no connection to instrument");
 
+        if parID == "FC_inlet":
+            log.warning(f"mapping 'FC_inlet' ~> 'FC_FC inlet' (with whitespace)")
+            parID = "FC_FC inlet"
+
         if not 'W' in _par_id_info.loc[parID].Access:  # may raise KeyError!
             raise ValueError(f"'{parID}' is read-only")
 
         if parID in __class__.set_value_limit and new_value > __class__.set_value_limit[parID]:
-            raise ValueError("set value limit of {__class__.set_value_limit[parID]} on '{parID}'")
+            raise ValueError(f"will not exceed set-value limit of {__class__.set_value_limit[parID]} on '{parID}'")
 
         if (future_cycle == 0 and not self.is_running):
             # Note: ioniTOF40 doesn't handle scheduling for the 0th cycle!
@@ -640,7 +653,7 @@ class MqttClient(MqttClientBase):
                 return self.write(parID, new_value)
 
         if not future_cycle > self.current_cycle:
-            log.warn(f"attempting to schedule past cycle, hope you know what you're doing");
+            log.warning(f"attempting to schedule past cycle, hope you know what you're doing");
             pass  # and at least let's debug it in MQTT browser (see also doc-string above)!
 
         topic, qos, retain = "IC_Command/Write/Scheduled", 1, False
@@ -772,7 +785,7 @@ class MqttClient(MqttClientBase):
             #  uninterruptible wait on an underlying lock. This means that no exceptions
             #  can occur, and in particular a SIGINT will not trigger a KeyboardInterrupt!
             if timeout_s is None and not self.is_running:
-                log.warn(f"waiting indefinitely for measurement to run...")
+                log.warning(f"waiting indefinitely for measurement to run...")
 
             yield q.get(block=True, timeout=timeout_s)
 

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/compose/composition.py

@@ -35,17 +35,17 @@ class Step:
     >>> Step("H50", {'AUTO_UseMean': 0}, 10, start_delay=2)
     Traceback (most recent call last):
       ...
-    AssertionError: Automation numbers cannot be defined
+    AssertionError: a Step must not define AME-numbers
 
     ..and neither can a 'OP_Mode' alongside anything else:
     >>> Step("Odd2", {'DPS_Udrift': 345, 'OP_Mode': 2}, 10, start_delay=2)
     Traceback (most recent call last):
       ...
-    AssertionError: if 'OP_Mode' is specified, nothing else can be
+    AssertionError: if Step defines 'OP_Mode', nothing else can be!
 
     '''
     protected_keys = ['AME_RunNumber', 'AME_StepNumber', 'AUTO_UseMean'] 
-    
+
     def __init__(self, name, set_values, duration, start_delay):
         self.name = str(name)
         self.set_values = dict(set_values)
@@ -58,9 +58,9 @@ class Step:
         assert self.start_delay < self.duration
 
         for key in self.set_values:
-            assert key not in Step.protected_keys, "Automation numbers cannot be defined"
+            assert key not in Step.protected_keys, "a Step must not define AME-numbers"
         if 'OP_Mode' in self.set_values:
-            assert len(self.set_values) == 1, "if 'OP_Mode' is specified, nothing else can be"
+            assert len(self.set_values) == 1, "if Step defines 'OP_Mode', nothing else can be!"
 
     def __repr__(self):
         return f"{self.name}: ({self.start_delay}/{self.duration}) sec ~> {self.set_values}"
@@ -87,7 +87,7 @@ class Composition(Iterable):
     ...without automation (default)...
     >>> list(co.sequence())
     [(8, {'Eins': 1}), (18, {'Zwei': 2})]
-    
+
     ...with an action-number at the start (note, that AME-numbers are 1 cycle ahead)...
     >>> co.start_action = 7
     >>> list(co.sequence())
@@ -98,7 +98,7 @@ class Composition(Iterable):
     >>> seq = co.sequence()
     >>> next(seq)
     (9, {'AME_ActionNumber': 7})
-    
+
     >>> next(seq)
     (8, {'Eins': 1})
 
@@ -116,14 +116,14 @@ class Composition(Iterable):
 
     >>> next(seq)
     (22, {'AUTO_UseMean': 1})
-    
+
     '''
 
     STEP_MARKER    = 'AME_StepNumber'
     RUN_MARKER     = 'AME_RunNumber'
     USE_MARKER     = 'AUTO_UseMean'
     ACTION_MARKER  = 'AME_ActionNumber'
-    
+
     @staticmethod
     def load(filename, **kwargs):
         with open(filename, 'r') as ifstream:
@@ -137,7 +137,7 @@ class Composition(Iterable):
         self.start_action        = int(start_action) if start_action is not None else None
         self.generate_automation = bool(generate_automation)
         self.foresight_runs      = int(foresight_runs) if self.max_runs < 0 else max(int(foresight_runs), self.max_runs)
-        
+
         assert len(self.steps) > 0, "empty step list"
         assert self.max_runs != 0, "max_runs cannot be zero"
         assert self.foresight_runs > 0, "foresight_runs must be positive"
@@ -150,7 +150,7 @@ class Composition(Iterable):
         return self.max_runs > 0
 
     def dump(self, ofstream):
-        json.dump(self, ofstream, indent=2, default=vars)
+        json.dump(self.steps, ofstream, indent=2, default=vars)
 
     def translate_op_modes(self, preset_items, check=True):
         '''Given the `preset_items` (from a presets-file), compile a list of set_values.
@@ -210,7 +210,7 @@ class Composition(Iterable):
             entry.update(carry)
             if check:
                 assert all(key in entry for key in preset_keys), "reaction-data missing in presets"
-        
+
         return set_values
 
     def sequence(self):
@@ -222,11 +222,11 @@ class Composition(Iterable):
         This generates AME_Run/Step-Number and AUTO_UseMean unless otherwise specified.
         '''
         _offset_ame = True  # whether ame-numbers should mark the *next* cycle, see [#2897]
-        
+
         future_cycle = self.start_cycle
         if self.start_action is not None:
             yield future_cycle + int(_offset_ame), dict([(self.ACTION_MARKER, int(self.start_action))])
-        
+
         for run, step, step_info in self:
             yield future_cycle, dict(step_info.set_values)
 
@@ -250,9 +250,9 @@ class Composition(Iterable):
     @coroutine
     def schedule_routine(self, schedule_fun):
         '''Create a coroutine that receives the current cycle and yields the last scheduled cycle.
-        
+
         'schedule_fun' should be a callable taking three arguments '(parID, value, schedule_cycle)'
-        
+
         >>> co = Composition([
         ...         Step("Oans", {"Eins": 1}, 10, start_delay=2),
         ...         Step("Zwoa", {"Zwei": 2}, 10, start_delay=3)
@@ -265,10 +265,10 @@ class Composition(Iterable):
         Eins 1 20
         Zwei 2 30
         Eins 1 40
-        
+
         >>> wake_cycle  # should wake up in time before the last run has begun..
         30
-        
+
         '''
         # feed all future updates for a given current cycle to the Dirigent
         log.debug("schedule_routine: initializing...")

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/helpers.py

@@ -6,7 +6,7 @@ common helper functions.
 def convert_labview_to_posix(lv_time_utc, utc_offset_sec):
     '''Create a `pandas.Timestamp` from LabView time.'''
     from pandas import Timestamp
-    
+
     # change epoch from 01.01.1904 to 01.01.1970:
     posix_time = lv_time_utc - 2082844800
     # the tz must be specified in isoformat like '+02:30'..
@@ -19,24 +19,24 @@ def convert_labview_to_posix(lv_time_utc, utc_offset_sec):
 
 def parse_presets_file(presets_file):
     '''Load a `presets_file` as XML-tree and interpret the "OP_Mode" of this `Composition`.
-    
+
     The tricky thing is, that any OP_Mode may or may not override previous settings!
     Therefore, it depends on the order of modes in this Composition to be able to assign
     each OP_Mode its actual dictionary of set_values.
-    
+
     Note, that the preset file uses its own naming convention that cannot neccessarily be
     translated into standard parID-names. You may choose whatever you like to do with it.
     '''
     import xml.etree.ElementTree as ET
     from collections import namedtuple, defaultdict
-    
-    _key = namedtuple('preset_item', ['name', 'ads_path', 'dtype'])        
+
+    _key = namedtuple('preset_item', ['name', 'ads_path', 'dtype'])
     _parse_value = {
         "FLOAT": float,
         "BOOL":  bool,
         "BYTE":  int,
         "ENUM":  int,
-    }        
+    }
     tree = ET.parse(presets_file)
     root = tree.getroot()
 
@@ -44,7 +44,7 @@ def parse_presets_file(presets_file):
     preset_items = defaultdict(dict)
     for index, preset in enumerate(root.iterfind('preset')):
         preset_names[index] = preset.find('name').text.strip()
-        
+
         if preset.find('WritePrimIon').text.upper() == "TRUE":
             val = preset.find('IndexPrimIon').text
             preset_items[index][_key('PrimionIdx', '', 'INT')] = int(val)
@@ -52,7 +52,7 @@ def parse_presets_file(presets_file):
         if preset.find('WriteTransmission').text.upper() == "TRUE":
             val = preset.find('IndexTransmission').text
             preset_items[index][_key('TransmissionIdx', '', 'INT')] = int(val)
-            
+
         for item in preset.iterfind('item'):
             if item.find('Write').text.upper() == "TRUE":
             #   device_index = item.find('DeviceIndex').text
@@ -61,9 +61,9 @@ def parse_presets_file(presets_file):
             #   page_name    = item.find('PageName').text
                 name         = item.find('Name').text
                 value_text   = item.find('Value').text
-                
+
                 key = _key(name, ads_path, data_type)
-                val = _parse_value[data_type](value_text)                    
+                val = _parse_value[data_type](value_text)
                 preset_items[index][key] = val
 
     return {index: (preset_names[index], preset_items[index]) for index in preset_names.keys()}
@@ -89,7 +89,7 @@ def setup_measurement_dir(config_dir=None, data_root_dir="D:/Data", suffix="",
     from datetime import datetime
     from itertools import chain
 
-    recipe = namedtuple('recipe', ['dirname', 'h5_file', 'pt_file', 'alarms_file'])
+    recipe = namedtuple('recipe', ['dirname', 'h5_file', 'pt_file', 'alarm_files'])
     _pt_formats = ['*.ionipt']
     _al_formats = ['*.alm']
     # make directory with current timestamp:
@@ -105,9 +105,9 @@ def setup_measurement_dir(config_dir=None, data_root_dir="D:/Data", suffix="",
         # we're done here..
         return recipe(new_recipe_dir, new_h5_file, '', '')
 
-    # find the *first* matching file or an empty string if no match...
+    # peaktable: find the *first* matching file or an empty string if no match:
     new_pt_file = next(chain.from_iterable(glob.iglob(config_dir + "/" + g) for g in _pt_formats), '')
-    new_al_file = next(chain.from_iterable(glob.iglob(config_dir + "/" + g) for g in _al_formats), '')
+    alm_files = sorted(chain.from_iterable(glob.iglob(config_dir + "/" + g) for g in _al_formats))
     # ...and copy all files from the master-recipe-dir:
     files2copy = glob.glob(config_dir + "/*")
     for file in files2copy:
@@ -122,5 +122,5 @@ def setup_measurement_dir(config_dir=None, data_root_dir="D:/Data", suffix="",
             # well, we can't set write permission
             pass
 
-    return recipe(new_recipe_dir, new_h5_file, new_pt_file, new_al_file)
+    return recipe(new_recipe_dir, new_h5_file, new_pt_file, alm_files)
 

{pytrms-0.9.6 → pytrms-0.9.7}/pytrms/peaktable.py

@@ -274,7 +274,7 @@ class PeakTable:
     @staticmethod
     def _parse_ionipt(file):
         
-        def _make_peak(ioni_p, borders, shift, parent=None):
+        def _make_peak(ioni_p, borders, shift, parent):
             return Peak(ioni_p["center"],
                 label=ioni_p["name"],
                 formula=ioni_p["ionic_isotope"],
@@ -292,23 +292,29 @@ class PeakTable:
             border_peak = item["border_peak"]
             borders = (item["low"], item["high"])
             shift = item["shift"]
-            parent = None
             MODE = int(item["mode"])
             IGNORE    = 0b00
             INTEGRATE = 0b01
             FIT_PEAKS = 0b10
+            BOTH      = 0b11
+
             if bool(MODE == IGNORE):
                 continue
-            if bool(MODE & INTEGRATE):
-                parent = _make_peak(border_peak, borders, shift)
+
+            if bool(MODE & FIT_PEAKS) or bool(MODE == BOTH):
+                # Note: this cannot be handled separately, because
+                #  every fit-peak needs a parent in our context!
+                parent = _make_peak(border_peak, borders, shift, None)
                 peaks.append(parent)
-            if bool(MODE & FIT_PEAKS):
                 for ioni_peak in item["peak"]:
-                    if parent is None:
-                        # Note: we denote a peak w/ parent as a "fitted" peak..
-                        #  as a workaround, use the first as (its own) parent:
-                        parent = ioni_peak["name"]
                     peaks.append(_make_peak(ioni_peak, borders, shift, parent))
+                continue
+
+            if bool(MODE & INTEGRATE):
+                # Note: MUST go last, since BOTH would apply and I forgot about
+                #  bitwise-operations in Python and don't want to remember..
+                peaks.append(_make_peak(border_peak, borders, shift, None))
+                continue
 
         return PeakTable(peaks)