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)