myokit 1.35.0__py3-none-any.whl → 1.35.2__py3-none-any.whl

myokit/formats/axon/_abf.py

@@ -1,8 +1,8 @@
 #
 # This module reads files in Axon Binary File format v1 or v2 used by Axon
 # Technologies and Molecular Devices.
-# The v1 format was used until Clampex version 9. Clampex 10 and onwards use
-# the v2 format.
+# The v1 format was used until Clampex version 9.
+# Clampex 10 and onwards use the v2 format.
 #
 # WARNING: This file hasn't been extensively tested.
 #
@@ -57,13 +57,6 @@
 #  an 'epoch'. The protocol section of a file defines one or more stimuli, each
 #  containing a list of epochs.
 #
-# Conversion to myokit formats
-# ----------------------------
-# There is no problem-free mapping of ABF data onto myokit structures, such as
-# the simulation log. A fundamental difference is that "sampling" during a
-# simulation happens at the same time for every signal. Channels in an ABF file
-# each have their own sampling rate.
-#
 #---------------------------------  license  ----------------------------------
 #
 # This file is part of Myokit.
@@ -71,12 +64,18 @@
 #
 #---------------------------------  credits  ----------------------------------
 #
-# This module is derived in part from code found in the Neo package for
-# representing electrophysiology data, specifically from a python module
-# authored by sgarcia and jnowacki.
+# A lot of this code uses the (sadly somewhat outdated) information made public
+# by Axon, e.g. at https://support.moleculardevices.com/s/article/
+#                               Axon-pCLAMP-ABF-File-Support-Pack-Download-Page
+# This information comes without a specific license, but states that
+# "Permission is granted to freely use, modify and copy the code in this file."
+#
+# In addition, this module was in part derived from an early version of the
+# Neo package for representing electrophysiology data, specifically from a
+# Python module authored by sgarcia and jnowacki.
 # Neo can be found at: http://neuralensemble.org/trac/neo
 #
-# The Neo package is licensed using the following BSD License:
+# The Neo package used was licensed using the following BSD License:
 #
 #----------------------------------  start  -----------------------------------
 # Copyright (c) 2010-2012, Neo authors and contributors
@@ -140,21 +139,21 @@
 # was also used: http://neurodata.hg.sourceforge.net/hgweb/neurodata/neurodata/
 #------------------------------------------------------------------------------
 import datetime
-import logging
 import os
 import struct
-import traceback
+import warnings
 
 import numpy as np
 
-from collections import OrderedDict
+import myokit
+import myokit.formats
 
 
 # Encoding for text parts of files
 _ENC = 'latin-1'
 
 
-class AbfFile:
+class AbfFile(myokit.formats.SweepSource):
     """
     Represents a read-only Axon Binary Format file (``.abf``), stored at the
     location pointed to by ``filepath``.
@@ -164,37 +163,63 @@ class AbfFile:
     assumption can be overruled by setting the ``is_protocol_file`` argument
     to either ``True`` or ``False``.
 
-    The "data" in an AbfFile is recorded (analog-to-digital) data. Any output
-    signals from the amplifier to the cell (digital-to-analog) are termed the
-    "protocol".
+    Data in ABF files is recorded in *sweeps*, where each sweep contains one or
+    more *channels* with recorded (A/D) data. In addition, zero or more output
+    waveforms may be defined (also called "protocol" or D/A channels). Where
+    possible, the :class`AbfFile` class will convert these embedded protocols
+    to time series and include them as additional channels.
 
-    Data in AbfFiles is recorded in episodes called "sweeps". Each sweep
-    contains the data from all recorded channels. The number of channels is
-    constant: channel 1 in sweep 1 contains data recorded from the same source
-    as channel 1 in sweep 10.
+    For example::
 
-    The data in an ``AbfFile`` can be read by iterating over it::
-
-        f = AbfFile('some_file.abf')
-        for sweep in f:
+        abf = AbfFile('some_file.abf')
+        for sweep in abf:
             for channel in sweep:
-                plt.plot(channel.times(), channel.values())
+                print(channel.name())
+            break
+
+    might show
 
-    Similarly, protocol data can be accessed using::
+        IN 0
+        10xVm
+        Cmd 0
 
-        for sweep in f.protocol():
+    where the first two channels are recorded A/D channels and the final one is
+    a reconstructed D/A output channel.
+
+    Sweeps and channels are represented by :class:`Sweep` and :class:`Channel`
+    objects respectively, and these can be used to obtain the data from a
+    file::
+
+        abf = AbfFile('some_file.abf')
+        for sweep in abf:
             for channel in sweep:
-                plt.plot(channel.times(), channel.values())
+                plot(channel.times(), channel.values())
+
+    In addition the ``AbfFile`` class implements the
+    :class`myokit.formats.SweepSource` interface. Note that this interface
+    treats A/D and D/A as separate things, so :meth:`channel_count` returns the
+    number of A/D channels, not the total number of channels in a
+    :class:`Sweep` object (which can include D/A channels).
+
+    Support notes:
 
-    Note that the number of output ("protocol") channels need not equal the
-    number of input ("data") channels.
+    - Protocol (D/A) conversion is only supported for "episodic stimulation"
+      with constant valued steps (so e.g. no ramps) and without "user lists".
+    - Protocols with more than one sampling rate are not supported.
+    - The publicly available information on the ABF format is not great, so
+      there will be several other issues and shortcomings.
 
-    Because each channel can have a different sampling rate, AbfFile data is
-    not one-on-one compatible with myokit Simulation logs. To obtain a
-    :class:`myokit.DataLog` version of the file's data, use:meth:`myokit_log`.
+    Arguments:
+
+    ``filepath``
+        The path to load the data from. Data will be read into memory
+        immediately upon construction.
+    ``is_protocol_file``
+        If set to ``True``, no attempt to read A/D data will be made and only
+        D/A "protocol" information will be read. If left at its default value
+        of ``None`` files with the extension ``.pro`` will be recognized as
+        protocol files.
 
-    In some cases, a myokit protocol can be created from a stored stimulus
-    protocol. To do this, use the method:meth:`myokit_protocol`.
     """
     def __init__(self, filepath, is_protocol_file=None):
         # The path to the file and its basename
@@ -202,504 +227,90 @@ class AbfFile:
         self._filepath = os.path.abspath(filepath)
         self._filename = os.path.basename(filepath)
 
-        # Abf format version
-        self._version = None
-
-        # Protocol info
-        self._epoch_functions = None
-        self._numberOfTrials = None
-        self._trialStartToStart = None
-        self._runsPerTrial = None
-        self._runStartToStart = None
-        self._sweepsPerRun = None
-        self._sweepStartToStart = None
-
         # Read as protocol file yes?
         if is_protocol_file is None:
             self._is_protocol_file = os.path.splitext(filepath)[1] == '.pro'
         else:
             self._is_protocol_file = bool(is_protocol_file)
 
-        # The file header (an ordered dictionary)
-        self._header = self._read_header()
-
-        # Date/time of recording
-        self._datetime = self._read_datetime()
-
-        # Number of channels, sampling rate (Hz) and acquisition mode
-        if self._version < 2:
-            self._nc = self._header['nADCNumChannels']
-            self._rate = 1e6 / (self._header['fADCSampleInterval'] * self._nc)
-            self._mode = self._header['nOperationMode']
-        else:
-            self._nc = self._header['sections']['ADC']['length']
-            self._rate = 1e6 / self._header['protocol']['fADCSequenceInterval']
-            self._mode = self._header['protocol']['nOperationMode']
-        if self._mode not in acquisition_modes:
-            raise NotImplementedError(
-                'Unknown acquisition mode: ' + str(mode))
-
-        # Conversion factors for integer data in the channels
-        self._adc_factors = None
-        self._adc_offsets = None
-        self._set_conversion_factors()
-
-        # The protocol used (a list of sweeps)
-        try:
-            self._protocol = self._read_protocol()
-        except Exception:   # pragma: no cover
-            # This is not something we _want_ to happen, so if we have test
-            # cases that trigger this error they should be resolved. At the
-            # same time, if it happens to a user we want it to "sort-of work"
-            # (an experimental rather than a production setting)
-            log = logging.getLogger(__name__)
-            log.warning('Unable to read protocol from ' + self._filepath)
-            log.warning(traceback.format_exc())
-            self._protocol = []
-
-        # The measured data as a list of sweeps
-        if self._is_protocol_file:
-            self._sweeps = []
-        else:
-            self._sweeps = self._read_sweeps()
-
-    def data_channels(self):
-        """
-        Returns the number of channels in this file's sweeps.
-        """
-        if len(self._sweeps) == 0:  # pragma: no cover
-            return 0
-        return len(self._sweeps[0])
-
-    def extract_channel(self, channel=0, join=False):
-        """
-        Extracts a selected data ``channel`` and returns its data in a tuple
-        containing::
-
-             A numpy array representing time
-             A numpy array representing the first sweep
-             A numpy array representing the second sweep
-             ...
-
-        An optional argument ``join=True`` can be set to join all sweeps
-        together and return just two arrays, one for time and one for data.
-
-        If no data is available, ``None`` is returned.
-        """
-        if len(self._sweeps) == 0:  # pragma: no cover
-            return None
-
-        # Join all sweeps
-        if join:
-            time, data = [], []
-            t = np.array(self._sweeps[0][channel].times())
-            for i, sweep in enumerate(self._sweeps):
-                time.append(t + i * self._sweepStartToStart)
-                data.append(np.array(sweep[channel].values()))
-            return (np.concatenate(time), np.concatenate(data))
-
-        # Standard reading
-        data = []
-        data.append(np.array(self._sweeps[0][channel].times()))
-        for sweep in self._sweeps:
-            data.append(np.array(sweep[channel].values()))
-        return tuple(data)
-
-    def extract_channel_as_myokit_log(self, channel=0):
-        """
-        Extracts the given data channel and returns it as a myokit
-        DataLog.
-
-        The log will contain an entry "time" that contains the time vector.
-        Each sweep will be in an entry "0.sweep", "1.sweep", "2.sweep" etc.
-        """
-        import myokit
-        log = myokit.DataLog()
-        if len(self._sweeps) == 0:  # pragma: no cover
-            return log
-        log.set_time_key('time')
-        log['time'] = np.array(self._sweeps[0][channel].times())
-        for k, sweep in enumerate(self._sweeps):
-            log['sweep', k] = np.array(sweep[channel].values())
-        return log
-
-    def filename(self):
-        """
-        Returns this AbfFile's filename.
-        """
-        return self._filepath
-
-    def __getitem__(self, key):
-        return self._sweeps.__getitem__(key)
-
-    def _get_conversion_factors(self, channel):
-        """
-        Returns the conversion factor and shift for the selected channel as a
-        tuple of floats ``(factor, shift)``.
-        """
-        return self._adc_factors[channel], self._adc_offsets[channel]
-
-    def info(self, show_header=False):
-        """
-        Returns a string with lots of info on this file.
-
-        The optional argument ``show_header`` can be used to add the full
-        header contents to the output.
-        """
-        out = []
-
-        # Show file info
-        if self._is_protocol_file:
-            out.append('Axon Protocol File: ' + self._filename)
-        else:
-            out.append('Axon Binary File: ' + self._filename)
-        out.append('ABF Format version ' + str(self._version))
-        out.append('Recorded on: ' + str(self._datetime))
-
-        # Show protocol info
-        out.append(
-            'Acquisition mode: ' + str(self._mode) + ': '
-            + acquisition_modes[self._mode])
-        if self._numberOfTrials:
-            out.append(
-                'Protocol set for ' + str(self._numberOfTrials)
-                + ' trials, spaced ' + str(self._trialStartToStart)
-                + 's apart.')
-            out.append(
-                '    with ' + str(self._runsPerTrial)
-                + ' runs per trial, spaced ' + str(self._runStartToStart)
-                + 's apart.')
-            out.append(
-                '     and ' + str(self._sweepsPerRun)
-                + ' sweeps per run, spaced ' + str(self._sweepStartToStart)
-                + 's apart.')
-        else:   # pragma: no cover
-            out.append('Protocol data could not be determined.')
-        out.append('Sampling rate: ' + str(self._rate) + ' Hz')
+        # Cached string-to-unit conversions
+        self._unit_cache = {}
 
-        # Show channel info
-        if self._sweeps:
-            for i, c in enumerate(self._sweeps[0]._channels):
-                out.append('Channel ' + str(i) + ': "' + c._name + '"')
-                if c._type:  # pragma: no cover
-                    # Cover pragma: Don't have appropriate test file
-                    out.append('  Type: ' + type_mode_names[c._type])
-                out.append('  Unit: ' + c._unit.strip())
-                if c._lopass:
-                    out.append('  Low-pass filter: ' + str(c._lopass) + ' Hz')
-                if c._cm:
-                    out.append('  Cm (telegraphed): ' + str(c._cm) + ' pF')
-                if c._rs:   # pragma: no cover
-                    # Cover pragma: Don't have appropriate test file
-                    out.append('  Rs (telegraphed): ' + str(c._rs))
-
-        # Methods
-        def show_dict(name, d, tab=''):
-            m = max(0, 38 - len(tab) - int(0.1 + len(name) / 2))
-            out.append(tab + '-' * m + '  ' + name + '  ' + '-' * m)
-            for n, v in d.items():
-                n = str(n)
-                if type(v) == OrderedDict:
-                    show_dict(n, v, tab + '  ')
-                elif type(v) == list:
-                    show_list(n, v, tab)
-                else:
-                    out.append(tab + n + ': ' + str(v))
-            m = max(0, 80 - 2 * len(tab))
-            out.append(tab + m * '-')
-
-        def show_list(name, d, tab=''):
-            for index, item in enumerate(d):
-                n = name + '[' + str(index) + ']'
-                if type(item) == OrderedDict:
-                    show_dict(n, item, tab)
-                elif type(item) == list:    # pragma: no cover
-                    # Cover pragma: Don't have appropriate test file
-                    show_list(n, item, tab)
-                else:
-                    out.append(tab + n + ': ' + str(item))
-
-        # Show full header info
-        if show_header:
-            if self.strings:
-                show_dict('Strings', {'strings': self.strings})
-            show_dict('file header', self._header)
-        return '\n'.join(out)
-
-    def matplotlib_figure(self):
-        """
-        Creates and returns a matplotlib figure of this abf file's contents.
-        """
-        import matplotlib.pyplot as plt
-        f = plt.figure()
-        plt.suptitle(self.filename())
-
-        # Show data channel
-        ax = plt.subplot(2, 1, 1)
-        ax.set_title('Measured data')
-        times = None
-        for sweep in self:
-            for channel in sweep:
-                if times is None:
-                    times = channel.times()
-                plt.plot(times, channel.values())
-
-        # Show protocol channels
-        n = self.protocol_channels()
-        ax = [plt.subplot(2, n, n + 1 + i) for i in range(n)]
-
-        for sweep in self.protocol():
-            times = None
-            for i, channel in enumerate(sweep):
-                if times is None:
-                    times = channel.times()
-                ax[i].set_title(channel.name())
-                ax[i].plot(times, channel.values())
-        return f
-
-    def myokit_log(self):
-        """
-        Converts the data in this ABF file to a:class:`myokit.DataLog` with an
-        entry for every channel. All sweeps will be joined together into a
-        single time series.
-
-        The log will contain an entry "time" that contains the time vector.
-        Channels will be stored using "0.ad", "1.ad" etc. for the recorded
-        (analog-to-digital) channels and "0.da", "1.da" etc. for the output
-        (digital-to-analog) channels.
-        """
-        import myokit
-        log = myokit.DataLog()
-        if self._sweeps:
-            # Gather parts of time and channel vectors
-            time = []
-            ad_channels = []
-            da_channels = []
-            for i in range(self.data_channels()):
-                ad_channels.append([])
-            for i in range(self.protocol_channels()):
-                da_channels.append([])
-
-            # Add ad channels
-            for sweep in self:
-                for channel in sweep:
-                    time.append(channel.times())
-                    break
-                for i, channel in enumerate(sweep):
-                    ad_channels[i].append(channel.values())
-
-            # Add da channels
-            for sweep in self.protocol():
-                for i, channel in enumerate(sweep):
-                    da_channels[i].append(channel.values())
-
-            # Combine into time series, store in log
-            log['time'] = np.concatenate(time)
-            log.set_time_key('time')
-            for i, channel in enumerate(ad_channels):
-                log['ad', i] = np.concatenate(channel)
-            for i, channel in enumerate(da_channels):
-                log['da', i] = np.concatenate(channel)
-
-        return log
-
-    def myokit_protocol(self, channel=None, ms=True):
-        """
-        Returns a single channel from an embedded protocol as a
-        :class:`myokit.Protocol`. The channel to return is specified by setting
-        ``channel`` to the correct index.
-
-        Only works for episodic stimulation, without user lists.
-
-        By default, all times are converted to milliseconds. To disable this
-        function, set ``ms=False``.
-        """
-        import myokit
-
-        # Only episodic stimulation is supported.
-        if self._mode != ACMODE_EPISODIC_STIMULATION:  # pragma: no cover
-            return myokit.Protocol()
-
-        # Check channel
-        if channel is None:
-            channel = 0
-        else:
-            channel = int(channel)
-
-        # User lists are not supported
-        if self._version < 2:  # pragma: no cover
-            if self._header['nULEnable'][channel]:
-                raise NotImplementedError('User lists are not supported.')
-        else:   # pragma: no cover
-            for userlist in self._header['listUserListInfo']:
-                en1 = 'nULEnable' in userlist and userlist['nULEnable']
-                en2 = 'nConditEnable' in userlist and userlist['nConditEnable']
-                if en1 or en2:
-                    raise NotImplementedError('User lists are not supported.')
-
-        # Create protocol
-        p = myokit.Protocol()
-
-        # Get epoch functions set by _read_protocol
-        dinfo, einfo_exists, einfo = self._epoch_functions
-        start = 0
-        next_start = 0
-        f = 1e3 if ms else 1
-        for iSweep in range(self._sweepsPerRun):
-
-            if not einfo_exists(channel):   # pragma: no cover
-                # Not sure if this can happen, if so, would need to update code
-                raise Exception('Missing protocol data')
-
-            for e in einfo(channel):
-                kind = e['type']
-
-                if kind not in epoch_types:
-                    raise NotImplementedError(
-                        'Unknown epoch type: ' + str(kind))
-
-                if kind == EPOCH_DISABLED:
-                    continue
-
-                elif kind == EPOCH_STEPPED:
-                    # Event at step
-                    dur = f * e['init_duration'] / self._rate
-                    inc = f * e['duration_inc'] / self._rate
-                    e_level = e['init_level'] + e['level_inc'] * iSweep
-                    e_start = start
-                    e_length = dur + iSweep * inc
-                    p.schedule(e_level, e_start, e_length)
-                    start += e_length
-
-                else:   # pragma: no cover
-                    raise NotImplementedError(
-                        'Usupported epoch type: ' + epoch_types(kind))
-
-            # Event at holding potential
-            next_start += f * self._sweepStartToStart
-            e_level = dinfo(channel, 'fDACHoldingLevel')
-            e_start = start
-            e_length = next_start - start
-            p.schedule(e_level, e_start, e_length)
-            start = next_start
-
-        return p
-
-    def protocol_channels(self):
-        """
-        Returns the number of channels in this file's protocol.
-        """
-        if self._version < 2:
-            return len(self._header['sDACChannelName'])
-        else:
-            return int(self._header['sections']['DAC']['length'])
-
-    def protocol_holding_level(self, channel=0):
-        """
-        Returns the holding level used by the requested output channel of the
-        embedded protocol.
-        """
-        dinfo, einfo_exists, einfo = self._epoch_functions
-        return dinfo(channel, 'fDACHoldingLevel')
-
-    def protocol_steps(self, channel=0):
-        """
-        For a stepped protocol, this function returns a tuple of lists of the
-        successive values (not including the holding value).
-
-        For example, for a protocol that has holding value ``-120mV`` and
-        performs steps to ``-100mV``, ``-80mV``, and ``-40mV`` the returned
-        output will be::
+        # Read the file header as an ordered dictionary
+        self._header = None
+        self._strings = None
+        self._version = None
+        self._version_str = None
+        self._read_1_header()
 
-            ([-100, -80, -40])
+        # Read the time of recording
+        self._datetime = None
+        self._read_2_time_of_recording()
 
-        For a more complicated protocol, where each step is followed by a step
-        down to ``-140mV``, the output would be::
+        # Read the protocol information
+        self._n_adc = None
+        self._n_dac = None
 
-            ([-100, -80, -40], [-140, -140, -140])
+        self._rate = None
+        self._mode = None
+
+        self._number_of_trials = None
+        self._trial_start_to_start = None
+        self._runs_per_trial = None
+        self._run_start_to_start = None
+        self._sweeps_per_run = None
+        self._sweep_start_to_start = None
+        self._samples_per_channel = None
+
+        # To be able to treat v1 and v2 slightly more easily, we define 3
+        # functions read epoch info from episodic stimulation protocols
+        self._epoch_functions = None
 
+        # Not all D/A channels can be converted, so we maintain an array with
+        # the original indices of the channels in the da_sweeps. (Note that
+        # this differs again from the "index" labels for user display, which
+        # are stored in the channels themselves).
+        self._dac_indices = []
 
-        """
-        # Get epoch functions set by _read_protocol
-        dinfo, einfo_exists, einfo = self._epoch_functions
-        if not einfo_exists(channel):  # pragma: no cover
-            # Not sure if this can happen, if so need to update code.
-            raise Exception('Missing protocol data')
-
-        # Create list of step lists
-        levels = []
-        for e in einfo(channel):
-            kind = e['type']
-            if kind not in epoch_types:
-                raise NotImplementedError('Unknown epoch type: ' + str(kind))
-            if kind == EPOCH_DISABLED:
-                continue
-            elif kind == EPOCH_STEPPED:
-                levels.append([])
-            else:
-                raise NotImplementedError(
-                    'Unsupported epoch type: ' + epoch_types(kind))
-
-        # Gather steps
-        levels = tuple(levels)
-        for i in range(self._sweepsPerRun):
-            j = 0
-            for e in einfo(channel):
-                if e['type'] == EPOCH_STEPPED:
-                    levels[j].append(e['init_level'] + e['level_inc'] * i)
-                    j += 1
-        return levels
+        # Read protocol information and create empty sweep objects
+        # Sweeps contain both A/D channels and D/A reconstructions. Some files
+        # will have A/D but no (or no supported) D/A. Conversely protocol files
+        # will have D/A only. So all in one sweep is easiest.
+        self._sweeps = None
 
-    def __iter__(self):
-        """
-        Returns an iterator over all sweeps
-        """
-        return iter(self._sweeps)
+        self._read_3_protocol_information()
 
-    def __len__(self):
-        """
-        Returns the number of sweeps in this file.
-        """
-        return len(self._sweeps)
+        # Read and calculate conversion factors for integer data in ADC
+        self._adc_factors = None
+        self._adc_offsets = None
+        self._read_4_ad_conversion_factors()
 
-    def protocol(self):
-        """
-        Returns an interator over the protocol data.
-        """
-        return iter(self._protocol)
+        # Read the A/D channel data and add it to the sweeps
+        if self._n_adc:
+            self._read_5_ad_data()
 
-    def _read_datetime(self):
-        """
-        Reads the date/time this file was recorded
-        """
-        # Get date and time
-        if self._version < 2:
-            t1 = str(self._header['lFileStartDate'])
-            t2 = float(self._header['lFileStartTime'])
-        else:
-            t1 = str(self._header['uFileStartDate'])
-            t2 = float(self._header['uFileStartTimeMS']) / 1000
+        # Reconstruct D/A signals as additional channels and add to the sweeps
+        self._read_6_da_reconstructions()
 
-        YY = int(t1[0:4])
-        MM = int(t1[4:6])
-        DD = int(t1[6:8])
-        hh = int(t2 / 3600)
-        mm = int((t2 - hh * 3600) / 60)
-        ss = t2 - hh * 3600 - mm * 60
-        ms = int((ss % 1) * 1e6)
-        ss = int(ss)
-
-        return datetime.datetime(YY, MM, DD, hh, mm, ss, ms)
+        # Copy channel names and units, for easier SweepSource implementation
+        self._ad_names = {}
+        self._da_names = {}
+        self._ad_units = []
+        self._da_units = []
+        for sweep in self._sweeps:
+            for i, channel in enumerate(sweep[:self._n_adc]):
+                self._ad_names[channel.name()] = i
+                self._ad_units.append(channel.unit())
+            for i, channel in enumerate(sweep[self._n_adc:]):
+                self._da_names[channel.name()] = i
+                self._da_units.append(channel.unit())
+            break
 
-    def _read_header(self):
-        """
-        Reads the file's header.
-        """
+    def _read_1_header(self):
+        """ Read the file header. """
 
         def read_f(f, form, offset=None):
-            """
-            Read and unpack a file section using the given format ``form``.
-            """
+            """ Read and unpack a file section in the format ``form``. """
             form = str(form)
             if offset is not None:
                 f.seek(offset)
@@ -719,7 +330,7 @@ class AbfFile:
             values = [0] * len(val)
             for i, v in enumerate(val):
                 if isinstance(v, bytes):
-                    v = v.decode(_ENC)
+                    v = v.decode(_ENC).strip()
                     # Handle long \x00 lists
                     if v and ord(v[0]) == 0:
                         return None
@@ -741,21 +352,21 @@ class AbfFile:
             elif sig == 'ABF2':
                 version = 2
             else:
-                raise NotImplementedError(
-                    'Unknown ABF Format "' + str(sig) + '".')
+                raise NotImplementedError('Unknown ABF Format "{sig}".')
 
             # Gather header fields
-            header = OrderedDict()
-            for key, offset, form in headerFields[version]:
+            header = {}
+            for key, offset, form in HEADER_FIELDS[version]:
                 header[key] = ups(read_f(f, form, offset))
 
             # Get uniform file version number
             if version < 2:
-                self._version = (
-                    np.round(header['fFileVersionNumber'] * 100) / 100)
+                self._version = np.round(header['fFileVersionNumber'], 5)
+                self._version_str = str(self._version)
             else:
-                n = header['fFileVersionNumber']
-                self._version = n[3] + 0.1 * n[2] + 0.01 * n[1] + 0.001 * n[0]
+                v = header['fFileVersionNumber']
+                self._version = v[3]
+                self._version_str = '.'.join([str(v) for v in reversed(v)])
 
             # Get file start time in seconds
             if version < 2:
@@ -771,21 +382,21 @@ class AbfFile:
                 for i in range(header['lNumTagEntries']):  # pragma: no cover
                     # Cover pragma: Don't have appropriate test file
                     f.seek(header['lTagSectionPtr'] + i * 64)
-                    tag = OrderedDict()
-                    for key, form in TagInfoDescription:
+                    tag = {}
+                    for key, form in ABF2_TAG_INFO_DESCRIPTION:
                         tag[key] = ups(read_f(f, form))
                     tags.append(tag)
                 header['tags'] = tags
-                self.strings = []
+                self._strings = []
 
             else:
 
                 # Version 2
                 # Find location of file sections
-                sections = OrderedDict()
-                for i, s in enumerate(abf2FileSections):
+                sections = {}
+                for i, s in enumerate(ABF2_FILE_SECTIONS):
                     index, data, length = read_f(f, 'IIl', 76 + i * 16)
-                    sections[s] = OrderedDict()
+                    sections[s] = {}
                     sections[s]['index'] = index
                     sections[s]['data'] = data
                     sections[s]['length'] = length
@@ -807,8 +418,8 @@ class AbfFile:
 
                 # C-style string termination
                 strings = strings.split(b'\x00')
-                strings = [s.decode(_ENC) for s in strings]
-                self.strings = strings
+                strings = [s.decode(_ENC).strip() for s in strings]
+                self._strings = strings
 
                 # Read tag section
                 tags = []
@@ -817,17 +428,17 @@ class AbfFile:
                 for i in range(sections['Tag']['length']):  # pragma: no cover
                     # Cover pragma: Don't have appropriate test file
                     f.seek(offs + i * size)
-                    tag = OrderedDict()
-                    for key, form in TagInfoDescription:
+                    tag = {}
+                    for key, form in ABF2_TAG_INFO_DESCRIPTION:
                         tag[key] = ups(read_f(f, form))
                     tags.append(tag)
                 header['tags'] = tags
 
                 # Read protocol section
-                protocol = OrderedDict()
+                protocol = {}
                 offs = sections['Protocol']['index'] * BLOCKSIZE
                 f.seek(offs)
-                for key, form in protocolFields:
+                for key, form in ABF2_PROTOCOL_FIELDS:
                     protocol[key] = ups(read_f(f, form))
                 header['protocol'] = protocol
 
@@ -836,9 +447,9 @@ class AbfFile:
                 offs = sections['ADC']['index'] * BLOCKSIZE
                 size = sections['ADC']['data']
                 for i in range(sections['ADC']['length']):
-                    ADC = OrderedDict()
+                    ADC = {}
                     f.seek(offs + i * size)
-                    for key, form in ADCFields:
+                    for key, form in ABF2_ADC_FIELDS:
                         ADC[key] = ups(read_f(f, form))
                     # Get channel name and unit
                     ADC['ADCChNames'] = (
@@ -853,8 +464,8 @@ class AbfFile:
                 size = sections['DAC']['data']
                 for i in range(sections['DAC']['length']):
                     f.seek(offs + size * i)
-                    DAC = OrderedDict()
-                    for key, form in DACFields:
+                    DAC = {}
+                    for key, form in ABF2_DAC_FIELDS:
                         DAC[key] = ups(read_f(f, form))
                     DAC['sDACChannelName'] = \
                         strings[DAC['lDACChannelNameIndex'] - 1]
@@ -864,81 +475,141 @@ class AbfFile:
                 header['listDACInfo'] = dac
 
                 # Read UserList section
-                userlists = []
+                user_lists = []
+                offs = sections['UserList']['index'] * BLOCKSIZE
+                size = sections['UserList']['data']
                 r = range(sections['UserList']['length'])
                 for i in r:  # pragma: no cover
                     # Cover pragma: User lists are not supported
                     f.seek(offs + size * i)
-                    UserList = OrderedDict()
-                    for key, form in UserListFields:
-                        UserList[key] = ups(read_f(f, form))
-                    userlists.append(DAC)
-                header['listUserListInfo'] = userlists
+                    user_list = {}
+                    for key, form in ABF2_USER_LIST_FIELDS:
+                        user_list[key] = ups(read_f(f, form))
+                    user_lists.append(user_list)
+                header['listUserListInfo'] = user_lists
 
                 # Read epoch-per-DAC section
                 # The resulting OrderedDict has the following structure:
                 #  - the first index is the DAC number
                 #  - the second index is the epoch number
-                header['epochInfoPerDAC'] = OrderedDict()
+                header['epochInfoPerDAC'] = {}
                 offs = sections['EpochPerDAC']['index'] * BLOCKSIZE
                 size = sections['EpochPerDAC']['data']
-                info = OrderedDict()
+                info = {}
                 for i in range(sections['EpochPerDAC']['length']):
                     f.seek(offs + size * i)
-                    einf = OrderedDict()
-                    for key, form in EpochInfoPerDACFields:
+                    einf = {}
+                    for key, form in ABF2_EPOCH_INFO_PER_DAC_FIELD:
                         einf[key] = ups(read_f(f, form))
                     DACNum = einf['nDACNum']
                     EpochNum = einf['nEpochNum']
                     if DACNum not in info:
-                        info[DACNum] = OrderedDict()
+                        info[DACNum] = {}
                     info[DACNum][EpochNum] = einf
                 header['epochInfoPerDAC'] = info
 
-        return header
+        self._header = header
 
-    def _read_protocol(self):
-        """
-        Reads the protocol stored in the ABF file and converts it to an analog
-        signal.
+    def _read_2_time_of_recording(self):
+        """ Read and process the time when this file was recorded. """
+
+        if self._version < 2:
+            t1 = str(self._header['lFileStartDate'])
+            t2 = float(self._header['lFileStartTime'])
+        else:
+            t1 = str(self._header['uFileStartDate'])
+            t2 = float(self._header['uFileStartTimeMS']) / 1000
 
-        Only works for episodic stimulation, without any user lists.
+        YY = int(t1[0:4])
+        MM = int(t1[4:6])
+        DD = int(t1[6:8])
+        hh = int(t2 / 3600)
+        mm = int((t2 - hh * 3600) / 60)
+        ss = t2 - hh * 3600 - mm * 60
+        ms = int((ss % 1) * 1e6)
+        ss = int(ss)
 
-        The resulting analog signal has the same size as the recorded signals,
-        so not the full length of the protocol! This is different from the
-        values returned by the Myokit
+        self._datetime = datetime.datetime(YY, MM, DD, hh, mm, ss, ms)
+
+    def _read_3_protocol_information(self):
+        """
+        Reads the header fields detailing the number of runs, sweeps, and the
+        type of protocol used. Create empty sweeps.
         """
+        h = self._header
+
+        # Number of channels, sampling rate (Hz) and acquisition mode
+        # Note: Number of A/D channels will be set to 0 if this is a
+        #       protocol-only file
+        # Note: Number of D/A channels will be adjusted after checking support
+        if self._version < 2:
+            # In (newer versions of) version 1.x, only 2 D/A channels have
+            # full "waveform" support. There are still 4 D/A channels but I
+            # don't understand what the other 2 do.
+            # 1.x versions only seem to have 1 DAC channel, but this is not
+            # supported here.
+            self._n_adc = int(h['nADCNumChannels'])
+            self._n_dac = min(len(h['sDACChannelName']), 2)
+            self._rate = 1e6 / (h['fADCSampleInterval'] * self._n_adc)
+            self._mode = h['nOperationMode']
+        else:
+            # In version 2, there are up to 8 "waveform" D/A channels
+
+            self._n_adc = int(h['sections']['ADC']['length'])
+            self._n_dac = int(h['sections']['DAC']['length'])
+            self._rate = 1e6 / h['protocol']['fADCSequenceInterval']
+            self._mode = h['protocol']['nOperationMode']
+
+        if self._mode not in acquisition_modes:  # pragma: no cover
+            raise NotImplementedError(f'Unknown acquisition mode: {mode}')
+
+        # Protocol files don't have A/D channels by definition
+        if self._is_protocol_file:
+            self._n_adc = 0
+
         # Only episodic stimulation is supported.
         if self._mode != ACMODE_EPISODIC_STIMULATION:  # pragma: no cover
-            return []
+            warnings.warn(
+                'Unsupported acquisition method '
+                + acquisition_modes[self._mode] + '; unable to read D/A'
+                ' channels.')
 
-        # Start reading
-        h = self._header
+            # Remaining code is all about reading D/A info for episodic
+            # stimulation, so return
+            self._n_dac = 0
+            return
 
-        # Step 1: Gather information about the protocol
+        # Gather protocol information
         if self._version < 2:
 
             # Before version 2: Sections are fixed length, locations absolute
-            self._numberOfTrials = h['lNumberOfTrials']
-            self._trialStartToStart = h['fTrialStartToStart']
-            self._runsPerTrial = h['lRunsPerTrial']
-            self._runStartToStart = h['fRunStartToStart']
-            self._sweepsPerRun = h['lSweepsPerRun']
-            self._sweepStartToStart = h['fEpisodeStartToStart']
+            self._number_of_trials = h['lNumberOfTrials']
+            self._trial_start_to_start = h['fTrialStartToStart']
+            self._runs_per_trial = h['lRunsPerTrial']
+            self._run_start_to_start = h['fRunStartToStart']
+            self._sweeps_per_run = h['lSweepsPerRun']
+            self._sweep_start_to_start = h['fEpisodeStartToStart']
 
             # Number of samples in a channel for each sweep
             # (Only works for fixed-length, high-speed-osc or episodic)
-            nSam = h['lNumSamplesPerEpisode'] // h['nADCNumChannels']
+            self._samples_per_channel = \
+                h['lNumSamplesPerEpisode'] // h['nADCNumChannels']
 
             def dinfo(index, name):
+                """ Return DAC channel info, ABF1 version. """
                 return h[name][index]
 
             def einfo_exists(index):
-                return True
+                """ Check that epoch info exists for a DAC, ABF1 version. """
+                # Fields always exist for 2 channels, not always set.
+                # But not useful to look at unset ones, so using n_dac instead
+                # of hardcoded 2!
+                return 0 <= index < self._n_dac
 
             def einfo(index):
+                """ Return epoch info for a DAC, ABF1 version. """
                 lo = index * 8
-                hi = index + 8
+                hi = lo + 8
                 for i in range(lo, hi):
                     yield {
                         'type': h['nEpochType'][i],
@@ -956,24 +627,28 @@ class AbfFile:
 
             # Trials, runs, sweeps
             # (According to the manual, there should only be 1 trial!)
-            self._numberOfTrials = p['lNumberOfTrials']
-            self._trialStartToStart = p['fTrialStartToStart']
-            self._runsPerTrial = p['lRunsPerTrial']
-            self._runStartToStart = p['fRunStartToStart']
-            self._sweepsPerRun = p['lSweepsPerRun']
-            self._sweepStartToStart = p['fSweepStartToStart']
+            self._number_of_trials = p['lNumberOfTrials']
+            self._trial_start_to_start = p['fTrialStartToStart']
+            self._runs_per_trial = p['lRunsPerTrial']
+            self._run_start_to_start = p['fRunStartToStart']
+            self._sweeps_per_run = p['lSweepsPerRun']
+            self._sweep_start_to_start = p['fSweepStartToStart']
 
             # Number of samples in a channel in a single sweep
-            nSam = p['lNumSamplesPerEpisode'] // h['sections']['ADC']['length']
+            self._samples_per_channel = \
+                p['lNumSamplesPerEpisode'] // h['sections']['ADC']['length']
 
             # Compatibility functions
             def dinfo(index, name):
+                """ Return DAC info, ABF2 version. """
                 return h['listDACInfo'][index][name]
 
             def einfo_exists(index):
+                """ Check that epoch info exists for a DAC, ABF2 version. """
                 return index in h['epochInfoPerDAC']
 
             def einfo(index):
+                """ Return epoch info for a DAC, ABF2 version. """
                 for e in h['epochInfoPerDAC'][index].values():
                     yield {
                         'type': e['nEpochType'],
@@ -985,190 +660,245 @@ class AbfFile:
             self._epoch_functions = (dinfo, einfo_exists, einfo)
 
         # If sweepStartToStart == 0, we set it to the duration of a sweep
-        if self._sweepStartToStart == 0:    # pragma: no cover
-            self._sweepStartToStart = nSam / self._rate
+        if self._sweep_start_to_start == 0:    # pragma: no cover
+            self._sweep_start_to_start = self._samples_per_channel / self._rate
 
-        # Step 2: Generate analog signals corresponding to the waveforms
-        # suggested by the 'epochs' in the protocol
-        # User lists are not supported
+        # Create empty sweeps
+        n = h['lActualSweeps']
+        if self._is_protocol_file:
+            n = self._sweeps_per_run
+        self._sweeps = [Sweep() for i in range(n)]
+
+        # User lists are not supported for D/A reconstruction
+        # I haven't been able to figure out how you see if a user list is
+        # being used, or which channel is using it. There is an 'enable' field
+        # but that's been 0 in files that definitely used a UserList...
+        # So for now not reading ANY DAC if a userlist even exists.
+        user_lists = False
         if self._version < 2:   # pragma: no cover
-            if any(self._header['nULEnable']):
-                return []
-        else:   # pragma: no cover
-            for userlist in self._header['listUserListInfo']:
-                if 'nULEnable' in userlist and userlist['nULEnable']:
-                    return []
-                if 'nConditEnable' in userlist and userlist['nConditEnable']:
-                    return []
-        sweeps = []
-
-        # Number of DAC channels = number of channels that can be used
-        #  to output a stimulation
-        nDac = self.protocol_channels()
-        start = 0
-        for iSweep in range(h['lActualSweeps']):
-            sweep = Sweep(nDac)
-
-            # Create channels for this sweep
-            for iDac in range(nDac):
-                c = Channel(self)
-                c._name = dinfo(iDac, 'sDACChannelName').strip()
-                c._unit = dinfo(iDac, 'sDACChannelUnits').strip()
-                if self._version < 2:
-                    c._numb = iDac
+            user_lists = any(self._header['nULEnable'])
+        else:                   # pragma: no cover
+            user_lists = len(self._header['listUserListInfo']) > 0
+        if user_lists:          # pragma: no cover
+            warnings.warn(
+                'Unsupported acquisition method: episodic with user lists;'
+                ' unable to read D/A channels.')
+            self._n_dac = 0
+            return
+
+        # Get indices of enabled and supported DAC reconstructions
+        supported = {EPOCH_DISABLED, EPOCH_STEPPED}
+        for i_dac in range(self._n_dac):
+            if einfo_exists(i_dac):
+                i = einfo(i_dac)
+                use = False
+
+                # Check for unsupported features (or disabled waveforms/epochs)
+                # Version 1 files can only have two waveform channels
+                if self._version < 2 and i_dac > 1:  # pragma: no cover
+                    source = DAC_DISABLED
                 else:
-                    c._numb = int(dinfo(iDac, 'lDACChannelNameIndex'))
-                c._data = np.ones(nSam) * dinfo(iDac, 'fDACHoldingLevel')
-                c._rate = self._rate
-                c._start = start
-                sweep[iDac] = c
+                    source = dinfo(i_dac, 'nWaveformSource')
+                if source == DAC_EPOCHTABLEWAVEFORM:
+                    # Any epoch types besides disabled/stepped? Then don't use
+                    # Also don't use if exclusively disabled
+                    for e in i:
+                        t = e['type']
+                        if t == EPOCH_STEPPED:
+                            use = True
+                        elif t != EPOCH_DISABLED:  # pragma: no cover
+                            use = False
+                            warnings.warn(
+                                f'Unsupported epoch type: {epoch_types(t)}')
+                            break
+                elif source == DAC_DACFILEWAVEFORM:  # pragma: no cover
+                    # Stimulus file? Then don't use
+                    warnings.warn('Stimulus file D/A channel not supported.')
 
-                # No stimulation info for this channel? Then continue
-                if not einfo_exists(iDac):
-                    continue
+                if use:
+                    self._dac_indices.append(i_dac)
 
-                # Save last sample index
-                i_last = int(nSam * 15625 / 1e6)  # TODO: What's this?
+        # Set true number of D/A outputs
+        self._n_dac = len(self._dac_indices)
 
-                # For each 'epoch' in the stimulation signal
-                for e in einfo(iDac):
-                    kind = e['type']
-                    if kind not in epoch_types:
-                        raise NotImplementedError(
-                            'Unknown epoch type: ' + str(kind))
+    def _read_4_ad_conversion_factors(self):
+        """ Calculate the factors to convert any integer data to float. """
+        self._adc_factors = []
+        self._adc_offsets = []
+        h = self._header
+        if self._version < 2:
+            for i in range(self._n_adc):
+                j = h['nADCSamplingSeq'][i]
+
+                # Multiplier
+                f = (
+                    h['fInstrumentScaleFactor'][j]
+                    * h['fADCProgrammableGain'][j]
+                    * h['lADCResolution']
+                    / h['fADCRange'])
+
+                # Signal conditioner used?
+                if h['nSignalType'] != 0:   # pragma: no cover
+                    # Cover pragma: Don't have appropriate test file
+                    f *= h['fSignalGain'][j]
 
-                    if kind == EPOCH_DISABLED:
+                # Additional gain?
+                if h['nTelegraphEnable'][j]:
+                    f *= h['fTelegraphAdditGain'][j]
 
-                        continue
+                # Set final gain factor
+                self._adc_factors.append(1 / f)
 
-                    elif kind == EPOCH_STEPPED:
+                # Shift
+                s = h['fInstrumentOffset'][j]
 
-                        dur = e['init_duration']
-                        inc = e['duration_inc']
-                        i1 = i_last
-                        i2 = i_last + dur + iSweep * inc
-                        if i2 > nSam:
-                            # The protocol may extend beyond the number of
-                            # samples in the recording
-                            i2 = nSam
-                        level = e['init_level'] + e['level_inc'] * iSweep
-                        c._data[i1:i2] = level * np.ones(len(range(i2 - i1)))
-                        i_last += dur
-                        if i_last > nSam:
-                            # The protocol may extend beyond the number of
-                            # samples in the recording
-                            break
+                # Signal conditioner used?
+                if h['nSignalType'] != 0:   # pragma: no cover
+                    # Cover pragma: Don't have appropriate test file
+                    s -= h['fSignalOffset'][j]
 
-                    else:  # pragma: no cover
+                # Set final offset
+                self._adc_offsets.append(s)
 
-                        log = logging.getLogger(__name__)
-                        log.warning(
-                            'Unsupported epoch type: ' + epoch_types(kind))
-                        continue
+        else:
 
-            sweeps.append(sweep)
-            start += self._sweepStartToStart
-        return sweeps
+            a = h['listADCInfo']
+            p = h['protocol']
+            for i in range(self._n_adc):
+                # Multiplier
+                f = (
+                    a[i]['fInstrumentScaleFactor']
+                    * a[i]['fADCProgrammableGain']
+                    * p['lADCResolution']
+                    / p['fADCRange'])
 
-    def _read_sweeps(self):
-        """
-        Reads the data from an ABF file and returns a list of sweeps
-        """
-        header = self._header
-        version = self._version
-        nc = self._nc
+                # Signal conditioner used?
+                if h.get('nSignalType', 0) != 0:  # pragma: no cover
+                    # Cover pragma: Don't have appropriate test file
+                    f *= a[i]['fSignalGain']
+
+                # Additional gain?
+                if a[i]['nTelegraphEnable']:
+                    f *= a[i]['fTelegraphAdditGain']
+
+                # Set final gain factor
+                self._adc_factors.append(1 / f)
+
+                # Shift
+                s = a[i]['fInstrumentOffset']
+
+                # Signal conditioner used?
+                if h.get('nSignalType', 0) != 0:  # pragma: no cover
+                    # Cover pragma: Don't have appropriate test file
+                    s -= a[i]['fSignalOffset']
+
+                # Set final offset
+                self._adc_offsets.append(s)
+
+    def _read_5_ad_data(self):
+        """ Reads the A/D data and appends it to the list of sweeps. """
+
+        h = self._header
 
         # Sampling rate is constant for all sweeps and channels
         # TODO: This won't work for 2-rate protocols
         rate = self._rate
 
         # Get binary integer format
-        dt = np.dtype('i2') if header['nDataFormat'] == 0 else np.dtype('f4')
+        dt = np.dtype('i2') if h['nDataFormat'] == 0 else np.dtype('f4')
 
         # Get number of channels, create a numpy memory map
-        if version < 2:
+        if self._version < 2:
             # Old files, get info from fields stored directly in header
-            o = header['lDataSectionPtr'] * BLOCKSIZE \
-                + header['nNumPointsIgnored'] * dt.itemsize
-            n = header['lActualAcqLength']
+            o = h['lDataSectionPtr'] * BLOCKSIZE \
+                + h['nNumPointsIgnored'] * dt.itemsize
+            n = h['lActualAcqLength']
         else:
             # New files, get info from appropriate header section
-            o = header['sections']['Data']['index'] * BLOCKSIZE
-            n = header['sections']['Data']['length']
+            o = h['sections']['Data']['index'] * BLOCKSIZE
+            n = h['sections']['Data']['length']
         data = np.memmap(self._filepath, dt, 'r', shape=(n,), offset=o)
 
         # Load list of sweeps (Sweeps are called 'episodes' in ABF < 2)
-        if version < 2:
-            n = header['lSynchArraySize']
-            o = header['lSynchArrayPtr'] * BLOCKSIZE
+        if self._version < 2:
+            n = h['lSynchArraySize']
+            o = h['lSynchArrayPtr'] * BLOCKSIZE
         else:
-            n = header['sections']['SynchArray']['length']
-            o = header['sections']['SynchArray']['index'] * BLOCKSIZE
+            n = h['sections']['SynchArray']['length']
+            o = h['sections']['SynchArray']['index'] * BLOCKSIZE
         if n > 0:
             dt = [(str('offset'), str('i4')), (str('len'), str('i4'))]
-            sdata = np.memmap(self._filepath, dt, 'r', shape=(n), offset=o)
+            sweep_data = np.memmap(
+                self._filepath, dt, 'r', shape=(n,), offset=o)
         else:   # pragma: no cover
             # Cover pragma: Don't have appropriate test file
-            sdata = np.empty((1), dt)
-            sdata[0]['len'] = data.size
-            sdata[0]['offset'] = 0
+            sweep_data = np.empty((1), dt)
+            sweep_data[0]['len'] = data.size
+            sweep_data[0]['offset'] = 0
 
-        # Get data
-        pos = 0
-
-        # Data structure
-        sweeps = []
+        # Number of sweeps must equal n
+        if n != h['lActualSweeps']:
+            raise NotImplementedError(
+                'Unable to read file with different sizes per sweep.')
 
-        # Time-offset at start of sweep
-        start = sdata[0]['offset'] / rate
-        for j in range(sdata.size):
+        # Time-offset at start of first sweep
+        start = sweep_data[0]['offset'] / rate
 
-            # Create a new sweep
-            sweep = Sweep(nc)
+        # Get data
+        pos = 0
+        for i_sweep, sdat in enumerate(sweep_data):
 
             # Get the number of data points
-            size = sdata[j]['len']
+            size = sdat['len']
 
             # Calculate the correct size for variable-length event mode
             if self._mode == ACMODE_VARIABLE_LENGTH_EVENTS:  # pragma: no cover
                 # Cover pragma: Only episodic stimulus is supported.
-                if version < 2:
-                    f = float(header['fSynchTimeUnit'])
+                if self._version < 2:
+                    f = float(h['fSynchTimeUnit'])
                 else:
-                    f = float(header['protocol']['fSynchTimeUnit'])
+                    f = float(h['protocol']['fSynchTimeUnit'])
                 if f != 0:
                     size /= f
 
             # Get a memory map to the relevant part of the data
             part = data[pos: pos + size]
             pos += size
-            part = part.reshape((part.size // nc, nc)).astype('f')
+            part = part.reshape(
+                (part.size // self._n_adc, self._n_adc)).astype('f')
 
             # If needed, reformat the integers
-            if header['nDataFormat'] == 0:
+            if h['nDataFormat'] == 0:
                 # Data given as integers? Convert to floating point
-                for i in range(nc):
-                    factor, offset = self._get_conversion_factors(i)
-                    part[:, i] *= factor
-                    part[:, i] += offset
 
-            # Create channel
+                for i in range(self._n_adc):
+                    part[:, i] *= self._adc_factors[i]
+                    part[:, i] += self._adc_offsets[i]
+
+            # Get start in other modes
             if self._mode != ACMODE_EPISODIC_STIMULATION:  # pragma: no cover
                 # All modes except episodic stimulation
-                start = sdata[j]['offset'] / rate
+                start = data['offset'] / rate
 
-            for i in range(nc):
+            # Create and populate sweep
+            sweep = self._sweeps[i_sweep]
+            for i in range(self._n_adc):
                 c = Channel(self)
-                c._data = part[:, i]
-                if version < 2:
-                    c._name = str(header['sADCChannelName'][i])
-                    c._unit = str(header['sADCUnits'][i])
-                    c._numb = int(header['nADCPtoLChannelMap'][i])
+                c._data = part[:, i]    # Actually store the data
+                c._rate = rate
+                c._start = start
+
+                if self._version < 2:
+                    j = h['nADCSamplingSeq'][i]
+
+                    c._name = h['sADCChannelName'][j]
+                    c._index = int(h['nADCPtoLChannelMap'][j])
+                    c._unit = self._unit(h['sADCUnits'][j])
 
                     # Get telegraphed info
                     def get(field):
                         try:
-                            return float(header[field][i])
+                            return float(h[field][j])
                         except KeyError:
                             return None
 
@@ -1179,7 +909,7 @@ class AbfFile:
                         c._lopass = get('fTelegraphFilter')
 
                     # Updated low-pass cutoff
-                    if header['nSignalType'] != 0:  # pragma: no cover
+                    if h['nSignalType'] != 0:  # pragma: no cover
                         # Cover pragma: Don't have appropriate test file
                         # If a signal conditioner is used, the cutoff frequency
                         # is an undescribed "complex function" of both low-pass
@@ -1187,135 +917,446 @@ class AbfFile:
                         c._lopass = None
 
                 else:
-
-                    c._name = str(header['listADCInfo'][i]['ADCChNames'])
-                    c._unit = str(header['listADCInfo'][i]['ADCChUnits'])
-                    c._numb = int(header['listADCInfo'][i]['nADCNum'])
+                    c._name = h['listADCInfo'][i]['ADCChNames']
+                    c._index = int(h['listADCInfo'][i]['nADCNum'])
+                    c._unit = self._unit(h['listADCInfo'][i]['ADCChUnits'])
 
                     # Get telegraphed info
-                    if header['listADCInfo'][i]['nTelegraphEnable']:
-                        c._type = int(
-                            header['listADCInfo'][i]['nTelegraphMode'])
+                    if h['listADCInfo'][i]['nTelegraphEnable']:
+                        c._type = int(h['listADCInfo'][i]['nTelegraphMode'])
                         c._cm = float(
-                            header['listADCInfo'][i]['fTelegraphMembraneCap'])
+                            h['listADCInfo'][i]['fTelegraphMembraneCap'])
                         c._rs = float(
-                            header['listADCInfo'][i][
-                                'fTelegraphAccessResistance'])
+                            h['listADCInfo'][i]['fTelegraphAccessResistance'])
                         c._lopass = float(
-                            header['listADCInfo'][i]['fTelegraphFilter'])
+                            h['listADCInfo'][i]['fTelegraphFilter'])
 
                     # Updated low-pass cutoff
-                    if 'nSignalType' in header['protocol']:  # pragma: no cover
+                    if 'nSignalType' in h['protocol']:  # pragma: no cover
                         # Cover pragma: Don't have appropriate test file
-                        if header['protocol']['nSignalType'] != 0:
+                        if h['protocol']['nSignalType'] != 0:
                             # If a signal conditioner is used, the cutoff
                             # frequency is an undescribed "complex function" of
                             # both low-pass settings...
                             c._lopass = None
-                c._rate = rate
-                c._start = start
-                sweep[i] = c
+
+                sweep._channels.append(c)
 
             if self._mode == ACMODE_EPISODIC_STIMULATION:
                 # Increase time according to sweeps in episodic stim. mode
-                start += self._sweepStartToStart
+                start += self._sweep_start_to_start
+
+    def _read_6_da_reconstructions(self):
+        """
+        Convert supported D/A waveforms to channels.
 
-            # Store sweep
-            sweeps.append(sweep)
+        Only works for episodic stimulation, with step protocols and no
+        user lists.
 
-        return sweeps
+        The resulting analog signal has the same size as the recorded
+        signals, so not always the full length of the protocol!
 
-    def _set_conversion_factors(self):
         """
-        Calculates the conversion factors to convert integer data from the ABF
-        file to floats.
+        dinfo, einfo_exists, einfo = self._epoch_functions
+
+        ns = self._samples_per_channel
+        start = 0
+        for i_sweep, sweep in enumerate(self._sweeps):
+            for i_dac in self._dac_indices:
+
+                # Create a channel
+                c = Channel(self)
+                c._name = dinfo(i_dac, 'sDACChannelName')
+                if self._version < 2:
+                    c._index = i_dac
+                else:
+                    c._index = int(dinfo(i_dac, 'lDACChannelNameIndex'))
+                c._data = np.ones(ns) * dinfo(i_dac, 'fDACHoldingLevel')
+                c._rate = self._rate
+                c._start = start
+                c._unit = self._unit(dinfo(i_dac, 'sDACChannelUnits'))
+
+                # Find start of first epoch. This is defined as being at t=0
+                # but axon likes to add some samples before the first and after
+                # the last epoch. We can find out the number of samples using
+                # a procedure found in ABF v1's _GetHoldingLength()
+                if self._is_protocol_file:
+                    i2 = 0
+                else:
+                    i2 = ns // 64  # ABFH_HOLDINGFRACTION = 64
+                    i2 -= i2 % self._n_adc
+                    if (i2 < self._n_adc):  # pragma: no cover
+                        i2 = self._n_adc
+
+                # For each 'epoch' in the stimulation signal
+                for e in einfo(i_dac):
+                    if e['type'] == EPOCH_STEPPED:
+                        dur = e['init_duration']
+                        inc = e['duration_inc']
+                        i1 = i2
+                        i2 += dur + i_sweep * inc
+                        level = e['init_level'] + e['level_inc'] * i_sweep
+                        c._data[i1:i2] = level * np.ones(len(range(i2 - i1)))
+
+                # Store channel
+                sweep._channels.append(c)
+
+            # Update start for next sweep
+            start += self._sweep_start_to_start
+
+    def __getitem__(self, key):
+        return self._sweeps[key]
+
+    def __iter__(self):
+        return iter(self._sweeps)
+
+    def __len__(self):
+        return len(self._sweeps)
+
+    def _channel_id(self, channel_id):
+        """ Checks an int or str channel id and returns a valid int. """
+        if len(self._sweeps) == 0:  # pragma: no cover
+            raise KeyError(f'Channel {channel_id} not found (empty file).')
+
+        # Handle string
+        if isinstance(channel_id, str):
+            int_id = self._ad_names[channel_id]  # Bubble KeyError to user
+        else:
+            int_id = int(channel_id)    # Propagate TypeError
+            if int_id < 0 or int_id >= self._n_adc:
+                raise IndexError(f'channel_id out of range: {channel_id}')
+
+        return int_id
+
+    def channel(self, channel_id, join_sweeps=False):
+        # Docstring in SweepSource
+        channel_id = self._channel_id(channel_id)
+        time, data = [], []
+        for i, sweep in enumerate(self._sweeps):
+            time.append(sweep[channel_id].times())
+            data.append(sweep[channel_id].values())
+        if join_sweeps:
+            return (np.concatenate(time), np.concatenate(data))
+        return time, data
+
+    def channel_count(self):
+        # Docstring in SweepSource
+        return self._n_adc
+
+    def channel_names(self, index=None):
+        # Docstring in SweepSource
+        if index is None:
+            return list(self._ad_names.keys())
+        return list(self._ad_names.keys())[index]
+
+    def channel_units(self, index=None):
+        # Docstring in SweepSource
+        if index is None:
+            return list(self._ad_units)
+        return self._ad_units[index]
+
+    def _da_id(self, output_id):
         """
-        self._adc_factors = []
-        self._adc_offsets = []
-        h = self._header
-        if self._version < 2:
-            for i in range(self._nc):
-                # Multiplier
-                f = (
-                    h['fInstrumentScaleFactor'][i]
-                    * h['fADCProgrammableGain'][i]
-                    * h['lADCResolution']
-                    / h['fADCRange'])
+        Checks an int or str D/A channel id and returns a valid int.
 
-                # Signal conditioner used?
-                if h['nSignalType'] != 0:   # pragma: no cover
-                    # Cover pragma: Don't have appropriate test file
-                    f *= h['fSignalGain'][i]
+        Note: The integer here is from 0 to da_count(), so not equal to the
+        channel :meth:`index()` shown in pclamp.
+        """
+        if len(self._sweeps) == 0:  # pragma: no cover
+            raise KeyError(f'D/A output {output_id} not found (empty file).')
 
-                # Additional gain?
-                if h['nTelegraphEnable'][i]:
-                    f *= h['fTelegraphAdditGain'][i]
+        # Handle string
+        if isinstance(output_id, str):
+            int_id = self._da_names[output_id]  # Propagate KeyError to user
+        else:
+            int_id = int(output_id)  # Propagate TypeError
+            if int_id < 0 or int_id >= self._n_dac:
+                raise IndexError(f'output_id out of range: {output_id}')
+
+        return int_id
+
+    def da(self, output_id, join_sweeps=False):
+        # Docstring in SweepSource
+        channel_id = self._n_adc + self._da_id(output_id)
+        time, data = [], []
+        for i, sweep in enumerate(self._sweeps):
+            time.append(sweep[channel_id].times())
+            data.append(sweep[channel_id].values())
+        if join_sweeps:
+            return (np.concatenate(time), np.concatenate(data))
+        return time, data
 
-                # Set fina gain factor
-                self._adc_factors.append(1.0 / f)
+    def da_count(self):
+        # Docstring in SweepSource
+        return self._n_dac
 
-                # Shift
-                s = h['fInstrumentOffset'][i]
+    def da_names(self, index=None):
+        # Docstring in SweepSource
+        if index is None:
+            return list(self._da_names.keys())
+        return list(self._da_names.keys())[index]
 
-                # Signal conditioner used?
-                if h['nSignalType'] != 0:   # pragma: no cover
-                    # Cover pragma: Don't have appropriate test file
-                    s -= h['fSignalOffset'][i]
+    def da_protocol(self, output_id=None, tu='ms', vu='mV', cu='pA',
+                    n_digits=9, include_initial_holding=False):
+        """
+        See :meth:`myokit.formats.SweepSource.da_protocol()`.
 
-                # Set final offset
-                self._adc_offsets.append(s)
+        This implementation adds a keyword argument ``include_initial_holding``
+        that lets you switch between the declared protocol (``False``) and the
+        protocol as actually implemented (``True``). In the latter case, a
+        short holding time is added before the first epoch in every sweep.
+        """
+
+        # Check the output id. This also raises an error if no supported D/A
+        # channels are present.
+        output_id = self._da_id(output_id or 0)
+
+        # Get the index in dinfo
+        i_dac = self._dac_indices[output_id]
+        dinfo, einfo_exists, einfo = self._epoch_functions
 
+        # Get the time and data conversion factors
+        units = myokit.units
+        tf = myokit.Unit.conversion_factor(units.s, tu)
+        if myokit.Unit.can_convert(self._da_units[output_id], units.V):
+            df = myokit.Unit.conversion_factor(self._da_units[output_id], vu)
+        elif myokit.Unit.can_convert(
+                self._da_units[output_id], units.A):  # pragma: no cover
+            df = myokit.Unit.conversion_factor(self._da_units[output_id], cu)
+        else:  # pragma: no cover
+            # Not a voltage or current? Then don't convert
+            df = 1
+        tf, df = float(tf), float(df)
+
+        # Axon has the annoying habit of adding some extra holding at the start
+        # We can include this if we want. See _read_6 for details.
+        if self._is_protocol_file:
+            offset = 0
         else:
+            offset = self._samples_per_channel // 64
+            offset -= offset % self._n_adc
+            if (offset < self._n_adc):  # pragma: no cover
+                # Don't have a test for this, but this is part of the
+                # established procedure.
+                offset = self._n_adc
+            offset /= self._rate
 
-            a = h['listADCInfo']
-            p = h['protocol']
-            for i in range(self._nc):
-                # Multiplier
-                f = (
-                    a[i]['fInstrumentScaleFactor']
-                    * a[i]['fADCProgrammableGain']
-                    * p['lADCResolution']
-                    / p['fADCRange'])
+        # Holding level (converted and rounded)
+        holding = round(df * dinfo(i_dac, 'fDACHoldingLevel'), n_digits)
 
-                # Signal conditioner used?
-                if 'nSignalType' in h:  # pragma: no cover
-                    # Cover pragma: Don't have appropriate test file
-                    if h['nSignalType'] != 0:
-                        f *= a[i]['fSignalGain']
+        # Create protocol
+        p = myokit.Protocol()
+        start = 0
+        next_start = self._sweep_start_to_start
+        for i_sweep in range(self._sweeps_per_run):
+            # Start of sweep: secret event at holding potential
+            if include_initial_holding:
+                e_start = round(tf * start, n_digits)
+                e_length = round(tf * offset, n_digits)
+                p.schedule(holding, e_start, e_length)
+                start += offset
+
+            for e in einfo(i_dac):
+                if e['type'] == EPOCH_STEPPED:
+                    dur = e['init_duration'] / self._rate
+                    inc = e['duration_inc'] / self._rate
+                    duration = dur + i_sweep * inc
+                    level = e['init_level'] + e['level_inc'] * i_sweep
+
+                    e_level = round(df * level, n_digits)
+                    e_start = round(tf * start, n_digits)
+                    e_length = round(tf * duration, n_digits)
+                    p.schedule(e_level, e_start, e_length)
 
-                # Additional gain?
-                if a[i]['nTelegraphEnable']:
-                    f *= a[i]['fTelegraphAdditGain']
+                    start += duration
+                # Note: Only other type can be EPOCH_DISABLED at this point
 
-                # Set final gain factor
-                self._adc_factors.append(1.0 / f)
+            # End of sweep: event at holding potential
+            e_start = round(tf * start, n_digits)
+            e_length = round(tf * (next_start - start), n_digits)
+            p.schedule(holding, e_start, e_length)
+            start = next_start
+            next_start += self._sweep_start_to_start
 
-                # Shift
-                s = a[i]['fInstrumentOffset']
+        return p
 
-                # Signal conditioner used?
-                if 'nSignalType' in h:  # pragma: no cover
+    def da_units(self, index=None):
+        # Docstring in SweepSource
+        if index is None:
+            return list(self._da_units)
+        return self._da_units[index]
+
+    def equal_length_sweeps(self):
+        # Always true for ABF
+        return True
+
+    def filename(self):
+        """ Returns this ABF file's filename. """
+        return self._filename
+
+    def log(self, join_sweeps=False, use_names=False, include_da=True):
+        # Docstring in SweepSource
+
+        # Create log, return if no sweeps or channels
+        log = myokit.DataLog()
+        ns = len(self._sweeps)
+        if ns == 0 or (self._n_adc + self._n_dac) == 0:  # pragma: no cover
+            return log
+
+        # Get channel names
+        if use_names:
+            nc = self._n_adc + (self._n_dac if include_da else 0)
+            names = [c.name() for c in self._sweeps[0][:nc]]
+        else:
+            names = [f'{i}.channel' for i in range(self._n_adc)]
+            if include_da:
+                names += [f'{i}.da' for i in range(self._n_dac)]
+
+        # Gather data and return
+        t = self._sweeps[0][0].times()
+        if not join_sweeps:
+            log['time'] = t
+            for i_sweep, sweep in enumerate(self._sweeps):
+                for channel, name in zip(sweep, names):
+                    log[name, i_sweep] = channel.values()
+        else:
+            log['time'] = np.concatenate(
+                [t + i * self._sweep_start_to_start for i in range(ns)])
+            for i_channel, name in enumerate(names):
+                log[name] = np.concatenate(
+                    [sweep[i_channel].values() for sweep in self._sweeps])
+        log.set_time_key('time')
+        return log
+
+    def matplotlib_figure(self):
+        """ Creates and returns a matplotlib figure with this file's data. """
+        import matplotlib.pyplot as plt
+        f = plt.figure()
+        plt.suptitle(self.filename())
+
+        # Plot AD channels
+        ax = plt.subplot(2, 1, 1)
+        ax.set_title('Measured data')
+        times = None
+        for sweep in self._sweeps:
+            for channel in sweep[:self._n_adc]:
+                if times is None:
+                    times = channel.times()
+                plt.plot(times, channel.values())
+
+        # Plot DA channels
+        n = self._n_dac
+        ax = [plt.subplot(2, n, n + 1 + i) for i in range(n)]
+        for sweep in self._sweeps:
+            for i, channel in enumerate(sweep[self._n_adc:]):
+                ax[i].set_title(channel.name())
+                ax[i].plot(times, channel.values())
+
+        return f
+
+    def meta_str(self, show_header=False):
+        """
+        Returns a multi-line string with meta data about this file.
+
+        The optional argument ``show_header`` can be used to add the full
+        header contents to the output.
+        """
+        out = []
+
+        # File info
+        if self._is_protocol_file:
+            out.append(f'Axon Protocol File: {self._filename}')
+        else:
+            out.append(f'Axon Binary File: {self._filename}')
+        out.append(f'ABF Format version {self._version_str}')
+        out.append(f'Recorded on: {self._datetime}')
+
+        # AProtocol info
+        out.append(
+            f'Acquisition mode: {self._mode}: {acquisition_modes[self._mode]}')
+        if self._number_of_trials:
+            out.append(
+                f'Protocol set for {self._number_of_trials} trials,'
+                f' spaced {self._trial_start_to_start}s apart.')
+            out.append(
+                f'    with {self._runs_per_trial} runs per trial,'
+                f' spaced {self._run_start_to_start}s apart.')
+            out.append(
+                f'     and {self._sweeps_per_run} sweeps per run,'
+                f' spaced {self._sweep_start_to_start}s apart.')
+        else:   # pragma: no cover
+            out.append('Protocol data could not be determined.')
+        out.append(f'Sampling rate: {self._rate} Hz')
+
+        # Channel info
+        if len(self._sweeps) > 0:
+
+            # A/D recordings
+            for i, c in enumerate(self._sweeps[0][:self._n_adc]):
+                out.append(f'A/D Channel {i}: "{c._name}"')
+                if c._type:  # pragma: no cover
                     # Cover pragma: Don't have appropriate test file
-                    if h['nSignalType'] != 0:
-                        s -= a[i]['fSignalOffset']
+                    out.append(f'  Type: {type_mode_names[c._type]}')
+                out.append(f'  Unit: {c._unit}')
+                if c._lopass:
+                    out.append(f'  Low-pass filter: {c._lopass} Hz')
+                if c._cm:
+                    out.append(f'  Cm (telegraphed): {c._cm} pF')
+                if c._rs:   # pragma: no cover
+                    # Cover pragma: Don't have appropriate test file
+                    out.append(f'  Rs (telegraphed): {c._rs}')
 
-                # Set final offset
-                self._adc_offsets.append(s)
+            # Reconstructed D/A outputs
+            for i, c in enumerate(self._sweeps[0][self._n_adc:]):
+                out.append(f'D/A Channel {i}: "{c._name}"')
+                if c._type:  # pragma: no cover
+                    # Cover pragma: Don't have appropriate test file
+                    out.append('  Type: {type_mode_names[c._type]}')
+                out.append(f'  Unit: {c._unit}')
+
+        # Add full header info
+        if show_header:
+            if self._strings:
+                dict_to_string(out, 'Strings', {'strings': self._strings})
+            dict_to_string(out, 'file header', self._header)
+
+        return '\n'.join(out)
+
+    def path(self):
+        """ Returns the path to the underlying ABF file. """
+        return self._filepath
+
+    def sweep_count(self):
+        # Docstring in SweepSource
+        return len(self._sweeps)
+
+    def time_unit(self):
+        # Docstring in SweepSource
+        # For ABF, this is always seconds
+        return myokit.units.s
+
+    def _unit(self, unit_string):
+        """ Parses a unit string and returns a :class:`myokit.Unit`. """
+        try:
+            return self._unit_cache[unit_string]
+        except KeyError:
+            unit = myokit.parse_unit(unit_string.replace(MU, 'u'))
+            self._unit_cache[unit_string] = unit
+            return unit
+
+    def version(self):
+        """ Returns a string representation of this file's version number. """
+        return self._version_str
 
 
 class Sweep:
     """
-    Represents a single sweep (also called an 'episode')
+    Represents a single sweep (also called an *episode*).
 
-    A sweep is represented as a fixed-size list of channels.
+    Each sweep contains a fixed number of :class:`channels<Channel>`.
     """
-    def __init__(self, n):
-        super().__init__()
-        n = int(n)
-        if n < 0:   # pragma: no cover
-            raise ValueError('Number channels cannot be negative.')
-        self._nc = n    # Number of channels
-        self._channels = [None] * n
+    def __init__(self):
+        self._channels = []
 
     def __getitem__(self, key):
         return self._channels[key]  # Handles slices etc.
@@ -1324,31 +1365,26 @@ class Sweep:
         return iter(self._channels)
 
     def __len__(self):
-        return self._nc
-
-    def __setitem__(self, key, value):
-        if type(key) == slice:
-            raise NotImplementedError(
-                'Assignment with slices is not supported.')
-        self._channels[key] = value
+        return len(self._channels)
 
 
 class Channel:
     """
-    Represents an analog signal for a single channel.
+    Represents a signal for a single channel.
 
-    To obtain this channel's formatted data, use times() and trace()
+    To obtain its data, use :meth:`times` and :meth:`values`.
     """
     def __init__(self, parent_file):
-        super().__init__()
         self._parent_file = parent_file  # The abf file this channel is from
         self._type = TYPE_UNKNOWN   # Type of recording
 
         # This channel's name
         self._name = None
 
-        # This channel's index (see note below)
-        self._numb = None
+        # This channel's index in the file. This is basically a name, and does
+        # not correspond to e.g. its index in the ADC/DAC info or its index in
+        # the sweep's list of channels.
+        self._index = None
 
         # The units this channel's data is in
         self._unit = None
@@ -1371,40 +1407,61 @@ class Channel:
         # The reported low-pass filter cut-off frequency
         self._lopass = None
 
-        # Note that the channel indices are not necessarily sequential! So a
-        # file with 2 channels can have indices 0 and 3.
+    def index(self):
+        """ Returns the index set for this channel. """
+        return self._index
 
     def name(self):
-        """
-        Returns the name set for this channel.
-        """
+        """ Returns the name set for this channel. """
         return self._name
 
-    def number(self):
-        """
-        Returns the channel index used by pClamp. Note that this does not
-        necessarily equal its index in the Python sweep data!
-        """
-        return self._numb
-
     def __str__(self):
-        return 'Channel(' + str(self._numb) + ' "' + str(self._name) \
-            + '"); ' + str(len(self._data)) + ' points sampled at ' \
-            + str(self._rate) + 'Hz, starts at t=' + str(self._start)
+        return (
+            f'Channel({self._index} "{self._name}"); {len(self._data)} points'
+            f' sampled at {self._rate}Hz, starts at t={self._start}.')
 
     def times(self):
-        """
-        Returns a copy of the values on the time axis.
-        """
+        """ Returns a copy of the values on the time axis. """
         n = len(self._data)
-        f = 1.0 / self._rate
+        f = 1 / self._rate
         return np.arange(self._start, self._start + n * f, f)[0:n]
 
+    def unit(self):
+        """ Returns the units this channel is in. """
+        return self._unit
+
     def values(self):
-        """
-        Returns a copy of the values on the data axis.
-        """
-        return np.array(self._data, copy=True)
+        """ Returns a copy of the values on the data axis. """
+        return np.copy(self._data)
+
+
+def dict_to_string(out, name, d, tab=''):
+    """ Used by AbfFile.info(). """
+    m = max(0, 38 - len(tab) - int(0.1 + len(name) / 2))
+    out.append(f'{tab}{"-" * m}  {name}  {"-" * m}')
+    for n, v in d.items():
+        n = str(n)
+        if type(v) == dict:
+            dict_to_string(out, n, v, f'{tab}  ')
+        elif type(v) == list:
+            list_to_string(out, n, v, tab)
+        else:
+            out.append(f'{tab}{n}: {v}')
+    m = max(0, 80 - 2 * len(tab))
+    out.append(f'{tab}{m * "-"}')
+
+
+def list_to_string(out, name, d, tab=''):
+    """ Used by AbfFile.info(). """
+    for index, item in enumerate(d):
+        n = f'{name}[{index}]'
+        if type(item) == dict:
+            dict_to_string(out, n, item, tab)
+        elif type(item) == list:    # pragma: no cover
+            # Cover pragma: Don't have appropriate test file
+            list_to_string(out, n, item, tab)
+        else:
+            out.append(f'{tab}{n}: {item}')
 
 
 # Some python struct types:
@@ -1416,11 +1473,17 @@ class Channel:
 BLOCKSIZE = 512
 
 
+# A mu, sometimes found in unit strings
+MU = '\u00b5'
+
+
 # Header fields for versions 1 and 2
 # Stored as (key, offset, format) where format corresponds to a struct
 #  unpacking format as documented in:
 #  http://docs.python.org/library/struct.html#format-characters
-headerFields = {
+HEADER_FIELDS = {
+    # Note that a lot of the groups in the version 1 header start with obsolete
+    # fields, followed later by their newer equivalents.
     1: [
         ('fFileSignature', 0, '4s'),       # Coarse file version indication
         # Group 1, File info and sizes
@@ -1517,7 +1580,7 @@ headerFields = {
         ('nDigitalHolding', 1584, 'h'),
         ('nDigitalInterEpisode', 1586, 'h'),
         ('nDigitalValue', 2588, '10h'),
-        ('lDACFilePtr', 2048, '2i'),            # Pointer to protocol?
+        ('lDACFilePtr', 2048, '2i'),
         ('lDACFileNumEpisodes', 2056, '2i'),
         ('fDACCalibrationFactor', 2074, '4f'),
         ('fDACCalibrationOffset', 2090, '4f'),
@@ -1529,13 +1592,12 @@ headerFields = {
         ('fEpochLevelInc', 2428, '20f'),
         ('lEpochInitDuration', 2508, '20i'),
         ('lEpochDurationInc', 2588, '20i'),
-        # Group 10, DAC Output file
+        # Group 10, DAC Output file (Stimulus file)
         ('fDACFileScale', 2708, 'd'),
         ('fDACFileOffset', 2716, 'd'),
         ('lDACFileEpisodeNum', 2724, 'i'),
         ('nDACFileADCNum', 2732, '2h'),
-        # 256 * 2char = utf8? or 2 strings?
-        ('sDACFilePath', 2736, '256s' * 2),
+        ('sDACFilePath', 2736, '256s' * 2),     # Two strings
         # Group 11,
         # Group 12, User list parameters
         ('nULEnable', 3360, '4h'),
@@ -1554,7 +1616,7 @@ headerFields = {
         # Group 22
         # Group 23 Post-processing
         # Group 24 Legacy stuff
-        # Group 6 again?
+        # Group 6 extended
         ('nTelegraphEnable', 4512, '16h'),
         ('fTelegraphAdditGain', 4576, '16f'),
     ],
@@ -1582,7 +1644,7 @@ headerFields = {
 
 
 # ABF2 File sections
-abf2FileSections = [
+ABF2_FILE_SECTIONS = [
     'Protocol',
     'ADC',
     'DAC',
@@ -1605,7 +1667,7 @@ abf2FileSections = [
 
 
 # ABF2 Fields in the tag section
-TagInfoDescription = [
+ABF2_TAG_INFO_DESCRIPTION = [
     ('lTagTime', 'i'),
     ('sComment', '56s'),
     ('nTagType', 'h'),
@@ -1614,7 +1676,7 @@ TagInfoDescription = [
 
 
 # ABF2 Fields in the protocol section
-protocolFields = [
+ABF2_PROTOCOL_FIELDS = [
     ('nOperationMode', 'h'),                # 0
     ('fADCSequenceInterval', 'f'),          # 2
     ('bEnableFileCompression', 'b'),        # 6
@@ -1690,7 +1752,7 @@ protocolFields = [
 
 
 # ABF2 Fields in the ADC section
-ADCFields = [
+ABF2_ADC_FIELDS = [
     ('nADCNum', 'h'),
     ('nTelegraphEnable', 'h'),
     ('nTelegraphInstrument', 'h'),
@@ -1722,7 +1784,7 @@ ADCFields = [
 
 
 # ABF2 Fields in the DAC section
-DACFields = [
+ABF2_DAC_FIELDS = [
     ('nDACNum', 'h'),
     ('nTelegraphDACScaleFactorEnable', 'h'),
     ('fInstrumentHoldingLevel', 'f'),
@@ -1769,7 +1831,7 @@ DACFields = [
 
 
 # ABF2 Fields in the DAC-Epoch section
-EpochInfoPerDACFields = [
+ABF2_EPOCH_INFO_PER_DAC_FIELD = [
     ('nEpochNum', 'h'),
     ('nDACNum', 'h'),
     ('nEpochType', 'h'),
@@ -1781,7 +1843,9 @@ EpochInfoPerDACFields = [
     ('lEpochPulseWidth', 'i'),
     ('sUnused', '18s'),
 ]
-UserListFields = [
+
+# ABF2 User list fields
+ABF2_USER_LIST_FIELDS = [
     ('nListNum', 'h'),
     ('nULEnable', 'h'),
     ('nULParamToVary', 'h'),
@@ -1860,6 +1924,12 @@ type_mode_names = {
 }
 
 
+# DAC waveform types
+DAC_DISABLED = 0
+DAC_EPOCHTABLEWAVEFORM = 1  # Epochs
+DAC_DACFILEWAVEFORM = 2     # Stimulus file
+
+
 # User list parameter to vary
 '''
 CONDITNUMPULSES 0