muchas cosas cambiaron mi joven padawan

artiq_master/last_rid.pyon

-19623
+20217

artiq_master/repository/Calibrations/IR_blinking.py

-import numpy as np
-from artiq.experiment import *
-from pyLIAF.artiq.controllers import UrukulCh
-
-
-class PMTCalibration(EnvExperiment):
-    """Blinking script plotting for pmt calibration """
-
-    def build(self):
-        self.setattr_device("ccb")
-        self.setattr_device("scheduler")
-        self.setattr_device("core")
-        self.pmt = self.get_device("ttl0")
-
-        self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
-        self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR") #corresponde a 0.8 Vpp
-
-        self.setattr_argument(f"t_readout",
-                              NumberValue(100*ms, unit='ms', scale=ms, min=1*ms),
-                             "PMT Calibration")
-
-    @rpc
-    def create_datasets(self):
-        self.set_dataset("pmt_counts_on", np.zeros(1, dtype=int), broadcast=True, archive=False)
-        self.set_dataset("pmt_counts_off", np.zeros(1, dtype=int), broadcast=True, archive=False)
-
-    @rpc
-    def create_applets(self):
-        self.ccb.issue("create_applet", "calibration_pmt_blinking",
-                        "${python} -m pyLIAF.artiq.applets.realtime "
-                        "200 "
-                        "pmt_counts_on "
-                        "--y2 pmt_counts_off")
-
-    @kernel
-    def init_kernel(self):
-        self.core.reset()
-        self.laserIR.initialize_channel()
-        self.laserUV.initialize_channel()
-        self.pmt.input()
-
-        delay(10*us)
-
-        self.laserIR.set_channel()
-        self.laserUV.set_channel()
-
-        self.core.wait_until_mu(now_mu())
-
-        delay(1*ms)
-        self.laserIR.on()
-        self.laserUV.on()
-
-
-    def run(self):
-        self.create_datasets()
-        self.create_applets()
-        self.init_kernel()
-
-        try:
-            while True:
-                self.measure_counts()
-                while self.scheduler.check_pause():
-                    print("PAUSED BLINKING")
-                    self.core.comm.close()
-                    self.scheduler.pause()
-                    # TODO: reset freqs/amps
-                    print("RESUMED BLINKING")
-        except TerminationRequested:
-            self.cleanup()
-            print("STOPPED BLINKING")
-
-    @kernel
-    def readout(self):
-        """Registro de cuentas emitidas"""
-       
-        here = self.pmt.gate_rising(self.t_readout)
-
-        cuentas = self.pmt.count(here)
-        delay(1*us)
-        return cuentas
-
-    @kernel
-    def measure_counts(self):
-        self.core.break_realtime()
-        self.laserUV.on()
-        self.laserIR.off()
-
-        self.mutate_dataset("pmt_counts_off", 0, self.readout())
-        at_mu(self.core.get_rtio_counter_mu() + 10000)
-
-        self.laserIR.on()          
-        self.mutate_dataset("pmt_counts_on", 0, self.readout())
-
-    @kernel
-    def cleanup(self):
-        self.core.break_realtime()
-        self.laserIR.off()
-        self.laserUV.off()
-

artiq_master/repository/Calibrations/Power Calibration AOM/Photodiode_in_time.py → artiq_master/repository/Calibrations/Photodiode_in_time.py

@@ -92,7 +92,7 @@ class PMTCalibration(EnvExperiment):
 
     @rpc(flags={"async"})
     def measure_PD(self, dump=False):
-        value = rpi.ReadPD_average_pi(0, 1)
+        value = rpi.ReadPD_average_pi(2, 1)
         #print(type(value))
         if not dump:
             self.mutate_dataset("Current_PD", 0, np.abs(value))

artiq_master/repository/Calibrations/Power Calibration AOM/IR/IR_Power_calibration_BS_rpi_multiple.py

-import numpy as np
-from time import sleep
-from artiq.experiment import *
-from pyLIAF.artiq.controllers import UrukulCh
-#from pyLIAF.RedPitaya import Read_analog as rp
-from pyLIAF.RaspberryPi.PD_reader import PDreader as rpi
-from scipy import interpolate
-
-class IR_LaserPowerCalibration_BS(EnvExperiment):
-    """Multiple powers - Binary search - IR Laser power calibration with photodiode and a raspberry pi """
-
-    def build(self):
-        self.setattr_device("ccb")
-        self.setattr_device("scheduler")
-        self.setattr_device("core")
-
-        self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.3, name="IR") #corresponde a 0.7 Vpp
-
-        self.setattr_argument("Target_PD_Value", NumberValue(0.4, min=0.01, max=3), "Calibration_parameters")
-
-        self.setattr_argument("Max_amplitude", NumberValue(0.30, min=0.01, max=0.35), "Calibration_parameters")
-        self.setattr_argument("Min_amplitude", NumberValue(0.01, min=0.01, max=0.35), "Calibration_parameters")
-
-        #self.setattr_argument("tolerance", NumberValue(0.005, max=0.5), "Calibration_parameters")
-
-
-        self.setattr_argument("Calibration_freqs_IR", Scannable(
-                                        default=CenterScan(208*MHz, 10*MHz, 0.1*MHz),
-                                        unit="MHz",
-                                        scale=MHz,
-                                        global_min = 1*MHz,
-                                        global_max = 400*MHz
-                                       )
-                             )
-
-
-    @rpc
-    def create_datasets(self):
-        #self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
-
-        self.set_dataset("Current_PD_IR", np.array([0.05]), broadcast=True, archive=False)
-        self.set_dataset("Calibration_freqs", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
-
-        self.set_dataset("Experiment_freqs_IR", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
-        self.set_dataset("Experiment_amps_IR", np.zeros(len(self.Calibration_freqs_IR.sequence), dtype=float), broadcast=True, archive=True)
-
-
-
-    @rpc(flags={"async"})
-    def create_applets(self):
-
-        self.ccb.issue("create_applet", "IR_powercalibration_BS",
-                        "${python} -m pyLIAF.artiq.applets.plot_xy "
-                        "Experiment_amps_IR "
-                        "--x Calibration_freqs")
-
-
-    @rpc(flags={"async"})
-    def Binary_Search(self, pd_value, initial_amplitude, final_amplitude, current_freq):
-        mid_amplitude = round(0.5*(initial_amplitude+final_amplitude), 4)
-        #print(f'mid_amplitude: {mid_amplitude}')
-        if abs(initial_amplitude - mid_amplitude) < 0.00001 or abs(final_amplitude - mid_amplitude) < 0.00001:
-            #print('toco un borde jejox')
-            return mid_amplitude
-        #else:
-        if mid_amplitude > self.Max_amplitude or mid_amplitude < self.Min_amplitude:
-            print('Pusiste al reves los limites')
-            raise
-        self.change_frequency(current_freq, mid_amplitude)
-        #self.measure_PD(dump=True)
-        self.measure_PD()
-        measured_PD = self.get_dataset("Current_PD_IR")[0]
-        if np.abs(measured_PD - pd_value) > 0.00005:
-            if measured_PD > pd_value:
-                return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq)
-            elif measured_PD < pd_value:
-                return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)
-            else:
-                #print('no se, fijate, paso algo')
-                return 0
-        else:
-            return mid_amplitude
-
-
-    @rpc(flags={"async"})
-    def measure_PD(self, dump=False): #este dump esta al pedo, habra que sacarlo en el futuro
-        value = rpi.ReadPD_average_pi(0, 1)
-        print(value)
-        if not dump:
-            self.mutate_dataset(f"Current_PD_IR", 0, np.abs(value))
-
-
-    @kernel
-    def init_kernel(self):
-        self.core.reset()
-        delay(1*ms)
-        self.core.break_realtime()
-        #self.laserIR.initialize_channel()
-
-        delay(100*us)
-
-        self.laserIR.set_channel()
-
-        self.core.wait_until_mu(now_mu())
-
-        delay(1*ms)
-        self.laserIR.on()
-
-    @kernel
-    def change_frequency(self, freq, amp):
-        self.core.break_realtime()
-        delay(50*ms)
-        self.laserIR.set_frequency(freq, amp)
-        delay(50*ms)
-
-
-    def run(self):
-        self.create_datasets()
-        self.create_applets()
-        self.init_kernel()
-        i = 0
-
-        self.measure_PD(dump=True)
-
-        initial_amplitude = self.Min_amplitude
-        final_amplitude = self.Max_amplitude
-
-        initial_PD = self.Target_PD_Value
-
-        for freq in self.Calibration_freqs_IR.sequence:
-            self.change_frequency(freq, initial_amplitude)
-            #self.measure_PD(dump=True)
-            calibrated_amplitude = self.Binary_Search(initial_PD, initial_amplitude, final_amplitude, freq)
-            print(f'Done freq {freq}')
-            self.mutate_dataset("Experiment_amps_IR", i, calibrated_amplitude)
-            #initial_amplitude = calibrated_amplitude-0.1
-            #final_amplitude = calibrated_amplitude+0.1
-            i = i + 1

artiq_master/repository/Calibrations/Power Calibration AOM/IR_Calibration_Fitting.py

-import numpy as np
-from time import sleep
-from artiq.experiment import *
-from pyLIAF.artiq.controllers import UrukulCh
-from pyLIAF.RedPitaya import Read_analog as rp
-from scipy import interpolate
-
-class IR_LaserPowerCalibration_BS(EnvExperiment):
-    """Binary search - IR Laser power calibration with photodiode and a red pitaya """
-
-    def build(self):
-        self.setattr_device("ccb")
-        self.setattr_device("scheduler")
-        self.setattr_device("core")
-
-        self.setattr_argument("Calibration_freqs_IR", Scannable(
-                                        default=CenterScan(208*MHz, 10*MHz, 0.1*MHz),
-                                        unit="MHz",
-                                        scale=MHz,
-                                        global_min = 1*MHz,
-                                        global_max = 400*MHz
-                                       )
-                             )        
-
-    @rpc
-    def create_datasets(self):
-        #self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
-
-        self.set_dataset("Current_PD_IR", np.array([0.05]), broadcast=True, archive=False)
-        self.set_dataset("Calibration_freqs", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
-
-        self.set_dataset("Experiment_freqs_IR_final", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
-        self.set_dataset("Experiment_amps_IR_final", np.zeros(len(self.Calibration_freqs_IR.sequence), dtype=float), broadcast=True, archive=True)
-
-
-    @rpc(flags={"async"})
-    def run(self):
-        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
-        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR"))
-     
-   
-    def run(self):
-        self.create_datasets()
-        self.init_kernel()
-
-
-
-

artiq_master/repository/Calibrations/Power Calibration AOM/Power_calibration_check.py

-import numpy as np
-from time import sleep
-from artiq.experiment import *
-from pyLIAF.artiq.controllers import UrukulCh
-from pyLIAF.RedPitaya import Read_analog as rp
-from scipy import interpolate
-
-class LaserPowerCalibration(EnvExperiment):
-    """Testing UV Laser power calibration with photodiode and a red pitaya """
-
-    def build(self):
-        self.setattr_device("ccb")
-        self.setattr_device("scheduler")
-        self.setattr_device("core")
-
-        self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
-
-    @rpc
-    def create_datasets(self):
-        self.Test_Experiment_freqs = self.get_dataset("Experiment_freqs")
-        self.Test_Experiment_amps = self.get_dataset("Experiment_amps")
-
-        self.set_dataset("Test_Experiment_freqs", self.Test_Experiment_freqs, broadcast=True, archive=True)
-        self.set_dataset("Test_Experiment_amps", self.Test_Experiment_amps, broadcast=True, archive=True)
-
-        self.set_dataset("Test_Measured_PD_UV_counts", list(np.zeros(len(self.Test_Experiment_freqs), dtype=int)), broadcast=True, archive=True)
-
-    @rpc(flags={"async"})
-    def create_applets(self):
-
-        self.ccb.issue("create_applet", "verification_powercalibration",
-                        "${python} -m pyLIAF.artiq.applets.plot_xy "
-                        "Test_Measured_PD_UV_counts "
-                        "--x Test_Experiment_freqs")
-        
-    """
-    @rpc(flags={"async"})
-    def measure_PD(self, i):
-        #sleep(1)
-        value = rp.ReadVoltage()
-        print(np.abs(value))
-        self.mutate_dataset("Test_Measured_PD_UV_counts", i, np.abs(value))
-    """
-
-    @rpc(flags={"async"})
-    def measure_PD(self, i, dump=False):
-        if not self.RPstatus:
-            self.rp_s = rp.Initiate_comm()
-            self.RPstatus = True
-        value = rp.ReadVoltage(self.rp_s)
-        print(value)
-        if not dump:
-            self.mutate_dataset(f"Test_Measured_PD_UV_counts", i, np.abs(value))
-
-    @kernel
-    def init_kernel(self):
-        self.core.reset()
-        self.laserUV.initialize_channel()
-
-        delay(10*us)
-
-        self.laserUV.set_channel()
-
-        self.core.wait_until_mu(now_mu())
-
-        delay(1*ms)
-        self.laserUV.on()
-
-    @kernel
-    def change_frequency(self, freq, amp):
-        self.core.break_realtime()
-        delay(50*ms)
-        self.laserUV.set_frequency(freq, amp)    
-        delay(50*ms)    
-
-        
-    def run(self):
-        self.create_datasets()
-        self.create_applets()
-        self.init_kernel()
-        self.RPstatus = False
-        self.No_freqs = len(self.Test_Experiment_freqs)
-
-        i = 0
-
-        self.measure_PD(0, dump=True)
-        
-        for amp, freq in zip(self.Test_Experiment_amps, self.Test_Experiment_freqs):
-            print(amp, freq)
-            #self.change_frequency(freq, 0.12)
-            self.change_frequency(freq, amp)
-            self.measure_PD(0, dump=True)
-            self.measure_PD(i)
-            i = i + 1
-

artiq_master/repository/Calibrations/Power Calibration AOM/Power_calibration_inversed.py

-import numpy as np
-from time import sleep
-from artiq.experiment import *
-from pyLIAF.artiq.controllers import UrukulCh
-from pyLIAF.RedPitaya import Read_analog as rp
-from scipy import interpolate
-
-class InvLaserPowerCalibration(EnvExperiment):
-    """INVERSED UV Laser power calibration with photodiode and a red pitaya """
-
-    def build(self):
-        self.setattr_device("ccb")
-        self.setattr_device("scheduler")
-        self.setattr_device("core")
-
-        self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
-
-
-        self.setattr_argument("Do_calibration", BooleanValue(False), "Calibration_parameters")
-        self.setattr_argument("Calibration_PD_Value", NumberValue(0.2, min=0.01, max=0.5, ndecimals=5), "Calibration_parameters")
-
-
-        self.setattr_argument("Calibration_freqs", Scannable(
-                                        default=CenterScan(110*MHz, 10*MHz, 0.1*MHz),
-                                        unit="MHz",
-                                        scale=MHz,
-                                        global_min = 1*MHz,
-                                        global_max = 400*MHz
-                                       )
-                             )        
-
-        self.setattr_argument("Calibration_amps", Scannable(
-                                        default=CenterScan(0.2, 0.1, 0.01),
-                                        global_min = 0,
-                                        global_max = 0.3
-                                       )
-                             )        
-
-
-#        self.setattr_argument("Experiment_frequencies", Scannable(
-#                                        default=CenterScan(110*MHz, 10*MHz, 0.1*MHz),
-#                                        unit="MHz",
-#                                        scale=MHz,
-#                                        global_min = 1*MHz,
-#                                        global_max = 400*MHz
-#                                       )
-#                             )        
-
-
-    @rpc
-    def create_datasets(self):
-        if self.Do_calibration:
-            self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
-        self.set_dataset("Calibration_freqs", len(self.Calibration_amps.sequence)*self.Calibration_freqs.sequence, broadcast=True, archive=True)
-        self.set_dataset("Calibration_amps", self.Calibration_amps.sequence, broadcast=True, archive=True)
-
-
-        self.set_dataset("Experiment_freqs", self.Calibration_freqs.sequence, broadcast=True, archive=True)
-        self.set_dataset("Experiment_amps", np.zeros(len(self.Calibration_freqs.sequence), dtype=float), broadcast=True, archive=True)
-
-
-    @rpc(flags={"async"})
-    def create_applets(self):
-
-        self.ccb.issue("create_applet", "powercalibration",
-                        "${python} -m pyLIAF.artiq.applets.plot_xy "
-                        "PD_UV_counts "
-                        "--x Calibration_freqs")
-
-    @rpc(flags={"async"})
-    def RemoveZeros(calib, freqs):
-        i, j = 0, 1
-        new_calib = calib
-        while i < len(calib):
-            if new_calib[0] == 0:
-                new_calib = new_calib[1:]
-                i = i + 1
-            else:            
-                init_len = len(new_calib)
-                final_calib = new_calib
-                while j < init_len:
-                    if final_calib[-1] == 0:
-                        final_calib = final_calib[:-1]
-                        j = j + 1
-                    else:
-                        if j == 1:
-                            return freqs[i:], final_calib
-                        else:
-                            return freqs[i:-j+1], final_calib
-
-
-    @rpc(flags={"async"})
-    def Calibrate_amplitudes(self):
-        Interpolation_functions = []
-
-        PD_UV_counts = self.get_dataset("PD_UV_counts")
-
-        n = len(self.Calibration_freqs.sequence)
-        PD_split = np.matrix([PD_UV_counts[i * n:(i + 1) * n] for i in range((len(PD_UV_counts) + n - 1) // n )])
-        PD_T = np.transpose(PD_split)
-
-        amps = self.Calibration_amps.sequence
-
-        for i in range(len(PD_T)):
-            #PD_values = np.array(PD_T[i][0])[0]
-            PD_values = np.array(PD_T[i])[0]
-            f = interpolate.interp1d(PD_values, amps, kind='linear')
-            Interpolation_functions.append(f)
-            
-
-        Calibration_PD_Value = self.Calibration_PD_Value
-
-        Calibrated_Amplitudes = []
-        for fi in Interpolation_functions:
-            try:
-                Calibrated_Amplitudes.append(float(fi(Calibration_PD_Value)))
-            except:
-                Calibrated_Amplitudes.append(0)
-                print('no, rey')
-
-        
-        #Freqs_withoutZeros, Calibs_withoutZeros = RemoveZeros(Calibs, freqs)        
-
-        Function_Calibs_vs_freq = interpolate.interp1d(self.Calibration_freqs.sequence, Calibrated_Amplitudes, kind='linear')    
-
-        i = 0
-        for freq in self.Calibration_freqs.sequence:
-            calibamp = Function_Calibs_vs_freq(freq)
-            print(calibamp)
-            self.mutate_dataset("Experiment_amps", i, calibamp)
-            i = i + 1
-
-        print('okarda con la calibreta')
-
-
-    @rpc(flags={"async"})
-    def Calibrate_amplitudes_v2(self):
-        Interpolation_functions = []
-
-        PD_UV_counts = self.get_dataset("PD_UV_counts")
-        n = len(self.Calibration_freqs.sequence)
-        PD_split = np.matrix([PD_UV_counts[i * n:(i + 1) * n] for i in range((len(PD_UV_counts) + n - 1) // n )])
-        PD_T = PD_split
-        #PD_T = PD_split
-
-        amps = self.Calibration_amps.sequence
-
-        Calibration_PD_Value = self.Calibration_PD_Value
-        Calibrated_Amplitudes = []
-        for i in range(len(PD_T)):
-            PD_values = np.array(PD_T[i])[0]
-            print(len(PD_values))
-            print(len(amps))
-            j = 0
-            while j < len(PD_values):
-                if PD_values[j] < Calibration_PD_Value:
-                    j = j + 1
-                elif PD_values[j] > Calibration_PD_Value:
-                    Calibrated_Amplitudes.append(amps[j])
-                    break
-                else:
-                    Calibrated_Amplitudes.append(0)
-                    print('malardo')
-                    break
-
-        i = 0
-        for i in range(len(Calibrated_Amplitudes)):
-            self.mutate_dataset("Experiment_amps", i, Calibrated_Amplitudes[i])
-            i = i + 1
-
-        print('okarda con la calibreta')
-
-    @rpc(flags={"async"})
-    def measure_PD(self, i):
-        value = rp.ReadVoltage()
-        print(value)
-        if i%self.No_freqs == 0:
-            sleep(0.3)
-            value = rp.ReadVoltage()
-            sleep(0.3)
-            print(f"Corrected value: {value}")
-        self.mutate_dataset(f"PD_UV_counts", i, np.abs(value))
-
-    @kernel
-    def init_kernel(self):
-        self.core.reset()
-        self.laserUV.initialize_channel()
-
-        delay(10*us)
-
-        self.laserUV.set_channel()
-
-        self.core.wait_until_mu(now_mu())
-
-        delay(1*ms)
-        self.laserUV.on()
-
-    @kernel
-    def change_frequency(self, freq, amp):
-        self.core.break_realtime()
-        delay(50*ms)
-        self.laserUV.set_frequency(freq, amp)
-
-        #def GetTargetAmplitude(self, amplitudes, PD_values, i):
-        #f = interpolate.interp1d(amplitudes, PD_values)
-        
-        #amplitudes_interpoladas = np.arange()
-        
-    def run(self):
-        self.create_datasets()
-        self.create_applets()
-        self.init_kernel()
-
-        self.No_freqs = len(self.Calibration_freqs.sequence)
-
-        i = 0
-        
-        if self.Do_calibration:
-            print('Usaremos mediciones nuevas')
-            for freq in self.Calibration_freqs.sequence:
-                print(freq)
-                for amp in self.Calibration_amps.sequence:
-                    self.change_frequency(freq, amp)
-                    self.measure_PD(i)
-                    i = i + 1
-            self.Calibrate_amplitudes()
-        else:
-            print('Usando mediciones ya hechas')
-            self.Calibrate_amplitudes_v2()        
-
-
-
-

artiq_master/repository/Calibrations/Power Calibration AOM/Power_calibration_v2.py

-import numpy as np
-from time import sleep
-from artiq.experiment import *
-from pyLIAF.artiq.controllers import UrukulCh
-from pyLIAF.RedPitaya import Read_analog as rp
-from scipy import interpolate
-
-class LaserPowerCalibration_v2(EnvExperiment):
-    """V2 - Binary search - UV Laser power calibration with photodiode and a red pitaya """
-
-    def build(self):
-        self.setattr_device("ccb")
-        self.setattr_device("scheduler")
-        self.setattr_device("core")
-
-        self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
-
-        self.setattr_argument("Target_PD_Value", NumberValue(0.2, min=0.01, max=0.5), "Calibration_parameters")
-
-        self.setattr_argument("Max_amplitude", NumberValue(0.25, min=0.01, max=0.5), "Calibration_parameters")
-        self.setattr_argument("Min_amplitude", NumberValue(0.01, min=0.01, max=0.5), "Calibration_parameters")
-
-        self.setattr_argument("tolerance", NumberValue(0.005, max=0.5), "Calibration_parameters")
-
-
-        self.setattr_argument("Calibration_freqs", Scannable(
-                                        default=CenterScan(110*MHz, 10*MHz, 0.1*MHz),
-                                        unit="MHz",
-                                        scale=MHz,
-                                        global_min = 1*MHz,
-                                        global_max = 400*MHz
-                                       )
-                             )        
-
-
-    @rpc
-    def create_datasets(self):
-        #self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
-
-        self.set_dataset("Current_PD_UV", np.array([0.05]), broadcast=True, archive=False)
-        self.set_dataset("Calibration_freqs", self.Calibration_freqs.sequence, broadcast=True, archive=True)
-
-        self.set_dataset("Experiment_freqs", self.Calibration_freqs.sequence, broadcast=True, archive=True)
-        self.set_dataset("Experiment_amps", np.zeros(len(self.Calibration_freqs.sequence), dtype=float), broadcast=True, archive=True)
-
-
-    @rpc(flags={"async"})
-    def create_applets(self):
-
-        self.ccb.issue("create_applet", "v2_powercalibration",
-                        "${python} -m pyLIAF.artiq.applets.plot_xy "
-                        "Experiment_amps "
-                        "--x Calibration_freqs")
-
-
-    @rpc(flags={"async"})
-    def Binary_Search(self, pd_value, initial_amplitude, final_amplitude, current_freq):
-        mid_amplitude = round(0.5*(initial_amplitude+final_amplitude), 4)
-        print(f'mid_amplitude: {mid_amplitude}')
-        if abs(initial_amplitude - mid_amplitude) < 0.00001 or abs(final_amplitude - mid_amplitude) < 0.00001:
-            print('toco un borde jejox')            
-            return mid_amplitude
-        #else:
-        if mid_amplitude > self.Max_amplitude or mid_amplitude < self.Min_amplitude:
-            raise
-        self.change_frequency(current_freq, mid_amplitude)   
-        self.measure_PD()
-        measured_PD = self.get_dataset("Current_PD_UV")[0]
-        if np.abs(measured_PD - pd_value) > 0.0005:
-            if measured_PD > pd_value:        
-                return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq) 
-            elif measured_PD < pd_value:
-                return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)                 
-            else:
-                print('no se, fijate, paso algo')
-                return 0
-        else:
-            return mid_amplitude
-
-
-    @rpc(flags={"async"})
-    def measure_PD(self):
-        value = rp.ReadVoltage()
-        print(np.abs(value))
-        self.mutate_dataset(f"Current_PD_UV", 0, np.abs(value))
-        
-
-    @kernel
-    def init_kernel(self):
-        self.core.reset()
-        delay(1*ms)
-        self.core.break_realtime()
-        self.laserUV.initialize_channel()
-
-        delay(100*us)
-
-        self.laserUV.set_channel()
-
-        self.core.wait_until_mu(now_mu())
-
-        delay(1*ms)
-        self.laserUV.on()
-
-    @kernel
-    def change_frequency(self, freq, amp):
-        self.core.break_realtime()
-        delay(50*ms)
-        self.laserUV.set_frequency(freq, amp)
-        delay(10*ms)
-
-       
-    def run(self):
-        self.create_datasets()
-        self.create_applets()
-        self.init_kernel()
-
-        i = 0
-
-        initial_amplitude = self.Min_amplitude
-        final_amplitude = self.Max_amplitude
-
-        initial_PD = self.Target_PD_Value
-        
-        
-
-        for freq in self.Calibration_freqs.sequence:
-            self.change_frequency(freq, initial_amplitude)
-            calibrated_amplitude = self.Binary_Search(initial_PD, initial_amplitude, final_amplitude, freq)
-            print(f'Done freq {freq}')
-            self.mutate_dataset("Experiment_amps", i, calibrated_amplitude)
-            #initial_amplitude = calibrated_amplitude-0.1
-            #final_amplitude = calibrated_amplitude+0.1
-            i = i + 1
-
-
-
-

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

@@ -9,8 +9,8 @@ PORT = 60000
 PASS = b'Secr3t Pa55W0rd'
 from multiprocessing.connection import Client
 
-class IR_Scan_withcal_optimized(EnvExperiment):
-    """Can change dc voltages - Two IR lasers - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays"""
+class IR_Scan_DCvoltages(EnvExperiment):
+    """IR scan with DC voltages changes ability"""
     def build(self):
         # Agrego kernel invariants a ver si mejoro algo de la performance
         kernel_invariants = getattr(self, 'kernel_invariants', set())

artiq_master/repository/Experiments/Spectrum/With_calibration/IR/FULLHEATING_IR_spectrum_withcalib_delaysfixed_TwoIRLasers_LaserHeatingStage.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_HeatingStages.py

@@ -8,8 +8,8 @@ PORT = 60000
 PASS = b'Secr3t Pa55W0rd'
 from multiprocessing.connection import Client
 
-class IR_Scan_withcal_optimized(EnvExperiment):
-    """Full heating - Two IR lasers - With heating stage - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays"""
+class IR_Scan_Heating(EnvExperiment):
+    """IR scan with FULL heating stage (blue-detuned UV laser or turning off lasers)"""
     def build(self):
         # Agrego kernel invariants a ver si mejoro algo de la performance
         kernel_invariants = getattr(self, 'kernel_invariants', set())

artiq_master/repository/Experiments/Spectrum/With_calibration/IR/SLOW_IR_spectrum_andor.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_andor.py

@@ -9,8 +9,8 @@ PORT = 60000
 PASS = b'Secr3t Pa55W0rd'
 from multiprocessing.connection import Client
 
-class IR_Scan_withcal_optimized_andor(EnvExperiment):
-    """Andor measurement - Two IR lasers - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays"""
+class IR_Scan_andor(EnvExperiment):
+    """IR scan with detection by Andor camera"""
     def build(self):
         # Agrego kernel invariants a ver si mejoro algo de la performance
         kernel_invariants = getattr(self, 'kernel_invariants', set())

artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_withcalib_delaysfixed_TwoIRLasers.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_simple.py

@@ -6,8 +6,8 @@ import numpy as np
 
 
 
-class IR_Scan_withcal_optimized(EnvExperiment):
-    """Two IR lasers - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays"""
+class IR_Scan_simple(EnvExperiment):
+    """Simple IR scan"""
     def build(self):
         # Agrego kernel invariants a ver si mejoro algo de la performance
         kernel_invariants = getattr(self, 'kernel_invariants', set())

artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_withcalib_delaysfixed_TwoIRLasers_LaserHeatingStage.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/old/IR_spectrum_withcalib_delaysfixed_TwoIRLasers_LaserHeatingStage.py

@@ -9,7 +9,7 @@ PASS = b'Secr3t Pa55W0rd'
 from multiprocessing.connection import Client
 
 class IR_Scan_withcal_optimized(EnvExperiment):
-    """Two IR lasers - With heating stage - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays"""
+    """IR scan with heating stage"""
     def build(self):
         # Agrego kernel invariants a ver si mejoro algo de la performance
         kernel_invariants = getattr(self, 'kernel_invariants', set())

artiq_master/repository/Experiments/Spectrum/With_calibration/UV/UV_spectrum_withcalib_AlternatingLasers.py → artiq_master/repository/Experiments/Spectrum/With_calibration/UV/UV_spectrum_alternatinglasers.py

@@ -7,7 +7,7 @@ import numpy as np
 
 
 class UV_Scan_withcalib_Haeffner(EnvExperiment):
-    """Alternating lasers - With Calib - UV frequency sweep - First N freqs, then change freq - Haeffner algorithm: measures only with UV laser on, after preparing S state"""
+    """ UV frequency sweep - Haeffner algorithm (measures only with UV laser on, after preparing S state)"""
     def build(self):
         # Agrego kernel invariants a ver si mejoro algo de la performance
         kernel_invariants = getattr(self, 'kernel_invariants', set())

artiq_master/repository/Experiments/Spectrum/With_calibration/UV/UV_spectrum_withcalib_bothlaserson.py

@@ -216,7 +216,6 @@ class UV_Scan_withcalib_bothlaserson(EnvExperiment):
                     delay(self.t_cool)
                 else:
                     delay(50*us)
-                #self.prep_S()
                 cuentas = self.readout(runN) # Hago la medicion y vuelvo con las cuentas
                 Accumulated_counts = Accumulated_counts + cuentas
             self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
@@ -256,10 +255,7 @@ class UV_Scan_withcalib_bothlaserson(EnvExperiment):
         self.core.break_realtime()
         self.core.wait_until_mu(now_mu())
 
-    @kernel
-    def prep_S(self):
-        pass
-        """Preparo el estado S prendiendo solamente el laser IR"""
+
 
     @kernel
     def readout(self, runN) -> TInt64:

artiq_master/repository/Experiments/Transitory/longtrapping.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jun  3 15:38:39 2024
+
+@author: liaf-ankylosaurus-admin
+"""
+
+import numpy as np
+from artiq.experiment import *
+from time import sleep
+#from pyLIAF.GenFunc.generador import Generador
+PORT = 60000
+PASS = b'Secr3t Pa55W0rd'
+from multiprocessing.connection import Client
+
+class InOut(EnvExperiment):
+    """
+    Long trapping
+    """
+    def build(self):
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+        self.ttl0 = self.get_device("ttl0")
+        self.ttl4 = self.get_device("ttl4")
+        
+        self.setattr_argument(f"t_med",
+                             NumberValue(300*ms, unit='ms', scale=ms, min=0.1*ms, max=1000*ms),
+                            "Experiment params")
+        
+        self.setattr_argument("t_exp",
+                             NumberValue(200*s, unit='s', scale=s, min=5*s, max=3000*s),
+                            "Experiment params")
+        
+        self.setattr_argument("N_ions_objective",
+                             NumberValue(1, min=1, max=1000, ndecimals=0, step=1), 
+                            "Experiment params")
+         
+        self.setattr_argument("Measurement_type",
+                                  EnumerationValue(["finite_time", "indefinite_time"]),
+                              "Scan params")
+
+        
+    @rpc
+    def initialize_tca_com(self):
+        address = ('localhost', PORT)
+        self.conn = Client(address, authkey=PASS)
+        sleep(0.1)
+
+
+    @rpc
+    def blinkRF(self,cmd='turnOnOffRF'):
+        self.conn.send(f'{cmd} blink')
+        rta = self.conn.recv()
+
+
+    @rpc(flags={"async"})
+    def create_datasets(self): 
+        self.set_dataset('time', [], broadcast=True, archive=True)
+        self.set_dataset('counts', [], broadcast=True, archive=True)
+        self.set_dataset('counts_indefinite',np.array([0.0]), broadcast=True, archive=False)
+        self.set_dataset("N_ions", [], broadcast=False, archive=True)
+
+        
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "longtrapping",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts "#Tiene que estar el espacio!!!
+                        "--x time") #Aca habria que definir bien el vector que se use en el eje x
+
+
+    
+    @rpc
+    def Varianza(self,sig)  -> TList(TFloat):
+        ruido=np.std(sig)
+        print(ruido)
+        return [ruido]
+
+    @kernel
+    def run(self): 
+        self.initialize_tca_com()
+        #Preparamos las variables y los graficos
+        self.create_datasets()
+        self.create_applets()
+        #Se prenden los "canales" a usar
+        self.core.reset()
+        self.ttl4.output()
+        self.ttl0.input()
+        self.ttl4.on()
+        
+        delay(20*ms)  # time for the artiq init.
+        
+        if self.Measurement_type=="indefinite_time":
+            while True:
+                cuentas=self.ttl0.gate_rising(self.t_med)
+                cuentas=self.ttl0.count(cuentas)
+                self.mutate_dataset("counts_indefinite",0,cuentas)
+                print(cuentas)
+                
+                self.core.break_realtime()
+                      
+        else:
+            sig=[]
+            for i in range(int(3/self.t_med)):
+                cuentas=self.ttl0.gate_rising(self.t_med)
+                sig=sig+[self.ttl0.count(cuentas)]
+                self.append_to_dataset("counts",sig[-1])
+                self.append_to_dataset("time",i/int(self.t_exp/self.t_med))
+                self.core.break_realtime()
+            ruido=self.Varianza(sig)[0]
+            delay(20*ms)
+            
+            for i in range(int(3/self.t_med),int(self.t_exp/self.t_med)):
+                cuentas=self.ttl0.gate_rising(self.t_med)
+                cuentas=self.ttl0.count(cuentas)
+                self.append_to_dataset("counts",cuentas)   
+                self.append_to_dataset("time",i/int(self.t_exp/self.t_med))
+
+                print(cuentas)
+                                    
+                self.core.break_realtime()
+            
+        start_time = now_mu()  # Record the start timeself.core.break_realtime()
+        self.core.break_realtime()

artiq_master/repository/Calibrations/IR_blinking_both.py → artiq_master/repository/Experiments/Vibration/IonMotionDetection.py

@@ -3,21 +3,53 @@ from artiq.experiment import *
 from pyLIAF.artiq.controllers import UrukulCh
 
 
-class PMTCalibration(EnvExperiment):
-    """BOTH - Blinking script plotting for pmt calibration - Plots the abs Fluo, and the Signal to Background ratio"""
+class IonVibration(EnvExperiment):
+    """Spectroscopic measurement of possible ion vibration"""
 
     def build(self):
         self.setattr_device("ccb")
         self.setattr_device("scheduler")
         self.setattr_device("core")
         self.pmt = self.get_device("ttl0")
+        self.led = self.get_device("ttl6")
 
         self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
         self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR") #corresponde a 0.8 Vpp
 
         self.setattr_argument(f"t_readout",
-                              NumberValue(100*ms, unit='ms', scale=ms, min=1*ms),
-                             "PMT Calibration")
+                              NumberValue(300*ms, unit='ms', scale=ms, min=1*ms),
+                             "Trapping")
+
+        self.setattr_argument(f"blinkfrequency",
+                              NumberValue(50*Hz, unit='Hz', scale=Hz, min=1*Hz),
+                             "Trapping")
+
+        self.setattr_argument(f"on_time",
+                              NumberValue(0.1, min=0, max=1),
+                             "Trapping")
+
+        self.setattr_argument("laserblinker",
+                                  EnumerationValue(["IR", "UV"]),
+                              "Trapping")
+
+        self.setattr_argument("Blink", BooleanValue(1==0), "Trapping")
+
+        self.setattr_argument(f"UV_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Lasers")
+
+        self.setattr_argument(f"UV_amp",
+                              NumberValue(0.18, min=0.000, max=0.300, step=0.001),
+                             "Lasers")
+
+        self.setattr_argument(f"IR_freq",
+                              NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Lasers")
+
+        self.setattr_argument(f"IR_amp",
+                              NumberValue(0.29, min=0.000, max=0.300, step=0.001),
+                             "Lasers")
+
 
     @rpc
     def create_datasets(self):
@@ -27,15 +59,25 @@ class PMTCalibration(EnvExperiment):
 
     @rpc
     def create_applets(self):
-        self.ccb.issue("create_applet", "ON_OFF_calibration_pmt_blinking",
-                        "${python} -m pyLIAF.artiq.applets.realtime "
-                        "200 "
-                        "pmt_counts_on "
-                        "--y2 pmt_counts_off")
+
+        if self.Blink:
+            self.ccb.issue("create_applet", "Trapping_on_off",
+                            "${python} -m pyLIAF.artiq.applets.realtime "
+                            "400 "
+                            "pmt_counts_on "
+                            "--y2 pmt_counts_off")
+
+        else:
+            self.ccb.issue("create_applet", "Monitoring_fluorescence",
+                            "${python} -m pyLIAF.artiq.applets.realtime_lines "
+                            "400 "
+                            "pmt_counts_on "
+                            "--y2 pmt_counts_off")
+            
 
         self.ccb.issue("create_applet", "DIFF_calibration_pmt_blinking",
                         "${python} -m pyLIAF.artiq.applets.realtime "
-                        "200 "
+                        "40 "
                         "pmt_counts_diff")
 
     @kernel
@@ -49,11 +91,14 @@ class PMTCalibration(EnvExperiment):
         #self.laserIR.channel.init()
         #self.laserUV.initialize_channel()
 
+        self.led.output()
 
         self.pmt.input()
 
         delay(1000*us)
 
+
+
         self.laserIR.set_channel()
         self.laserUV.set_channel()
 
@@ -63,8 +108,14 @@ class PMTCalibration(EnvExperiment):
         self.laserIR.on()
         self.laserUV.on()
 
+        delay(1000*us)
 
-    def run(self):
+        self.laserIR.set_frequency(self.IR_freq, self.IR_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_freq, self.UV_amp, profile=0)
+
+        delay(1000*us)
+
+    def runt(self):
         self.create_datasets()
         self.create_applets()
         self.init_kernel()
@@ -82,6 +133,41 @@ class PMTCalibration(EnvExperiment):
             self.cleanup()
             print("STOPPED BLINKING")
 
+
+    def run(self):
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        print('este')
+
+#        print(period_off)
+
+        self.core.break_realtime()
+
+        self.blinkear()
+
+    @kernel
+    def blinkear(self):
+        period = 1/self.blinkfrequency
+        period_on = self.on_time*period
+        #print(period_on)
+        period_off = (1-self.on_time)*period
+        #print(period_off)
+        self.core.break_realtime()
+        while True:
+            if self.Blink:
+                if self.laserblinker == "IR":
+                    self.laserIR.off()
+                    delay(period_off)
+                    self.laserIR.on()
+                    delay(period_on)
+                else:
+                    self.laserUV.off()
+                    delay(period_off)
+                    self.laserUV.on()
+                    delay(period_on)
+
+
     @kernel
     def readout(self):
         """Registro de cuentas emitidas"""
@@ -94,20 +180,29 @@ class PMTCalibration(EnvExperiment):
 
     @kernel
     def measure_counts(self):
-        self.core.break_realtime()
-        self.laserUV.on()
-        self.laserIR.off()
-        delay(10*us)
-        counts_off = self.readout()
-        self.mutate_dataset("pmt_counts_off", 0, counts_off)
-        at_mu(self.core.get_rtio_counter_mu() + 10000)
 
-        self.laserIR.on()
-        delay(10*us)          
-        counts_on = self.readout()
-        self.mutate_dataset("pmt_counts_on", 0, counts_on)
-        at_mu(self.core.get_rtio_counter_mu() + 10000)        
-        self.mutate_dataset("pmt_counts_diff", 0, counts_on/counts_off)
+
+        period = 1/self.blinkfrequency
+
+        period_on = self.on_time*period
+        print(period_on)
+        period_off = (1-self.on_time)*period
+        print(period_off)
+
+        self.core.break_realtime()
+        #self.laserUV.on()
+        if self.Blink:
+            if self.laserblinker == "IR":
+                self.laserIR.off()
+                delay(period_off)
+                self.laserIR.on()
+                delay(period_on)
+            else:
+                self.laserUV.off()
+                delay(period_off)
+                self.laserUV.on()
+                delay(period_on)
+        
 
     @kernel
     def cleanup(self):