def test_extract_amplitude_super_complex(data):
actual_amplitude = \
data['lia'].extract_signal_amplitude(
modulation_frequency=105.4*ureg.Hz,
sync_phase_delay=data['sync_phase'])
desired_amplitude = 0.035890070877237404 * ureg.V
assert_equal_qt(actual_amplitude, desired_amplitude)
def test_current_range(keithley, timeout):
keithley['device'].mode = 'current'
keithley['device'].current = 1 * ureg.uA
keithley['device'].current_range = 1 * ureg.uA
desired_range = 1 * ureg.uA
actual_range = keithley['device'].current_range
assert_equal_qt(actual_range, desired_range)
def test_measure_current(keithley, timeout):
desired_voltage = 21 * ureg.V
keithley['device'].voltage_compliance = desired_voltage
keithley['device'].current = 10 * ureg.mA
actual_voltage, actual_current = keithley['device'].measure('current')
assert_equal_qt(actual_voltage, desired_voltage)
assert abs(actual_current) < 0.01 * ureg.mA
def test_extract_amplitude_real_data(file_path):
test_data = pd.read_csv(file_path + '/data/photovoltage_data.csv',
skiprows=1)
lia = LIA(test_data)
actual_amplitude = lia.extract_signal_amplitude()
desired_amplitude = (-0.0185371754 - 4.60284137e-11) * ureg.mV
assert_equal_qt(actual_amplitude, desired_amplitude)
def test_current_range_auto(keithley, timeout):
"""
Check that the voltage range increases when trying to set a voltage higher than we are currently able.
"""
keithley['device'].mode = 'current'
desired_range = 10 * ureg.uA
keithley['device'].current = 2 * ureg.uA
actual_range = keithley['device'].current_range
assert_equal_qt(actual_range, desired_range)
def test_reset(keithley, timeout):
keithley['device'].reset()
time.sleep(0.1)
desired_voltage = 0 * ureg.V
desired_current = 0 * ureg.uA
desired_voltage_compliance = 20 * ureg.V
desired_current_compliance = 100 * ureg.mA
actual_voltage = keithley['device'].voltage
actual_current = keithley['device'].current.to(ureg.uA)
actual_voltage_compliance = keithley['device'].voltage_compliance
actual_current_compliance = keithley['device'].current_compliance.to(
ureg.uA)
assert_equal_qt(actual_voltage, desired_voltage)
assert_equal_qt(actual_current, desired_current)
assert_equal_qt(actual_current_compliance, desired_current_compliance)
assert_equal_qt(actual_voltage_compliance, desired_voltage_compliance)
def test_voltage_range(keithley, timeout):
keithley['device'].mode = 'voltage'
keithley['device'].voltage_range = 2 * ureg.V
desired_range = 20 * ureg.V
actual_range = keithley['device'].voltage_range
assert_equal_qt(actual_range, desired_range)
def test_set_voltage_compliance_units(keithley, timeout):
desired_compliance = 1 * ureg.V
keithley['device'].voltage_compliance = desired_compliance
actual_compliance = keithley['device'].voltage_compliance
assert_equal_qt(actual_compliance, desired_compliance)
def test_set_current_compliance_units(keithley, timeout):
desired_compliance = 1 * ureg.mA
keithley['device'].current_compliance = desired_compliance
actual_compliance = keithley['device'].current_compliance
assert_equal_qt(actual_compliance, desired_compliance)
def test_extract_signal_frequency(data):
actual_frequency = data['lia'].extract_signal_frequency(
data['test_data'], sync_indices=data['sync_indices'])
desired_frequency = 105.32030401737242 * ureg.Hz
assert_equal_qt(actual_frequency, desired_frequency)
def test_extract_signal_frequency_simple(data1):
actual_frequency = data1['lia'].extract_signal_frequency(
data1['data'], sync_indices=data1['sync_indices'])
desired_frequency = data1['signal_frequency']
assert_equal_qt(actual_frequency, desired_frequency)
def testLIASetup(data):
assert_equal_qt(data['lia'].sampling_frequency, data['sampling_frequency'])
desired_data = data['test_data']
actual_data = data['lia'].data
assert_frame_equal(actual_data, desired_data)
def test_set_current_setpoint_unitless(tec):
desired_current = 1 * ureg.A
tec.current_setpoint = 1
actual_current = tec.current_setpoint
assert_equal_qt(actual_current, desired_current)
def test_set_voltage_setpoint(tec):
desired_voltage = 50
tec.voltage_setpoint = desired_voltage
actual_voltage = tec.voltage_setpoint
assert_equal_qt(actual_voltage, desired_voltage)
def test_set_voltage_units(keithley, timeout):
desired_voltage = 10 * ureg.V
keithley['device'].voltage = desired_voltage
keithley['device'].output_on = True
actual_voltage = keithley['device'].voltage
assert_equal_qt(actual_voltage, desired_voltage)
def test_set_current(keithley, timeout):
desired_current = 10 * ureg.mA
keithley['device'].current = 0.01
keithley['device'].output_on = True
actual_current = keithley['device'].current
assert_equal_qt(actual_current, desired_current)
def test_measure_voltage(keithley, timeout):
desired_voltage = 1 * ureg.V
keithley['device'].voltage = desired_voltage
actual_voltage, actual_current = keithley['device'].measure()
assert_equal_qt(actual_voltage, desired_voltage)
assert abs(actual_current) < 0.1 * ureg.nA
