def test_modulated_photocurrent():
data_length = 1000
sampling_frequency = 1 * ureg.kHz
signal_frequency = 0.1 * ureg.kHz
sampling_period = (1 / sampling_frequency).to(ureg.s)
gain = 1.5 * ureg.Mohm
cond = {'gain': gain, 'sampling_frequency': 1 * ureg.kHz}
number_periods = int(
np.floor(data_length / (sampling_frequency / signal_frequency)))
number_sync_points = number_periods
indices = np.arange(0, number_sync_points, 1)
sync_indices = (1 / 2 * sampling_frequency / signal_frequency *
(1 + 2 * indices)).astype(np.int).magnitude
zero_column = np.zeros(data_length, dtype=np.int)
zero_column[sync_indices] = 1
times = np.arange(0, data_length, 1) * sampling_period
voltages = 0.5 * ureg.mV * np.sin(2 * np.pi * signal_frequency * times)
data = pd.DataFrame({
'time (ms)': times.to(ureg.ms).magnitude,
'voltage (mV)': voltages.to(ureg.mV).magnitude,
'Sync': zero_column
})
desired_data = (0.5 * ureg.mV / gain).to(ureg.pA)
actual_data = modulated_photocurrent(data, cond)
assert_allclose_qt(actual_data, desired_data)
def test_noise_current():
data_length = 10000
sampling_frequency = 10 * ureg.kHz
nyquist_frequency = sampling_frequency / 2
sampling_period = (1 / sampling_frequency).to(ureg.s)
noise_voltage = np.random.normal(size=data_length) * ureg.uV
filter_cutoff = 200 * ureg.Hz
times = np.arange(0, data_length, 1) * sampling_period
data = pd.DataFrame({
'Time (ms)': times.to(ureg.ms).magnitude,
'voltage (uV)': noise_voltage.to(ureg.uV).magnitude,
})
gain = 1.0 * ureg.Mohm
cond = {'gain': gain, 'filter_cutoff': filter_cutoff}
filter_correction_factor = (nyquist_frequency - filter_cutoff) / \
nyquist_frequency
desired_noise_current_psd = \
np.square(noise_voltage.std() / gain) / nyquist_frequency
desired_noise_current_psd = desired_noise_current_psd.to(ureg.A**2 /
ureg.Hz)
actual_noise_current_psd = noise_current(data, cond)
assert_allclose_qt(actual_noise_current_psd,
desired_noise_current_psd,
atol=1e-31,
rtol=5e-2)
def test_with_large_dc():
test_data = pd.DataFrame({
'time (ms)': [1, 2, 3, 4, 5, 6],
'val (V)': 10000 + np.array([1, 0, -1, 0, 1, 0]),
'Sync': [1, 0, 0, 0, 1, 0]
})
lia = LIA(test_data)
desired_amplitude = 1 * ureg.V / np.sqrt(2)
actual_amplitude = lia.extract_signal_amplitude(sync_phase_delay=np.pi / 2)
assert_allclose_qt(actual_amplitude, desired_amplitude, atol=1e-6)
def test_extract_minus_pi_2_offset():
test_data = pd.DataFrame({
'time (ms)': [1, 2, 3, 4, 5, 6, 7],
'val (V)': [1, 0, -1, 0, 1, 0, -1],
'Sync': [1, 0, 0, 0, 1, 0, 0]
})
lia = LIA(test_data)
desired_amplitude = 1 * ureg.V / np.sqrt(2)
actual_amplitude = lia.extract_signal_amplitude(sync_phase_delay=np.pi / 2)
assert_allclose_qt(actual_amplitude, desired_amplitude, atol=1e-6)
def test_extract_zero_with_offset():
test_data = pd.DataFrame({
'time (ms)': [0, 1, 2, 3, 4, 5, 6, 7],
'val (V)': [1, 1, 1, 1, 1, 1, 1, 1],
'Sync': [0, 0, 1, 0, 0, 0, 1, 0]
})
lia = LIA(test_data)
desired_amplitude = 0 * ureg.V
actual_amplitude = lia.extract_signal_amplitude(sync_phase_delay=np.pi)
assert_allclose_qt(actual_amplitude, desired_amplitude, atol=1e-6)
def test_dc_photocurrent():
gain = 10 * ureg.Mohm
input_data = pd.DataFrame({
'time (ms)': [0, 0.01, 0.02],
'voltage (uV)': [0.1, 0.2, 0.3]
})
desired_photocurrent = 2e-5 * ureg.nA
cond = {'gain': gain}
actual_photocurrent = dc_photocurrent(input_data, cond)
assert_allclose_qt(actual_photocurrent, desired_photocurrent)
def test_extract_power_noiseless_data_third_harmonic(real_data):
"""
"""
desired_power = 5e-19 * 1e-12 * (ureg.A**2)
frequency = 3 * 100 * ureg.Hz
actual_power = extract_power(real_data,
frequency,
siding='double',
window='hann')
assert_allclose_qt(actual_power, desired_power, atol=1e-32, rtol=1e-3)
def test_extract_power_double_sided_sinewave():
"""
"""
data = pd.DataFrame({'Time (s)': [0, 1, 2, 3], 'Value (A)': [0, 1, 0, -1]})
desired_power = 0.5 * ureg.A**2
frequency = 0.25 * ureg.Hz
actual_power = extract_power(data,
frequency,
siding='double',
window='boxcar')
assert_allclose_qt(actual_power, desired_power)
def test_extract_power_double_sided_with_leak_hann():
"""
"""
data = pd.DataFrame({
'Time (s)': [0, 1, 2, 3, 4],
'Value (A)': [1, -1, 1, -1, 1]
})
desired_power = 1 * ureg.A**2
frequency = 0.5 * ureg.Hz
actual_power = extract_power(data,
frequency,
siding='double',
window='hann')
assert_allclose_qt(actual_power, desired_power)
def test_extract_power_double_sided_no_leak_diff_units():
"""
"""
data = pd.DataFrame({
'Time (ms)': [0, 1, 2, 3],
'Value (A)': [1, -1, 1, -1]
})
desired_power = 1 * ureg.A**2
frequency = 0.5 * ureg.kHz
actual_power = extract_power(data,
frequency,
siding='double',
window='boxcar')
assert_allclose_qt(actual_power, desired_power)
def test_extract_amplitude_complex(data1):
actual_amplitude = data1['lia'].extract_signal_amplitude(
sync_phase_delay=data1['sync_phase_delay'])
desired_amplitude = 1 * ureg.V
assert_allclose_qt(actual_amplitude, desired_amplitude)
