Biasstep rebias

sodetlib/operations/bias_dets.py

@@ -3,7 +3,7 @@
 import time
 import matplotlib.pyplot as plt
 from sodetlib.operations.iv import IVAnalysis
-
+from sodetlib.operations import uxm_setup, uxm_relock, tracking, bias_steps, iv, bias_dets
 np.seterr(all="ignore")
 
 
@@ -201,3 +201,347 @@ def bias_to_rfrac(S, cfg, rfrac=0.5, bias_groups=None, iva=None,
 
     return biases
 
+def biasstep_rebias(
+        S, cfg, target_percentage_rn = 0.5, bias_groups=None,
+        math_only=False):
+
+    """
+    Scripts work well when detectors are already in transistion. For extreme cases
+    such as detectors are all in SC, it takes a few run to put them perfectly in
+    transition. Next step is making this script can handle extreme cases faster
+
+
+    """
+
+    ## take the initial biasstep
+    S.log("taking the first biasstep")
+    intical_current_biasvoltage = S.get_tes_bias_bipolar_array()
+    S.log(f"current biasvoltage {intical_current_biasvoltage}")
+    bsa_0 = bias_steps.take_bias_steps(S, cfg)
+    if not math_only:
+        bias_steps.plot_Rfrac(bsa_0)
+
+    ## load IV analysis result so can use dynamic step size
+    iva = iv.IVAnalysis.load(bsa_0.meta['iv_file'])
+
+    repeat_biasstep = False
+    ## check for script failue
+    for bl in bias_groups:
+        mask_bg = np.where(bsa_0.bgmap==bl)[0]
+        per_bl_R0 = bsa_0.R0[mask_bg]
+        if np.isnan(np.nanmedian(per_bl_R0)):
+            ## the yield is very low, could it be the biasstep analysis script failed? repeat again
+            repeat_biasstep = True
+            S.log("the biasstep script might have failed, going to repeat the measurement")
+
+    if repeat_biasstep:
+        S.log("retaking biasstep due to failure")
+        bsa_0 = bias_steps.take_bias_steps(S, cfg)
+        repeat_biasstep = False
+
+    percentage_rn_0 = bsa_0.R0/bsa_0.R_n_IV
+    ## add in checks if detectors are SC  
+    bg_overbias_needed = []
+    overbias_needed = False
+    for bl in bias_groups:
+        mask_bg = np.where(bsa_0.bgmap==bl)[0]
+        per_bl_percentage_rn_0 = percentage_rn_0[mask_bg]
+        ## mask for SC
+        mask_sc = np.where((per_bl_percentage_rn_0 < 0.1) & (per_bl_percentage_rn_0 > -0.1))
+        ## if more than 10 percent of the detectors are SC
+        if len(mask_sc[0]) > 0.1*len(mask_bg):
+            bg_overbias_needed.append(bl)
+            overbias_needed = True
+
+    ## add in check if detectors are normal, hence we should increase the drop step
+    bg_detectors_normal = []
+    drop_from_normal = False
+    for bl in bias_groups:
+        mask_bg = np.where(bsa_0.bgmap==bl)[0]
+        per_bl_percentage_rn_0 = percentage_rn_0[mask_bg]
+        ## mask for normal
+        mask_normal = np.where((per_bl_percentage_rn_0 > 0.9) | (per_bl_percentage_rn_0 < -0.9))
+        ## if more than half of the detectors are normal
+        if len(mask_normal[0]) > 0.5*len(mask_bg):
+            bg_detectors_normal.append(bl)   
+            drop_from_normal = True
+
+
+    if overbias_needed:
+        S.log(f"some BL: {bg_overbias_needed} are stuck in SC, going to over bias them, this takes about 5mins")
+        previous_dc_biases = S.get_tes_bias_bipolar_array()
+
+        sdl.overbias_dets(S, cfg, bias_groups=bg_overbias_needed)
+        ##force wait time 5 mins for UFM to reach equalibrium 
+        for sleep_index in range(5):
+            time.sleep(60)
+        safe_dc_biases = previous_dc_biases.copy()
+        for replace_bg in bg_overbias_needed:
+            safe_dc_biases[replace_bg] = cfg.dev.bias_groups[replace_bg]["testbed_100mK_bias_voltage"]
+
+        S.set_tes_bias_bipolar_array(safe_dc_biases)  
+        bsa_0 = bias_steps.take_bias_steps(S, cfg)
+        bias_steps.plot_Rfrac(bsa_0)
+
+        ## add in check if detectors are normal now
+        percentage_rn_0 = bsa_0.R0/bsa_0.R_n_IV
+        drop_from_normal = False
+        for bl in bg_overbias_needed:
+            mask_bg = np.where(bsa_0.bgmap==bl)[0]
+            per_bl_percentage_rn_0 = percentage_rn_0[mask_bg]
+            ## mask for normal
+            mask_normal = np.where((per_bl_percentage_rn_0 > 0.9) | (per_bl_percentage_rn_0 < -0.9))
+            ## if more than half of the detectors are normal
+            if len(mask_normal[0]) > 0.5*len(mask_bg):
+                bg_detectors_normal.append(bl)   
+                drop_from_normal = True
+
+## drop normal detector into transition first
+    while drop_from_normal:
+        S.log(f"some biaslines are still in normal state: {bg_detectors_normal}")
+        percentage_rn_0 = bsa_0.R0/bsa_0.R_n_IV
+        S.log("droping detectors from normal to transition")
+        previous_dc_biases_dfn = S.get_tes_bias_bipolar_array()
+
+        S.log(f"current tes bias voltages are: {previous_dc_biases_dfn}")
+        for bl in bg_detectors_normal:
+            mask_bg = np.where(bsa_0.bgmap==bl)[0]
+            v_sc = iva.v_bias[iva.idxs[[mask_bg], 0]]
+            v_norm = iva.v_bias[iva.idxs[[mask_bg], 1]]
+            v_spread = np.nanmedian(v_norm) - np.nanmedian(v_sc)
+            if previous_dc_biases_dfn[bl] > v_spread:
+                previous_dc_biases_dfn[bl] =  previous_dc_biases_dfn[bl] - 0.5 * v_spread
+            else:
+                previous_dc_biases_dfn[bl] =  previous_dc_biases_dfn[bl] - 0.3 * v_spread 
+                bg_detectors_normal.remove(bl)
+                S.log(f'biasline {bl} is approching 0 voltage, a confirmation new IV curve is recommended')
+
+        S.set_tes_bias_bipolar_array(previous_dc_biases_dfn)
+        S.log(f"applying: {previous_dc_biases_dfn}")
+        S.log(f"waiting 10s for dissipation of UFM local heating")
+        time.sleep(10)
+        bsa_0 = bias_steps.take_bias_steps(S, cfg)
+        percentage_rn_0 = bsa_0.R0/bsa_0.R_n_IV
+        drop_from_normal = False
+        for bl in bg_detectors_normal:
+            mask_bg = np.where(bsa_0.bgmap==bl)[0]
+            per_bl_percentage_rn_0 = percentage_rn_0[mask_bg]
+            ## mask for normal
+            mask_normal = np.where((per_bl_percentage_rn_0 > 0.9) | (per_bl_percentage_rn_0 < -0.9))
+            ## if more than half of the detectors are normal
+            if len(mask_normal[0]) > 0.5*len(mask_bg):
+                drop_from_normal = True
+            else:
+                bg_detectors_normal.remove(bl)
+        for bl in bg_detectors_normal:
+            if previous_dc_biases_dfn[bl] < 0.5:
+                bg_detectors_normal.remove(bl)
+
+
+
+
+    ##preparing for the 2nd step
+    initial_dc_biases = S.get_tes_bias_bipolar_array()
+    new_bias_voltage = initial_dc_biases.copy()
+
+
+
+
+    for bl in bias_groups:
+        mask_bg = np.where(bsa_0.bgmap==bl)[0]
+
+        per_bl_percentage_rn_0 = percentage_rn_0[mask_bg]
+
+        med_per_bl_percentage_rn = np.nanmedian(per_bl_percentage_rn_0)
+
+        ## use the latest IV to decide the step size, might be tricky to get a good step size in field
+        v_sc = iva.v_bias[iva.idxs[[mask_bg], 0]]
+        v_norm = iva.v_bias[iva.idxs[[mask_bg], 1]]
+        v_spread = np.nanmedian(v_norm) - np.nanmedian(v_sc)
+        ## take 15% of the spread as the step size, so the next biasstep will be taken from 0.25 ~ 0.75 percent Rn after considering the spread
+        delta_dc_bias = 0.15 * v_spread
+
+
+        ## if the current bias point is below 50% Rn, increase V_biaa
+        if med_per_bl_percentage_rn < 0.5:
+            new_bias_voltage[bl] =  initial_dc_biases[bl] + delta_dc_bias
+        if med_per_bl_percentage_rn >= 0.5:
+            new_bias_voltage[bl] =  initial_dc_biases[bl] - delta_dc_bias
+
+    S.log(f"applying new voltage for 2nd biasstep {new_bias_voltage}")
+    S.set_tes_bias_bipolar_array(new_bias_voltage)  
+
+    ## taking the second bias step
+    S.log("taking the 2nd biasstep")
+    bsa_1 = bias_steps.take_bias_steps(S, cfg)
+    if not math_only:
+        bias_steps.plot_Rfrac(bsa_1)
+
+    ## check for script failue
+    for bl in bias_groups:
+        mask_bg = np.where(bsa_1.bgmap==bl)[0]
+        per_bl_R0 = bsa_1.R0[mask_bg]
+        if np.isnan(np.nanmedian(per_bl_R0)):
+            ## the yield is very low, could it be the biasstep analysis script failed? repeat again
+            repeat_biasstep = True
+            S.log("the biasstep script might have failed, going to repeat the measurement")
+
+    if repeat_biasstep:
+        bsa_1 = bias_steps.take_bias_steps(S, cfg)
+        repeat_biasstep = False
+
+    percentage_rn_1 = bsa_1.R0/bsa_1.R_n_IV
+
+    target_percentage_rn_array = target_percentage_rn * np.ones(len(percentage_rn_0))
+    ## getting result from the previous 2
+    v0 = np.zeros(bsa_0.bgmap.shape[0])
+    for bl in range(12):
+        mask_bl = np.where(bsa_0.bgmap==bl)[0]
+        v0[mask_bl] = initial_dc_biases[bl]
+
+    v1 = np.zeros(bsa_1.bgmap.shape[0])
+    for bl in range(12):
+        mask_bl = np.where(bsa_1.bgmap==bl)[0]
+        v1[mask_bl] = new_bias_voltage[bl]   
+    ## deciding the new bias point
+    vbias_estimate_array = (v0*(target_percentage_rn_array-percentage_rn_1) + v1*(percentage_rn_0 - target_percentage_rn_array)) / (percentage_rn_0 - percentage_rn_1)
+
+    vbias_estimate = initial_dc_biases.copy()
+    for bl in bias_groups:
+        mask_bg = np.where(bsa_0.bgmap==bl)[0]
+
+        per_bl_vbias_estimate = vbias_estimate_array[mask_bg]
+        med_per_bl_vbias_estimate = np.nanmedian(per_bl_vbias_estimate)
+        if np.isnan(med_per_bl_vbias_estimate):
+            med_per_bl_vbias_estimate = (v1 + v0)/2
+        vbias_estimate[bl] = med_per_bl_vbias_estimate
+
+    S.log("applying the new bias voltages")
+    S.set_tes_bias_bipolar_array(vbias_estimate)  
+    S.log(f"applying {vbias_estimate}")
+    S.log("taking the final biasstep")
+    bsa_2 = bias_steps.take_bias_steps(S, cfg)
+
+    ## check for script failue
+    for bl in bias_groups:
+        mask_bg = np.where(bsa_2.bgmap==bl)[0]
+        per_bl_R0 = bsa_2.R0[mask_bg]
+        if np.isnan(np.nanmedian(per_bl_R0)):
+            ## the yield is very low, could it be the biasstep analysis script failed? repeat again
+            repeat_biasstep = True
+            S.log("the biasstep script might have failed, going to repeat the measurement")
+
+    if repeat_biasstep:
+        bsa_2 = bias_steps.take_bias_steps(S, cfg)
+        repeat_biasstep = False
+
+    if not math_only:
+        bias_steps.plot_Rfrac(bsa_2)
+
+
+    S.log("confirming if the current result is close to the target")
+    percentage_rn_confirm = bsa_2.R0/bsa_2.R_n_IV
+    succeeded_bl = []
+    un_succeeded_bl = []
+    for bl in bias_groups:
+        mask_bg = np.where(bsa_2.bgmap==bl)[0]
+        per_bl_percentage_rn_confirm = np.nanmedian(percentage_rn_confirm[mask_bg])
+        if per_bl_percentage_rn_confirm > target_percentage_rn - 0.05 and per_bl_percentage_rn_confirm < target_percentage_rn + 0.05:
+            succeeded_bl.append(bl)
+        else:
+            un_succeeded_bl.append(bl)
+    S.log(f"succeeded bl: {succeeded_bl}")
+    S.log(f"unsucceeded bl: {un_succeeded_bl}")
+
+    if len(un_succeeded_bl)==0:
+        bsa_final = bsa_2
+        vbias_estimate_final = vbias_estimate
+
+
+    if len(un_succeeded_bl)!=0:
+        extra_step_bias_voltage = vbias_estimate.copy()
+        S.log("fine tunning unsucceeded bl")
+        for bl in un_succeeded_bl:
+            mask_bg = np.where(bsa_2.bgmap==bl)[0]
+            per_bl_percentage_rn_confirm = percentage_rn_confirm[mask_bg]
+            med_per_bl_percentage_confirm = np.nanmedian(per_bl_percentage_rn_confirm)
+
+            ## use the latest IV to decide the step size, might be tricky to get a good step size in field
+            v_sc = iva.v_bias[iva.idxs[[mask_bg], 0]]
+            v_norm = iva.v_bias[iva.idxs[[mask_bg], 1]]
+            v_spread = np.nanmedian(v_norm) - np.nanmedian(v_sc)
+            ## take 15% of the spread as the step size, so the next biasstep will be taken from 0.25 ~ 0.75 percent Rn after considering the spread
+            delta_dc_bias = 0.15 * v_spread
+            ## if the current bias point is below 50% Rn, increase V_biaa
+            if med_per_bl_percentage_confirm < 0.5:
+                extra_step_bias_voltage[bl] =  vbias_estimate[bl] + delta_dc_bias
+            if med_per_bl_percentage_confirm >= 0.5:
+                extra_step_bias_voltage[bl] =  vbias_estimate[bl] - delta_dc_bias
+
+        S.log(f"applying new voltage for extra step biasstep {extra_step_bias_voltage}")
+        S.set_tes_bias_bipolar_array(extra_step_bias_voltage)
+
+        ## taking the extra bias step
+        S.log("taking the extra biasstep")
+        bsa_extra = bias_steps.take_bias_steps(S, cfg)
+
+        ## check for script failue
+        for bl in bias_groups:
+            mask_bg = np.where(bsa_extra.bgmap==bl)[0]
+            per_bl_R0 = bsa_extra.R0[mask_bg]
+            if np.isnan(np.nanmedian(per_bl_R0)):
+            ## the yield is very low, could it be the biasstep analysis script failed? repeat again
+                repeat_biasstep = True
+                S.log("the biasstep script might have failed, going to repeat the measurement")
+
+        if repeat_biasstep:
+            bsa_extra = bias_steps.take_bias_steps(S, cfg)
+            repeat_biasstep = False
+
+        if not math_only:
+            bias_steps.plot_Rfrac(bsa_extra)
+
+        percentage_rn_extra = bsa_extra.R0/bsa_extra.R_n_IV
+
+        ## getting result from the previous 2
+        v0 = np.zeros(bsa_2.bgmap.shape[0])
+        for bl in range(12):
+            mask_bl = np.where(bsa_2.bgmap==bl)[0]
+            v0[mask_bl] = vbias_estimate[bl]
+
+        v1 = np.zeros(bsa_extra.bgmap.shape[0])
+        for bl in range(12):
+            mask_bl = np.where(bsa_extra.bgmap==bl)[0]
+            v1[mask_bl] = extra_step_bias_voltage[bl]
+        ## deciding the new bias point
+        vbias_estimate_array_extra = (v0*(target_percentage_rn_array-percentage_rn_extra) + v1*(percentage_rn_confirm - target_percentage_rn_array)) / (percentage_rn_confirm - percentage_rn_extra)
+
+        vbias_estimate_final = initial_dc_biases.copy()
+        for bl in bias_groups:
+            mask_bg = np.where(bsa_2.bgmap==bl)[0]
+
+            per_bl_vbias_estimate = vbias_estimate_array_extra[mask_bg]
+            med_per_bl_vbias_estimate = np.nanmedian(per_bl_vbias_estimate)
+            if np.isnan(med_per_bl_vbias_estimate):
+                med_per_bl_vbias_estimate = (v1 + v0)/2
+            vbias_estimate_final[bl] = med_per_bl_vbias_estimate
+
+
+        S.log("applying the new bias voltages")
+        S.set_tes_bias_bipolar_array(vbias_estimate_final)
+        S.log(f"applying {vbias_estimate_final}")
+        S.log("taking the final biasstep")
+        bsa_final = bias_steps.take_bias_steps(S, cfg)
+        if not math_only:
+            bias_steps.plot_Rfrac(bsa_final)
+
+
+    return bsa_final,vbias_estimate_final
+
+
+
+
+
+
+
+

sodetlib/operations/bias_steps.py

@@ -960,7 +960,7 @@ def plot_Rfrac(bsa, text_loc=(0.6, 0.8)):
     chmap = sdl.map_band_chans(bsa.bands, bsa.channels,
                                iva.bands, iva.channels)
 
-    Rfracs = bsa.R0 / iva.R_n_IV[chmap]
+    Rfracs = bsa.R0 / iva.R_n[chmap]
     lim = (-0.1, 1.2)
     nbins=30
     bins = np.linspace(*lim, nbins)