def finalize(self, hvsrc, vsrc, elm):
self.process.emit("progress", 0, 2)
try:
self.elm_set_zero_check(elm, True)
assert self.elm_get_zero_check(elm) == True, "failed to enable zero check"
finally:
self.process.emit("message", "Ramp to zero...")
self.process.emit("progress", 1, 2)
self.process.emit("state", dict(
elm_current=None,
vsrc_current=None,
hvsrc_current=None
))
voltage_step = self.get_parameter('voltage_step')
voltage = self.hvsrc_get_voltage_level(hvsrc)
logging.info("HV Source ramp to zero: from %E V to %E V with step %E V", voltage, 0, 1.0)
for voltage in comet.Range(voltage, 0, 1.0):
self.process.emit("message", "Ramp to zero... {}".format(format_metric(voltage, "V")))
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(
hvsrc_voltage=voltage,
))
time.sleep(QUICK_RAMP_DELAY)
bias_voltage = self.vsrc_get_voltage_level(vsrc)
logging.info("V Source ramp bias to zero: from %E V to %E V with step %E V", bias_voltage, 0, 1.0)
for voltage in comet.Range(bias_voltage, 0, 1.0):
self.process.emit("message", "Ramp bias to zero... {}".format(format_metric(voltage, "V")))
self.vsrc_set_voltage_level(vsrc, voltage)
self.process.emit("state", dict(
vsrc_voltage=voltage,
))
time.sleep(QUICK_RAMP_DELAY)
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_OFF)
self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_OFF)
self.process.emit("state", dict(
hvsrc_output=self.hvsrc_get_output_state(hvsrc),
hvsrc_voltage=None,
hvsrc_current=None,
vsrc_output=self.vsrc_get_output_state(vsrc),
vsrc_voltage=None,
vsrc_current=None,
env_chuck_temperature=None,
env_box_temperature=None,
env_box_humidity=None
))
self.process.emit("progress", 2, 2)
def finalize(self, hvsrc, vsrc):
self.process.emit("progress", 1, 2)
self.process.emit("message", "Ramp to zero...")
voltage_step_after = self.get_parameter(
'voltage_step_after') or self.get_parameter('voltage_step')
waiting_time_after = self.get_parameter('waiting_time_after')
waiting_time_end = self.get_parameter('waiting_time_end')
voltage = self.hvsrc_get_voltage_level(hvsrc)
logger.info("HV Source ramp to zero: from %E V to %E V with step %E V",
voltage, 0, voltage_step_after)
for voltage in comet.Range(voltage, 0, voltage_step_after):
self.process.emit(
"message",
"Ramp to zero... {}".format(format_metric(voltage, "V")))
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(hvsrc_voltage=voltage, ))
time.sleep(waiting_time_after)
bias_voltage = self.vsrc_get_voltage_level(vsrc)
logger.info(
"V Source ramp bias to zero: from %E V to %E V with step %E V",
bias_voltage, 0, voltage_step_after)
for voltage in comet.Range(bias_voltage, 0, voltage_step_after):
self.process.emit(
"message",
"Ramp bias to zero... {}".format(format_metric(voltage, "V")))
self.vsrc_set_voltage_level(vsrc, voltage)
self.process.emit("state", dict(vsrc_voltage=voltage, ))
time.sleep(waiting_time_after)
# Waiting time after ramp down.
self.wait(waiting_time_end)
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_OFF)
self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_OFF)
self.process.emit(
"state",
dict(hvsrc_output=self.hvsrc_get_output_state(hvsrc),
hvsrc_voltage=None,
hvsrc_current=None,
vsrc_output=self.vsrc_get_output_state(vsrc),
vsrc_voltage=None,
vsrc_current=None,
env_chuck_temperature=None,
env_box_temperature=None,
env_box_humidity=None))
self.process.emit("progress", 2, 2)
def quick_ramp_zero(self, hvsrc):
"""Ramp to zero voltage without measuring current."""
self.process.emit("message", "Ramp to zero...")
self.process.emit("progress", 0, 1)
bias_voltage_step = self.get_parameter('bias_voltage_step')
hvsrc_output_state = self.hvsrc_get_output_state(hvsrc)
self.process.emit("state", dict(
hvsrc_output=hvsrc_output_state
))
if hvsrc_output_state:
hvsrc_voltage_level = self.hvsrc_get_voltage_level(hvsrc)
ramp = comet.Range(hvsrc_voltage_level, 0, bias_voltage_step)
for step, voltage in enumerate(ramp):
self.process.emit("progress", step + 1, ramp.count)
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(
hvsrc_voltage=voltage
))
time.sleep(QUICK_RAMP_DELAY)
hvsrc_output_state = self.hvsrc_get_output_state(hvsrc)
self.process.emit("state", dict(
hvsrc_output=hvsrc_output_state
))
self.process.emit("message", "")
self.process.emit("progress", 1, 1)
def finalize(self, vsrc):
self.process.emit("progress", 1, 2)
self.process.emit("state", dict(vsrc_voltage=None))
current_step = self.get_parameter('current_step')
current = self.vsrc_get_current_level(vsrc)
logging.info("V Source ramp to zero: from %E A to %E A with step %E A",
current, 0, current_step)
for current in comet.Range(current, 0, current_step):
self.process.emit(
"message",
"Ramp to zero... {}".format(format_metric(current, "A")))
self.vsrc_set_current_level(vsrc, current)
self.process.emit("state", dict(vsrc_current=current, ))
time.sleep(QUICK_RAMP_DELAY)
self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_OFF)
self.vsrc_check_error(vsrc)
self.process.emit(
"state",
dict(vsrc_output=self.vsrc_get_output_state(vsrc),
env_chuck_temperature=None,
env_box_temperature=None,
env_box_humidity=None))
self.process.emit("progress", 2, 2)
def quick_ramp_zero(self, lcr):
"""Ramp to zero voltage without measuring current."""
self.process.emit("message", "Ramp to zero...")
self.process.emit("progress", 0, 1)
bias_voltage_step_after = self.get_parameter('bias_voltage_step_after') or self.get_parameter('bias_voltage_step')
waiting_time_after = self.get_parameter('waiting_time_after')
lcr_output=self.lcr_get_bias_state(lcr)
self.process.emit("state", dict(
lcr_output=lcr_output
))
if lcr_output:
lcr_voltage_level = self.lcr_get_bias_voltage_level(lcr)
ramp = comet.Range(lcr_voltage_level, 0, bias_voltage_step_after)
for step, voltage in enumerate(ramp):
self.process.emit("progress", step + 1, ramp.count)
self.lcr_set_bias_voltage_level(lcr, voltage)
self.process.emit("state", dict(
lcr_voltage=voltage
))
time.sleep(waiting_time_after)
self.process.emit("state", dict(
lcr_output=self.lcr_get_bias_state(lcr)
))
self.process.emit("message", "")
self.process.emit("progress", 1, 1)
def finalize(self, hvsrc):
voltage_step = self.get_parameter('voltage_step')
voltage = self.hvsrc_get_voltage_level(hvsrc)
self.process.emit(
"state",
dict(hvsrc_voltage=voltage,
hvsrc_current=None,
hvsrc_output=self.hvsrc_get_output_state(hvsrc)))
logging.info(
"HV Source ramp to zero: from %E V to %E V with step %E V",
voltage, 0, voltage_step)
for voltage in comet.Range(voltage, 0, voltage_step):
self.process.emit(
"message",
"Ramp to zero... {}".format(format_metric(voltage, "V")))
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(hvsrc_voltage=voltage))
time.sleep(QUICK_RAMP_DELAY)
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_OFF)
self.process.emit(
"state",
dict(hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc),
hvsrc_output=self.hvsrc_get_output_state(hvsrc)))
self.process.emit("progress", 5, 5)
def safe_initialize_vsrc(self, resource):
context = settings.vsrc_instrument(resource)
if context.get_output() == context.OUTPUT_ON:
self.emit("message", "Ramping down V Source...")
start_voltage = context.get_source_voltage()
stop_voltage = 0.0
step_voltage = min(25.0, max(5.0, start_voltage / 100.))
for voltage in comet.Range(start_voltage, stop_voltage,
step_voltage):
context.set_source_voltage(voltage)
self.emit("message", "Disable output V Source...")
context.set_output(context.OUTPUT_OFF)
self.emit("message", "Initialized VSource.")
def finalize(self, hvsrc, elm):
self.process.emit("progress", 0, 2)
voltage_step_after = self.get_parameter(
'voltage_step_after') or self.get_parameter('voltage_step')
waiting_time_after = self.get_parameter('waiting_time_after')
waiting_time_end = self.get_parameter('waiting_time_end')
try:
self.elm_set_zero_check(elm, True)
assert self.elm_get_zero_check(
elm) == True, "failed to enable zero check"
finally:
self.process.emit("message", "Ramp to zero...")
self.process.emit("progress", 1, 2)
self.process.emit("state",
dict(hvsrc_current=None, elm_current=None))
voltage = self.hvsrc_get_voltage_level(hvsrc)
logger.info(
"HV Source ramp to zero: from %E V to %E V with step %E V",
voltage, 0, voltage_step_after)
for voltage in comet.Range(voltage, 0, voltage_step_after):
self.process.emit(
"message",
"Ramp to zero... {}".format(format_metric(voltage, "V")))
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(hvsrc_voltage=voltage, ))
time.sleep(waiting_time_after)
# Waiting time after ramp down.
self.wait(waiting_time_end)
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_OFF)
self.process.emit(
"state",
dict(hvsrc_output=self.hvsrc_get_output_state(hvsrc),
env_chuck_temperature=None,
env_box_temperature=None,
env_box_humidity=None))
self.process.emit("progress", 2, 2)
def finalize(self, vsrc):
self.process.emit("progress", 1, 2)
self.process.emit("state", dict(vsrc_voltage=None))
current_step_after = self.get_parameter(
'current_step_after') or self.get_parameter('current_step')
waiting_time_after = self.get_parameter('waiting_time_after')
waiting_time_end = self.get_parameter('waiting_time_end')
current = self.vsrc_get_current_level(vsrc)
logger.info("V Source ramp to zero: from %E A to %E A with step %E A",
current, 0, current_step_after)
for current in comet.Range(current, 0, current_step_after):
self.process.emit(
"message",
"Ramp to zero... {}".format(format_metric(current, "A")))
self.vsrc_set_current_level(vsrc, current)
self.process.emit("state", dict(vsrc_current=current, ))
time.sleep(waiting_time_after)
# Waiting time after ramp down.
self.wait(waiting_time_end)
self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_OFF)
self.vsrc_check_error(vsrc)
self.process.emit(
"state",
dict(vsrc_output=self.vsrc_get_output_state(vsrc),
env_chuck_temperature=None,
env_box_temperature=None,
env_box_humidity=None))
self.process.emit("progress", 2, 2)
def quick_ramp_zero(self, vsrc):
"""Ramp to zero voltage without measuring current."""
self.process.emit("message", "Ramp to zero...")
self.process.emit("progress", 0, 1)
bias_voltage_step_after = self.get_parameter(
'bias_voltage_step_after') or self.get_parameter(
'bias_voltage_step')
waiting_time_after = self.get_parameter('waiting_time_after')
vsrc_output_state = self.vsrc_get_output_state(vsrc)
self.process.emit("state", dict(vsrc_output=vsrc_output_state))
if vsrc_output_state:
vsrc_voltage_level = self.vsrc_get_voltage_level(vsrc)
ramp = comet.Range(vsrc_voltage_level, 0, bias_voltage_step_after)
for step, voltage in enumerate(ramp):
self.process.emit("progress", step + 1, ramp.count)
self.vsrc_set_voltage_level(vsrc, voltage)
self.process.emit("state", dict(vsrc_voltage=voltage))
time.sleep(waiting_time_after)
self.process.emit("state",
dict(vsrc_output=self.vsrc_get_output_state(vsrc)))
self.process.emit("message", "")
self.process.emit("progress", 1, 1)
def measure(self, vsrc):
current_start = self.get_parameter('current_start')
current_step = self.get_parameter('current_step')
current_stop = self.get_parameter('current_stop')
waiting_time = self.get_parameter('waiting_time')
vsrc_voltage_compliance = self.get_parameter('vsrc_voltage_compliance')
if not self.process.running:
return
current = self.vsrc_get_current_level(vsrc)
ramp = comet.Range(current, current_stop, current_step)
est = Estimate(ramp.count)
self.process.emit("progress", *est.progress)
t0 = time.time()
logging.info(
"V Source ramp to end current: from %E A to %E A with step %E A",
current, ramp.end, ramp.step)
for current in ramp:
self.vsrc_clear(vsrc)
self.vsrc_set_current_level(vsrc, current)
self.process.emit("state", dict(vsrc_current=current, ))
time.sleep(waiting_time)
dt = time.time() - t0
est.advance()
self.process.emit(
"message",
"{} | V Source {}".format(format_estimate(est),
format_metric(current, "A")))
self.process.emit("progress", *est.progress)
# read V Source
vsrc_reading = self.vsrc_read_voltage(vsrc)
self.process.emit("reading", "vsrc",
abs(current) if ramp.step < 0 else current,
vsrc_reading)
self.process.emit("update")
self.process.emit("state", dict(vsrc_voltage=vsrc_reading))
self.environment_update()
self.process.emit(
"state",
dict(env_chuck_temperature=self.environment_temperature_chuck,
env_box_temperature=self.environment_temperature_box,
env_box_humidity=self.environment_humidity_box))
# Append series data
self.append_series(
timestamp=dt,
current=current,
voltage_vsrc=vsrc_reading,
temperature_box=self.environment_temperature_box,
temperature_chuck=self.environment_temperature_chuck,
humidity_box=self.environment_humidity_box)
# Compliance tripped?
self.vsrc_check_compliance(vsrc)
if not self.process.running:
break
def initialize(self, hvsrc, lcr):
self.process.emit("progress", 1, 6)
# Parameters
bias_voltage_start = self.get_parameter('bias_voltage_start')
bias_voltage_step = self.get_parameter('bias_voltage_step')
bias_voltage_stop = self.get_parameter('bias_voltage_stop')
waiting_time = self.get_parameter('waiting_time')
bias_voltage_step_before = self.get_parameter(
'bias_voltage_step_before') or self.get_parameter(
'bias_voltage_step')
waiting_time_before = self.get_parameter('waiting_time_before')
bias_voltage_step_after = self.get_parameter(
'bias_voltage_step_after') or self.get_parameter(
'bias_voltage_step')
waiting_time_after = self.get_parameter('waiting_time_after')
waiting_time_start = self.get_parameter('waiting_time_start')
waiting_time_end = self.get_parameter('waiting_time_end')
hvsrc_current_compliance = self.get_parameter(
'hvsrc_current_compliance')
hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance')
# Extend meta data
self.set_meta("bias_voltage_start", f"{bias_voltage_start:G} V")
self.set_meta("bias_voltage_stop", f"{bias_voltage_stop:G} V")
self.set_meta("bias_voltage_step", f"{bias_voltage_step:G} V")
self.set_meta("waiting_time", f"{waiting_time:G} s")
self.set_meta("bias_voltage_step_before",
f"{bias_voltage_step_before:G} V")
self.set_meta("waiting_time_before", f"{waiting_time_before:G} s")
self.set_meta("bias_voltage_step_after",
f"{bias_voltage_step_after:G} V")
self.set_meta("waiting_time_after", f"{waiting_time_after:G} s")
self.set_meta("waiting_time_start", f"{waiting_time_start:G} s")
self.set_meta("waiting_time_end", f"{waiting_time_end:G} s")
self.set_meta("hvsrc_current_compliance",
f"{hvsrc_current_compliance:G} A")
self.set_meta("hvsrc_accept_compliance", hvsrc_accept_compliance)
self.hvsrc_update_meta()
self.lcr_update_meta()
self.environment_update_meta()
# Series units
self.set_series_unit("timestamp", "s")
self.set_series_unit("voltage_hvsrc", "V")
self.set_series_unit("current_hvsrc", "A")
self.set_series_unit("capacitance", "F")
self.set_series_unit("capacitance2", "1")
self.set_series_unit("resistance", "Ohm")
self.set_series_unit("temperature_box", "degC")
self.set_series_unit("temperature_chuck", "degC")
self.set_series_unit("humidity_box", "%")
# Series
self.register_series("timestamp")
self.register_series("voltage_hvsrc")
self.register_series("current_hvsrc")
self.register_series("capacitance")
self.register_series("capacitance2")
self.register_series("resistance")
self.register_series("temperature_box")
self.register_series("temperature_chuck")
self.register_series("humidity_box")
# Initialize HV Source
self.hvsrc_reset(hvsrc)
self.process.emit("progress", 3, 6)
self.hvsrc_setup(hvsrc)
hvsrc_current_compliance = self.get_parameter(
'hvsrc_current_compliance')
self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance)
self.process.emit("progress", 4, 6)
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON)
hvsrc_output_state = self.hvsrc_get_output_state(hvsrc)
self.process.emit("state", dict(hvsrc_output=hvsrc_output_state, ))
# Initialize LCR
self.lcr_reset(lcr)
self.lcr_setup(lcr)
self.process.emit("progress", 5, 6)
# Ramp to start voltage
hvsrc_voltage_level = self.hvsrc_get_voltage_level(hvsrc)
logger.info(
"HV Source ramp to start voltage: from %E V to %E V with step %E V",
hvsrc_voltage_level, bias_voltage_start, bias_voltage_step_before)
for voltage in comet.Range(hvsrc_voltage_level, bias_voltage_start,
bias_voltage_step_before):
self.process.emit(
"message",
"Ramp to start... {}".format(format_metric(voltage, "V")))
self.hvsrc_set_voltage_level(hvsrc, voltage)
time.sleep(waiting_time_before)
self.process.emit("state", dict(hvsrc_voltage=voltage, ))
# Compliance tripped?
self.hvsrc_check_compliance(hvsrc)
if not self.process.running:
break
# Waiting time before measurement ramp.
self.wait(waiting_time_start)
self.process.emit("progress", 6, 6)
def measure(self, hvsrc, lcr):
self.process.emit("progress", 1, 2)
# Parameters
bias_voltage_step = self.get_parameter('bias_voltage_step')
bias_voltage_stop = self.get_parameter('bias_voltage_stop')
waiting_time = self.get_parameter('waiting_time')
hvsrc_current_compliance = self.get_parameter(
'hvsrc_current_compliance')
hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance')
lcr_soft_filter = self.get_parameter('lcr_soft_filter')
if not self.process.running:
return
hvsrc_voltage_level = self.hvsrc_get_voltage_level(hvsrc)
ramp = comet.Range(hvsrc_voltage_level, bias_voltage_stop,
bias_voltage_step)
est = Estimate(ramp.count)
self.process.emit("progress", *est.progress)
t0 = time.time()
self.hvsrc_clear(hvsrc)
benchmark_step = Benchmark("Single_Step")
benchmark_lcr = Benchmark("Read_LCR")
benchmark_hvsrc = Benchmark("Read_HV_Source")
benchmark_environ = Benchmark("Read_Environment")
logger.info(
"HV Source ramp to end voltage: from %E V to %E V with step %E V",
hvsrc_voltage_level, ramp.end, ramp.step)
for voltage in ramp:
with benchmark_step:
self.hvsrc_set_voltage_level(hvsrc, voltage)
# Delay
time.sleep(waiting_time)
dt = time.time() - t0
est.advance()
self.process.emit(
"message",
"{} | HV Source {}".format(format_estimate(est),
format_metric(voltage, "V")))
self.process.emit("progress", *est.progress)
self.environment_update()
# read HV Source
with benchmark_hvsrc:
hvsrc_reading = self.hvsrc_read_current(hvsrc)
self.process.emit("update", )
self.process.emit(
"state",
dict(hvsrc_voltage=voltage, hvsrc_current=hvsrc_reading))
# read LCR, for CpRp -> prim: Cp, sec: Rp
with benchmark_lcr:
try:
if lcr_soft_filter:
lcr_prim, lcr_sec = self.lcr_acquire_filter_reading(
lcr)
else:
lcr_prim, lcr_sec = self.lcr_acquire_reading(lcr)
except Exception as exc:
raise RuntimeError(
f"Failed to read from LCR: {exc}") from exc
try:
lcr_prim2 = 1.0 / (lcr_prim * lcr_prim)
except ZeroDivisionError:
lcr_prim2 = 0.0
self.process.emit("reading", "lcr",
abs(voltage) if ramp.step < 0 else voltage,
lcr_prim)
self.process.emit("reading", "lcr2",
abs(voltage) if ramp.step < 0 else voltage,
lcr_prim2)
# Append series data
self.append_series(
timestamp=dt,
voltage_hvsrc=voltage,
current_hvsrc=hvsrc_reading,
capacitance=lcr_prim,
capacitance2=lcr_prim2,
resistance=lcr_sec,
temperature_box=self.environment_temperature_box,
temperature_chuck=self.environment_temperature_chuck,
humidity_box=self.environment_humidity_box)
# Compliance tripped?
if hvsrc_accept_compliance:
if self.hvsrc_compliance_tripped(hvsrc):
logger.info(
"HV Source compliance tripped, gracefully stopping measurement."
)
break
else:
self.hvsrc_check_compliance(hvsrc)
if not self.process.running:
break
logger.info(benchmark_step)
logger.info(benchmark_lcr)
logger.info(benchmark_hvsrc)
logger.info(benchmark_environ)
def measure(self, hvsrc, vsrc, elm):
self.process.emit("progress", 1, 2)
# Parameters
voltage_start = self.get_parameter('voltage_start')
voltage_stop = self.get_parameter('voltage_stop')
voltage_step = self.get_parameter('voltage_step')
waiting_time = self.get_parameter('waiting_time')
bias_voltage = self.get_parameter('bias_voltage')
bias_mode = self.get_parameter('bias_mode')
elm_read_timeout = self.get_parameter('elm_read_timeout')
if not self.process.running:
return
# Electrometer reading format: READ
elm.resource.write(":FORM:ELEM READ")
elm.resource.query("*OPC?")
self.elm_check_error(elm)
voltage = self.hvsrc_get_voltage_level(hvsrc)
ramp = comet.Range(voltage, voltage_stop, voltage_step)
est = Estimate(ramp.count)
self.process.emit("progress", *est.progress)
t0 = time.time()
benchmark_step = Benchmark("Single_Step")
benchmark_elm = Benchmark("Read_ELM")
benchmark_hvsrc = Benchmark("Read_HV_Source")
benchmark_vsrc = Benchmark("Read_V_Source")
benchmark_environ = Benchmark("Read_Environment")
logging.info("HV Source ramp to end voltage: from %E V to %E V with step %E V", voltage, ramp.end, ramp.step)
for voltage in ramp:
with benchmark_step:
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(
hvsrc_voltage=voltage,
))
# Move bias TODO
if bias_mode == "offset":
bias_voltage += abs(ramp.step) if ramp.begin <= ramp.end else -abs(ramp.step)
self.vsrc_set_voltage_level(vsrc, bias_voltage)
self.process.emit("state", dict(
vsrc_voltage=bias_voltage,
))
time.sleep(waiting_time)
dt = time.time() - t0
est.advance()
self.process.emit("message", "{} | HV Source {} | Bias {}".format(format_estimate(est), format_metric(voltage, "V"), format_metric(bias_voltage, "V")))
self.process.emit("progress", *est.progress)
# read ELM
with benchmark_elm:
try:
elm_reading = self.elm_read(elm, timeout=elm_read_timeout)
except Exception as exc:
raise RuntimeError(f"Failed to read from ELM: {exc}") from exc
self.elm_check_error(elm)
logging.info("ELM reading: %s", format_metric(elm_reading, "A"))
self.process.emit("reading", "elm", abs(voltage) if ramp.step < 0 else voltage, elm_reading)
# read V Source
with benchmark_vsrc:
vsrc_reading = self.vsrc_read_current(vsrc)
# read HV Source
with benchmark_hvsrc:
hvsrc_reading = self.hvsrc_read_current(hvsrc)
self.process.emit("update")
self.process.emit("state", dict(
elm_current=elm_reading,
hvsrc_current=hvsrc_reading,
vsrc_current=vsrc_reading,
))
self.environment_update()
self.process.emit("state", dict(
env_chuck_temperature=self.environment_temperature_chuck,
env_box_temperature=self.environment_temperature_box,
env_box_humidity=self.environment_humidity_box
))
# Append series data
self.append_series(
timestamp=dt,
voltage=voltage,
current_elm=elm_reading,
current_vsrc=vsrc_reading,
current_hvsrc=hvsrc_reading,
bias_voltage=bias_voltage,
temperature_box=self.environment_temperature_box,
temperature_chuck=self.environment_temperature_chuck,
humidity_box=self.environment_humidity_box
)
# Compliance tripped?
self.hvsrc_check_compliance(hvsrc)
self.vsrc_check_compliance(vsrc)
if not self.process.running:
break
logging.info(benchmark_step)
logging.info(benchmark_elm)
logging.info(benchmark_hvsrc)
logging.info(benchmark_vsrc)
logging.info(benchmark_environ)
self.process.emit("progress", 2, 2)
def measure(self, hvsrc):
# Parameters
voltage_start = self.get_parameter('voltage_start')
voltage_stop = self.get_parameter('voltage_stop')
voltage_step = self.get_parameter('voltage_step')
waiting_time = self.get_parameter('waiting_time')
hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance')
if not self.process.running:
return
voltage = self.hvsrc_get_voltage_level(hvsrc)
t0 = time.time()
ramp = comet.Range(voltage, voltage_stop, voltage_step)
est = Estimate(ramp.count)
self.process.emit("progress", *est.progress)
logger.info(
"HV Source ramp to end voltage: from %E V to %E V with step %E V",
voltage, ramp.end, ramp.step)
for voltage in ramp:
self.hvsrc_set_voltage_level(hvsrc, voltage)
time.sleep(waiting_time)
td = time.time() - t0
self.environment_update()
reading_current = self.hvsrc_read_current(hvsrc)
self.process.emit("reading", "hvsrc",
abs(voltage) if ramp.step < 0 else voltage,
reading_current)
self.process.emit("update")
self.process.emit(
"state",
dict(hvsrc_voltage=voltage, hvsrc_current=reading_current))
# Append series data
self.append_series(
timestamp=td,
voltage=voltage,
current_hvsrc=reading_current,
temperature_box=self.environment_temperature_box,
temperature_chuck=self.environment_temperature_chuck,
humidity_box=self.environment_humidity_box)
est.advance()
self.process.emit(
"message",
"{} | HV Source {}".format(format_estimate(est),
format_metric(voltage, "V")))
self.process.emit("progress", *est.progress)
# Compliance tripped?
if hvsrc_accept_compliance:
if self.hvsrc_compliance_tripped(hvsrc):
logger.info(
"HV Source compliance tripped, gracefully stopping measurement."
)
break
else:
self.hvsrc_check_compliance(hvsrc)
if not self.process.running:
break
self.process.emit("progress", 0, 0)
def initialize(self, hvsrc):
self.process.emit("progress", 1, 4)
# Parameters
voltage_start = self.get_parameter('voltage_start')
voltage_stop = self.get_parameter('voltage_stop')
voltage_step = self.get_parameter('voltage_step')
waiting_time = self.get_parameter('waiting_time')
hvsrc_current_compliance = self.get_parameter(
'hvsrc_current_compliance')
# Extend meta data
self.set_meta("voltage_start", f"{voltage_start:G} V")
self.set_meta("voltage_stop", f"{voltage_stop:G} V")
self.set_meta("voltage_step", f"{voltage_step:G} V")
self.set_meta("waiting_time", f"{waiting_time:G} s")
self.set_meta("hvsrc_current_compliance",
f"{hvsrc_current_compliance:G} A")
self.hvsrc_update_meta()
self.environment_update_meta()
# Series units
self.set_series_unit("timestamp", "s")
self.set_series_unit("voltage", "V")
self.set_series_unit("current_hvsrc", "A")
self.set_series_unit("temperature_box", "degC")
self.set_series_unit("temperature_chuck", "degC")
self.set_series_unit("humidity_box", "%")
# Series
self.register_series("timestamp")
self.register_series("voltage")
self.register_series("current_hvsrc")
self.register_series("temperature_box")
self.register_series("temperature_chuck")
self.register_series("humidity_box")
self.process.emit(
"state",
dict(hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc),
hvsrc_current=None,
hvsrc_output=self.hvsrc_get_output_state(hvsrc)))
self.hvsrc_reset(hvsrc)
self.hvsrc_setup(hvsrc)
hvsrc_current_compliance = self.get_parameter(
'hvsrc_current_compliance')
self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance)
self.process.emit("progress", 2, 4)
# If output enabled
if self.hvsrc_get_output_state(hvsrc):
voltage = self.hvsrc_get_voltage_level(hvsrc)
logging.info(
"HV Source ramp to zero: from %E V to %E V with step %E V",
voltage, 0, voltage_step)
for voltage in comet.Range(voltage, 0, voltage_step):
self.process.emit("message", f"{voltage:.3f} V")
self.hvsrc_set_voltage_level(hvsrc, voltage)
time.sleep(QUICK_RAMP_DELAY)
if not self.process.running:
break
# If output disabled
else:
voltage = 0
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON)
time.sleep(.100)
self.process.emit(
"state",
dict(hvsrc_voltage=voltage,
hvsrc_output=self.hvsrc_get_output_state(hvsrc)))
self.process.emit("progress", 3, 4)
if self.process.running:
voltage = self.hvsrc_get_voltage_level(hvsrc)
logging.info(
"HV Source ramp to start voltage: from %E V to %E V with step %E V",
voltage, voltage_start, voltage_step)
for voltage in comet.Range(voltage, voltage_start, voltage_step):
self.process.emit(
"message",
"Ramp to start... {}".format(format_metric(voltage, "V")))
self.hvsrc_set_voltage_level(hvsrc, voltage)
time.sleep(QUICK_RAMP_DELAY)
# Compliance tripped?
self.hvsrc_check_compliance(hvsrc)
if not self.process.running:
break
self.process.emit(
"state",
dict(hvsrc_voltage=voltage,
hvsrc_output=self.hvsrc_get_output_state(hvsrc)))
self.process.emit("progress", 4, 4)
def measure(self, hvsrc, elm):
# Parameters
voltage_start = self.get_parameter('voltage_start')
voltage_stop = self.get_parameter('voltage_stop')
voltage_step = self.get_parameter('voltage_step')
waiting_time = self.get_parameter('waiting_time')
hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance')
elm_read_timeout = self.get_parameter('elm_read_timeout')
if not self.process.running:
return
voltage = self.hvsrc_get_voltage_level(hvsrc)
# Electrometer reading format: READ
elm.resource.write(":FORM:ELEM READ")
elm.resource.query("*OPC?")
self.elm_check_error(elm)
ramp = comet.Range(voltage, voltage_stop, voltage_step)
est = Estimate(ramp.count)
self.process.emit("progress", *est.progress)
t0 = time.time()
benchmark_step = Benchmark("Single_Step")
benchmark_elm = Benchmark("Read_ELM")
benchmark_hvsrc = Benchmark("Read_HV_Source")
benchmark_environ = Benchmark("Read_Environment")
logger.info(
"HV Source ramp to end voltage: from %E V to %E V with step %E V",
voltage, ramp.end, ramp.step)
for voltage in ramp:
with benchmark_step:
self.hvsrc_clear(hvsrc)
self.hvsrc_set_voltage_level(hvsrc, voltage)
time.sleep(waiting_time)
dt = time.time() - t0
est.advance()
self.process.emit(
"message",
"{} | V Source {}".format(format_estimate(est),
format_metric(voltage, "V")))
self.process.emit("progress", *est.progress)
self.environment_update()
# read HV Source
with benchmark_hvsrc:
hvsrc_reading = self.hvsrc_read_current(hvsrc)
self.process.emit("reading", "hvsrc",
abs(voltage) if ramp.step < 0 else voltage,
hvsrc_reading)
# read ELM
with benchmark_elm:
try:
elm_reading = self.elm_read(elm,
timeout=elm_read_timeout)
except Exception as exc:
raise RuntimeError(
f"Failed to read from ELM: {exc}") from exc
self.elm_check_error(elm)
logger.info("ELM reading: %s", format_metric(elm_reading, "A"))
self.process.emit("reading", "elm",
abs(voltage) if ramp.step < 0 else voltage,
elm_reading)
self.process.emit("update")
self.process.emit(
"state",
dict(hvsrc_voltage=voltage,
hvsrc_current=hvsrc_reading,
elm_current=elm_reading))
# Append series data
self.append_series(
timestamp=dt,
voltage=voltage,
current_hvsrc=hvsrc_reading,
current_elm=elm_reading,
temperature_box=self.environment_temperature_box,
temperature_chuck=self.environment_temperature_chuck,
humidity_box=self.environment_humidity_box)
# Compliance tripped?
if hvsrc_accept_compliance:
if self.hvsrc_compliance_tripped(hvsrc):
logger.info(
"HV Source compliance tripped, gracefully stopping measurement."
)
break
else:
self.hvsrc_check_compliance(hvsrc)
if not self.process.running:
break
logger.info(benchmark_step)
logger.info(benchmark_elm)
logger.info(benchmark_hvsrc)
logger.info(benchmark_environ)
self.process.emit("progress", 4, 5)
def initialize(self, hvsrc, vsrc):
self.process.emit("progress", 1, 5)
# Parameters
voltage_start = self.get_parameter('voltage_start')
voltage_stop = self.get_parameter('voltage_stop')
voltage_step = self.get_parameter('voltage_step')
waiting_time = self.get_parameter('waiting_time')
voltage_step_before = self.get_parameter(
'voltage_step_before') or self.get_parameter('voltage_step')
waiting_time_before = self.get_parameter('waiting_time_before')
voltage_step_after = self.get_parameter(
'voltage_step_after') or self.get_parameter('voltage_step')
waiting_time_after = self.get_parameter('waiting_time_after')
waiting_time_start = self.get_parameter('waiting_time_start')
waiting_time_end = self.get_parameter('waiting_time_end')
bias_voltage = self.get_parameter('bias_voltage')
bias_mode = self.get_parameter('bias_mode')
hvsrc_current_compliance = self.get_parameter(
'hvsrc_current_compliance')
hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance')
vsrc_current_compliance = self.get_parameter('vsrc_current_compliance')
vsrc_accept_compliance = self.get_parameter('vsrc_accept_compliance')
# Extend meta data
self.set_meta("voltage_start", f"{voltage_start:G} V")
self.set_meta("voltage_stop", f"{voltage_stop:G} V")
self.set_meta("voltage_step", f"{voltage_step:G} V")
self.set_meta("waiting_time", f"{waiting_time:G} s")
self.set_meta("voltage_step_before", f"{voltage_step_before:G} V")
self.set_meta("waiting_time_before", f"{waiting_time_before:G} s")
self.set_meta("voltage_step_after", f"{voltage_step_after:G} V")
self.set_meta("waiting_time_after", f"{waiting_time_after:G} s")
self.set_meta("waiting_time_start", f"{waiting_time_start:G} s")
self.set_meta("waiting_time_end", f"{waiting_time_end:G} s")
self.set_meta("bias_voltage", f"{bias_voltage:G} V")
self.set_meta("hvsrc_current_compliance",
f"{hvsrc_current_compliance:G} A")
self.set_meta("hvsrc_accept_compliance", hvsrc_accept_compliance)
self.hvsrc_update_meta()
self.set_meta("vsrc_current_compliance",
f"{vsrc_current_compliance:G} A")
self.set_meta("vsrc_accept_compliance", vsrc_accept_compliance)
self.vsrc_update_meta()
self.environment_update_meta()
# Series units
self.set_series_unit("timestamp", "s")
self.set_series_unit("voltage", "V")
self.set_series_unit("current_vsrc", "A")
self.set_series_unit("bias_voltage", "V")
self.set_series_unit("temperature_box", "degC")
self.set_series_unit("temperature_chuck", "degC")
self.set_series_unit("humidity_box", "%")
# Series
self.register_series("timestamp")
self.register_series("voltage")
self.register_series("current_vsrc")
self.register_series("bias_voltage")
self.register_series("temperature_box")
self.register_series("temperature_chuck")
self.register_series("humidity_box")
# Initialize HV Source
self.hvsrc_reset(hvsrc)
self.hvsrc_setup(hvsrc)
self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance)
self.process.emit(
"state",
dict(hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc),
hvsrc_current=None,
hvsrc_output=self.hvsrc_get_output_state(hvsrc)))
if not self.process.running:
return
# Initialize V Source
self.vsrc_reset(vsrc)
self.vsrc_setup(vsrc)
# Voltage source
self.vsrc_set_function_voltage(vsrc)
self.vsrc_set_current_compliance(vsrc, vsrc_current_compliance)
if not self.process.running:
return
# Output enable
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON)
time.sleep(.100)
self.process.emit(
"state", dict(hvsrc_output=self.hvsrc_get_output_state(hvsrc)))
self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_ON)
time.sleep(.100)
self.process.emit("state",
dict(vsrc_output=self.vsrc_get_output_state(vsrc)))
self.process.emit("message", "Ramp to start...")
# Ramp HV Spource to bias voltage
voltage = self.vsrc_get_voltage_level(vsrc)
logger.info(
"V Source ramp to bias voltage: from %E V to %E V with step %E V",
voltage, bias_voltage, voltage_step_before)
for voltage in comet.Range(voltage, bias_voltage, voltage_step_before):
self.process.emit(
"message",
"Ramp to bias... {}".format(format_metric(voltage, "V")))
self.vsrc_set_voltage_level(vsrc, voltage)
self.process.emit("state", dict(vsrc_voltage=voltage, ))
time.sleep(waiting_time_before)
# Compliance tripped?
self.vsrc_check_compliance(vsrc)
if not self.process.running:
break
# Ramp HV Source to start voltage
voltage = self.hvsrc_get_voltage_level(hvsrc)
logger.info(
"HV Source ramp to start voltage: from %E V to %E V with step %E V",
voltage, voltage_start, voltage_step_before)
for voltage in comet.Range(voltage, voltage_start,
voltage_step_before):
self.process.emit(
"message",
"Ramp to start... {}".format(format_metric(voltage, "V")))
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(hvsrc_voltage=voltage, ))
time.sleep(waiting_time_before)
# Compliance tripped?
self.hvsrc_check_compliance(hvsrc)
if not self.process.running:
break
# Waiting time before measurement ramp.
self.wait(waiting_time_start)
self.process.emit("progress", 5, 5)
def initialize(self, hvsrc, vsrc, elm):
self.process.emit("progress", 1, 5)
# Parameters
voltage_start = self.get_parameter('voltage_start')
voltage_stop = self.get_parameter('voltage_stop')
voltage_step = self.get_parameter('voltage_step')
waiting_time = self.get_parameter('waiting_time')
bias_voltage = self.get_parameter('bias_voltage')
bias_mode = self.get_parameter('bias_mode')
hvsrc_current_compliance = self.get_parameter('hvsrc_current_compliance')
vsrc_current_compliance = self.get_parameter('vsrc_current_compliance')
vsrc_sense_mode = self.get_parameter('vsrc_sense_mode')
vsrc_filter_enable = self.get_parameter('vsrc_filter_enable')
vsrc_filter_count = self.get_parameter('vsrc_filter_count')
vsrc_filter_type = self.get_parameter('vsrc_filter_type')
elm_filter_enable = self.get_parameter('elm_filter_enable')
elm_filter_count = self.get_parameter('elm_filter_count')
elm_filter_type = self.get_parameter('elm_filter_type')
elm_zero_correction = self.get_parameter('elm_zero_correction')
elm_integration_rate = self.get_parameter('elm_integration_rate')
elm_current_range = self.get_parameter('elm_current_range')
elm_current_autorange_enable = self.get_parameter('elm_current_autorange_enable')
elm_current_autorange_minimum = self.get_parameter('elm_current_autorange_minimum')
elm_current_autorange_maximum = self.get_parameter('elm_current_autorange_maximum')
elm_read_timeout = self.get_parameter('elm_read_timeout')
# Extend meta data
self.set_meta("voltage_start", f"{voltage_start:G} V")
self.set_meta("voltage_stop", f"{voltage_stop:G} V")
self.set_meta("voltage_step", f"{voltage_step:G} V")
self.set_meta("waiting_time", f"{waiting_time:G} s")
self.set_meta("bias_voltage", f"{bias_voltage:G} V")
self.set_meta("hvsrc_current_compliance", f"{hvsrc_current_compliance:G} A")
self.hvsrc_update_meta()
self.set_meta("vsrc_current_compliance", f"{vsrc_current_compliance:G} A")
self.vsrc_update_meta()
self.set_meta("elm_filter_enable", elm_filter_enable)
self.set_meta("elm_filter_count", elm_filter_count)
self.set_meta("elm_filter_type", elm_filter_type)
self.set_meta("elm_zero_correction", elm_zero_correction)
self.set_meta("elm_integration_rate", elm_integration_rate)
self.set_meta("elm_current_range", format(elm_current_range, 'G'))
self.set_meta("elm_current_autorange_enable", elm_current_autorange_enable)
self.set_meta("elm_current_autorange_minimum", format(elm_current_autorange_minimum, 'G'))
self.set_meta("elm_current_autorange_maximum", format(elm_current_autorange_maximum, 'G'))
self.set_meta("elm_read_timeout", format(elm_read_timeout, 'G'))
self.elm_update_meta()
self.environment_update_meta()
# Series units
self.set_series_unit("timestamp", "s")
self.set_series_unit("voltage", "V")
self.set_series_unit("current_elm", "A")
self.set_series_unit("current_vsrc", "A")
self.set_series_unit("current_hvsrc", "A")
self.set_series_unit("bias_voltage", "V")
self.set_series_unit("temperature_box", "degC")
self.set_series_unit("temperature_chuck", "degC")
self.set_series_unit("humidity_box", "%")
# Series
self.register_series("timestamp")
self.register_series("voltage")
self.register_series("current_elm")
self.register_series("current_vsrc")
self.register_series("current_hvsrc")
self.register_series("bias_voltage")
self.register_series("temperature_box")
self.register_series("temperature_chuck")
self.register_series("humidity_box")
# Initialize HV Source
self.hvsrc_reset(hvsrc)
self.hvsrc_setup(hvsrc)
self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance)
self.process.emit("state", dict(
hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc),
hvsrc_current=None,
hvsrc_output=self.hvsrc_get_output_state(hvsrc)
))
if not self.process.running:
return
# Initialize V Source
self.vsrc_reset(vsrc)
self.vsrc_setup(vsrc)
# Voltage source
self.vsrc_set_function_voltage(vsrc)
self.vsrc_set_current_compliance(vsrc, vsrc_current_compliance)
if not self.process.running:
return
# Initialize Electrometer
self.elm_safe_write(elm, "*RST")
self.elm_safe_write(elm, "*CLS")
# Filter
self.elm_safe_write(elm, f":SENS:CURR:AVER:COUN {elm_filter_count:d}")
if elm_filter_type == "repeat":
self.elm_safe_write(elm, ":SENS:CURR:AVER:TCON REP")
elif elm_filter_type == "moving":
self.elm_safe_write(elm, ":SENS:CURR:AVER:TCON MOV")
if elm_filter_enable:
self.elm_safe_write(elm, ":SENS:CURR:AVER:STATE ON")
else:
self.elm_safe_write(elm, ":SENS:CURR:AVER:STATE OFF")
nplc = elm_integration_rate / 10.
self.elm_safe_write(elm, f":SENS:CURR:NPLC {nplc:02f}")
self.elm_set_zero_check(elm, True)
assert self.elm_get_zero_check(elm) == True, "failed to enable zero check"
self.elm_safe_write(elm, ":SENS:FUNC 'CURR'") # note the quotes!
assert elm.resource.query(":SENS:FUNC?") == '"CURR:DC"', "failed to set sense function to current"
self.elm_safe_write(elm, f":SENS:CURR:RANG {elm_current_range:E}")
if elm_zero_correction:
self.elm_safe_write(elm, ":SYST:ZCOR ON") # perform zero correction
# Auto range
self.elm_safe_write(elm, f":SENS:CURR:RANG:AUTO {elm_current_autorange_enable:d}")
self.elm_safe_write(elm, f":SENS:CURR:RANG:AUTO:LLIM {elm_current_autorange_minimum:E}")
self.elm_safe_write(elm, f":SENS:CURR:RANG:AUTO:ULIM {elm_current_autorange_maximum:E}")
self.elm_set_zero_check(elm, False)
assert self.elm_get_zero_check(elm) == False, "failed to disable zero check"
self.process.emit("message", "Ramp to start...")
# Output enable
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON)
time.sleep(.100)
self.process.emit("state", dict(
hvsrc_output=self.hvsrc_get_output_state(hvsrc)
))
self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_ON)
time.sleep(.100)
self.process.emit("state", dict(
vsrc_output=self.vsrc_get_output_state(vsrc)
))
# Ramp HV Spource to bias voltage
voltage = self.vsrc_get_voltage_level(vsrc)
logging.info("V Source ramp to bias voltage: from %E V to %E V with step %E V", voltage, bias_voltage, 1.0)
for voltage in comet.Range(voltage, bias_voltage, 1.0):
self.process.emit("message", "Ramp to bias... {}".format(format_metric(voltage, "V")))
self.vsrc_set_voltage_level(vsrc, voltage)
self.process.emit("state", dict(
vsrc_voltage=voltage,
))
time.sleep(QUICK_RAMP_DELAY)
# Compliance tripped?
self.vsrc_check_compliance(vsrc)
if not self.process.running:
break
# Ramp HV Source to start voltage
voltage = self.hvsrc_get_voltage_level(hvsrc)
logging.info("HV Source ramp to start voltage: from %E V to %E V with step %E V", voltage, voltage_start, 1.0)
for voltage in comet.Range(voltage, voltage_start, 1.0):
self.process.emit("message", "Ramp to start... {}".format(format_metric(voltage, "V")))
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(
hvsrc_voltage=voltage,
))
time.sleep(QUICK_RAMP_DELAY)
# Compliance tripped?
self.hvsrc_check_compliance(hvsrc)
if not self.process.running:
break
self.process.emit("progress", 5, 5)
def measure(self, hvsrc, vsrc):
self.process.emit("progress", 1, 2)
# Parameters
voltage_start = self.get_parameter('voltage_start')
voltage_stop = self.get_parameter('voltage_stop')
voltage_step = self.get_parameter('voltage_step')
waiting_time = self.get_parameter('waiting_time')
bias_voltage = self.get_parameter('bias_voltage')
bias_mode = self.get_parameter('bias_mode')
hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance')
vsrc_accept_compliance = self.get_parameter('vsrc_accept_compliance')
if not self.process.running:
return
voltage = self.hvsrc_get_voltage_level(hvsrc)
ramp = comet.Range(voltage, voltage_stop, voltage_step)
est = Estimate(ramp.count)
self.process.emit("progress", *est.progress)
t0 = time.time()
logger.info(
"HV Source ramp to end voltage: from %E V to %E V with step %E V",
voltage, ramp.end, ramp.step)
for voltage in ramp:
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(hvsrc_voltage=voltage, ))
# Move bias TODO
if bias_mode == "offset":
bias_voltage += abs(
ramp.step) if ramp.begin <= ramp.end else -abs(ramp.step)
self.vsrc_set_voltage_level(vsrc, bias_voltage)
self.process.emit("state", dict(vsrc_voltage=bias_voltage, ))
time.sleep(waiting_time)
dt = time.time() - t0
est.advance()
self.process.emit(
"message", "{} | HV Source {} | Bias {}".format(
format_estimate(est), format_metric(voltage, "V"),
format_metric(bias_voltage, "V")))
self.process.emit("progress", *est.progress)
self.environment_update()
# read V Source
vsrc_reading = self.vsrc_read_current(vsrc)
self.process.emit("reading", "vsrc",
abs(voltage) if ramp.step < 0 else voltage,
vsrc_reading)
# read HV Source
hvsrc_reading = self.hvsrc_read_current(hvsrc)
self.process.emit("update")
self.process.emit(
"state",
dict(hvsrc_current=hvsrc_reading, vsrc_current=vsrc_reading))
# Append series data
self.append_series(
timestamp=dt,
voltage=voltage,
current_vsrc=vsrc_reading,
bias_voltage=bias_voltage,
temperature_box=self.environment_temperature_box,
temperature_chuck=self.environment_temperature_chuck,
humidity_box=self.environment_humidity_box)
# Compliance tripped?
if hvsrc_accept_compliance:
if self.hvsrc_compliance_tripped(hvsrc):
logger.info(
"HV Source compliance tripped, gracefully stopping measurement."
)
break
else:
self.hvsrc_check_compliance(hvsrc)
if vsrc_accept_compliance:
if self.vsrc_compliance_tripped(vsrc):
logger.info(
"V Source compliance tripped, gracefully stopping measurement."
)
break
else:
self.vsrc_check_compliance(vsrc)
if not self.process.running:
break
self.process.emit("progress", 2, 2)
def initialize(self, vsrc):
self.process.emit("progress", 0, 5)
# Parameters
current_start = self.get_parameter('current_start')
current_stop = self.get_parameter('current_stop')
current_step = self.get_parameter('current_step')
waiting_time = self.get_parameter('waiting_time')
vsrc_voltage_compliance = self.get_parameter('vsrc_voltage_compliance')
vsrc_sense_mode = self.get_parameter('vsrc_sense_mode')
vsrc_filter_enable = self.get_parameter('vsrc_filter_enable')
vsrc_filter_count = self.get_parameter('vsrc_filter_count')
vsrc_filter_type = self.get_parameter('vsrc_filter_type')
# Extend meta data
self.set_meta("current_start", f"{current_start:G} A")
self.set_meta("current_stop", f"{current_stop:G} A")
self.set_meta("current_step", f"{current_step:G} A")
self.set_meta("waiting_time", f"{waiting_time:G} s")
self.set_meta("vsrc_voltage_compliance",
f"{vsrc_voltage_compliance:G} V")
self.vsrc_update_meta()
self.environment_update_meta()
# Series units
self.set_series_unit("timestamp", "s")
self.set_series_unit("current", "A")
self.set_series_unit("voltage_vsrc", "V")
self.set_series_unit("temperature_box", "degC")
self.set_series_unit("temperature_chuck", "degC")
self.set_series_unit("humidity_box", "%")
# Series
self.register_series("timestamp")
self.register_series("current")
self.register_series("voltage_vsrc")
self.register_series("temperature_box")
self.register_series("temperature_chuck")
self.register_series("humidity_box")
self.process.emit(
"state",
dict(vsrc_voltage=self.vsrc_get_voltage_level(vsrc),
vsrc_current=self.vsrc_get_current_level(vsrc),
vsrc_output=self.vsrc_get_output_state(vsrc)))
# Initialize V Source
self.process.emit("progress", 1, 5)
self.vsrc_reset(vsrc)
self.process.emit("progress", 2, 5)
self.vsrc_setup(vsrc)
# Current source
self.vsrc_set_function_current(vsrc)
self.vsrc_set_voltage_compliance(vsrc, vsrc_voltage_compliance)
self.process.emit("progress", 3, 5)
# Override display
self.vsrc_set_display(vsrc, 'voltage')
self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_ON)
time.sleep(.100)
self.process.emit("state",
dict(vsrc_output=self.vsrc_get_output_state(vsrc), ))
self.process.emit("progress", 4, 5)
if self.process.running:
current = self.vsrc_get_current_level(vsrc)
logging.info(
"V Source ramp to start current: from %E A to %E A with step %E A",
current, current_start, current_step)
for current in comet.Range(current, current_start, current_step):
self.process.emit(
"message",
"Ramp to start... {}".format(format_metric(current, "A")))
self.vsrc_set_current_level(vsrc, current)
time.sleep(QUICK_RAMP_DELAY)
self.process.emit("state", dict(vsrc_current=current, ))
# Compliance tripped?
self.vsrc_check_compliance(vsrc)
if not self.process.running:
break
self.process.emit("progress", 5, 5)
def initialize(self, hvsrc, elm):
self.process.emit("progress", 0, 5)
# Parameters
voltage_start = self.get_parameter('voltage_start')
voltage_stop = self.get_parameter('voltage_stop')
voltage_step = self.get_parameter('voltage_step')
waiting_time = self.get_parameter('waiting_time')
voltage_step_before = self.get_parameter(
'voltage_step_before') or self.get_parameter('voltage_step')
waiting_time_before = self.get_parameter('waiting_time_before')
voltage_step_after = self.get_parameter(
'voltage_step_after') or self.get_parameter('voltage_step')
waiting_time_after = self.get_parameter('waiting_time_after')
waiting_time_start = self.get_parameter('waiting_time_start')
waiting_time_end = self.get_parameter('waiting_time_end')
hvsrc_current_compliance = self.get_parameter(
'hvsrc_current_compliance')
hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance')
elm_filter_enable = self.get_parameter('elm_filter_enable')
elm_filter_count = self.get_parameter('elm_filter_count')
elm_filter_type = self.get_parameter('elm_filter_type')
elm_zero_correction = self.get_parameter('elm_zero_correction')
elm_integration_rate = self.get_parameter('elm_integration_rate')
elm_current_range = self.get_parameter('elm_current_range')
elm_current_autorange_enable = self.get_parameter(
'elm_current_autorange_enable')
elm_current_autorange_minimum = self.get_parameter(
'elm_current_autorange_minimum')
elm_current_autorange_maximum = self.get_parameter(
'elm_current_autorange_maximum')
elm_read_timeout = self.get_parameter('elm_read_timeout')
# Extend meta data
self.set_meta("voltage_start", f"{voltage_start:G} V")
self.set_meta("voltage_stop", f"{voltage_stop:G} V")
self.set_meta("voltage_step", f"{voltage_step:G} V")
self.set_meta("waiting_time", f"{waiting_time:G} s")
self.set_meta("voltage_step_before", f"{voltage_step_before:G} V")
self.set_meta("waiting_time_before", f"{waiting_time_before:G} s")
self.set_meta("voltage_step_after", f"{voltage_step_after:G} V")
self.set_meta("waiting_time_after", f"{waiting_time_after:G} s")
self.set_meta("waiting_time_start", f"{waiting_time_start:G} s")
self.set_meta("waiting_time_end", f"{waiting_time_end:G} s")
self.set_meta("hvsrc_current_compliance",
f"{hvsrc_current_compliance:G} A")
self.set_meta("hvsrc_accept_compliance", hvsrc_accept_compliance)
self.hvsrc_update_meta()
self.set_meta("elm_filter_enable", elm_filter_enable)
self.set_meta("elm_filter_count", elm_filter_count)
self.set_meta("elm_filter_type", elm_filter_type)
self.set_meta("elm_zero_correction", elm_zero_correction)
self.set_meta("elm_integration_rate", elm_integration_rate)
self.set_meta("elm_current_range", format(elm_current_range, 'G'))
self.set_meta("elm_current_autorange_enable",
elm_current_autorange_enable)
self.set_meta("elm_current_autorange_minimum",
format(elm_current_autorange_minimum, 'G'))
self.set_meta("elm_current_autorange_maximum",
format(elm_current_autorange_maximum, 'G'))
self.set_meta("elm_read_timeout", format(elm_read_timeout, 'G'))
self.elm_update_meta()
self.environment_update_meta()
# Series units
self.set_series_unit("timestamp", "s")
self.set_series_unit("voltage", "V")
self.set_series_unit("current_hvsrc", "A")
self.set_series_unit("current_elm", "A")
self.set_series_unit("temperature_box", "degC")
self.set_series_unit("temperature_chuck", "degC")
self.set_series_unit("humidity_box", "%")
# Series
self.register_series("timestamp")
self.register_series("voltage")
self.register_series("current_hvsrc")
self.register_series("current_elm")
self.register_series("temperature_box")
self.register_series("temperature_chuck")
self.register_series("humidity_box")
self.hvsrc_reset(hvsrc)
self.hvsrc_setup(hvsrc)
self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance)
self.process.emit(
"state",
dict(hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc),
hvsrc_current=None,
hvsrc_output=self.hvsrc_get_output_state(hvsrc),
elm_current=None))
self.process.emit("progress", 1, 5)
# If output disabled
voltage = 0
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON)
time.sleep(.100)
self.process.emit(
"state", dict(hvsrc_output=self.hvsrc_get_output_state(hvsrc)))
self.process.emit("progress", 2, 5)
self.elm_safe_write(elm, "*RST")
self.elm_safe_write(elm, "*CLS")
# Filter
self.elm_safe_write(elm, f":SENS:CURR:AVER:COUN {elm_filter_count:d}")
if elm_filter_type == "repeat":
self.elm_safe_write(elm, ":SENS:CURR:AVER:TCON REP")
elif elm_filter_type == "repeat":
self.elm_safe_write(elm, ":SENS:CURR:AVER:TCON MOV")
if elm_filter_enable:
self.elm_safe_write(elm, ":SENS:CURR:AVER:STATE ON")
else:
self.elm_safe_write(elm, ":SENS:CURR:AVER:STATE OFF")
nplc = elm_integration_rate / 10.
self.elm_safe_write(elm, f":SENS:CURR:NPLC {nplc:02f}")
self.elm_set_zero_check(elm, True)
assert self.elm_get_zero_check(
elm) == True, "failed to enable zero check"
self.elm_safe_write(elm, ":SENS:FUNC 'CURR'") # note the quotes!
assert elm.resource.query(
":SENS:FUNC?"
) == '"CURR:DC"', "failed to set sense function to current"
self.elm_safe_write(elm, f":SENS:CURR:RANG {elm_current_range:E}")
if elm_zero_correction:
self.elm_safe_write(elm,
":SYST:ZCOR ON") # perform zero correction
# Auto range
self.elm_safe_write(
elm, f":SENS:CURR:RANG:AUTO {elm_current_autorange_enable:d}")
self.elm_safe_write(
elm,
f":SENS:CURR:RANG:AUTO:LLIM {elm_current_autorange_minimum:E}")
self.elm_safe_write(
elm,
f":SENS:CURR:RANG:AUTO:ULIM {elm_current_autorange_maximum:E}")
self.elm_set_zero_check(elm, False)
assert self.elm_get_zero_check(
elm) == False, "failed to disable zero check"
voltage = self.hvsrc_get_voltage_level(hvsrc)
logger.info(
"HV Source ramp to start voltage: from %E V to %E V with step %E V",
voltage, voltage_start, voltage_step_before)
for voltage in comet.Range(voltage, voltage_start,
voltage_step_before):
self.process.emit("message", f"{voltage:.3f} V")
self.hvsrc_set_voltage_level(hvsrc, voltage)
self.process.emit("state", dict(hvsrc_voltage=voltage, ))
time.sleep(waiting_time_before)
# Compliance tripped?
self.hvsrc_check_compliance(hvsrc)
if not self.process.running:
break
# Waiting time before measurement ramp.
self.wait(waiting_time_start)
self.process.emit("progress", 3, 5)
def measure(self, lcr):
self.process.emit("progress", 1, 2)
# Parameters
bias_voltage_start = self.get_parameter('bias_voltage_start')
bias_voltage_step = self.get_parameter('bias_voltage_step')
bias_voltage_stop = self.get_parameter('bias_voltage_stop')
waiting_time = self.get_parameter('waiting_time')
lcr_soft_filter = self.get_parameter('lcr_soft_filter')
# Ramp to start voltage
lcr_voltage_level = self.lcr_get_bias_voltage_level(lcr)
logging.info(
"LCR Meter ramp to start voltage: from %E V to %E V with step %E V",
lcr_voltage_level, bias_voltage_start, bias_voltage_step)
for voltage in comet.Range(lcr_voltage_level, bias_voltage_start,
bias_voltage_step):
self.process.emit(
"message",
"Ramp to start... {}".format(format_metric(voltage, "V")))
self.process.emit("progress", 0, 1)
self.lcr_set_bias_voltage_level(lcr, voltage)
time.sleep(QUICK_RAMP_DELAY)
self.process.emit("state", dict(lcr_voltage=voltage, ))
if not self.process.running:
break
if not self.process.running:
return
lcr_voltage_level = self.lcr_get_bias_voltage_level(lcr)
ramp = comet.Range(lcr_voltage_level, bias_voltage_stop,
bias_voltage_step)
est = Estimate(ramp.count)
self.process.emit("progress", *est.progress)
t0 = time.time()
lcr.clear()
benchmark_step = Benchmark("Single_Step")
benchmark_lcr = Benchmark("Read_LCR")
benchmark_lcr_source = Benchmark("Read_LCR_Source")
benchmark_environ = Benchmark("Read_Environment")
logging.info(
"LCR Meter ramp to end voltage: from %E V to %E V with step %E V",
lcr_voltage_level, ramp.end, ramp.step)
for voltage in ramp:
with benchmark_step:
self.lcr_set_bias_voltage_level(lcr, voltage)
# Delay
time.sleep(waiting_time)
dt = time.time() - t0
est.advance()
self.process.emit(
"message",
"{} | V Source {}".format(format_estimate(est),
format_metric(voltage, "V")))
self.process.emit("progress", *est.progress)
# read LCR, for CpRp -> prim: Cp, sec: Rp
with benchmark_lcr:
try:
if lcr_soft_filter:
lcr_prim, lcr_sec = self.lcr_acquire_filter_reading(
lcr)
else:
lcr_prim, lcr_sec = self.lcr_acquire_reading(lcr)
except Exception as exc:
raise RuntimeError(
f"Failed to read from LCR: {exc}") from exc
try:
lcr_prim2 = 1.0 / (lcr_prim * lcr_prim)
except ZeroDivisionError:
lcr_prim2 = 0.0
# read V Source
with benchmark_lcr_source:
lcr_reading = self.lcr_get_bias_polarity_current_level(lcr)
logging.info("LCR reading: %s",
format_metric(lcr_reading, "A"))
self.process.emit("reading", "lcr",
abs(voltage) if ramp.step < 0 else voltage,
lcr_prim)
self.process.emit("reading", "lcr2",
abs(voltage) if ramp.step < 0 else voltage,
lcr_prim2)
self.process.emit("update")
self.process.emit(
"state", dict(lcr_voltage=voltage,
lcr_current=lcr_reading))
self.environment_update()
self.process.emit(
"state",
dict(env_chuck_temperature=self.
environment_temperature_chuck,
env_box_temperature=self.environment_temperature_box,
env_box_humidity=self.environment_humidity_box))
# Append series data
self.append_series(
timestamp=dt,
voltage_lcr=voltage,
current_lcr=lcr_reading,
capacitance=lcr_prim,
capacitance2=lcr_prim2,
resistance=lcr_sec,
temperature_box=self.environment_temperature_box,
temperature_chuck=self.environment_temperature_chuck,
humidity_box=self.environment_humidity_box)
if not self.process.running:
break
logging.info(benchmark_step)
logging.info(benchmark_lcr)
logging.info(benchmark_lcr_source)
logging.info(benchmark_environ)
def initialize(self, lcr):
self.process.emit("progress", 1, 6)
# Parameters
bias_voltage_start = self.get_parameter('bias_voltage_start')
bias_voltage_step = self.get_parameter('bias_voltage_step')
bias_voltage_stop = self.get_parameter('bias_voltage_stop')
waiting_time = self.get_parameter('waiting_time')
bias_voltage_step_before = self.get_parameter('bias_voltage_step_before') or self.get_parameter('bias_voltage_step')
waiting_time_before = self.get_parameter('waiting_time_before')
bias_voltage_step_after = self.get_parameter('bias_voltage_step_after') or self.get_parameter('bias_voltage_step')
waiting_time_after = self.get_parameter('waiting_time_after')
waiting_time_start = self.get_parameter('waiting_time_start')
waiting_time_end = self.get_parameter('waiting_time_end')
# Extend meta data
self.set_meta("bias_voltage_start", f"{bias_voltage_start:G} V")
self.set_meta("bias_voltage_stop", f"{bias_voltage_stop:G} V")
self.set_meta("bias_voltage_step", f"{bias_voltage_step:G} V")
self.set_meta("waiting_time", f"{waiting_time:G} s")
self.set_meta("bias_voltage_step_before", f"{bias_voltage_step_before:G} V")
self.set_meta("waiting_time_before", f"{waiting_time_before:G} s")
self.set_meta("bias_voltage_step_after", f"{bias_voltage_step_after:G} V")
self.set_meta("waiting_time_after", f"{waiting_time_after:G} s")
self.set_meta("waiting_time_start", f"{waiting_time_start:G} s")
self.set_meta("waiting_time_end", f"{waiting_time_end:G} s")
self.lcr_update_meta()
self.environment_update_meta()
# Series units
self.set_series_unit("timestamp", "s")
self.set_series_unit("voltage_lcr", "V")
self.set_series_unit("current_lcr", "A")
self.set_series_unit("capacitance", "F")
self.set_series_unit("capacitance2", "1")
self.set_series_unit("resistance", "Ohm")
self.set_series_unit("temperature_box", "degC")
self.set_series_unit("temperature_chuck", "degC")
self.set_series_unit("humidity_box", "%")
# Series
self.register_series("timestamp")
self.register_series("voltage_lcr")
self.register_series("current_lcr")
self.register_series("capacitance")
self.register_series("capacitance2")
self.register_series("resistance")
self.register_series("temperature_box")
self.register_series("temperature_chuck")
self.register_series("humidity_box")
# Initialize LCR
self.quick_ramp_zero(lcr)
self.lcr_reset(lcr)
self.process.emit("progress", 5, 6)
self.lcr_setup(lcr)
self.process.emit("progress", 6, 6)
self.lcr_set_bias_voltage_level(lcr, 0)
self.lcr_set_bias_state(lcr, True)
self.process.emit("state", dict(
lcr_voltage=self.lcr_get_bias_voltage_level(lcr),
lcr_output=self.lcr_get_bias_state(lcr),
))
# Ramp to start voltage
lcr_voltage_level = self.lcr_get_bias_voltage_level(lcr)
logger.info("LCR Meter ramp to start voltage: from %E V to %E V with step %E V", lcr_voltage_level, bias_voltage_start, bias_voltage_step_before)
for voltage in comet.Range(lcr_voltage_level, bias_voltage_start, bias_voltage_step_before):
self.process.emit("message", "Ramp to start... {}".format(format_metric(voltage, "V")))
self.process.emit("progress", 0, 1)
self.lcr_set_bias_voltage_level(lcr, voltage)
time.sleep(waiting_time_after)
self.process.emit("state", dict(
lcr_voltage=voltage,
))
if not self.process.running:
break
# Waiting time before measurement ramp.
self.wait(waiting_time_start)
