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_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 save_mdf4(path, output, fmt):
os.chdir(path)
x = MDF(r'test.mf4')
with Timer('Save file',
'asammdf {} mdfv4'.format(asammdf_version),
fmt) as timer:
x.save(r'x.mf4', overwrite=True)
output.send([timer.output, timer.error])
def save_mdf3(path, output, fmt, memory):
os.chdir(path)
x = MDF(r'test.mdf', memory=memory)
with Timer('Save file',
'asammdf {} {} mdfv3'.format(asammdf_version,
memory), fmt) as timer:
x.save(r'x.mdf', overwrite=True)
output.send([timer.output, timer.error])
def save_mdf4_nodata(path, output, fmt):
os.chdir(path)
x = MDF(r'test.mf4', load_measured_data=False)
with Timer('Save file',
'asammdf {} nodata mdfv4'.format(asammdf_version),
fmt) as timer:
x.save(r'x.mf4', overwrite=True)
output.send([timer.output, timer.error])
def all_mdf3_nodata():
os.chdir(path)
with Timer('asammdf {} mdfv3 nodata'.format(asammdf_version)):
x = MDF(r'test.mdf', load_measured_data=False)
for i, gp in enumerate(x.groups):
for j in range(len(gp['channels'])):
y = x.get(group=i, index=j, samples_only=True)
x.save(r'x.mdf', overwrite=True)
def all_mdf4():
os.chdir(path)
with Timer('asammdf {} mdfv4'.format(asammdf_version)):
x = MDF(r'test.mf4')
for i, gp in enumerate(x.groups):
for j in range(len(gp['channels'])):
y = x.get(group=i, index=j, samples_only=True)
x.save(r'x.mf4', overwrite=True)
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_attachment_blocks_wo_filename(self):
original_data = b"Testing attachemnt block\nTest line 1"
mdf = MDF()
mdf.attach(
original_data,
file_name=None,
comment=None,
compression=True,
mime=r"text/plain",
embedded=True,
)
outfile = mdf.save(
Path(TestMDF4.tempdir.name) / "attachment.mf4", overwrite=True,
)
with MDF(outfile) as attachment_mdf:
data, filename, md5_sum = attachment_mdf.extract_attachment(index=0)
self.assertEqual(data, original_data)
self.assertEqual(filename, Path("bin.bin"))
mdf.close()
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 save_mdf3_compressed():
os.chdir(path)
x = MDF(r'test.mdf', compression=True)
with Timer('asammdf {} compression mdfv3'.format(asammdf_version)):
x.save(r'x.mdf')
def save_mdf3():
os.chdir(path)
x = MDF(r'test.mdf')
with Timer('asammdf {} mdfv3'.format(asammdf_version)):
x.save(r'x.mdf')
# 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')
# append the 3 signals to the new file
signals = [s_uint8, s_int32, s_float64]
mdf4.append(signals, 'Created by Python')
# save new file
mdf4.save('my_new_file.mf4', overwrite=True)
# convert new file to mdf version 3.10 with lowest possible RAM usage
mdf3 = mdf4.convert('3.10', memory='minimum')
print(mdf3.version)
# get the float signal
sig = mdf3.get('Float64_Signal')
print(sig)
# cut measurement from 0.3s to end of measurement
mdf4_cut = mdf4.cut(start=0.3)
mdf4_cut.get('Float64_Signal').plot()
# cut measurement from start of measurement to 0.4s
mdf4_cut = mdf4.cut(stop=0.45)
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)
l3_arr,
l3_arr,
]
types = [
("level21", l3_arr.dtype),
("level22", l3_arr.dtype),
]
l2_arr = np.core.records.fromarrays(l2_arr, dtype=types)
l1_arr = [
l2_arr,
]
types = [
("level11", l2_arr.dtype),
]
l1_arr = np.core.records.fromarrays(l1_arr, dtype=types)
sigs.append(Signal(
l1_arr,
t,
name="Nested_structures",
))
mdf.append(sigs, "arrays", common_timebase=True)
mdf.save("demo.mf4", overwrite=True)
def save_mdf4_nodata():
os.chdir(path)
x = MDF(r'test.mf4', load_measured_data=False)
with Timer('asammdf {} nodata mdfv4'.format(asammdf_version)):
x.save(r'x.mf4', overwrite=True)
def save_mdf4():
os.chdir(path)
x = MDF(r'test.mf4')
with Timer('asammdf {} mdfv4'.format(asammdf_version)):
x.save(r'x.mf4', overwrite=True)
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.int32),
timestamps=timestamps,
name='Float64_Signal',
unit='f8')
# create empty MDf version 4.00 file
mdf4 = MDF(version='4.00')
# append the 3 signals to the new file
signals = [s_uint8, s_int32, s_float64]
mdf4.append(signals, 'Created by Python')
# save new file
mdf4.save('my_new_file.mf4')
# convert new file to mdf version 3.10 with compression of raw channel data
mdf3 = mdf4.convert(to='3.10', compression=True)
print(mdf3.version)
# prints >>> 3.10
# get the float signal
sig = mdf3.get('Float64_Signal')
print(sig)
# prints >>> Signal { name="Float64_Signal": s=[-20 -10 0 10 20] t=[ 0.1 0.2 0.30000001 0.40000001 0.5 ] unit="f8" conversion=None }
