def test_read_mdf4_10(self):
seed = np.random.randint(0, 2**31)
np.random.seed(seed)
print("Read 4.10 using seed =", seed)
sig_int = Signal(
np.random.randint(-(2**31), 2**31, CHANNEL_LEN),
np.arange(CHANNEL_LEN),
name="Integer Channel",
unit="unit1",
)
sig_float = Signal(
np.random.random(CHANNEL_LEN),
np.arange(CHANNEL_LEN),
name="Float Channel",
unit="unit2",
)
with MDF(version="4.10") as mdf:
mdf.append([sig_int, sig_float], common_timebase=True)
outfile = mdf.save(Path(TestMDF4.tempdir.name) / "tmp",
overwrite=True)
with MDF(outfile) as mdf:
ret_sig_int = mdf.get(sig_int.name)
ret_sig_float = mdf.get(sig_float.name)
self.assertTrue(np.array_equal(ret_sig_int.samples, sig_int.samples))
self.assertTrue(
np.array_equal(ret_sig_float.samples, sig_float.samples))
def test_mixed(self):
t = np.arange(15, dtype="<f8")
s1 = Signal(
np.frombuffer(b"\x00\x00\x00\x02" * 15, dtype=">u4"), t, name="Motorola"
)
s2 = Signal(
np.frombuffer(b"\x04\x00\x00\x00" * 15, dtype="<u4"), t, name="Intel"
)
for version in ("3.30", "4.10"):
mdf = MDF(version=version)
mdf.append([s1, s2], common_timebase=True)
outfile = mdf.save(
Path(TestEndianess.tempdir.name) / f"out", overwrite=True
)
mdf.close()
with MDF(outfile) as mdf:
self.assertTrue(np.array_equal(mdf.get("Motorola").samples, [2] * 15))
self.assertTrue(np.array_equal(mdf.get("Intel").samples, [4] * 15))
for version in ("3.30", "4.10"):
mdf = MDF(version=version)
mdf.append([s2, s1], common_timebase=True)
outfile = mdf.save(
Path(TestEndianess.tempdir.name) / f"out", overwrite=True
)
mdf.close()
with MDF(outfile) as mdf:
self.assertTrue(np.array_equal(mdf.get("Motorola").samples, [2] * 15))
self.assertTrue(np.array_equal(mdf.get("Intel").samples, [4] * 15))
def test_sub(self):
s = Signal(
np.arange(5, dtype='<f4'),
np.arange(5, dtype='<f8'),
name='S',
)
target = np.zeros(5, dtype='<f4')
res = s - s
self.assertTrue(np.array_equal(res.samples, target))
s -= s
res = s
self.assertTrue(np.array_equal(res.samples, target))
# - 2
s = Signal(
np.arange(5, dtype='<f4'),
np.arange(5, dtype='<f8'),
name='S',
)
target = np.arange(-2, 3, dtype='<f4')
res = s - 2
self.assertTrue(np.array_equal(res.samples, target))
res = -(2 - s)
self.assertTrue(np.array_equal(res.samples, target))
s -= 2
res = s
self.assertTrue(np.array_equal(res.samples, target))
def test_add(self):
s = Signal(
np.arange(5, dtype='<f4'),
np.arange(5, dtype='<f8'),
name='S',
)
target = np.arange(0, 10, 2, dtype='<f4')
res = s + s
self.assertTrue(np.array_equal(res.samples, target))
s += s
res = s
self.assertTrue(np.array_equal(res.samples, target))
# + 2
s = Signal(
np.arange(5, dtype='<f4'),
np.arange(5, dtype='<f8'),
name='S',
)
target = np.arange(2, 7, dtype='<f4')
res = s + 2
self.assertTrue(np.array_equal(res.samples, target))
res = 2 + s
self.assertTrue(np.array_equal(res.samples, target))
s += 2
res = s
self.assertTrue(np.array_equal(res.samples, target))
def test_mul(self):
s = Signal(
np.arange(5, dtype='<f4'),
np.arange(5, dtype='<f8'),
name='S',
)
target = np.arange(5, dtype='<f4')**2
res = s * s
self.assertTrue(np.array_equal(res.samples, target))
s *= s
res = s
self.assertTrue(np.array_equal(res.samples, target))
s = Signal(
np.arange(5, dtype='<f4'),
np.arange(5, dtype='<f8'),
name='S',
)
target = np.arange(0, 10, 2, dtype='<f4')
res = s * 2
self.assertTrue(np.array_equal(res.samples, target))
res = 2 * s
self.assertTrue(np.array_equal(res.samples, target))
s *= 2
res = s
self.assertTrue(np.array_equal(res.samples, target))
def test_div(self):
s = Signal(
np.arange(1, 5, dtype='<f4'),
np.arange(1, 5, dtype='<f8'),
name='S',
)
target = np.ones(4, dtype='<f4')
res = s / s
self.assertTrue(np.array_equal(res.samples, target))
s /= s
res = s
self.assertTrue(np.array_equal(res.samples, target))
s = Signal(
np.arange(1, 5, dtype='<f4'),
np.arange(1, 5, dtype='<f8'),
name='S',
)
target = np.arange(2, 10, 2, dtype='<f4')
res = 1 / (0.5 / s)
self.assertTrue(np.array_equal(res.samples, target))
s /= 0.5
res = s
self.assertTrue(np.array_equal(res.samples, target))
def export_to_mf4(self):
print("exporting to mf4")
timestamps = np.array(self.data['t'])
voltages = Signal(samples=np.array(self.data['v'], dtype=np.float32),
timestamps=timestamps,
name='Voltage',
unit='V')
currents = Signal(samples=np.array(self.data['c'], dtype=np.float32),
timestamps=timestamps,
name='Current',
unit='A')
powers = Signal(samples=np.array(self.data['p'], dtype=np.float32),
timestamps=timestamps,
name='Power',
unit='W')
capacities = Signal(samples=np.array(self.data['cap'],
dtype=np.float32),
timestamps=timestamps,
name='Capacity',
unit='AH')
mdf4 = MDF(version='4.10')
signals = [voltages, currents, powers, capacities]
mdf4.start_time = self.start_time
mdf4.append(signals, comment='Battery test: {}'.format(self.cell_id))
mdf4.save("test.mf4", overwrite=True)
return mdf4
def test_read_mdf4_10(self):
seed = np.random.randint(0, 2**31)
np.random.seed(seed)
print('Read 4.10 using seed =', seed)
sig_int = Signal(
np.random.randint(-2**31, 2**31, CHANNEL_LEN),
np.arange(CHANNEL_LEN),
name='Integer Channel',
unit='unit1',
)
sig_float = Signal(
np.random.random(CHANNEL_LEN),
np.arange(CHANNEL_LEN),
name='Float Channel',
unit='unit2',
)
for memory in MEMORY:
with MDF(version='4.10', memory=memory) as mdf:
mdf.append([sig_int, sig_float], common_timebase=True)
outfile = mdf.save('tmp', overwrite=True)
with MDF(outfile, memory=memory) as mdf:
ret_sig_int = mdf.get(sig_int.name)
ret_sig_float = mdf.get(sig_float.name)
self.assertTrue(np.array_equal(ret_sig_int.samples,
sig_int.samples))
self.assertTrue(np.array_equal(ret_sig_float.samples,
sig_float.samples))
def test_read_mdf3_00(self):
seed = np.random.randint(0, 2 ** 31)
np.random.seed(seed)
print("Read 3.00 using seed =", seed)
sig_int = Signal(
np.random.randint(-2 ** 16, 2 ** 16, CHANNEL_LEN, np.int32),
np.arange(CHANNEL_LEN),
name="Integer Channel",
unit="unit1",
)
sig_float = Signal(
np.random.random(CHANNEL_LEN),
np.arange(CHANNEL_LEN),
name="Float Channel",
unit="unit2",
)
for memory in MEMORY:
print(memory)
with MDF(version="3.00", memory=memory) as mdf:
mdf.append([sig_int, sig_float], common_timebase=True)
outfile = mdf.save("tmp", overwrite=True)
with MDF(outfile, memory=memory) as mdf:
ret_sig_int = mdf.get(sig_int.name)
ret_sig_float = mdf.get(sig_float.name)
self.assertTrue(np.array_equal(ret_sig_int.samples, sig_int.samples))
self.assertTrue(np.array_equal(ret_sig_float.samples, sig_float.samples))
def test_mixed(self):
t = np.arange(15, dtype='<f8')
s1 = Signal(
np.frombuffer(b'\x00\x00\x00\x02' * 15, dtype='>u4'),
t,
name='Motorola'
)
s2 = Signal(
np.frombuffer(b'\x04\x00\x00\x00' * 15, dtype='<u4'),
t,
name='Intel'
)
for version in ('3.30', '4.10'):
mdf = MDF(version=version)
mdf.append([s1, s2], common_timebase=True)
outfile = mdf.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
mdf.close()
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get('Motorola').samples, [2,] * 15
)
)
self.assertTrue(
np.array_equal(
mdf.get('Intel').samples, [4,] * 15
)
)
for version in ('3.30', '4.10'):
mdf = MDF(version=version)
mdf.append([s2, s1], common_timebase=True)
outfile = mdf.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
mdf.close()
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get('Motorola').samples, [2,] * 15
)
)
self.assertTrue(
np.array_equal(
mdf.get('Intel').samples, [4,] * 15
)
)
def test_pow(self):
s = Signal(np.arange(1, 5, dtype="<f4"), np.arange(1, 5, dtype="<f8"), name="S")
target = np.arange(1, 5, dtype="<f4") ** 3
res = s ** 3
self.assertTrue(np.array_equal(res.samples, target))
def test_resample(self):
raster = 1.33
sigs = [
Signal(
samples=np.arange(1000, dtype='f8'),
timestamps=np.concatenate(
[np.arange(500), np.arange(1000, 1500)]),
name=f'Signal_{i}',
) for i in range(20)
]
mdf = MDF()
mdf.append(sigs)
mdf = mdf.resample(raster=raster)
target_timestamps = np.arange(0, 1500, 1.33)
target_samples = np.concatenate([
np.arange(0, 500, 1.33),
np.linspace(499.00215568862274, 499.9976646706587, 376),
np.arange(500.1600000000001, 1000, 1.33)
])
for i, sig in enumerate(mdf.iter_channels(skip_master=True)):
self.assertTrue(np.array_equal(sig.timestamps, target_timestamps))
self.assertTrue(np.allclose(sig.samples, target_samples))
def mdfsave(mdf, df, filename):
t = 0.05 * df.index.values
sigs=[]
for v in df.columns:
sigs += [Signal(df[v].values, t, name=v)]
mdf.append(sigs)
mdf.save(filename, overwrite=True, compression=1)
def get(self, name, raw=False):
"""
Gets the signals based on the name
Parameters
----------
name : string
signal name
Returns
-------
signal : asammdf.Signal
Signal object
Raises
------
KeyError : if the signal is not found
"""
if name not in self.signals:
raise Exception('Channel "{}" not found in "{}"'.format(name, self.name,))
signal = self.signals[name]
samples = signal.data
if "Time" in self.signals:
timestamps = self.signals["Time"].data
else:
timestamps = np.array([0.001 * i for i in range(len(samples))])
if not raw:
conversion = None
if signal.factor is not None:
samples = samples * signal.factor + signal.offset
else:
if signal.factor is not None:
conversion = ChannelConversion(a=signal.factor, b=signal.offset,)
else:
conversion = None
raw = False
if samples.dtype.kind == "S":
encoding = "utf-8"
else:
encoding = None
return Signal(
samples=samples,
timestamps=timestamps,
name=name,
unit=self.signals[name].unit,
conversion=conversion,
raw=raw,
encoding=encoding,
)
def test_resample_raster_0(self):
sigs = [
Signal(
samples=np.ones(1000) * i,
timestamps=np.arange(1000),
name=f'Signal_{i}',
) for i in range(20)
]
mdf = MDF()
mdf.append(sigs)
mdf.configure(read_fragment_size=1)
with self.assertRaises(AssertionError):
mdf = mdf.resample(raster=0)
def test_init_errors(self):
with self.assertRaises(MdfException):
Signal([], [1], name='s')
with self.assertRaises(MdfException):
Signal([1], [], name='s')
with self.assertRaises(MdfException):
Signal([1, 2, 3], [1, 2], name='s')
with self.assertRaises(MdfException):
Signal(np.array([]), np.array([1]), name='s')
with self.assertRaises(MdfException):
Signal(np.array([1]), np.array([]), name='s')
with self.assertRaises(MdfException):
Signal(np.array([1, 2, 3]), np.array([1, 2]), name='s')
with self.assertRaises(MdfException):
Signal(np.array([]), np.array([]))
def test_resample_raster_0(self):
sigs = [
Signal(
samples=np.ones(1000) * i,
timestamps=np.arange(1000),
name=f'Signal_{i}',
) for i in range(20)
]
mdf = MDF()
mdf.append(sigs)
mdf.configure(read_fragment_size=1)
mdf = mdf.resample(raster=0)
for i, sig in enumerate(mdf.iter_channels(skip_master=True)):
self.assertTrue(np.array_equal(sig.samples, sigs[i].samples))
self.assertTrue(np.array_equal(sig.timestamps, sigs[i].timestamps))
def generate_test_files():
print('Generating test files:')
for version in ('3.30', '4.10'):
print("-> generating file for version", version)
mdf = MDF(version=version, memory='minimum')
if version == '3.30':
cycles = 500
channels_count = 8000
filename = 'test.mdf'
else:
cycles = 500
channels_count = 20000
filename = 'test.mf4'
if os.path.exists(filename):
continue
t = np.arange(cycles, dtype=np.float64)
# no conversion
sigs = []
for i in range(channels_count):
sig = Signal(
np.ones(cycles, dtype=np.uint16),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=None,
comment='Unsinged int 16bit channel {}'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs)
# linear
sigs = []
for i in range(channels_count):
conversion = {
'type': SignalConversions.CONVERSION_LINEAR,
'a': float(i),
'b': -0.5,
}
sig = Signal(
np.ones(cycles, dtype=np.int16),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=conversion,
comment='Signed 16bit channel {} with linear conversion'.
format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs)
# algebraic
sigs = []
for i in range(channels_count):
conversion = {
'type': SignalConversions.CONVERSION_ALGEBRAIC,
'formula': '{} * sin(X)'.format(i),
}
sig = Signal(
np.arange(cycles, dtype=np.int32) / 100,
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=conversion,
comment='Sinus channel {} with algebraic conversion'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs)
# rational
sigs = []
for i in range(channels_count):
conversion = {
'type': SignalConversions.CONVERSION_RATIONAL,
'P1': 0,
'P2': i,
'P3': -0.5,
'P4': 0,
'P5': 0,
'P6': 1,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=conversion,
comment='Channel {} with rational conversion'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs)
mdf.save(filename, overwrite=True)
del mdf
MDF.merge([
filename,
] * 10, version, memory='minimum').save(filename, overwrite=True)
def generate_test_files(version='4.10'):
cycles = 3000
channels_count = 2000
mdf = MDF(version=version)
if version <= '3.30':
filename = r'test.mdf'
else:
filename = r'test.mf4'
if os.path.exists(filename):
return filename
t = np.arange(cycles, dtype=np.float64)
cls = v4b.ChannelConversion if version >= '4.00' else v3b.ChannelConversion
# no conversion
sigs = []
for i in range(channels_count):
sig = Signal(
np.ones(cycles, dtype=np.uint64) * i,
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=None,
comment='Unsigned int 16bit channel {}'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# linear
sigs = []
for i in range(channels_count):
conversion = {
'conversion_type':
v4c.CONVERSION_TYPE_LIN
if version >= '4.00' else v3c.CONVERSION_TYPE_LINEAR,
'a':
float(i),
'b':
-0.5,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=cls(**conversion),
comment='Signed 16bit channel {} with linear conversion'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# algebraic
sigs = []
for i in range(channels_count):
conversion = {
'conversion_type':
v4c.CONVERSION_TYPE_ALG
if version >= '4.00' else v3c.CONVERSION_TYPE_FORMULA,
'formula':
'{} * sin(X)'.format(i),
}
sig = Signal(
np.arange(cycles, dtype=np.int32) / 100.0,
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=cls(**conversion),
comment='Sinus channel {} with algebraic conversion'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# rational
sigs = []
for i in range(channels_count):
conversion = {
'conversion_type':
v4c.CONVERSION_TYPE_RAT
if version >= '4.00' else v3c.CONVERSION_TYPE_RAT,
'P1':
0,
'P2':
i,
'P3':
-0.5,
'P4':
0,
'P5':
0,
'P6':
1,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=cls(**conversion),
comment='Channel {} with rational conversion'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# string
sigs = []
for i in range(channels_count):
sig = [
'Channel {} sample {}'.format(i, j).encode('ascii')
for j in range(cycles)
]
sig = Signal(
np.array(sig),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
comment='String channel {}'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# byte array
sigs = []
ones = np.ones(cycles, dtype=np.dtype('(8,)u1'))
for i in range(channels_count):
sig = Signal(
ones * (i % 255),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
comment='Byte array channel {}'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# value to text
sigs = []
ones = np.ones(cycles, dtype=np.uint64)
conversion = {
'raw':
np.arange(255, dtype=np.float64),
'phys':
np.array(['Value {}'.format(i).encode('ascii') for i in range(255)]),
'conversion_type':
v4c.CONVERSION_TYPE_TABX
if version >= '4.00' else v3c.CONVERSION_TYPE_TABX,
'links_nr':
260,
'ref_param_nr':
255,
}
for i in range(255):
conversion['val_{}'.format(i)] = conversion['param_val_{}'.format(
i)] = conversion['raw'][i]
conversion['text_{}'.format(i)] = conversion['phys'][i]
conversion['text_{}'.format(255)] = 'Default'
for i in range(channels_count):
sig = Signal(
ones * i,
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
comment='Value to text channel {}'.format(i),
conversion=cls(**conversion),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
mdf.save(filename, overwrite=True)
# -*- coding: utf-8 -*-
"""
*asammdf* Signal usage example
"""
import numpy as np
from asammdf import Signal
# create 3 Signal objects with different time stamps
# unit8 with 100ms time raster
timestamps = np.array([0.1 * t for t in range(5)], dtype=np.float32)
s_uint8 = Signal(
samples=np.array([t for t in range(5)], dtype=np.uint8),
timestamps=timestamps,
name="Uint8_Signal",
unit="u1",
)
# int32 with 50ms time raster
timestamps = np.array([0.05 * t for t in range(10)], dtype=np.float32)
s_int32 = Signal(
samples=np.array(list(range(-500, 500, 100)), dtype=np.int32),
timestamps=timestamps,
name="Int32_Signal",
unit="i4",
)
# float64 with 300ms time raster
timestamps = np.array([0.3 * t for t in range(3)], dtype=np.float32)
s_float64 = Signal(
# -*- coding: utf-8 -*-
"""
*asammdf* Signal usage example
"""
from __future__ import print_function, division
from asammdf import Signal
import numpy as np
# create 3 Signal objects with different time stamps
# unit8 with 100ms time raster
timestamps = np.array([0.1 * t for t in range(5)], dtype=np.float32)
s_uint8 = Signal(samples=np.array([t for t in range(5)], dtype=np.uint8),
timestamps=timestamps,
name='Uint8_Signal',
unit='u1')
# int32 with 50ms time raster
timestamps = np.array([0.05 * t for t in range(10)], dtype=np.float32)
s_int32 = Signal(samples=np.array(list(range(-500, 500, 100)), dtype=np.int32),
timestamps=timestamps,
name='Int32_Signal',
unit='i4')
# float64 with 300ms time raster
timestamps = np.array([0.3 * t for t in range(3)], dtype=np.float32)
s_float64 = Signal(samples=np.array(list(range(2000, -1000, -1000)), dtype=np.int32),
timestamps=timestamps,
name='Float64_Signal',
unit='f8')
from asammdf import MDF, Signal
import numpy as np
cycles = 100
sigs = []
mdf = MDF()
t = np.arange(cycles, dtype=np.float64)
# no conversion
sig = Signal(
np.ones(cycles, dtype=np.uint64),
t,
name="Channel_no_conversion",
unit="s",
conversion=None,
comment="Unsigned 64 bit channel {}",
)
sigs.append(sig)
# linear
conversion = {
"a": 2,
"b": -0.5,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name="Channel_linear_conversion",
unit="Nm",
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
from __future__ import print_function, division
from asammdf import MDF, Signal
import numpy as np
# create 3 Signal objects
timestamps = np.array([0.1, 0.2, 0.3, 0.4, 0.5], dtype=np.float32)
# unit8
s_uint8 = Signal(samples=np.array([0, 1, 2, 3, 4], dtype=np.uint8),
timestamps=timestamps,
name='Uint8_Signal',
unit='u1')
# int32
s_int32 = Signal(samples=np.array([-20, -10, 0, 10, 20], dtype=np.int32),
timestamps=timestamps,
name='Int32_Signal',
unit='i4')
# float64
s_float64 = Signal(samples=np.array([-20, -10, 0, 10, 20], dtype=np.float64),
timestamps=timestamps,
name='Float64_Signal',
unit='f8')
# create empty MDf version 4.00 file
mdf4 = MDF(version='4.10')
def generate_arrays_test_file(tmpdir):
version = "4.10"
mdf = MDF(version=version)
filename = Path(tmpdir) / f"arrays_test_{version}.mf4"
if filename.exists():
return filename
t = np.arange(cycles, dtype=np.float64)
# lookup tabel with axis
sigs = []
for i in range(array_channels_count):
samples = [
np.ones((cycles, 2, 3), dtype=np.uint64) * i,
np.ones((cycles, 2), dtype=np.uint64) * i,
np.ones((cycles, 3), dtype=np.uint64) * i,
]
types = [
("Channel_{}".format(i), "(2, 3)<u8"),
("channel_{}_axis_1".format(i), "(2, )<u8"),
("channel_{}_axis_2".format(i), "(3, )<u8"),
]
sig = Signal(
np.core.records.fromarrays(samples, dtype=np.dtype(types)),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=None,
comment="Array channel {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# lookup tabel with default axis
sigs = []
for i in range(array_channels_count):
samples = [np.ones((cycles, 2, 3), dtype=np.uint64) * i]
types = [("Channel_{}".format(i), "(2, 3)<u8")]
sig = Signal(
np.core.records.fromarrays(samples, dtype=np.dtype(types)),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=None,
comment="Array channel {} with default axis".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# structure channel composition
sigs = []
for i in range(array_channels_count):
samples = [
np.ones(cycles, dtype=np.uint8) * i,
np.ones(cycles, dtype=np.uint16) * i,
np.ones(cycles, dtype=np.uint32) * i,
np.ones(cycles, dtype=np.uint64) * i,
np.ones(cycles, dtype=np.int8) * i,
np.ones(cycles, dtype=np.int16) * i,
np.ones(cycles, dtype=np.int32) * i,
np.ones(cycles, dtype=np.int64) * i,
]
types = [
("struct_{}_channel_0".format(i), np.uint8),
("struct_{}_channel_1".format(i), np.uint16),
("struct_{}_channel_2".format(i), np.uint32),
("struct_{}_channel_3".format(i), np.uint64),
("struct_{}_channel_4".format(i), np.int8),
("struct_{}_channel_5".format(i), np.int16),
("struct_{}_channel_6".format(i), np.int32),
("struct_{}_channel_7".format(i), np.int64),
]
sig = Signal(
np.core.records.fromarrays(samples, dtype=np.dtype(types)),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=None,
comment="Structure channel composition {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
name = mdf.save(filename, overwrite=True)
def test_cut_int(self):
s = Signal(
np.arange(5),
np.arange(5, dtype='<f8'),
name='S',
)
res = s.cut()
self.assertTrue(np.array_equal(np.arange(5), res.samples))
self.assertTrue(
np.array_equal(np.arange(5, dtype='<f8'), res.timestamps))
# stop == None
res = s.cut(start=-1)
self.assertTrue(np.array_equal(np.arange(5), res.samples))
self.assertTrue(
np.array_equal(np.arange(5, dtype='<f8'), res.timestamps))
res = s.cut(start=-1, include_ends=False)
self.assertTrue(np.array_equal(np.arange(5), res.samples))
self.assertTrue(
np.array_equal(np.arange(5, dtype='<f8'), res.timestamps))
res = s.cut(start=0)
self.assertTrue(np.array_equal(np.arange(5), res.samples))
self.assertTrue(
np.array_equal(np.arange(5, dtype='<f8'), res.timestamps))
res = s.cut(start=0, include_ends=False)
self.assertTrue(np.array_equal(np.arange(5), res.samples))
self.assertTrue(
np.array_equal(np.arange(5, dtype='<f8'), res.timestamps))
res = s.cut(start=0.5)
self.assertTrue(np.array_equal([0, 1, 2, 3, 4], res.samples))
self.assertTrue(
np.array_equal(np.array([0.5, 1, 2, 3, 4], dtype='<f8'),
res.timestamps))
res = s.cut(start=0.5, include_ends=False)
self.assertTrue(np.array_equal([1, 2, 3, 4], res.samples))
self.assertTrue(
np.array_equal(np.array([1, 2, 3, 4], dtype='<f8'),
res.timestamps))
res = s.cut(start=4)
self.assertTrue(np.array_equal([4], res.samples))
self.assertTrue(
np.array_equal(np.array([4], dtype='<f8'), res.timestamps))
res = s.cut(start=4, include_ends=False)
self.assertTrue(np.array_equal([4], res.samples))
self.assertTrue(
np.array_equal(np.array([4], dtype='<f8'), res.timestamps))
res = s.cut(start=4.1)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
res = s.cut(start=4.1, include_ends=False)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
# start == None
res = s.cut(stop=-1)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
res = s.cut(stop=-1, include_ends=False)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
res = s.cut(stop=0)
self.assertTrue(np.array_equal([0], res.samples))
self.assertTrue(
np.array_equal(np.array([0], dtype='<f8'), res.timestamps))
res = s.cut(stop=0, include_ends=False)
self.assertTrue(np.array_equal([0], res.samples))
self.assertTrue(
np.array_equal(np.array([0], dtype='<f8'), res.timestamps))
res = s.cut(stop=0.5)
self.assertTrue(np.array_equal([0, 0], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 0.5], dtype='<f8'), res.timestamps))
res = s.cut(stop=0.5, include_ends=False)
self.assertTrue(np.array_equal([0], res.samples))
self.assertTrue(
np.array_equal(np.array([0], dtype='<f8'), res.timestamps))
res = s.cut(stop=4)
self.assertTrue(np.array_equal([0, 1, 2, 3, 4], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 1, 2, 3, 4], dtype='<f8'),
res.timestamps))
res = s.cut(stop=4, include_ends=False)
self.assertTrue(np.array_equal([0, 1, 2, 3, 4], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 1, 2, 3, 4], dtype='<f8'),
res.timestamps))
res = s.cut(stop=4.1)
self.assertTrue(np.array_equal([0, 1, 2, 3, 4], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 1, 2, 3, 4], dtype='<f8'),
res.timestamps))
res = s.cut(stop=4.1, include_ends=False)
self.assertTrue(np.array_equal([0, 1, 2, 3, 4], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 1, 2, 3, 4], dtype='<f8'),
res.timestamps))
# with start and stop
res = s.cut(start=-2, stop=-1)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
res = s.cut(start=-2, stop=-1, include_ends=False)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
res = s.cut(start=-2, stop=0)
self.assertTrue(np.array_equal([0], res.samples))
self.assertTrue(
np.array_equal(np.array([0], dtype='<f8'), res.timestamps))
res = s.cut(start=-2, stop=0, include_ends=False)
self.assertTrue(np.array_equal([0], res.samples))
self.assertTrue(
np.array_equal(np.array([0], dtype='<f8'), res.timestamps))
res = s.cut(start=-2, stop=0.5)
self.assertTrue(np.array_equal([0, 0], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 0.5], dtype='<f8'), res.timestamps))
res = s.cut(start=-2, stop=0.5, include_ends=False)
self.assertTrue(np.array_equal([0], res.samples))
self.assertTrue(
np.array_equal(np.array([0], dtype='<f8'), res.timestamps))
res = s.cut(start=-2, stop=1.1)
self.assertTrue(np.array_equal([0, 1, 1], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 1, 1.1], dtype='<f8'), res.timestamps))
res = s.cut(start=-2, stop=1.1, include_ends=False)
self.assertTrue(np.array_equal([0, 1], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 1], dtype='<f8'), res.timestamps))
res = s.cut(start=0, stop=1)
self.assertTrue(np.array_equal([0, 1], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 1], dtype='<f8'), res.timestamps))
res = s.cut(start=0, stop=1, include_ends=False)
self.assertTrue(np.array_equal([0, 1], res.samples))
self.assertTrue(
np.array_equal(np.array([0, 1], dtype='<f8'), res.timestamps))
res = s.cut(start=0.1, stop=3.5)
self.assertTrue(np.array_equal([0, 1, 2, 3, 3], res.samples))
self.assertTrue(
np.array_equal(np.array([0.1, 1, 2, 3, 3.5], dtype='<f8'),
res.timestamps))
res = s.cut(start=0.1, stop=3.5, include_ends=False)
self.assertTrue(np.array_equal([1, 2, 3], res.samples))
self.assertTrue(
np.array_equal(np.array([1, 2, 3], dtype='<f8'), res.timestamps))
res = s.cut(start=1.1, stop=1.9)
self.assertTrue(np.array_equal([1, 1], res.samples))
self.assertTrue(
np.array_equal(np.array([1.1, 1.9], dtype='<f8'), res.timestamps))
res = s.cut(start=1.1, stop=1.9, include_ends=False)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
res = s.cut(start=3.5, stop=4.5)
self.assertTrue(np.array_equal([3, 4], res.samples))
self.assertTrue(
np.array_equal(np.array([3.5, 4], dtype='<f8'), res.timestamps))
res = s.cut(start=3.5, stop=4.5, include_ends=False)
self.assertTrue(np.array_equal([4], res.samples))
self.assertTrue(
np.array_equal(np.array([4], dtype='<f8'), res.timestamps))
res = s.cut(start=4, stop=4.5)
self.assertTrue(np.array_equal([4], res.samples))
self.assertTrue(
np.array_equal(np.array([4], dtype='<f8'), res.timestamps))
res = s.cut(start=4, stop=4.5, include_ends=False)
self.assertTrue(np.array_equal([4], res.samples))
self.assertTrue(
np.array_equal(np.array([4], dtype='<f8'), res.timestamps))
res = s.cut(start=4.1, stop=4.2)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
res = s.cut(start=4.1, stop=4.2, include_ends=False)
self.assertTrue(np.array_equal([], res.samples))
self.assertTrue(
np.array_equal(np.array([], dtype='<f8'), res.timestamps))
def test_overlapping_channels_mdf_v4(self):
t = np.arange(15, dtype="<f8")
s1 = Signal(
np.frombuffer(b"\x00\x00\x3F\x02\x04\xF8\x00\x00" * 15,
dtype="<u8"),
t,
name="Parent",
)
s2 = Signal(
np.frombuffer(b"\x04\xF8\x00\x00" * 15, dtype="<u4"),
t,
name="OverlappingMotorola",
)
s3 = Signal(
np.frombuffer(b"\x04\x00\x00\x00" * 15, dtype="<u4"),
t,
name="OverlappingIntel",
)
with MDF(version="4.11") as mdf_source:
mdf_source.append([s1, s2, s3], common_timebase=True)
for parent_data_type in (
v4c.DATA_TYPE_REAL_MOTOROLA,
v4c.DATA_TYPE_SIGNED_MOTOROLA,
v4c.DATA_TYPE_UNSIGNED_MOTOROLA,
v4c.DATA_TYPE_REAL_INTEL,
v4c.DATA_TYPE_SIGNED_INTEL,
v4c.DATA_TYPE_UNSIGNED_INTEL,
):
parent = mdf_source.groups[0].channels[1]
parent.data_type = parent_data_type
ch3 = mdf_source.groups[0].channels[2]
ch3.byte_offset = 3 + t.itemsize
ch3.data_type = v4c.DATA_TYPE_UNSIGNED_MOTOROLA
ch3.bit_count = 16
ch3.bit_offset = 0
ch4 = mdf_source.groups[0].channels[3]
ch4.byte_offset = 3 + t.itemsize
ch4.data_type = v4c.DATA_TYPE_UNSIGNED_INTEL
ch4.bit_count = 16
ch4.bit_offset = 0
outfile = mdf_source.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get("OverlappingMotorola").samples, [
0x0204,
] * 15))
self.assertTrue(
np.array_equal(
mdf.get("OverlappingIntel").samples, [
0x0402,
] * 15))
ch3 = mdf_source.groups[0].channels[2]
ch3.byte_offset = 2 + t.itemsize
ch3.data_type = v4c.DATA_TYPE_UNSIGNED_MOTOROLA
ch3.bit_count = 24
ch3.bit_offset = 0
ch4 = mdf_source.groups[0].channels[3]
ch4.byte_offset = 2 + t.itemsize
ch4.data_type = v4c.DATA_TYPE_UNSIGNED_INTEL
ch4.bit_count = 24
ch4.bit_offset = 0
outfile = mdf_source.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get("OverlappingMotorola").samples, [
0x3F0204,
] * 15))
self.assertTrue(
np.array_equal(
mdf.get("OverlappingIntel").samples, [
0x04023F,
] * 15))
ch3 = mdf_source.groups[0].channels[2]
ch3.byte_offset = 2 + t.itemsize
ch3.data_type = v4c.DATA_TYPE_UNSIGNED_MOTOROLA
ch3.bit_count = 21
ch3.bit_offset = 5
ch4 = mdf_source.groups[0].channels[3]
ch4.byte_offset = 2 + t.itemsize
ch4.data_type = v4c.DATA_TYPE_UNSIGNED_INTEL
ch4.bit_count = 21
ch4.bit_offset = 6
outfile = mdf_source.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get("OverlappingMotorola").samples,
[
(0x3F0204F8 >> 5) & (2**21 - 1),
] * 15,
))
self.assertTrue(
np.array_equal(
mdf.get("OverlappingIntel").samples,
[
(0xF8040200 >> 6) & (2**21 - 1),
] * 15,
))
ch3 = mdf_source.groups[0].channels[2]
ch3.byte_offset = 3 + t.itemsize
ch3.data_type = v4c.DATA_TYPE_UNSIGNED_MOTOROLA
ch3.bit_count = 2
ch3.bit_offset = 1
ch4 = mdf_source.groups[0].channels[3]
ch4.byte_offset = 3 + t.itemsize
ch4.data_type = v4c.DATA_TYPE_UNSIGNED_INTEL
ch4.bit_count = 2
ch4.bit_offset = 1
outfile = mdf_source.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get("OverlappingMotorola").samples,
[0x1] * 15))
self.assertTrue(
np.array_equal(
mdf.get("OverlappingIntel").samples, [0x1] * 15))
def generate_test_files(version="4.10"):
cycles = 3000
channels_count = 2000
mdf = MDF(version=version)
if version <= "3.30":
filename = r"test.mdf"
else:
filename = r"test.mf4"
if os.path.exists(filename):
return filename
t = np.arange(cycles, dtype=np.float64)
cls = v4b.ChannelConversion if version >= "4.00" else v3b.ChannelConversion
# no conversion
sigs = []
for i in range(channels_count):
sig = Signal(
np.ones(cycles, dtype=np.uint64) * i,
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=None,
comment="Unsigned int 16bit channel {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# linear
sigs = []
for i in range(channels_count):
conversion = {
"conversion_type":
v4c.CONVERSION_TYPE_LIN
if version >= "4.00" else v3c.CONVERSION_TYPE_LINEAR,
"a":
float(i),
"b":
-0.5,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=cls(**conversion),
comment="Signed 16bit channel {} with linear conversion".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# algebraic
sigs = []
for i in range(channels_count):
conversion = {
"conversion_type":
v4c.CONVERSION_TYPE_ALG
if version >= "4.00" else v3c.CONVERSION_TYPE_FORMULA,
"formula":
"{} * sin(X)".format(i),
}
sig = Signal(
np.arange(cycles, dtype=np.int32) / 100.0,
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=cls(**conversion),
comment="Sinus channel {} with algebraic conversion".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# rational
sigs = []
for i in range(channels_count):
conversion = {
"conversion_type":
v4c.CONVERSION_TYPE_RAT
if version >= "4.00" else v3c.CONVERSION_TYPE_RAT,
"P1":
0,
"P2":
i,
"P3":
-0.5,
"P4":
0,
"P5":
0,
"P6":
1,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=cls(**conversion),
comment="Channel {} with rational conversion".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# string
sigs = []
for i in range(channels_count):
sig = [
"Channel {} sample {}".format(i, j).encode("ascii")
for j in range(cycles)
]
sig = Signal(
np.array(sig),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
comment="String channel {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# byte array
sigs = []
ones = np.ones(cycles, dtype=np.dtype("(8,)u1"))
for i in range(channels_count):
sig = Signal(
ones * (i % 255),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
comment="Byte array channel {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# value to text
sigs = []
ones = np.ones(cycles, dtype=np.uint64)
conversion = {
"raw":
np.arange(255, dtype=np.float64),
"phys":
np.array(["Value {}".format(i).encode("ascii") for i in range(255)]),
"conversion_type":
v4c.CONVERSION_TYPE_TABX
if version >= "4.00" else v3c.CONVERSION_TYPE_TABX,
"links_nr":
260,
"ref_param_nr":
255,
}
for i in range(255):
conversion["val_{}".format(i)] = conversion["param_val_{}".format(
i)] = conversion["raw"][i]
conversion["text_{}".format(i)] = conversion["phys"][i]
conversion["text_{}".format(255)] = "Default"
for i in range(channels_count):
sig = Signal(
ones * i,
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
comment="Value to text channel {}".format(i),
conversion=cls(**conversion),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
mdf.save(filename, overwrite=True)
def test_not_aligned_mdf_v3(self):
t = np.arange(15, dtype="<f8")
s1 = Signal(np.frombuffer(b"\x00\x00\x3F\x02" * 15, dtype=">u4"),
t,
name="Motorola")
s2 = Signal(np.frombuffer(b"\x04\xF8\x00\x00" * 15, dtype="<u4"),
t,
name="Intel")
s3 = Signal(
np.frombuffer(b"\xBB\x55" * 2 * 15, dtype="<u4"),
t,
name="NotAlignedMotorola",
)
s4 = Signal(np.frombuffer(b"\xBB\x55" * 2 * 15, dtype="<u4"),
t,
name="NotAlignedIntel")
with MDF(version="3.30") as mdf_source:
mdf_source.append([s1, s2, s3, s4], common_timebase=True)
ch3 = mdf_source.groups[0].channels[3]
ch3.start_offset = 24 + t.itemsize * 8
ch3.data_type = v23c.DATA_TYPE_UNSIGNED_MOTOROLA
ch3.bit_count = 16
ch4 = mdf_source.groups[0].channels[4]
ch4.start_offset = 24 + t.itemsize * 8
ch4.data_type = v23c.DATA_TYPE_UNSIGNED_INTEL
ch4.bit_count = 16
outfile = mdf_source.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get("NotAlignedMotorola").samples, [
0x0204,
] * 15))
self.assertTrue(
np.array_equal(
mdf.get("NotAlignedIntel").samples, [
0x0402,
] * 15))
ch3 = mdf_source.groups[0].channels[3]
ch3.start_offset = 16 + t.itemsize * 8
ch3.data_type = v23c.DATA_TYPE_UNSIGNED_MOTOROLA
ch3.bit_count = 24
ch4 = mdf_source.groups[0].channels[4]
ch4.start_offset = 16 + t.itemsize * 8
ch4.data_type = v23c.DATA_TYPE_UNSIGNED_INTEL
ch4.bit_count = 24
outfile = mdf_source.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get("NotAlignedMotorola").samples, [
0x3F0204,
] * 15))
self.assertTrue(
np.array_equal(
mdf.get("NotAlignedIntel").samples, [
0x04023F,
] * 15))
ch3 = mdf_source.groups[0].channels[3]
ch3.start_offset = 16 + t.itemsize * 8 + 5
ch3.data_type = v23c.DATA_TYPE_UNSIGNED_MOTOROLA
ch3.bit_count = 21
ch4 = mdf_source.groups[0].channels[4]
ch4.start_offset = 16 + t.itemsize * 8 + 6
ch4.data_type = v23c.DATA_TYPE_UNSIGNED_INTEL
ch4.bit_count = 21
outfile = mdf_source.save(
Path(TestEndianess.tempdir.name) / f"out",
overwrite=True,
)
with MDF(outfile) as mdf:
self.assertTrue(
np.array_equal(
mdf.get("NotAlignedMotorola").samples,
[
(0x3F0204F8 >> 5) & (2**21 - 1),
] * 15,
))
self.assertTrue(
np.array_equal(
mdf.get("NotAlignedIntel").samples,
[
(0xF8040200 >> 6) & (2**21 - 1),
] * 15,
))
from asammdf import MDF, SUPPORTED_VERSIONS, Signal
import numpy as np
cycles = 100
sigs = []
mdf = MDF()
t = np.arange(cycles, dtype=np.float64)
# no conversion
sig = Signal(
np.ones(cycles, dtype=np.uint64),
t,
name='Channel_no_conversion',
unit='s',
conversion=None,
comment='Unsigned 64 bit channel {}',
)
sigs.append(sig)
# linear
conversion = {
'a': 2,
'b': -0.5,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name='Channel_linear_conversion',
unit='Nm',
def test_init_empty(self):
s = Signal([], [], name='s')
self.assertEqual(len(s), 0)
