def test_get_lna_num():
for lnaidx, lnaname in enumerate(["HA1", "HA2", "HA3", "HB3", "HB2", "HB1"]):
assert get_lna_num(lnaname) == lnaidx
for lnaidx, lnaname in enumerate(["H0", "H1", "H2", "H3", "H4", "H5"]):
assert get_lna_num(lnaname) == lnaidx
for lnaidx, lnaname in enumerate(["Q1", "Q2", "Q3", "Q4", "Q5", "Q6"]):
assert get_lna_num(lnaname) == lnaidx
for lnaidx, lnaname in enumerate(range(6)):
assert get_lna_num(lnaname) == lnaidx
def load_one_curve_polna(datfile, tags_arr, pol, lna, tag_ref="SET_VGVD_"):
"""
This function obtains the ID, VG and VD for one LNA
(in one polarimeter).
Params:
-------
Return:
-------
"""
lna_num = st.get_lna_num(lna)
idcur_in = f"{pol}_{lna}_{tag_ref}"
tagcur_all = get_string_from_tag(tags_arr, idcur_in, relational_op="in")
#
vg_idx = np.unique(
np.array([cc.split("_")[0] for cc in tagcur_all]).astype(int))
vd_idx = np.unique(
np.array([cc.split("_")[1] for cc in tagcur_all]).astype(int))
curAll = np.zeros(
[np.max(vg_idx) + 1, np.max(vd_idx) + 1],
[("DrainI", "<f4"), ("GateV", "<f4"), ("DrainV", "<f4")],
)
curInfo = np.zeros(
[np.max(vg_idx) + 1, np.max(vd_idx) + 1],
[("count", "<f4"), ("t_start", "<f4"), ("t_end", "<f4")],
)
param_vg = f"BIAS POL_{pol} VG{lna_num}_HK"
param_vd = f"BIAS POL_{pol} VD{lna_num}_HK"
param_id = f"BIAS POL_{pol} ID{lna_num}_HK"
print(f"Case: {idcur_in}")
print(f"reading: {param_vg}, {param_vd}, {param_id}\n")
# print(f"\n\t tagcur_all: {tagcur_all}")
# print(f"\n\t vg_idx: {vg_idx}\n\t vd_idx: {vd_idx}")
for cc in tagcur_all:
idx_vg = int(cc.split("_")[0])
idx_vd = int(cc.split("_")[1])
t0, t1 = get_time_tag_in(tags_arr, idcur_in + cc)[0]
tvg, vvg, dictVG = get_selection_param(datfile, param_vg, t0, t1)
tvd, vvd, dictVD = get_selection_param(datfile, param_vd, t0, t1)
tid, vid, dictID = get_selection_param(datfile, param_id, t0, t1)
nc_vg, nc_vd, nc_id = dictVG["count"], dictVD["count"], dictID["count"]
if nc_vg != nc_vd or nc_vd != nc_id:
valid = f"\n\t{pol}_{lna} for {cc} (nVg,nVD,nID):{nc_vg},{nc_vd},{nc_id}"
raise warnings.warn(f"VG, VD and ID counts are different {valid}")
curAll[idx_vg, idx_vd] = vid, vvg, vvd
curInfo[idx_vg, idx_vd] = nc_id, t0, t1
return curAll, curInfo
def setup_lna_bias(self,
polarimeter,
lna,
bias_dict,
param_name,
excel_entry,
value=None,
step=1):
self.setup_bias(
polarimeter=polarimeter,
index=get_lna_num(lna),
bias_dict=bias_dict,
param_name=param_name,
excel_entry=excel_entry,
value=value,
step=step,
)
def get_calibration_curve(self, polarimeter, hk, component):
"""Return a :class:`CalibrationCurve` object for an housekeeping parameter
Args:
polarimeter (str): the name of the polarimeter, e.g., `I4` or `W3`
hk (str): one of the following strings:
- ``vdrain``: drain voltage
- ``idrain``: drain current
- ``vgate``: gate voltage
- ``vphsw``: voltage pin for a phase switch
- ``iphsw``: current pin for a phase switch
component (str): name of the component within the
polarimeter. For LNAs, you can use whatever string
works with :meth:`striptease.get_lna_num`. For phase
switches, you must pass an integer number in the range
0…3.
Return:
A :class:`.CalibrationCurve` object.
"""
hk_key = hk.lower()
polarimeter_id = normalize_polarimeter_name(polarimeter)
if hk_key in ("vdrain", "idrain", "vgate"):
component_id = get_lna_num(component)
else:
component_id = component
return self.calibration_curves[hk_key][polarimeter_id][component_id]
def run(self):
# Turn on the polarimeter(s)
for cur_board in STRIP_BOARD_NAMES:
# Append the sequence of commands to turnon this board to
# the JSON object
# self.command_emitter.command_list += self.turn_on_board(cur_board)
pass
# Verification step
with StripTag(
conn=self.command_emitter,
name="IVTEST_VERIFICATION_TURNON",
):
# Wait a while after having turned on all the boards
self.wait(seconds=10)
# Load the matrices of the unit-test measurements done in
# Bicocca and save them in "self.bicocca_data"
self.bicocca_test = get_unit_test(args.bicocca_test_id)
module_name = InstrumentBiases().polarimeter_to_module_name(
self.bicocca_test.polarimeter_name)
log.info(
"Test %d for %s (%s) loaded from %s, is_cryogenic=%s",
args.bicocca_test_id,
self.bicocca_test.polarimeter_name,
module_name,
self.bicocca_test.url,
str(self.bicocca_test.is_cryogenic),
)
self.bicocca_data = load_unit_test_data(self.bicocca_test)
assert isinstance(self.bicocca_data, UnitTestDC)
log.info(
" The polarimeter %s corresponds to module %s",
self.bicocca_test.polarimeter_name,
module_name,
)
calibr = CalibrationTables()
defaultBias = InstrumentBiases()
lna_list = get_lna_list(pol_name=self.bicocca_test.polarimeter_name)
#--> First test: ID vs VD --> For each VG, we used VD curves
self.conn.tag_start(name=f"IVTEST_IDVD_{module_name}")
for lna in lna_list:
lna_number = get_lna_num(lna)
#Read default configuration
with StripTag(
conn=self.command_emitter,
name=f"{module_name}_{lna}_READDEFAULT_VGVD",
):
# read bias in mV
default_vg_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vgate",
component=lna,
value=defaultBias.get_biases(module_name,
param_hk=f"VG{lna_number}"),
)
# read bias in mV
default_vd_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vdrain",
component=lna,
value=defaultBias.get_biases(module_name,
param_hk=f"VD{lna_number}"),
)
#Get the data matrix and the Gate Voltage vector.
matrixIDVD = self.bicocca_data.components[lna].curves["IDVD"]
#from V to mV
vgate = np.mean(matrixIDVD["GateV"], axis=0) * 1000
selvg = vgate >= -360
vgate = vgate[selvg]
# For each Vg, we have several curves varing Vd
for vg_idx, vg in enumerate(vgate):
vg_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vgate",
component=lna,
value=vg,
)
self.conn.set_vg(
polarimeter=module_name,
lna=lna,
value_adu=vg_adu,
)
#from V to mV
curve_vdrain = matrixIDVD["DrainV"][:, vg_idx] * 1000
for vd_idx, vd in enumerate(curve_vdrain):
vd_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vdrain",
component=lna,
value=vd,
)
self.conn.set_vd(
polarimeter=module_name,
lna=lna,
value_adu=vd_adu,
)
with StripTag(
conn=self.command_emitter,
name=
f"{module_name}_{lna}_SET_VGVD_{vg_idx}_{vd_idx}",
comment=f"VG_{vg:.2f}mV_VD_{vd:.2f}mV",
):
self.conn.set_hk_scan(allboards=True)
self.conn.wait(self.waittime_perconf_s)
# Back to the default values of vd and vg (for each LNA)
with StripTag(
conn=self.command_emitter,
name=f"{module_name}_{lna}_BACK2DEFAULT_VGVD",
):
self.conn.set_vg(
polarimeter=module_name,
lna=lna,
value_adu=default_vg_adu,
)
self.conn.set_vd(
polarimeter=module_name,
lna=lna,
value_adu=default_vd_adu,
)
self.conn.wait(self.waittime_perconf_s)
self.conn.tag_stop(name=f"IVTEST_IDVD_{module_name}")
#
#--> Second test: ID vs VG --> For each VD, we used VG curves
self.conn.tag_start(name=f"IVTEST_IDVG_{module_name}")
for lna in lna_list:
lna_number = get_lna_num(lna)
#Read default configuration
with StripTag(
conn=self.command_emitter,
name=f"{module_name}_{lna}_READDEFAULT_VDVG",
):
# read bias in mV
default_vg_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vgate",
component=lna,
value=defaultBias.get_biases(module_name,
param_hk=f"VG{lna_number}"),
)
# read bias in mV
default_vd_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vdrain",
component=lna,
value=defaultBias.get_biases(module_name,
param_hk=f"VD{lna_number}"),
)
#Get the data matrix and the Gate Voltage vector.
matrixIDVG = self.bicocca_data.components[lna].curves["IDVG"]
#from V to mV
vdrain = np.mean(matrixIDVG["DrainV"], axis=0) * 1000
# For each Vd, we have several curves varing Vg
for vd_idx, vd in enumerate(vdrain):
vd_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vdrain",
component=lna,
value=vd,
)
self.conn.set_vg(
polarimeter=module_name,
lna=lna,
value_adu=vd_adu,
)
#from V to mV
curve_vgate = matrixIDVG["GateV"][:, vd_idx] * 1000.
selcurvg = curve_vgate >= -360
curve_vgate = vgate[selvg]
for vg_idx, vg in enumerate(curve_vgate):
vg_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vgate",
component=lna,
value=vg,
)
self.conn.set_vd(
polarimeter=module_name,
lna=lna,
value_adu=vg_adu,
)
with StripTag(
conn=self.command_emitter,
name=f"{module_name}_{lna}_VDVG_{vd_idx}_{vg_idx}",
comment=f"VD_{vd:0.2f}mV_VG_{vg:.2f}mV",
):
#
self.conn.set_hk_scan(allboards=True)
self.conn.wait(self.waittime_perconf_s)
# Back to the default values of vd and vg (for each LNA)
with StripTag(
conn=self.command_emitter,
name=f"IVTEST_IDVG_{module_name}_{lna}_BACK2DEFAULT_VDVG",
):
self.conn.set_vg(
polarimeter=module_name,
lna=lna,
value_adu=default_vg_adu,
)
self.conn.set_vd(
polarimeter=module_name,
lna=lna,
value_adu=default_vd_adu,
)
self.conn.wait(self.waittime_perconf_s)
self.conn.tag_stop(name=f"IVTEST_IDVG_{module_name}")
def run(self):
# Turn on the polarimeter(s)
for cur_board in STRIP_BOARD_NAMES:
# Append the sequence of commands to turnon this board to
# the JSON object
# self.command_emitter.command_list += self.turn_on_board(cur_board)
pass
# Verification step
with StripTag(conn=self.command_emitter,
name="IVTEST_VERIFICATION_TURNON"):
# Wait a while after having turned on all the boards
self.wait(seconds=10)
# Load the matriix with the min, max and step for
# each LNA for each polarimeter
count_conf = 0
for pol_name in self.polarimeters:
module_name = self.inputBiasIV["Module"][pol_name]
log.info("-->Polarimeter %s (%s)", pol_name, module_name)
calibr = CalibrationTables()
defaultBias = InstrumentBiases()
lna_list = get_lna_list(pol_name=pol_name)
# --> First test: ID vs VD --> For each VG, we used VD curves
self.conn.tag_start(name=f"IVTEST_{module_name}")
for lna in lna_list:
lna_number = get_lna_num(lna)
# Read default configuration
with StripTag(
conn=self.command_emitter,
name=f"{module_name}_{lna}_READDEFAULT_VGVD",
):
# read bias in mV
default_vg_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vgate",
component=lna,
value=getattr(defaultBias.get_biases(module_name),
f"vg{lna_number}"),
)
# read bias in mV
default_vd_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vdrain",
component=lna,
value=getattr(defaultBias.get_biases(module_name),
f"vd{lna_number}"),
)
# Get the data matrix and the Gate Voltage vector.
# in mV
vgate = self.get_bias_curve(pol_name, lna)
vdrain = np.arange(0, 900, 50)
count_conf += len(vgate) * len(vdrain)
# For each Vg, we have several curves varing Vd
for vg_idx, vg in enumerate(vgate):
vg_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vgate",
component=lna,
value=vg)
self.conn.set_vg(polarimeter=module_name,
lna=lna,
value_adu=vg_adu)
for vd_idx, vd in enumerate(vdrain):
vd_adu = calibr.physical_units_to_adu(
polarimeter=module_name,
hk="vdrain",
component=lna,
value=vd,
)
self.conn.set_vd(polarimeter=module_name,
lna=lna,
value_adu=vd_adu)
with StripTag(
conn=self.command_emitter,
name=
f"{module_name}_{lna}_SET_VGVD_{vg_idx}_{vd_idx}",
comment=f"VG_{vg:.2f}mV_VD_{vd:.2f}mV",
):
if self.hk_scan == "True":
# print(f"hk_scan is {self.hk_scan}")
self.conn.set_hk_scan(allboards=True)
self.conn.wait(self.waittime_perconf_s)
# Back to the default values of vd and vg (for each LNA)
with StripTag(
conn=self.command_emitter,
name=f"{module_name}_{lna}_BACK2DEFAULT_VGVD",
):
self.conn.set_vg(polarimeter=module_name,
lna=lna,
value_adu=default_vg_adu)
self.conn.set_vd(polarimeter=module_name,
lna=lna,
value_adu=default_vd_adu)
self.conn.wait(self.waittime_perconf_s)
count_conf += 1
self.conn.tag_stop(name=f"IVTEST_IDVD_{module_name}")
log.info(
"Number of configuration and time [hrs, days]: %s [%s, %s]\n",
int(count_conf),
np.around(count_conf * self.waittime_perconf_s / 3600.0, 1),
np.around(count_conf * self.waittime_perconf_s / 3600 / 24, 3),
)
