todo

artiq_master/last_rid.pyon

-14234
+14317

artiq_master/repository/Experiments/Spectrum/With_calibration/IR/MICROMOTION_IR_spectrum_withcalib_delaysfixed_TwoIRLasers.py

@@ -129,8 +129,12 @@ class IR_Scan_withcal_optimized(EnvExperiment):
                              "Scan params")
 
 
-        self.setattr_argument("Voltage_Scan_type",
-                                  EnumerationValue(["volt_dcA", "volt_dcB", "volt_compOven"]),
+        self.setattr_argument("Sweep_type",
+                                  EnumerationValue(["heating_time", "volt_dcA", "volt_dcB", "volt_compOven"]),
+                              "Scan params")
+
+        self.setattr_argument("Plot_type",
+                                  EnumerationValue(["relative_depths", "absolute_depths"]),
                               "Scan params")
 
         self.setattr_argument("Scanning_voltages", Scannable(
@@ -140,6 +144,14 @@ class IR_Scan_withcal_optimized(EnvExperiment):
                                        ),
                              "Scan params")
 
+        self.setattr_argument("Scanning_heattimes", Scannable(
+                                       default=CenterScan(1*ms, 0.1*ms, 0.1*ms),
+                                        unit="ms",
+                                        scale=ms,
+                                        global_min = 0*ms,
+                                        global_max = 1000*ms
+                                       ),
+                             "Scan params")
 
         self.setattr_argument("Comments", StringValue(" "), "General comments")
 
@@ -171,6 +183,7 @@ class IR_Scan_withcal_optimized(EnvExperiment):
         self.set_dataset("IR2_CPT_freq", self.IR2_CPT_freq, broadcast=False, archive=True)
         self.set_dataset("IR2_CPT_amp", self.IR2_CPT_amp, broadcast=False, archive=True)
 
+        self.set_dataset("scanning_heattimes", self.Scanning_heattimes.sequence, broadcast=True, archive=True)
         self.set_dataset("scanning_voltages", self.Scanning_voltages.sequence, broadcast=True, archive=True)
 
         self.set_dataset("t_cool", self.t_cool, broadcast=False, archive=True)
@@ -178,9 +191,10 @@ class IR_Scan_withcal_optimized(EnvExperiment):
         self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
         self.set_dataset("t_heating", self.t_heating, broadcast=False, archive=True)
 
-        self.set_dataset("plot_array", np.zeros(len(self.Scanning_voltages.sequence)), broadcast=True, archive=True)
+        #self.set_dataset("plot_array", np.zeros(len(self.Scanning_voltages.sequence)), broadcast=True, archive=True)
+        self.set_dataset("plot_array", np.zeros(len(self.Scanning_heattimes.sequence)), broadcast=True, archive=True)
 
-        self.set_dataset("scanned_electrode", self.Voltage_Scan_type, broadcast=False, archive=True)
+        self.set_dataset("scanned", self.Sweep_type, broadcast=False, archive=True)
 
         self.set_dataset("initialvoltage_dcA", self.read_dcvoltage(cmd="volt_dcA")[0], broadcast=False, archive=True)
         self.set_dataset("initialvoltage_dcB", self.read_dcvoltage(cmd="volt_dcB")[0], broadcast=False, archive=True)
@@ -207,7 +221,7 @@ class IR_Scan_withcal_optimized(EnvExperiment):
         self.ccb.issue("create_applet", "DR_depth",
                         "${python} -m pyLIAF.artiq.applets.plot_xy "
                         "plot_array "
-                        "--x scanning_voltages")
+                        "--x scanning_heattimess")
 
     @rpc
     def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
@@ -224,7 +238,8 @@ class IR_Scan_withcal_optimized(EnvExperiment):
         self.set_dataset("IR1_Frequencies", np.array(Experiment_freqs), broadcast=True, archive=True)
         self.set_dataset("no_freqs", len(Calibrated_Experiment_freqs), broadcast=True, archive=True)
         #self.set_dataset("counts_spectrum", np.zeros(len(Experiment_freqs), dtype=int), broadcast=True, archive=True)
-        self.set_dataset("data_array", np.zeros(len(self.Scanning_voltages.sequence)*len(Experiment_freqs), dtype=int), broadcast=False, archive=True)
+        #self.set_dataset("data_array", np.zeros(len(self.Scanning_voltages.sequence)*len(Experiment_freqs), dtype=int), broadcast=False, archive=True)
+        self.set_dataset("data_array", np.zeros(len(self.Scanning_heattimes.sequence)*len(Experiment_freqs), dtype=int), broadcast=False, archive=True)
         return Experiment_freqs
 
 
@@ -273,10 +288,12 @@ class IR_Scan_withcal_optimized(EnvExperiment):
     @kernel
     def run(self):
 
+        initial_voltage = [0.2]
         self.initialize_andor_com()
+        if not self.Sweep_type == "heating_time":
+            print('ojo')
 
-        initial_voltage = self.read_dcvoltage(cmd=self.Voltage_Scan_type)
-
+            initial_voltage = self.read_dcvoltage(cmd=self.Sweep_type)
             print('initial voltage: ', initial_voltage[0])
 
         t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
@@ -284,6 +301,9 @@ class IR_Scan_withcal_optimized(EnvExperiment):
         Freqs = self.Get_Calibrated_Frequencies()
         #Freqs = self.UV_Freqs.sequence
         Amps = self.Get_Calibrated_Amplitudes()
+
+        Heattimes = self.Scanning_heattimes.sequence
+        print(Heattimes)
         Voltages = self.Scanning_voltages.sequence
         self.create_datasets()
         self.create_applets(len(Freqs))
@@ -297,9 +317,11 @@ class IR_Scan_withcal_optimized(EnvExperiment):
 
         self.enfriar_ion()
 
+        if not self.Sweep_type == "heating_time":
             voltage_index = 0
             while voltage_index < len(Voltages):
-            self.change_dcvoltage(Voltages[voltage_index], cmd=self.Voltage_Scan_type)
+                if not self.Sweep_type == "heating_time":
+                    self.change_dcvoltage(Voltages[voltage_index], cmd=self.Sweep_type)
                 iter_index = 0
                 temporal_freq_list=[0]*len(Freqs)
                 while iter_index < len(Freqs):
@@ -325,22 +347,76 @@ class IR_Scan_withcal_optimized(EnvExperiment):
                     delay(5000*us)
                     iter_index = iter_index + 1
 
+
+                if self.Plot_type == 'relative_depths':
                     self.mutate_dataset("plot_array", voltage_index, (temporal_freq_list[0]-temporal_freq_list[1])/temporal_freq_list[0])
+                elif self.Plot_type == 'absolute_depths':
+                    self.mutate_dataset("plot_array", voltage_index, temporal_freq_list[1])
                 #self.mutate_dataset("plot_array", voltage_index, (temporal_freq_list[0]-temporal_freq_list[1])/1)
 
                 voltage_index = voltage_index + 1
             delay(500*us)
 
+        if self.Sweep_type == "heating_time":
+            print('1')
+            voltage_index = 0
+            while voltage_index < len(Heattimes):
+                print(2)
+                iter_index = 0
+                temporal_freq_list=[0]*len(Freqs)
+                while iter_index < len(Freqs):
+                    Accumulated_counts = 0
+                    self.core.break_realtime()
+                    delay(10000*us)
+                    self.laserIR1.set_frequency(Freqs[iter_index], Amps[iter_index], profile=1) # Cambio la frec del perfil 1 (estoy en el 0)
+                    for runN in range(self.no_measures):
+                        if runN % 20 == 0:
+                            delay(self.t_cool)
+                        else:
+                            delay(100*us)
+
+                        self.laserUV.off()
+                        delay(Heattimes[voltage_index])
+                        self.laserUV.on()
+                        self.core.break_realtime()
+                        delay(20*us)
+                        cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                        Accumulated_counts = Accumulated_counts + cuentas
+                    self.mutate_dataset("data_array", voltage_index*len(Freqs)+iter_index, Accumulated_counts)
+                    temporal_freq_list[iter_index] = Accumulated_counts
+                    delay(5000*us)
+                    iter_index = iter_index + 1
+                print("done time")
+                if self.Plot_type == 'relative_depths':
+                    print(3)
+                    self.mutate_dataset("plot_array", voltage_index, (temporal_freq_list[0]-temporal_freq_list[1])/temporal_freq_list[0])
+                elif self.Plot_type == 'absolute_depths':
+                    self.mutate_dataset("plot_array", voltage_index, temporal_freq_list[1])
+
+                voltage_index = voltage_index + 1
+            delay(500*us)
+
+
+        self.core.break_realtime()
+        delay(50*us)
         self.laserUV.select_profile(1)
         self.laserIR1.select_profile(1)
         self.laserIR2.select_profile(1)
 
         self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=1)
+        self.core.break_realtime()
+        delay(50*us)
         self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=1)
+        self.core.break_realtime()
+        delay(50*us)
         self.laserIR1.set_frequency(self.IR1_final_freq, self.IR1_final_amp, profile=1)
+        self.core.break_realtime()
+        delay(50*us)
         self.laserIR2.set_frequency(self.IR2_final_freq, self.IR2_final_amp, profile=1)
-
-        self.change_dcvoltage(initial_voltage[0], cmd=self.Voltage_Scan_type)
+        self.core.break_realtime()
+        delay(50*us)
+        if not self.Sweep_type == "heating_time":
+            self.change_dcvoltage(initial_voltage[0], cmd=self.Sweep_type)
 
         print("jose maria listorti")