def test_derived_quantity_sum(exp, convert_name):
fudge_data_1 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [0.5, 0.6, 0.7]
})
fudge_data_2 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [1, 1.2, 1.4]
})
name_1 = convert_name('TEST1~wavelength-1~replicate-0')
name_2 = convert_name('TEST1~wavelength-1~replicate-1')
group_name = convert_name('TEST1~wavelength-1')
desired_quantities = {group_name: 11.400000000000002 * ureg.pC}
data_dict = {name_1: fudge_data_1, name_2: fudge_data_2}
def charge(data, cond):
charges = data['Photocurrent (nA)'].values* \
data['Time (ms)'].values*ureg.nA*ureg.ms
total_charge = charges.sum().to(ureg.pC)
return total_charge
actual_quantities = exp.derived_quantity(data_dict=data_dict,
quantity_func=charge,
sum_along='replicate')
assertDataDictEqual(actual_quantities, desired_quantities)
def testExtractDerivedQuantityPSD(exp, convert_name):
"""
Attempts to extract the PSD from a set of data
"""
fudge_data_1 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [0.5, 0.6, 0.7]
})
fudge_data_2 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [1, 1.2, 1.4]
})
name_1 = convert_name('TEST1~wavelength-1~replicate-0')
name_2 = convert_name('TEST1~wavelength-1~replicate-1')
data_dict = {name_1: fudge_data_1, name_2: fudge_data_2}
def powerSpectrum(data, cond):
return power_spectrum(data)
actual_psd_data = exp.derived_quantity(data_dict=data_dict,
quantity_func=powerSpectrum)
desired_psd_data = {
name_1: power_spectrum(fudge_data_1),
name_2: power_spectrum(fudge_data_2)
}
assertDataDictEqual(actual_psd_data, desired_psd_data)
def test_master_data_dict_exclude_c(exp, exp_data, convert_name):
names = [convert_name(name) for name in \
[
'TEST1~temperature=25.0~wavelength=1',
'TEST1~temperature=25.0~wavelength=2',
'TEST1~temperature=35.0~wavelength=1',
'TEST1~temperature=35.0~wavelength=2',
]]
data_dict = {
names[0]: 1.0,
names[1]: 2.0,
names[2]: 3.0,
names[3]: 4.0,
}
desired_data = {
convert_name('TEST1~temperature=c~wavelength=x'): {
convert_name('TEST1~temperature=25.0~wavelength=x'):
pd.DataFrame({
'wavelength': [1, 2],
'Value': [1.0, 2.0]
}),
convert_name('TEST1~temperature=35.0~wavelength=x'):
pd.DataFrame({
'wavelength': [1, 2],
'Value': [3.0, 4.0]
}),
},
}
actual_data = exp.master_data_dict(data_dict,
c_axis_exclude=['wavelength'])
assertDataDictEqual(actual_data, desired_data)
def testExtractDerivedQuantityMean(exp, convert_name):
"""
Attempst to extract the mean from a set of data
"""
fudge_data_1 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [0.5, 0.6, 0.7]
})
fudge_data_2 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [1, 1.2, 1.4]
})
mean_data_1 = np.float64(0.6)
mean_data_2 = np.float64(1.2)
name_1 = convert_name('TEST1~wavelength-1~replicate-0')
name_2 = convert_name('TEST1~wavelength-1~replicate-1')
desired_quantities = {name_1: mean_data_1, name_2: mean_data_2}
data_dict = {name_1: fudge_data_1, name_2: fudge_data_2}
def getPhotocurrentMean(pandas_dict, cond):
return np.mean(pandas_dict['Photocurrent (nA)'].values)
actual_quantities = exp.derived_quantity(data_dict=data_dict,
quantity_func=getPhotocurrentMean,
average_along=None)
assertDataDictEqual(actual_quantities, desired_quantities)
def testExtractDerivedQuantityPSDAverage(exp, convert_name):
fudge_data_1 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [0.5, 0.6, 0.7]
})
fudge_data_2 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [1, 1.2, 1.4]
})
name_1 = convert_name('TEST1~wavelength-1~replicate-0')
name_2 = convert_name('TEST1~wavelength-1~replicate-1')
data_dict = {name_1: fudge_data_1, name_2: fudge_data_2}
data_psd_1 = power_spectrum(fudge_data_1)
data_psd_2 = power_spectrum(fudge_data_2)
data_psd_1.iloc[:, 1:] += data_psd_2.iloc[:, 1:]
data_psd_1.iloc[:, 1:] /= 2
def powerSpectrum(data, cond):
return power_spectrum(data)
desired_psd = data_psd_1
desired_data_dict = {convert_name('TEST1~wavelength-1'): desired_psd}
actual_data_dict = exp.derived_quantity(data_dict=data_dict,
quantity_func=powerSpectrum,
average_along='replicate')
assertDataDictEqual(actual_data_dict, desired_data_dict)
def test_average_data_pandas(exp, convert_name):
fudge_data_1 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [0.5, 0.6, 0.7]
})
fudge_data_2 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [1, 1.2, 1.4]
})
averaged_data = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [0.75, 0.9, 1.05]
})
condition_1 = {'frequency': 8500, 'wavelength': 1, 'replicate': 0}
condition_2 = {'frequency': 8500, 'wavelength': 1, 'replicate': 1}
name_1 = convert_name('TEST1~wavelength-1~replicate-0')
name_2 = convert_name('TEST1~wavelength-1~replicate-1')
group_name = convert_name('TEST1~wavelength-1')
data_dict = {name_1: fudge_data_1, name_2: fudge_data_2}
averaged_data_desired = {group_name: averaged_data}
averaged_data_actual_first = exp.average_data(data_dict,
average_along='replicate',
averaging_type='first')
averaged_data_actual_last = exp.average_data(data_dict,
average_along='replicate',
averaging_type='last')
assertDataDictEqual(averaged_data_actual_first, averaged_data_desired)
assertDataDictEqual(averaged_data_actual_last, averaged_data_desired)
def test_data_from_master(exp, exp_data):
js, ns = exp_data['major_separator'], exp_data['minor_separator']
master_data = pd.DataFrame({'wavelength': [1, 2], 'Value': [3, 4]})
name1 = 'TEST1' + js + 'wavelength' + ns + '1'
name2 = 'TEST1' + js + 'wavelength' + ns + '2'
desired_data = {name1: 3, name2: 4}
actual_data = exp.data_from_master(master_data)
assertDataDictEqual(actual_data, desired_data)
def test_group_by_value(exp, convert_name):
actual_data = exp['exp'].group_data(
data_dict=exp['data_dict'], group_along='wavelength', grouping_type='value')
desired_data = {
convert_name('TEST1~wavelength-1'): {
convert_name('TEST1~wavelength-1~replicate-0'): exp['fudge_data_1'],
convert_name('TEST1~wavelength-1~replicate-1'): exp['fudge_data_2'],}}
assertDataDictEqual(actual_data, desired_data)
def test_group_data_none(exp):
"""
Assert that when group_along is none we just pass through the data
"""
desired_data = exp['data_dict']
actual_data = exp['exp'].group_data(
data_dict=exp['data_dict'], group_along=None)
assertDataDictEqual(actual_data, desired_data)
def test_condition_from_name_units(exp,exp_data, convert_name):
name = convert_name('TEST1~wavelength=100nm~temperature=25K')
desired_condition = {
'wavelength': ureg.nm * 100,
'temperature': ureg.degK * 25,
'frequency': exp_data['frequency']}
actual_condition = exp.conditionFromName(name)
assertDataDictEqual(actual_condition, desired_condition)
def test_generate_groups_value(exp, convert_name):
desired_groups = {
convert_name('TEST1~replicate-0'): {
convert_name('TEST1~wavelength-1~replicate-0'): None},
convert_name('TEST1~replicate-1'): {
convert_name('TEST1~wavelength-1~replicate-1'): None}}
actual_groups = exp['exp'].generate_groups(
data_dict=exp['data_dict'], group_along='replicate', grouping_type='value')
assertDataDictEqual(actual_groups, desired_groups)
def test_data_from_master_units(exp_units, convert_name):
desired_name = convert_name('TEST1~temperature=305K~wavelength=25nm')
master_data = pd.DataFrame({
'temperature (K)': [305],
'wavelength (nm)': [25],
'voltage (mV)': [1.5]
})
desired_data = {desired_name: 1.5 * ureg.mV}
actual_data = exp_units.data_from_master(master_data)
assertDataDictEqual(actual_data, desired_data)
def test_group_by_name(exp, convert_name):
actual_data = exp['exp'].group_data(
data_dict=exp['data_dict'], group_along='replicate', grouping_type='name')
desired_data = {
convert_name('TEST1~wavelength-1'): {
convert_name('TEST1~wavelength-1~replicate-0'): exp['fudge_data_1'],
convert_name('TEST1~wavelength-1~replicate-1'): exp['fudge_data_2']}}
# Assert all values inside the pandas array are identical
assertDataDictEqual(actual_data, desired_data)
def testGenerateGroups(exp, convert_name):
desired_groups = {convert_name('TEST1~wavelength-1'): {
convert_name('TEST1~wavelength-1~replicate-0'): None,
convert_name('TEST1~wavelength-1~replicate-1'): None,
}}
actual_groups = exp['exp'].generate_groups(
data_dict=exp['data_dict'], group_along='replicate')
assertDataDictEqual(actual_groups, desired_groups)
def testGenerateMasterDataDict1Var(exp, exp_data):
js, ns = exp_data['major_separator'], exp_data['minor_separator']
name1 = 'TEST1' + js + 'wavelength' + ns + '1'
name2 = 'TEST1' + js + 'wavelength' + ns + '2'
name_all = 'TEST1' + js + 'wavelength' + ns + 'all'
data_dict = {name1: 3.0, name2: 4.0}
desired_data = {
name_all: pd.DataFrame({
'wavelength': [1, 2],
'Value': [3.0, 4.0]
})
}
actual_data = exp.master_data_dict(data_dict)
assertDataDictEqual(actual_data, desired_data)
def test_master_data_dict_1var_units(exp_units, convert_name):
name1 = convert_name('TEST1~wavelength=1nm')
name2 = convert_name('TEST1~wavelength=2nm')
name_all = convert_name('TEST1~wavelength=all')
data_dict = {name1: 3.0 * ureg.nA, name2: 4.0 * ureg.nA}
desired_data = {
name_all:
pd.DataFrame({
'wavelength (nm)': [1, 2],
'current (nA)': [3.0, 4.0]
})
}
actual_data = exp_units.master_data_dict(data_dict)
assertDataDictEqual(actual_data, desired_data)
def test_master_data_dict_2var(exp, exp_data, convert_name):
js, ns = exp_data['major_separator'], exp_data['minor_separator']
master_data = pd.DataFrame({
'wavelength': [0, 1, 2, 0, 1, 2],
'temperature': [25.0, 25.0, 25.0, 35.0, 35.0, 35.0],
'Value': [0, 1, 2, 3, 4, 5]
})
names = [
convert_name('TEST1~temperature=25.0~wavelength=0'),
convert_name('TEST1~temperature=25.0~wavelength=1'),
convert_name('TEST1~temperature=25.0~wavelength=2'),
convert_name('TEST1~temperature=35.0~wavelength=0'),
convert_name('TEST1~temperature=35.0~wavelength=1'),
convert_name('TEST1~temperature=35.0~wavelength=2'),
]
data_dict = {name: i for i, name in enumerate(names)}
desired_data = {
convert_name('TEST1~temperature=x~wavelength=c'): {
convert_name('TEST1~temperature=x~wavelength=0'):
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [0, 3]
}),
convert_name('TEST1~temperature=x~wavelength=1'):
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [1, 4]
}),
convert_name('TEST1~temperature=x~wavelength=2'):
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [2, 5]
})
},
convert_name('TEST1~temperature=c~wavelength=x'): {
convert_name('TEST1~temperature=25.0~wavelength=x'):
pd.DataFrame({
'wavelength': [0, 1, 2],
'Value': [0, 1, 2]
}),
convert_name('TEST1~temperature=35.0~wavelength=x'):
pd.DataFrame({
'wavelength': [0, 1, 2],
'Value': [3, 4, 5]
})
},
}
actual_data = exp.master_data_dict(data_dict)
assertDataDictEqual(actual_data, desired_data)
def testLookup(exp, convert_name):
fudge_data = pd.DataFrame(
{'Time (ms)': [1, 2, 3],
'Voltage (V)': [0,0.1, 0.2]})
exp.data = {
convert_name('TEST1~wavelengths-1~temperatures-25'):fudge_data,
convert_name('TEST1~wavelengths-2~temperatures-25'):fudge_data,
convert_name('TEST1~wavelengths-2~temperatures-35'):fudge_data,
convert_name('TEST1~wavelengths-2~temperatures-35'):fudge_data,
}
data_actual = exp.lookup(temperatures=25)
data_desired = {
convert_name('TEST1~wavelengths-1~temperatures-25'):fudge_data,
convert_name('TEST1~wavelengths-2~temperatures-25'):fudge_data,}
assertDataDictEqual(data_actual, data_desired)
def test_units_init(ureg):
wavelength = ureg.nm * np.array([500, 505])
temperature = ureg.degK * np.array([25.0, 35.0])
sampling_frequency = ureg.Hz * 1.0
my_exp = Experiment(kind='test',
name='TEST1',
wavelength=wavelength,
temperature=temperature,
sampling_frequency=sampling_frequency)
desired_factors = {'wavelength': wavelength, 'temperature': temperature}
desired_constants = {'sampling_frequency': sampling_frequency}
actual_factors = my_exp.factors
actual_constants = my_exp.constants
assertDataDictEqual(actual_factors, desired_factors)
assertDataDictEqual(actual_constants, desired_constants)
def test_average_data_scalar(exp, convert_name):
fudge_data_1 = 2.0
fudge_data_2 = 3.0
averaged_data = 2.5
condition_1 = {'frequency': 8500, 'wavelength': 1, 'replicate': 0}
condition_2 = {'frequency': 8500, 'wavelength': 1, 'replicate': 1}
name_1 = convert_name('TEST1~wavelength-1~replicate-0')
name_2 = convert_name('TEST1~wavelength-1~replicate-1')
data_dict = {name_1: fudge_data_1, name_2: fudge_data_2}
group_name = convert_name('TEST1~wavelength-1')
averaged_data_desired = {group_name: averaged_data}
averaged_data_actual = exp.average_data(data_dict,
average_along='replicate')
assertDataDictEqual(averaged_data_actual, averaged_data_desired)
def test_group_scalar_data(exp, convert_name):
"""
Tests whether we can compress the derived quantity as a bunch of
scalar-only dicts into a bunch of plottable and usaable pandas array.
"""
scalar_data = {convert_name('TEST1~wavelength-1~temperature-25'): 1,
convert_name('TEST1~wavelength-1~temperature-35'): 2}
desired_data = {convert_name('TEST1~wavelength-1'): {
convert_name('TEST1~wavelength-1~temperature-25'): 1,
convert_name('TEST1~wavelength-1~temperature-35'): 2,}}
actual_data = exp['exp'].group_data(
data_dict=scalar_data, group_along='temperature')
assertDataDictEqual(actual_data, desired_data)
def test_data_from_master_2var(exp, exp_data, convert_name):
master_data = pd.DataFrame({
'temperature': [25.0, 25.0, 25.0, 35.0, 35.0, 35.0],
'wavelength': [0, 1, 2, 0, 1, 2],
'Value': [0, 1, 2, 3, 4, 5]
})
names = [
convert_name('TEST1~temperature=25.0~wavelength=0'),
convert_name('TEST1~temperature=25.0~wavelength=1'),
convert_name('TEST1~temperature=25.0~wavelength=2'),
convert_name('TEST1~temperature=35.0~wavelength=0'),
convert_name('TEST1~temperature=35.0~wavelength=1'),
convert_name('TEST1~temperature=35.0~wavelength=2'),
]
desired_data_dict = {name: i for i, name in enumerate(names)}
actual_data_dict = exp.data_from_master(master_data)
assertDataDictEqual(actual_data_dict, desired_data_dict)
def testExecuteExperimentDataCorrect(exp, exp_data, convert_name):
exp.Execute()
desired_data = {
convert_name('TEST1~replicate=0~temperature=25~wavelength=1'):
exp_data['fake_data'],
convert_name('TEST1~replicate=1~temperature=25~wavelength=1'):
exp_data['fake_data'],
convert_name('TEST1~replicate=0~temperature=50~wavelength=1'):
exp_data['fake_data'],
convert_name('TEST1~replicate=1~temperature=50~wavelength=1'):
exp_data['fake_data'],
convert_name('TEST1~replicate=0~temperature=25~wavelength=2'):
exp_data['fake_data'],
convert_name('TEST1~replicate=1~temperature=25~wavelength=2'):
exp_data['fake_data'],
convert_name('TEST1~replicate=0~temperature=50~wavelength=2'):
exp_data['fake_data'],
convert_name('TEST1~replicate=1~temperature=50~wavelength=2'):
exp_data['fake_data'],
}
actual_data = exp.data
assertDataDictEqual(actual_data, desired_data)
def test_sum_data_pandas(exp, convert_name):
fudge_data_1 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [0.5, 0.6, 0.7]
})
fudge_data_2 = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [1, 1.2, 1.4]
})
name_1 = convert_name('TEST1~wavelength-1~replicate-0')
name_2 = convert_name('TEST1~wavelength-1~replicate-1')
summed_data = pd.DataFrame({
'Time (ms)': [1, 2, 3],
'Photocurrent (nA)': [1.5, 1.8, 2.1]
})
data_dict = {name_1: fudge_data_1, name_2: fudge_data_2}
group_name = convert_name('TEST1~wavelength-1')
summed_data_desired = {group_name: summed_data}
summed_data_actual = exp.average_data(data_dict, sum_along='replicate')
assertDataDictEqual(summed_data_actual, summed_data_desired)
def test_process_photocurrent_simple(convert_name, sim_exp):
"""
Verifies that, given a sinusoidal input with a known offset and amplitude, the correct data is generated.
"""
wavelength = np.array([700, 750]) * ureg.nm
material = ['Au', 'Al']
gain = 1 * ureg.Mohm
current_offset = 100
current_amplitude = 1
dR_R0_ratio = current_amplitude / current_offset
reference_condition = dict(material='Au')
# Ensures no spectral leakage for simple test case
sin_data = pd.DataFrame({
'Time (ms)': np.array([0, 1, 2, 3, 4, 5, 6, 7]),
'Voltage (mV)': current_offset + \
current_amplitude * np.array([0, -1, 0, 1, 0, -1, 0, 1]),
'Sync': np.array([1, 0, 0, 0, 1, 0, 0, 0]),
})
test_data = {
convert_name('TEST1~material=Au~wavelength=700nm'): sin_data,
convert_name('TEST1~material=Al~wavelength=700nm'): sin_data,
convert_name('TEST1~material=Au~wavelength=750nm'): sin_data,
convert_name('TEST1~material=Al~wavelength=750nm'): sin_data,
}
exp = Experiment(name='TEST1',
kind='test',
wavelength=wavelength,
material=material,
gain=gain)
exp.data = test_data
R0_actual, dR_actual, inoise_actual = exp.process_photocurrent(
reference_condition=reference_condition, sim_exp=sim_exp)
R0_desired = {
convert_name('TEST1~material=Au~wavelength=700nm~spectra=R0'): 0.93329,
convert_name('TEST1~material=Al~wavelength=700nm~spectra=R0'): 0.93329,
convert_name('TEST1~material=Au~wavelength=750nm~spectra=R0'):
0.948615,
convert_name('TEST1~material=Al~wavelength=750nm~spectra=R0'):
0.948615,
}
dR_desired = {
convert_name('TEST1~material=Au~wavelength=700nm~spectra=dR'): \
0.93329 * dR_R0_ratio,
convert_name('TEST1~material=Al~wavelength=700nm~spectra=dR'): \
0.93329 * dR_R0_ratio,
convert_name('TEST1~material=Au~wavelength=750nm~spectra=dR'): \
0.948615 * dR_R0_ratio,
convert_name('TEST1~material=Al~wavelength=750nm~spectra=dR'): \
0.948615 * dR_R0_ratio,
}
inoise_desired = {
convert_name('TEST1~material=Au~wavelength=700nm'): \
1.3333333333333333e-21 * ureg.A ** 2 / ureg.Hz,
convert_name('TEST1~material=Al~wavelength=700nm'): \
1.3333333333333333e-21 * ureg.A ** 2 / ureg.Hz,
convert_name('TEST1~material=Au~wavelength=750nm'): \
1.3333333333333333e-21 * ureg.A ** 2 / ureg.Hz,
convert_name('TEST1~material=Al~wavelength=750nm'): \
1.3333333333333333e-21 * ureg.A ** 2 / ureg.Hz,
}
assertDataDictEqual(R0_actual, R0_desired)
assertDataDictEqual(dR_actual, dR_desired)
assertDataDictEqual(inoise_actual, inoise_desired)
def testGenerateGroupsNone(exp):
desired_groups = exp['data_dict']
actual_groups = exp['exp'].generate_groups(
data_dict=exp['data_dict'], group_along=None)
assertDataDictEqual(actual_groups, desired_groups)
def test_master_data_dict_3var(exp, exp_data, convert_name):
master_data = pd.DataFrame({
'wavelength': [0, 0, 0, 0, 1, 1, 1, 1],
'temperature': [25.0, 25.0, 35.0, 35.0, 25.0, 25.0, 35.0, 35.0],
'material': ['Au', 'Al', 'Au', 'Al', 'Au', 'Al', 'Au', 'Al'],
'Value': [0, 1, 2, 3, 4, 5, 6, 7]
})
names = [
convert_name('TEST1~material=Au~temperature=25.0~wavelength=0'),
convert_name('TEST1~material=Al~temperature=25.0~wavelength=0'),
convert_name('TEST1~material=Au~temperature=35.0~wavelength=0'),
convert_name('TEST1~material=Al~temperature=35.0~wavelength=0'),
convert_name('TEST1~material=Au~temperature=25.0~wavelength=1'),
convert_name('TEST1~material=Al~temperature=25.0~wavelength=1'),
convert_name('TEST1~material=Au~temperature=35.0~wavelength=1'),
convert_name('TEST1~material=Al~temperature=35.0~wavelength=1'),
]
data_dict = {name: i for i, name in enumerate(names)}
desired_data = \
{
'TEST1~material=x~temperature=c~wavelength=0':
{'TEST1~material=x~temperature=25.0~wavelength=0':
pd.DataFrame({
'material': ['Al', 'Au'],
'Value': [1, 0]}),
'TEST1~material=x~temperature=35.0~wavelength=0':
pd.DataFrame({
'material': ['Al', 'Au'],
'Value': [3, 2]}),
},
'TEST1~material=x~temperature=c~wavelength=1':
{'TEST1~material=x~temperature=25.0~wavelength=1':
pd.DataFrame({
'material': ['Al', 'Au'],
'Value': [5, 4]}),
'TEST1~material=x~temperature=35.0~wavelength=1':
pd.DataFrame({
'material': ['Al', 'Au'],
'Value': [7, 6]}),
},
'TEST1~material=x~temperature=25.0~wavelength=c':
{'TEST1~material=x~temperature=25.0~wavelength=0':
pd.DataFrame({
'material': ['Al', 'Au'],
'Value': [1, 0]}),
'TEST1~material=x~temperature=25.0~wavelength=1':
pd.DataFrame({
'material': ['Al', 'Au'],
'Value': [5, 4]}),
},
'TEST1~material=x~temperature=35.0~wavelength=c':
{'TEST1~material=x~temperature=35.0~wavelength=0':
pd.DataFrame({
'material': ['Al', 'Au'],
'Value': [3, 2]}),
'TEST1~material=x~temperature=35.0~wavelength=1':
pd.DataFrame({
'material': ['Al', 'Au'],
'Value': [7, 6]}),
},
'TEST1~material=c~temperature=x~wavelength=0':
{'TEST1~material=Au~temperature=x~wavelength=0':
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [0, 2]
}),
'TEST1~material=Al~temperature=x~wavelength=0':
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [1, 3]})
},
'TEST1~material=c~temperature=x~wavelength=1':
{'TEST1~material=Au~temperature=x~wavelength=1':
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [4, 6]}),
'TEST1~material=Al~temperature=x~wavelength=1':
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [5, 7]}),
},
'TEST1~material=Au~temperature=x~wavelength=c':
{'TEST1~material=Au~temperature=x~wavelength=0':
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [0, 2]
}),
'TEST1~material=Au~temperature=x~wavelength=1':
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [4, 6]})
},
'TEST1~material=Al~temperature=x~wavelength=c':
{'TEST1~material=Al~temperature=x~wavelength=0':
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [1, 3]}),
'TEST1~material=Al~temperature=x~wavelength=1':
pd.DataFrame({
'temperature': [25.0, 35.0],
'Value': [5, 7]}),
},
'TEST1~material=c~temperature=25.0~wavelength=x':
{'TEST1~material=Au~temperature=25.0~wavelength=x':
pd.DataFrame({
'wavelength': [0, 1],
'Value': [0, 4]}),
'TEST1~material=Al~temperature=25.0~wavelength=x':
pd.DataFrame({
'wavelength': [0, 1],
'Value': [1, 5]}),
},
'TEST1~material=c~temperature=35.0~wavelength=x':
{'TEST1~material=Au~temperature=35.0~wavelength=x':
pd.DataFrame({
'wavelength': [0, 1],
'Value': [2, 6]
}),
'TEST1~material=Al~temperature=35.0~wavelength=x':
pd.DataFrame({
'wavelength': [0, 1],
'Value': [3, 7]
}),
},
'TEST1~material=Au~temperature=c~wavelength=x':
{'TEST1~material=Au~temperature=25.0~wavelength=x':
pd.DataFrame({
'wavelength': [0, 1],
'Value': [0, 4]}),
'TEST1~material=Au~temperature=35.0~wavelength=x':
pd.DataFrame({
'wavelength': [0, 1],
'Value': [2, 6]}),
},
'TEST1~material=Al~temperature=c~wavelength=x':
{'TEST1~material=Al~temperature=25.0~wavelength=x':
pd.DataFrame({
'wavelength': [0, 1],
'Value': [1, 5]}),
'TEST1~material=Al~temperature=35.0~wavelength=x':
pd.DataFrame({
'wavelength': [0, 1],
'Value': [3, 7]}),
}
}
actual_data = exp.master_data_dict(data_dict)
assertDataDictEqual(actual_data, desired_data)
