chris/galvani
1
0
Fork 0
mirror of https://github.com/echemdata/galvani.git synced 2025-12-14 01:15:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reformatted BioLogic.py with black 23.12.1

Browse Source
This commit is contained in:
Chris Kerr
2024-01-20 21:45:28 +02:00
parent 31416533d8
commit dee8af3a86
1 changed files with 329 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files

551
galvani/BioLogic.py
View File

@@ -5,7 +5,7 @@
#
# SPDX-License-Identifier: GPL-3.0-or-later
__all__ = ['MPTfileCSV', 'MPTfile']
__all__ = ["MPTfileCSV", "MPTfile"]
import re
import csv
@@ -21,19 +21,44 @@ def fieldname_to_dtype(fieldname):
"""Converts a column header from the MPT file into a tuple of
canonical name and appropriate numpy dtype"""
if fieldname == 'mode':
return ('mode', np.uint8)
elif fieldname in ("ox/red", "error", "control changes", "Ns changes",
"counter inc."):
if fieldname == "mode":
return ("mode", np.uint8)
elif fieldname in (
"ox/red",
"error",
"control changes",
"Ns changes",
"counter inc.",
):
return (fieldname, np.bool_)
elif fieldname in ("time/s", "P/W", "(Q-Qo)/mA.h", "x", "control/V",
"control/mA", "control/V/mA", "(Q-Qo)/C", "dQ/C",
"freq/Hz", "|Ewe|/V", "|I|/A", "Phase(Z)/deg",
"|Z|/Ohm", "Re(Z)/Ohm", "-Im(Z)/Ohm"):
elif fieldname in (
"time/s",
"P/W",
"(Q-Qo)/mA.h",
"x",
"control/V",
"control/mA",
"control/V/mA",
"(Q-Qo)/C",
"dQ/C",
"freq/Hz",
"|Ewe|/V",
"|I|/A",
"Phase(Z)/deg",
"|Z|/Ohm",
"Re(Z)/Ohm",
"-Im(Z)/Ohm",
):
return (fieldname, np.float_)
elif fieldname in ("Q charge/discharge/mA.h", "step time/s",
"Q charge/mA.h", "Q discharge/mA.h",
"Temperature/°C", "Efficiency/%", "Capacity/mA.h"):
elif fieldname in (
"Q charge/discharge/mA.h",
"step time/s",
"Q charge/mA.h",
"Q discharge/mA.h",
"Temperature/°C",
"Efficiency/%",
"Capacity/mA.h",
):
return (fieldname, np.float_)
elif fieldname in ("cycle number", "I Range", "Ns", "half cycle"):
return (fieldname, np.int_)
@@ -43,12 +68,28 @@ def fieldname_to_dtype(fieldname):
return ("I/mA", np.float_)
elif fieldname in ("Ewe/V", "<Ewe>/V", "Ecell/V"):
return ("Ewe/V", np.float_)
elif fieldname.endswith(("/s", "/Hz", "/deg",
"/W", "/mW", "/W.h", "/mW.h",
"/A", "/mA", "/A.h", "/mA.h",
"/V", "/mV",
"/F", "/mF", "/uF",
"/C", "/Ohm",)):
elif fieldname.endswith(
(
"/s",
"/Hz",
"/deg",
"/W",
"/mW",
"/W.h",
"/mW.h",
"/A",
"/mA",
"/A.h",
"/mA.h",
"/V",
"/mV",
"/F",
"/mF",
"/uF",
"/C",
"/Ohm",
)
):
return (fieldname, np.float_)
else:
raise ValueError("Invalid column header: %s" % fieldname)
@@ -56,11 +97,11 @@ def fieldname_to_dtype(fieldname):
def comma_converter(float_text):
"""Convert text to float whether the decimal point is '.' or ','"""
trans_table = bytes.maketrans(b',', b'.')
trans_table = bytes.maketrans(b",", b".")
return float(float_text.translate(trans_table))
def MPTfile(file_or_path, encoding='ascii'):
def MPTfile(file_or_path, encoding="ascii"):
"""Opens .mpt files as numpy record arrays
Checks for the correct headings, skips any comments and returns a
@@ -68,16 +109,15 @@ def MPTfile(file_or_path, encoding='ascii'):
"""
if isinstance(file_or_path, str):
mpt_file = open(file_or_path, 'rb')
mpt_file = open(file_or_path, "rb")
else:
mpt_file = file_or_path
magic = next(mpt_file)
if magic not in (b'EC-Lab ASCII FILE\r\n', b'BT-Lab ASCII FILE\r\n'):
if magic not in (b"EC-Lab ASCII FILE\r\n", b"BT-Lab ASCII FILE\r\n"):
raise ValueError("Bad first line for EC-Lab file: '%s'" % magic)
nb_headers_match = re.match(rb'Nb header lines : (\d+)\s*$',
next(mpt_file))
nb_headers_match = re.match(rb"Nb header lines : (\d+)\s*$", next(mpt_file))
nb_headers = int(nb_headers_match.group(1))
if nb_headers < 3:
raise ValueError("Too few header lines: %d" % nb_headers)
@@ -86,14 +126,12 @@ def MPTfile(file_or_path, encoding='ascii'):
# make three lines. Every additional line is a comment line.
comments = [next(mpt_file) for i in range(nb_headers - 3)]
fieldnames = next(mpt_file).decode(encoding).strip().split('\t')
fieldnames = next(mpt_file).decode(encoding).strip().split("\t")
record_type = np.dtype(list(map(fieldname_to_dtype, fieldnames)))
# Must be able to parse files where commas are used for decimal points
converter_dict = dict(((i, comma_converter)
for i in range(len(fieldnames))))
mpt_array = np.loadtxt(mpt_file, dtype=record_type,
converters=converter_dict)
converter_dict = dict(((i, comma_converter) for i in range(len(fieldnames))))
mpt_array = np.loadtxt(mpt_file, dtype=record_type, converters=converter_dict)
return mpt_array, comments
@@ -106,15 +144,15 @@ def MPTfileCSV(file_or_path):
"""
if isinstance(file_or_path, str):
mpt_file = open(file_or_path, 'r')
mpt_file = open(file_or_path, "r")
else:
mpt_file = file_or_path
magic = next(mpt_file)
if magic.rstrip() != 'EC-Lab ASCII FILE':
if magic.rstrip() != "EC-Lab ASCII FILE":
raise ValueError("Bad first line for EC-Lab file: '%s'" % magic)
nb_headers_match = re.match(r'Nb header lines : (\d+)\s*$', next(mpt_file))
nb_headers_match = re.match(r"Nb header lines : (\d+)\s*$", next(mpt_file))
nb_headers = int(nb_headers_match.group(1))
if nb_headers < 3:
raise ValueError("Too few header lines: %d" % nb_headers)
@@ -123,154 +161,206 @@ def MPTfileCSV(file_or_path):
# make three lines. Every additional line is a comment line.
comments = [next(mpt_file) for i in range(nb_headers - 3)]
mpt_csv = csv.DictReader(mpt_file, dialect='excel-tab')
mpt_csv = csv.DictReader(mpt_file, dialect="excel-tab")
expected_fieldnames = (
["mode", "ox/red", "error", "control changes", "Ns changes",
"counter inc.", "time/s", "control/V/mA", "Ewe/V", "dq/mA.h",
"P/W", "<I>/mA", "(Q-Qo)/mA.h", "x"],
['mode', 'ox/red', 'error', 'control changes', 'Ns changes',
'counter inc.', 'time/s', 'control/V', 'Ewe/V', 'dq/mA.h',
'<I>/mA', '(Q-Qo)/mA.h', 'x'],
["mode", "ox/red", "error", "control changes", "Ns changes",
"counter inc.", "time/s", "control/V", "Ewe/V", "I/mA",
"dQ/mA.h", "P/W"],
["mode", "ox/red", "error", "control changes", "Ns changes",
"counter inc.", "time/s", "control/V", "Ewe/V", "<I>/mA",
"dQ/mA.h", "P/W"])
[
"mode",
"ox/red",
"error",
"control changes",
"Ns changes",
"counter inc.",
"time/s",
"control/V/mA",
"Ewe/V",
"dq/mA.h",
"P/W",
"<I>/mA",
"(Q-Qo)/mA.h",
"x",
],
[
"mode",
"ox/red",
"error",
"control changes",
"Ns changes",
"counter inc.",
"time/s",
"control/V",
"Ewe/V",
"dq/mA.h",
"<I>/mA",
"(Q-Qo)/mA.h",
"x",
],
[
"mode",
"ox/red",
"error",
"control changes",
"Ns changes",
"counter inc.",
"time/s",
"control/V",
"Ewe/V",
"I/mA",
"dQ/mA.h",
"P/W",
],
[
"mode",
"ox/red",
"error",
"control changes",
"Ns changes",
"counter inc.",
"time/s",
"control/V",
"Ewe/V",
"<I>/mA",
"dQ/mA.h",
"P/W",
],
)
if mpt_csv.fieldnames not in expected_fieldnames:
raise ValueError("Unrecognised headers for MPT file format")
return mpt_csv, comments
VMPmodule_hdr = np.dtype([('shortname', 'S10'),
('longname', 'S25'),
('length', '<u4'),
('version', '<u4'),
('date', 'S8')])
VMPmodule_hdr = np.dtype(
[
("shortname", "S10"),
("longname", "S25"),
("length", "<u4"),
("version", "<u4"),
("date", "S8"),
]
)
# Maps from colID to a tuple defining a numpy dtype
VMPdata_colID_dtype_map = {
4: ('time/s', '<f8'),
5: ('control/V/mA', '<f4'),
6: ('Ewe/V', '<f4'),
7: ('dQ/mA.h', '<f8'),
8: ('I/mA', '<f4'), # 8 is either I or <I> ??
9: ('Ece/V', '<f4'),
11: ('I/mA', '<f8'),
13: ('(Q-Qo)/mA.h', '<f8'),
16: ('Analog IN 1/V', '<f4'),
19: ('control/V', '<f4'),
20: ('control/mA', '<f4'),
23: ('dQ/mA.h', '<f8'), # Same as 7?
24: ('cycle number', '<f8'),
26: ('Rapp/Ohm', '<f4'),
32: ('freq/Hz', '<f4'),
33: ('|Ewe|/V', '<f4'),
34: ('|I|/A', '<f4'),
35: ('Phase(Z)/deg', '<f4'),
36: ('|Z|/Ohm', '<f4'),
37: ('Re(Z)/Ohm', '<f4'),
38: ('-Im(Z)/Ohm', '<f4'),
39: ('I Range', '<u2'),
69: ('R/Ohm', '<f4'),
70: ('P/W', '<f4'),
74: ('Energy/W.h', '<f8'),
75: ('Analog OUT/V', '<f4'),
76: ('<I>/mA', '<f4'),
77: ('<Ewe>/V', '<f4'),
78: ('Cs-2/µF-2', '<f4'),
96: ('|Ece|/V', '<f4'),
98: ('Phase(Zce)/deg', '<f4'),
99: ('|Zce|/Ohm', '<f4'),
100: ('Re(Zce)/Ohm', '<f4'),
101: ('-Im(Zce)/Ohm', '<f4'),
123: ('Energy charge/W.h', '<f8'),
124: ('Energy discharge/W.h', '<f8'),
125: ('Capacitance charge/µF', '<f8'),
126: ('Capacitance discharge/µF', '<f8'),
131: ('Ns', '<u2'),
163: ('|Estack|/V', '<f4'),
168: ('Rcmp/Ohm', '<f4'),
169: ('Cs/µF', '<f4'),
172: ('Cp/µF', '<f4'),
173: ('Cp-2/µF-2', '<f4'),
174: ('Ewe/V', '<f4'),
241: ('|E1|/V', '<f4'),
242: ('|E2|/V', '<f4'),
271: ('Phase(Z1) / deg', '<f4'),
272: ('Phase(Z2) / deg', '<f4'),
301: ('|Z1|/Ohm', '<f4'),
302: ('|Z2|/Ohm', '<f4'),
331: ('Re(Z1)/Ohm', '<f4'),
332: ('Re(Z2)/Ohm', '<f4'),
361: ('-Im(Z1)/Ohm', '<f4'),
362: ('-Im(Z2)/Ohm', '<f4'),
391: ('<E1>/V', '<f4'),
392: ('<E2>/V', '<f4'),
422: ('Phase(Zstack)/deg', '<f4'),
423: ('|Zstack|/Ohm', '<f4'),
424: ('Re(Zstack)/Ohm', '<f4'),
425: ('-Im(Zstack)/Ohm', '<f4'),
426: ('<Estack>/V', '<f4'),
430: ('Phase(Zwe-ce)/deg', '<f4'),
431: ('|Zwe-ce|/Ohm', '<f4'),
432: ('Re(Zwe-ce)/Ohm', '<f4'),
433: ('-Im(Zwe-ce)/Ohm', '<f4'),
434: ('(Q-Qo)/C', '<f4'),
435: ('dQ/C', '<f4'),
438: ('step time/s', '<f8'),
441: ('<Ecv>/V', '<f4'),
462: ('Temperature/°C', '<f4'),
467: ('Q charge/discharge/mA.h', '<f8'),
468: ('half cycle', '<u4'),
469: ('z cycle', '<u4'),
471: ('<Ece>/V', '<f4'),
473: ('THD Ewe/%', '<f4'),
474: ('THD I/%', '<f4'),
476: ('NSD Ewe/%', '<f4'),
477: ('NSD I/%', '<f4'),
479: ('NSR Ewe/%', '<f4'),
480: ('NSR I/%', '<f4'),
486: ('|Ewe h2|/V', '<f4'),
487: ('|Ewe h3|/V', '<f4'),
488: ('|Ewe h4|/V', '<f4'),
489: ('|Ewe h5|/V', '<f4'),
490: ('|Ewe h6|/V', '<f4'),
491: ('|Ewe h7|/V', '<f4'),
492: ('|I h2|/A', '<f4'),
493: ('|I h3|/A', '<f4'),
494: ('|I h4|/A', '<f4'),
495: ('|I h5|/A', '<f4'),
496: ('|I h6|/A', '<f4'),
497: ('|I h7|/A', '<f4'),
498: ('Q charge/mA.h', '<f8'),
499: ('Q discharge/mA.h', '<f8'),
500: ('step time/s', '<f8'),
501: ('Efficiency/%', '<f8'),
502: ('Capacity/mA.h', '<f8'),
505: ('Rdc/Ohm', '<f4'),
509: ('Acir/Dcir Control', '<u1'),
4: ("time/s", "<f8"),
5: ("control/V/mA", "<f4"),
6: ("Ewe/V", "<f4"),
7: ("dQ/mA.h", "<f8"),
8: ("I/mA", "<f4"), # 8 is either I or <I> ??
9: ("Ece/V", "<f4"),
11: ("I/mA", "<f8"),
13: ("(Q-Qo)/mA.h", "<f8"),
16: ("Analog IN 1/V", "<f4"),
19: ("control/V", "<f4"),
20: ("control/mA", "<f4"),
23: ("dQ/mA.h", "<f8"), # Same as 7?
24: ("cycle number", "<f8"),
26: ("Rapp/Ohm", "<f4"),
32: ("freq/Hz", "<f4"),
33: ("|Ewe|/V", "<f4"),
34: ("|I|/A", "<f4"),
35: ("Phase(Z)/deg", "<f4"),
36: ("|Z|/Ohm", "<f4"),
37: ("Re(Z)/Ohm", "<f4"),
38: ("-Im(Z)/Ohm", "<f4"),
39: ("I Range", "<u2"),
69: ("R/Ohm", "<f4"),
70: ("P/W", "<f4"),
74: ("Energy/W.h", "<f8"),
75: ("Analog OUT/V", "<f4"),
76: ("<I>/mA", "<f4"),
77: ("<Ewe>/V", "<f4"),
78: ("Cs-2/µF-2", "<f4"),
96: ("|Ece|/V", "<f4"),
98: ("Phase(Zce)/deg", "<f4"),
99: ("|Zce|/Ohm", "<f4"),
100: ("Re(Zce)/Ohm", "<f4"),
101: ("-Im(Zce)/Ohm", "<f4"),
123: ("Energy charge/W.h", "<f8"),
124: ("Energy discharge/W.h", "<f8"),
125: ("Capacitance charge/µF", "<f8"),
126: ("Capacitance discharge/µF", "<f8"),
131: ("Ns", "<u2"),
163: ("|Estack|/V", "<f4"),
168: ("Rcmp/Ohm", "<f4"),
169: ("Cs/µF", "<f4"),
172: ("Cp/µF", "<f4"),
173: ("Cp-2/µF-2", "<f4"),
174: ("Ewe/V", "<f4"),
241: ("|E1|/V", "<f4"),
242: ("|E2|/V", "<f4"),
271: ("Phase(Z1) / deg", "<f4"),
272: ("Phase(Z2) / deg", "<f4"),
301: ("|Z1|/Ohm", "<f4"),
302: ("|Z2|/Ohm", "<f4"),
331: ("Re(Z1)/Ohm", "<f4"),
332: ("Re(Z2)/Ohm", "<f4"),
361: ("-Im(Z1)/Ohm", "<f4"),
362: ("-Im(Z2)/Ohm", "<f4"),
391: ("<E1>/V", "<f4"),
392: ("<E2>/V", "<f4"),
422: ("Phase(Zstack)/deg", "<f4"),
423: ("|Zstack|/Ohm", "<f4"),
424: ("Re(Zstack)/Ohm", "<f4"),
425: ("-Im(Zstack)/Ohm", "<f4"),
426: ("<Estack>/V", "<f4"),
430: ("Phase(Zwe-ce)/deg", "<f4"),
431: ("|Zwe-ce|/Ohm", "<f4"),
432: ("Re(Zwe-ce)/Ohm", "<f4"),
433: ("-Im(Zwe-ce)/Ohm", "<f4"),
434: ("(Q-Qo)/C", "<f4"),
435: ("dQ/C", "<f4"),
438: ("step time/s", "<f8"),
441: ("<Ecv>/V", "<f4"),
462: ("Temperature/°C", "<f4"),
467: ("Q charge/discharge/mA.h", "<f8"),
468: ("half cycle", "<u4"),
469: ("z cycle", "<u4"),
471: ("<Ece>/V", "<f4"),
473: ("THD Ewe/%", "<f4"),
474: ("THD I/%", "<f4"),
476: ("NSD Ewe/%", "<f4"),
477: ("NSD I/%", "<f4"),
479: ("NSR Ewe/%", "<f4"),
480: ("NSR I/%", "<f4"),
486: ("|Ewe h2|/V", "<f4"),
487: ("|Ewe h3|/V", "<f4"),
488: ("|Ewe h4|/V", "<f4"),
489: ("|Ewe h5|/V", "<f4"),
490: ("|Ewe h6|/V", "<f4"),
491: ("|Ewe h7|/V", "<f4"),
492: ("|I h2|/A", "<f4"),
493: ("|I h3|/A", "<f4"),
494: ("|I h4|/A", "<f4"),
495: ("|I h5|/A", "<f4"),
496: ("|I h6|/A", "<f4"),
497: ("|I h7|/A", "<f4"),
498: ("Q charge/mA.h", "<f8"),
499: ("Q discharge/mA.h", "<f8"),
500: ("step time/s", "<f8"),
501: ("Efficiency/%", "<f8"),
502: ("Capacity/mA.h", "<f8"),
505: ("Rdc/Ohm", "<f4"),
509: ("Acir/Dcir Control", "<u1"),
}
# These column IDs define flags which are all stored packed in a single byte
# The values in the map are (name, bitmask, dtype)
VMPdata_colID_flag_map = {
1: ('mode', 0x03, np.uint8),
2: ('ox/red', 0x04, np.bool_),
3: ('error', 0x08, np.bool_),
21: ('control changes', 0x10, np.bool_),
31: ('Ns changes', 0x20, np.bool_),
65: ('counter inc.', 0x80, np.bool_),
1: ("mode", 0x03, np.uint8),
2: ("ox/red", 0x04, np.bool_),
3: ("error", 0x08, np.bool_),
21: ("control changes", 0x10, np.bool_),
31: ("Ns changes", 0x20, np.bool_),
65: ("counter inc.", 0x80, np.bool_),
}
def parse_BioLogic_date(date_text):
"""Parse a date from one of the various formats used by Bio-Logic files."""
date_formats = ['%m/%d/%y', '%m-%d-%y', '%m.%d.%y']
date_formats = ["%m/%d/%y", "%m-%d-%y", "%m.%d.%y"]
if isinstance(date_text, bytes):
date_string = date_text.decode('ascii')
date_string = date_text.decode("ascii")
else:
date_string = date_text
for date_format in date_formats:
@@ -281,8 +371,10 @@ def parse_BioLogic_date(date_text):
else:
break
else:
raise ValueError(f'Could not parse timestamp {date_string!r}'
f' with any of the formats {date_formats}')
raise ValueError(
f"Could not parse timestamp {date_string!r}"
f" with any of the formats {date_formats}"
)
return date(tm.tm_year, tm.tm_mon, tm.tm_mday)
@@ -309,9 +401,9 @@ def VMPdata_dtype_from_colIDs(colIDs):
# in the overall record is determined by the position of the first
# column ID of flag type. If there are several flags present,
# there is still only one 'flags' int
if 'flags' not in field_name_counts:
type_list.append(('flags', 'u1'))
field_name_counts['flags'] = 1
if "flags" not in field_name_counts:
type_list.append(("flags", "u1"))
field_name_counts["flags"] = 1
flag_name, flag_mask, flag_type = VMPdata_colID_flag_map[colID]
# TODO what happens if a flag colID has already been seen
# i.e. if flag_name is already present in flags_dict?
@@ -322,15 +414,15 @@ def VMPdata_dtype_from_colIDs(colIDs):
field_name_counts[field_name] += 1
count = field_name_counts[field_name]
if count > 1:
unique_field_name = '%s %d' % (field_name, count)
unique_field_name = "%s %d" % (field_name, count)
else:
unique_field_name = field_name
type_list.append((unique_field_name, field_type))
else:
raise NotImplementedError("Column ID {cid} after column {prev} "
"is unknown"
.format(cid=colID,
prev=type_list[-1][0]))
raise NotImplementedError(
"Column ID {cid} after column {prev} "
"is unknown".format(cid=colID, prev=type_list[-1][0])
)
return np.dtype(type_list), flags_dict
@@ -341,12 +433,13 @@ def read_VMP_modules(fileobj, read_module_data=True):
N.B. the offset yielded is the offset to the start of the data i.e. after
the end of the header. The data runs from (offset) to (offset+length)"""
while True:
module_magic = fileobj.read(len(b'MODULE'))
module_magic = fileobj.read(len(b"MODULE"))
if len(module_magic) == 0: # end of file
break
elif module_magic != b'MODULE':
raise ValueError("Found %r, expecting start of new VMP MODULE"
% module_magic)
elif module_magic != b"MODULE":
raise ValueError(
"Found %r, expecting start of new VMP MODULE" % module_magic
)
hdr_bytes = fileobj.read(VMPmodule_hdr.itemsize)
if len(hdr_bytes) < VMPmodule_hdr.itemsize:
@@ -354,23 +447,24 @@ def read_VMP_modules(fileobj, read_module_data=True):
hdr = np.frombuffer(hdr_bytes, dtype=VMPmodule_hdr, count=1)
hdr_dict = dict(((n, hdr[n][0]) for n in VMPmodule_hdr.names))
hdr_dict['offset'] = fileobj.tell()
hdr_dict["offset"] = fileobj.tell()
if read_module_data:
hdr_dict['data'] = fileobj.read(hdr_dict['length'])
if len(hdr_dict['data']) != hdr_dict['length']:
raise IOError("""Unexpected end of file while reading data
hdr_dict["data"] = fileobj.read(hdr_dict["length"])
if len(hdr_dict["data"]) != hdr_dict["length"]:
raise IOError(
"""Unexpected end of file while reading data
current module: %s
length read: %d
length expected: %d""" % (hdr_dict['longname'],
len(hdr_dict['data']),
hdr_dict['length']))
length expected: %d"""
% (hdr_dict["longname"], len(hdr_dict["data"]), hdr_dict["length"])
)
yield hdr_dict
else:
yield hdr_dict
fileobj.seek(hdr_dict['offset'] + hdr_dict['length'], SEEK_SET)
fileobj.seek(hdr_dict["offset"] + hdr_dict["length"], SEEK_SET)
MPR_MAGIC = b'BIO-LOGIC MODULAR FILE\x1a'.ljust(48) + b'\x00\x00\x00\x00'
MPR_MAGIC = b"BIO-LOGIC MODULAR FILE\x1a".ljust(48) + b"\x00\x00\x00\x00"
class MPRfile:
@@ -392,41 +486,44 @@ class MPRfile:
def __init__(self, file_or_path):
self.loop_index = None
if isinstance(file_or_path, str):
mpr_file = open(file_or_path, 'rb')
mpr_file = open(file_or_path, "rb")
else:
mpr_file = file_or_path
magic = mpr_file.read(len(MPR_MAGIC))
if magic != MPR_MAGIC:
raise ValueError('Invalid magic for .mpr file: %s' % magic)
raise ValueError("Invalid magic for .mpr file: %s" % magic)
modules = list(read_VMP_modules(mpr_file))
self.modules = modules
settings_mod, = (m for m in modules if m['shortname'] == b'VMP Set ')
data_module, = (m for m in modules if m['shortname'] == b'VMP data ')
maybe_loop_module = [m for m in modules if m['shortname'] == b'VMP loop ']
maybe_log_module = [m for m in modules if m['shortname'] == b'VMP LOG ']
(settings_mod,) = (m for m in modules if m["shortname"] == b"VMP Set ")
(data_module,) = (m for m in modules if m["shortname"] == b"VMP data ")
maybe_loop_module = [m for m in modules if m["shortname"] == b"VMP loop "]
maybe_log_module = [m for m in modules if m["shortname"] == b"VMP LOG "]
n_data_points = np.frombuffer(data_module['data'][:4], dtype='<u4')
n_columns = np.frombuffer(data_module['data'][4:5], dtype='u1').item()
n_data_points = np.frombuffer(data_module["data"][:4], dtype="<u4")
n_columns = np.frombuffer(data_module["data"][4:5], dtype="u1").item()
if data_module['version'] == 0:
column_types = np.frombuffer(data_module['data'][5:], dtype='u1',
count=n_columns)
remaining_headers = data_module['data'][5 + n_columns:100]
main_data = data_module['data'][100:]
elif data_module['version'] in [2, 3]:
column_types = np.frombuffer(data_module['data'][5:], dtype='<u2',
count=n_columns)
if data_module["version"] == 0:
column_types = np.frombuffer(
data_module["data"][5:], dtype="u1", count=n_columns
)
remaining_headers = data_module["data"][5 + n_columns : 100]
main_data = data_module["data"][100:]
elif data_module["version"] in [2, 3]:
column_types = np.frombuffer(
data_module["data"][5:], dtype="<u2", count=n_columns
)
# There are bytes of data before the main array starts
if data_module['version'] == 3:
if data_module["version"] == 3:
num_bytes_before = 406 # version 3 added `\x01` to the start
else:
num_bytes_before = 405
remaining_headers = data_module['data'][5 + 2 * n_columns:405]
main_data = data_module['data'][num_bytes_before:]
remaining_headers = data_module["data"][5 + 2 * n_columns : 405]
main_data = data_module["data"][num_bytes_before:]
else:
raise ValueError("Unrecognised version for data module: %d" %
data_module['version'])
raise ValueError(
"Unrecognised version for data module: %d" % data_module["version"]
)
assert not any(remaining_headers)
@@ -436,36 +533,40 @@ class MPRfile:
# No idea what these 'column types' mean or even if they are actually
# column types at all
self.version = int(data_module['version'])
self.version = int(data_module["version"])
self.cols = column_types
self.npts = n_data_points
self.startdate = parse_BioLogic_date(settings_mod['date'])
self.startdate = parse_BioLogic_date(settings_mod["date"])
if maybe_loop_module:
loop_module, = maybe_loop_module
if loop_module['version'] == 0:
self.loop_index = np.fromstring(loop_module['data'][4:],
dtype='<u4')
self.loop_index = np.trim_zeros(self.loop_index, 'b')
(loop_module,) = maybe_loop_module
if loop_module["version"] == 0:
self.loop_index = np.fromstring(loop_module["data"][4:], dtype="<u4")
self.loop_index = np.trim_zeros(self.loop_index, "b")
else:
raise ValueError("Unrecognised version for data module: %d" %
data_module['version'])
raise ValueError(
"Unrecognised version for data module: %d" % data_module["version"]
)
if maybe_log_module:
log_module, = maybe_log_module
self.enddate = parse_BioLogic_date(log_module['date'])
(log_module,) = maybe_log_module
self.enddate = parse_BioLogic_date(log_module["date"])
# There is a timestamp at either 465 or 469 bytes
# I can't find any reason why it is one or the other in any
# given file
ole_timestamp1 = np.frombuffer(log_module['data'][465:],
dtype='<f8', count=1)
ole_timestamp2 = np.frombuffer(log_module['data'][469:],
dtype='<f8', count=1)
ole_timestamp3 = np.frombuffer(log_module['data'][473:],
dtype='<f8', count=1)
ole_timestamp4 = np.frombuffer(log_module['data'][585:],
dtype='<f8', count=1)
ole_timestamp1 = np.frombuffer(
log_module["data"][465:], dtype="<f8", count=1
)
ole_timestamp2 = np.frombuffer(
log_module["data"][469:], dtype="<f8", count=1
)
ole_timestamp3 = np.frombuffer(
log_module["data"][473:], dtype="<f8", count=1
)
ole_timestamp4 = np.frombuffer(
log_module["data"][585:], dtype="<f8", count=1
)
if ole_timestamp1 > 40000 and ole_timestamp1 < 50000:
ole_timestamp = ole_timestamp1
@@ -483,14 +584,16 @@ class MPRfile:
ole_timedelta = timedelta(days=ole_timestamp[0])
self.timestamp = ole_base + ole_timedelta
if self.startdate != self.timestamp.date():
raise ValueError("Date mismatch:\n"
raise ValueError(
"Date mismatch:\n"
+ " Start date: %s\n" % self.startdate
+ " End date: %s\n" % self.enddate
+ " Timestamp: %s\n" % self.timestamp)
+ " Timestamp: %s\n" % self.timestamp
)
def get_flag(self, flagname):
if flagname in self.flags_dict:
mask, dtype = self.flags_dict[flagname]
return np.array(self.data['flags'] & mask, dtype=dtype)
return np.array(self.data["flags"] & mask, dtype=dtype)
else:
raise AttributeError("Flag '%s' not present" % flagname)