actualizo archivos de mediciones

artiq_master/repository/Experiments/Saturation/DP_Saturation_measurement.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class IR_Saturation(EnvExperiment):
+    """Saturation measurement of the DP transition"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "IR_Freqs", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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"IR_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"UV_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(200*ms, unit='ms', scale=ms, min=1*ms),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_wait",
+                              NumberValue(50*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+        
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+        self.setattr_argument("IR_amps", Scannable(
+                                        default=CenterScan(0., 0.3, 0.01),
+                                        global_min = 0.,
+                                        global_max = 0.35
+                                       )
+                             )
+
+    @rpc
+    def create_datasets(self):
+
+        self.set_dataset("measurements_IR_sat", np.zeros(len(self.IR_amps.sequence), dtype=int), broadcast=True, archive=True)
+        self.set_dataset("IR_amps", self.IR_amps.sequence, broadcast=True, archive=True)
+
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "SaturationIR",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "measurements_IR_sat "
+                        "--x IR_amps")
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_wait) # Precomputo esto para despues
+        cuentas = 0
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+        self.laserIR.on()
+        self.laserUV.on()
+
+        self.laserIR.set_frequency(self.IR_freq, 0.35)
+        self.laserUV.set_frequency(self.UV_freq, 0.30)
+
+        save_index = 0
+        for amp in self.IR_amps.sequence:
+            at_mu(self.core.get_rtio_counter_mu()) # espero lo que haya que esperar por el mutate
+            delay(1*ms) # Agrego unos forros 200us porque si no no anda
+            self.laserIR.set_amp(amp, self.IR_freq) # Cambio la frec del perfil 1 (estoy en el 0)
+            delay(100*us)
+            cuentas_ON = self.readout() # Hago la medicion y vuelvo con las cuentas
+            delay(100*us)
+            self.laserIR.off()
+            delay(100*us)
+            cuentas_OFF = self.readout() # Hago la medicion y vuelvo con las cuentas
+            counts = cuentas_ON-cuentas_OFF
+            #print(counts)
+            self.mutate_dataset("measurements_IR_sat", save_index, counts)
+            delay(150*us)   
+            self.laserIR.on()
+            save_index = save_index + 1
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.laserUV.initialize_channel()
+        #self.laserIR.initialize_channel()
+
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser la referencia, el 1 va a ser el que se mueve
+        delay(1000*us)
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+
+        #delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+
+        return self.pmt.count(here) # recupero las cuentas medidas

artiq_master/repository/Experiments/Saturation/SP_Saturation_measurement.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class UV_Saturation(EnvExperiment):
+    """Saturation measurement of the SP transition"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "IR_Freqs", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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"IR_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"UV_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(200*ms, unit='ms', scale=ms, min=1*ms),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_wait",
+                              NumberValue(50*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+        
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+        self.setattr_argument("UV_amps", Scannable(
+                                        default=CenterScan(0., 0.3, 0.01),
+                                        global_min = 0.,
+                                        global_max = 0.3
+                                       )
+                             )
+
+    @rpc
+    def create_datasets(self):
+
+        self.set_dataset("measurements_UV_sat", np.zeros(len(self.UV_amps.sequence), dtype=int), broadcast=True, archive=True)
+        self.set_dataset("UV_amps", self.UV_amps.sequence, broadcast=True, archive=True)
+
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "SaturationUV",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "measurements_UV_sat "
+                        "--x UV_amps")
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_wait) # Precomputo esto para despues
+        cuentas = 0
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+        self.laserIR.on()
+        self.laserUV.on()
+
+        self.laserIR.set_frequency(self.IR_freq, 0.35)
+        self.laserUV.set_frequency(self.UV_freq, 0.30)
+
+        save_index = 0
+        for amp in self.UV_amps.sequence:
+            at_mu(self.core.get_rtio_counter_mu()) # espero lo que haya que esperar por el mutate
+            delay(1*ms) # Agrego unos forros 200us porque si no no anda
+            self.laserUV.set_amp(amp, self.UV_freq) # Cambio la frec del perfil 1 (estoy en el 0)
+            delay(100*us)
+            cuentas_ON = self.readout() # Hago la medicion y vuelvo con las cuentas
+            delay(100*us)
+            self.laserIR.off()
+            delay(100*us)
+            cuentas_OFF = self.readout() # Hago la medicion y vuelvo con las cuentas
+            counts = cuentas_ON-cuentas_OFF
+            #print(counts)
+            self.mutate_dataset("measurements_UV_sat", save_index, counts)
+            delay(150*us)   
+            self.laserIR.on()
+            save_index = save_index + 1
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.laserUV.initialize_channel()
+        #self.laserIR.initialize_channel()
+
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser la referencia, el 1 va a ser el que se mueve
+        delay(1000*us)
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+
+        #delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+
+        return self.pmt.count(here) # recupero las cuentas medidas

artiq_master/repository/Experiments/Spectrum/Tests/TEST_IR_spectrum.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class TEST_IR_Scan_cal(EnvExperiment):
+    """TEST_With Calib - IR frequency sweep - Inversed (first N freqs, then change freq)"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(5000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_CPT_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"UV_CPT_amp",
+                              NumberValue(0.3, min=0.1, max=0.3),
+                             "CPT params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(500*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(20*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+        #self.setattr_argument("UV_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("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_transitory", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+
+        self.ccb.issue("create_applet", "Calib_IR_espectro_xy",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy_scan "
+                        "measurements "
+                        "no_freqs "
+                        "--x Experiment_freqs_IR "
+                        "--update-delay 0.2")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
+        self.set_dataset("IR_Frequencies", np.array(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+        self.set_dataset("no_freqs", len(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+        self.set_dataset("measurements", np.zeros(len(Calibrated_Experiment_freqs)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR"))
+        self.set_dataset("IR_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+    
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = [210*MHz, 220*MHz]
+        Amps = [0.2, 0.3]
+        self.init_kernel()
+        delay(1*ms)
+        self.laserIR.on()
+        self.laserUV.on()
+        iter_index = 0
+        self.prof1()
+        while iter_index < len(Freqs):
+            #self.printing(Freqs, Amps, iter_index)
+            self.prof0()
+            delay(1*s)
+            self.laserIR.set_frequency(Freqs[iter_index], Amps[iter_index], profile=1) # Cambio la frec del perfil 1 (estoy en el 0)   
+            for runN in range(3):
+                #at_mu(self.core.get_rtio_counter_mu()) # espero lo que haya que esperar por el mutate
+                delay(150*us)
+                self.prof0()
+                delay(1*s)
+                self.prof1()
+                delay(1*s)
+            iter_index = iter_index + 1
+        delay(500*us)
+        self.prof0()
+
+    @rpc(flags={"async"})
+    def printing(self, Freqs, Amps, iter_index):
+        print(Freqs[iter_index])
+        print(Amps[iter_index])
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser la referencia, el 1 va a ser el que se mueve
+        self.laserIR.set_channel()
+        #self.laserUV.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, 0., profile=0)
+        #self.laserUV.set_frequency(self.UV_cooling_freq, 0.2, profile=0)
+        self.laserIR.set_channel(profile=1)
+        #self.laserUV.set_channel(profile=1)
+        #self.laserUV.set_frequency(self.UV_CPT_freq, 0., profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def prof0(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        # self.laserIR.set_frequency(self.IR_cooling_freq)
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil referencia
+        #self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+
+
+    @kernel
+    def prof1(self):
+        self.laserIR.select_profile(1) # Pongo el laser en el perfil que mide
+        #self.laserUV.select_profile(1) # Pongo el laser en el perfil que mide
+
+
+
+
+

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

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class IR_Scan_withcal(EnvExperiment):
+    """IR frequency sweep - With calibration - Inversed (first N freqs, then change freq)"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(5000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_CPT_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"UV_CPT_amp",
+                              NumberValue(0.3, min=0.1, max=0.3),
+                             "CPT params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(500*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(20*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+        #self.setattr_argument("UV_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("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_transitory", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+
+        self.ccb.issue("create_applet", "Calib_IR_espectro_xy",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy_scan "
+                        "measurements "
+                        "no_freqs "
+                        "--x Experiment_freqs_IR "
+                        "--update-delay 0.2")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
+        self.set_dataset("IR_Frequencies", np.array(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+        self.set_dataset("no_freqs", len(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+        self.set_dataset("measurements", np.zeros(len(Calibrated_Experiment_freqs)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR"))
+        self.set_dataset("IR_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+    
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        #Freqs = self.UV_Freqs.sequence
+        Amps = self.Get_Calibrated_Amplitudes()
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+        self.laserIR.on()
+        self.laserUV.on()
+        
+        iter_index = 0
+        save_index = 0
+
+        #for freq, amp in zip(Freqs, Amps):
+        #for amp in Amps:  
+        while iter_index < len(Freqs):         
+            print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            for runN in range(self.no_measures):
+                at_mu(self.core.get_rtio_counter_mu()) # espero lo que haya que esperar por el mutate #CREO QUE HAY QUE SACAR ESTO
+                delay(150*us) # Agrego unos forros 200us porque si no no anda
+                delay(self.t_cool) # Mas el tiempo de cooling, ~ 50us
+
+                self.laserIR.set_frequency(Freqs[iter_index], Amps[iter_index], profile=1) # Cambio la frec del perfil 1 (estoy en el 0)
+                #self.laserIR.set_frequency(Freqs[iter_index], 0.25, profile=1) # Cambio la frec del perfil 1 (estoy en el 0)
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                self.mutate_dataset("measurements", save_index, cuentas)
+                save_index = save_index + 1
+            iter_index = iter_index + 1
+        #at_mu(self.core.get_rtio_counter_mu())    
+        delay(500*us)    
+        #self.laserIR.set_frequency(Freqs[-1], Amps[-1], profile=0) #dejo al final del experimento estos parametros en el perfil 0. Podria tambien cambiar al profile 1
+        self.laserUV.select_profile(1)
+        self.laserIR.select_profile(1)
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser la referencia, el 1 va a ser el que se mueve
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, 0.15, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, 0.15, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+        self.laserUV.set_frequency(self.UV_CPT_freq, self.UV_CPT_amp, profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        # self.laserIR.set_frequency(self.IR_cooling_freq)
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        self.laserIR.select_profile(1) # Paso al perfil que cambia
+        delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

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

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class IR_Scan_withcal_optimized(EnvExperiment):
+    """IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(5000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR_cooling_amp",
+                              NumberValue(0.2, min=0.01, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.2, min=0.01, max=0.3),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_CPT_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"UV_CPT_amp",
+                              NumberValue(0.3, min=0.1, max=0.3),
+                             "CPT params")
+
+        self.setattr_argument(f"IR_final_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR_final_amp",
+                              NumberValue(0.35, min=0.01, max=0.35),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Final params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(500*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(20*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+        #self.setattr_argument("UV_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("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("counts_spectrum", np.zeros(len(self.UV_Freqs.sequence), dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("IR_cooling_freq", self.IR_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_cooling_amp", self.IR_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_cooling_freq", self.UV_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_cooling_amp", self.UV_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_CPT_freq", self.UV_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_CPT_amp", self.UV_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_transitory", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+        self.ccb.issue("create_applet", "IR_espectro_fixeddelays",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts_spectrum "
+                        "--x Experiment_freqs_IR")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
+        self.set_dataset("IR_Frequencies", np.array(Calibrated_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(Calibrated_Experiment_freqs), dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR"))
+        self.set_dataset("IR_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+    
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        #Freqs = self.UV_Freqs.sequence
+        Amps = self.Get_Calibrated_Amplitudes()
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserUV.on()
+        
+        self.enfriar_ion()
+
+        iter_index = 0
+
+        while iter_index < len(Freqs):         
+            #print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            Accumulated_counts = 0
+            delay(10000*us)
+            self.laserIR.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 % 10 == 0:                
+                    delay(self.t_cool)
+                else:
+                    delay(100*us)
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                Accumulated_counts = Accumulated_counts + cuentas
+            self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
+            delay(5000*us)
+            iter_index = iter_index + 1
+
+        delay(500*us)    
+
+        self.laserUV.select_profile(1)
+        self.laserIR.select_profile(1)
+
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=1)
+        self.laserIR.set_frequency(self.IR_final_freq, self.IR_final_amp, profile=1)
+
+        print("jose maria listorti")
+
+
+
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.laserUV.initialize_channel()
+        #self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser el de ENFRIADO, el 1 va a ser el de MEDICION
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, self.IR_cooling_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+        self.laserUV.set_frequency(self.UV_CPT_freq, self.UV_CPT_amp, profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        self.laserIR.select_profile(1) # Paso al perfil que cambia
+        delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

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

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+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"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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.laserTISA = UrukulCh(self, ch=3, freq=80.0, amp=0.37, name="IR") #corresponde a 0.8 Vpp
+
+        self.setattr_argument("no_measures",
+                              NumberValue(10000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR_cooling_amp",
+                              NumberValue(0.2, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Cooling params")
+
+        self.setattr_argument(f"TISA_cooling_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"TISA_cooling_amp",
+                              NumberValue(0.06, min=0.0, max=0.37),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_CPT_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"UV_CPT_amp",
+                              NumberValue(0.3, min=0.000, max=0.300, step=0.001),
+                             "CPT params")
+
+        self.setattr_argument(f"TISA_CPT_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"TISA_CPT_amp",
+                              NumberValue(0., min=0., max=0.37),
+                             "CPT params")
+
+        self.setattr_argument(f"IR_final_freq",
+                              NumberValue(211*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR_final_amp",
+                              NumberValue(0.12, min=0.0, max=0.35),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Final params")
+
+        self.setattr_argument(f"TISA_final_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"TISA_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Final params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1000*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(50*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+        #self.setattr_argument("UV_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("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("counts_spectrum", np.zeros(len(self.UV_Freqs.sequence), dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("IR_cooling_freq", self.IR_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_cooling_amp", self.IR_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_cooling_freq", self.UV_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_cooling_amp", self.UV_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("TISA_cooling_freq", self.TISA_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("TISA_cooling_amp", self.TISA_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_CPT_freq", self.UV_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_CPT_amp", self.UV_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("TISA_CPT_freq", self.TISA_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("TISA_CPT_amp", self.TISA_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("t_cool", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_trans", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+        self.ccb.issue("create_applet", "IR_espectro_fixeddelays",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts_spectrum "
+                        "--x Experiment_freqs_IR")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
+        self.set_dataset("IR_Frequencies", np.array(Calibrated_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(Calibrated_Experiment_freqs), dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR"))
+        self.set_dataset("IR_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+    
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        #Freqs = self.UV_Freqs.sequence
+        Amps = self.Get_Calibrated_Amplitudes()
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserTISA.on()
+        self.laserUV.on()
+        
+        self.enfriar_ion()
+
+        iter_index = 0
+
+        while iter_index < len(Freqs):         
+            #print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            Accumulated_counts = 0
+            delay(10000*us)
+            self.laserIR.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)
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                Accumulated_counts = Accumulated_counts + cuentas
+            self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
+            delay(5000*us)
+            iter_index = iter_index + 1
+
+        delay(500*us)    
+
+        self.laserUV.select_profile(1)
+        self.laserIR.select_profile(1)
+        self.laserTISA.select_profile(1)
+
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=1)
+        #self.laserUV.set_frequency(self.UV_final_freq, 0.025, profile=1)
+        self.laserIR.set_frequency(self.IR_final_freq, self.IR_final_amp, profile=1)
+        self.laserTISA.set_frequency(self.TISA_final_freq, self.TISA_final_amp, profile=1)
+
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.laserUV.initialize_channel()
+        #self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser el de ENFRIADO, el 1 va a ser el de MEDICION
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserTISA.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, self.IR_cooling_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserTISA.set_frequency(self.TISA_cooling_freq, self.TISA_cooling_amp, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+        self.laserTISA.set_channel(profile=1)
+        self.core.break_realtime()
+        #self.laserUV.set_frequency(self.UV_CPT_freq, self.UV_CPT_amp, profile=1)
+        self.laserUV.set_frequency(self.UV_CPT_freq, 0.07, profile=1)
+        self.core.break_realtime()
+        self.laserTISA.set_frequency(self.TISA_CPT_freq, self.TISA_CPT_amp, profile=1)
+        #self.laserTISA.set_frequency(self.TISA_CPT_freq, 0.035, profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserTISA.select_profile(0)
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        self.laserIR.select_profile(1) # Paso al perfil que cambia
+        self.laserTISA.select_profile(1) # Paso al perfil que cambia
+        delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_withcalib_delaysfixed_TwoIRLasers.py.save

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+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"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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.laserTISA = UrukulCh(self, ch=3, freq=80.0, amp=0.37, name="IR") #corresponde a 0.8 Vpp
+
+        self.setattr_argument("no_measures",
+                              NumberValue(10000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR_cooling_amp",
+                              NumberValue(0.2, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Cooling params")
+
+        self.setattr_argument(f"TISA_cooling_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"TISA_cooling_amp",
+                              NumberValue(0.06, min=0.0, max=0.37),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_CPT_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"UV_CPT_amp",
+                              NumberValue(0.3, min=0.000, max=0.300, step=0.001),
+                             "CPT params")
+
+        self.setattr_argument(f"TISA_CPT_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"TISA_CPT_amp",
+                              NumberValue(0., min=0., max=0.37),
+                             "CPT params")
+
+        self.setattr_argument(f"IR_final_freq",
+                              NumberValue(211*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR_final_amp",
+                              NumberValue(0.12, min=0.0, max=0.35),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Final params")
+
+        self.setattr_argument(f"TISA_final_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"TISA_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Final params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1000*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(50*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+        #self.setattr_argument("UV_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("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("counts_spectrum", np.zeros(len(self.UV_Freqs.sequence), dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("IR_cooling_freq", self.IR_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_cooling_amp", self.IR_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_cooling_freq", self.UV_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_cooling_amp", self.UV_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("TISA_cooling_freq", self.TISA_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("TISA_cooling_amp", self.TISA_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_CPT_freq", self.UV_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_CPT_amp", self.UV_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("TISA_CPT_freq", self.TISA_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("TISA_CPT_amp", self.TISA_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("t_cool", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_trans", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+        self.ccb.issue("create_applet", "IR_espectro_fixeddelays",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts_spectrum "
+                        "--x Experiment_freqs_IR")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
+        self.set_dataset("IR_Frequencies", np.array(Calibrated_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(Calibrated_Experiment_freqs), dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR"))
+        self.set_dataset("IR_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+    
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        #Freqs = self.UV_Freqs.sequence
+        Amps = self.Get_Calibrated_Amplitudes()
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserTISA.on()
+        self.laserUV.on()
+        
+        self.enfriar_ion()
+
+        iter_index = 0
+
+        while iter_index < len(Freqs):         
+            #print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            Accumulated_counts = 0
+            delay(10000*us)
+            self.laserIR.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)
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                Accumulated_counts = Accumulated_counts + cuentas
+            self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
+            delay(5000*us)
+            iter_index = iter_index + 1
+
+        delay(500*us)    
+
+        self.laserUV.select_profile(1)
+        self.laserIR.select_profile(1)
+        self.laserTISA.select_profile(1)
+
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=1)
+        #self.laserUV.set_frequency(self.UV_final_freq, 0.025, profile=1)
+        self.laserIR.set_frequency(self.IR_final_freq, self.IR_final_amp, profile=1)
+        self.laserTISA.set_frequency(self.TISA_final_freq, self.TISA_final_amp, profile=1)
+
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.laserUV.initialize_channel()
+        #self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser el de ENFRIADO, el 1 va a ser el de MEDICION
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserTISA.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, self.IR_cooling_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserTISA.set_frequency(self.TISA_cooling_freq, self.TISA_cooling_amp, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+        self.laserTISA.set_channel(profile=1)
+        self.core.break_realtime()
+        #self.laserUV.set_frequency(self.UV_CPT_freq, self.UV_CPT_amp, profile=1)
+        self.laserUV.set_frequency(self.UV_CPT_freq, 0.09
+, profile=1)
+        self.core.break_realtime()
+        self.laserTISA.set_frequency(self.TISA_CPT_freq, self.TISA_CPT_amp, profile=1)
+        #self.laserTISA.set_frequency(self.TISA_CPT_freq, 0.035, profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserTISA.select_profile(0)
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        self.laserIR.select_profile(1) # Paso al perfil que cambia
+        self.laserTISA.select_profile(1) # Paso al perfil que cambia
+        delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

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

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class IR_Scan_withcal_optimized_superfine(EnvExperiment):
+    """SUPERFINE - Two IR lasers - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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.laserTISA = UrukulCh(self, ch=3, freq=80.0, amp=0.37, name="IR") #corresponde a 0.8 Vpp
+
+        self.setattr_argument("no_measures",
+                              NumberValue(10000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR_cooling_amp",
+                              NumberValue(0.2, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Cooling params")
+
+        self.setattr_argument(f"TISA_cooling_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"TISA_cooling_amp",
+                              NumberValue(0.06, min=0.0, max=0.37),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_CPT_freq",
+                              NumberValue(90*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"UV_CPT_amp",
+                              NumberValue(0.3, min=0., max=0.3),
+                             "CPT params")
+
+        self.setattr_argument(f"TISA_CPT_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"TISA_CPT_amp",
+                              NumberValue(0., min=0., max=0.37),
+                             "CPT params")
+
+        self.setattr_argument(f"IR_final_freq",
+                              NumberValue(211*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR_final_amp",
+                              NumberValue(0.12, min=0.0, max=0.35),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Final params")
+
+        self.setattr_argument(f"TISA_final_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"TISA_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Final params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1000*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(50*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+        #self.setattr_argument("UV_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("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("counts_spectrum", np.zeros(len(self.UV_Freqs.sequence), dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("IR_cooling_freq", self.IR_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_cooling_amp", self.IR_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_cooling_freq", self.UV_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_cooling_amp", self.UV_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("TISA_cooling_freq", self.TISA_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("TISA_cooling_amp", self.TISA_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_CPT_freq", self.UV_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_CPT_amp", self.UV_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("TISA_CPT_freq", self.TISA_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("TISA_CPT_amp", self.TISA_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("t_cool", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_trans", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+        self.ccb.issue("create_applet", "IR_espectro_fixeddelays",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts_spectrum "
+                        "--x Experiment_freqs_IR")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR_fine")
+        self.set_dataset("IR_Frequencies", np.array(Calibrated_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(Calibrated_Experiment_freqs), dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR_fine"))
+        self.set_dataset("IR_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+    
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        #Freqs = self.UV_Freqs.sequence
+        Amps = self.Get_Calibrated_Amplitudes()
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserTISA.on()
+        self.laserUV.on()
+        
+        self.enfriar_ion()
+
+        iter_index = 0
+
+        while iter_index < len(Freqs):         
+            #print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            Accumulated_counts = 0
+            delay(10000*us)
+            self.laserIR.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)
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                Accumulated_counts = Accumulated_counts + cuentas
+            self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
+            delay(5000*us)
+            iter_index = iter_index + 1
+
+        delay(500*us)    
+
+        self.laserUV.select_profile(1)
+        self.laserIR.select_profile(1)
+        self.laserTISA.select_profile(1)
+
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=1)
+        self.laserIR.set_frequency(self.IR_final_freq, self.IR_final_amp, profile=1)
+        self.laserTISA.set_frequency(self.TISA_final_freq, self.TISA_final_amp, profile=1)
+
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.laserUV.initialize_channel()
+        #self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser el de ENFRIADO, el 1 va a ser el de MEDICION
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserTISA.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, self.IR_cooling_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserTISA.set_frequency(self.TISA_cooling_freq, self.TISA_cooling_amp, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+        self.laserTISA.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_CPT_freq, self.UV_CPT_amp, profile=1)
+        self.core.break_realtime()
+        self.laserTISA.set_frequency(self.TISA_CPT_freq, self.TISA_CPT_amp, profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserTISA.select_profile(0)
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        self.laserIR.select_profile(1) # Paso al perfil que cambia
+        self.laserTISA.select_profile(1) # Paso al perfil que cambia
+        delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

artiq_master/repository/Experiments/Spectrum/With_calibration/Motional/DEBUG_Motional_Spectrum_UV_blinking.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class MotionalSpectrum(EnvExperiment):
+    """DEBUG - Motional spectrum by blinking UV laser"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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"UV_measurement_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"UV_measurement_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Experiment params")
+
+        
+        self.setattr_argument(f"IR_measurement_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"IR_measurement_amp",
+                              NumberValue(0.3, min=0.01, max=0.35),
+                             "Experiment params")
+
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(2*s, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("blink_freqs", Scannable(
+                                       default=CenterScan(1*Hz, 10000*Hz, 0.01*Hz),
+                                        unit="Hz",
+                                        scale=Hz,
+                                       )
+                             )
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+
+    @rpc
+    def create_datasets(self):
+
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("IR_measurement_freq", self.IR_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_measurement_amp", self.IR_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_measurement_freq", self.UV_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_measurement_amp", self.UV_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("blink_freqs", self.blink_freqs.sequence, broadcast=True, archive=True)    
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        self.set_dataset("counts", np.zeros(len(self.blink_freqs.sequence), dtype=int), broadcast=True, archive=True)
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+
+        self.ccb.issue("create_applet", "Motional_spectrum",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts "
+                        "--x blink_freqs "
+                        "--update-delay 0.2")
+
+    @rpc(flags={"async"})
+    def monitor(self, period):
+        print(period)
+        
+    @kernel
+    def blink_laser(self, N, period):
+        runN = 0
+        self.core.break_realtime()
+        while runN < N:
+            delay(0.5*period)
+            self.laserUV.channel.sw.off()
+            delay(0.5*period)
+            self.laserUV.channel.sw.on()
+            #delay(0.5*period)
+            runN = runN + 1        
+
+
+    @kernel
+    def run(self):
+
+        #t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserUV.on()
+
+        delay(1*ms)
+
+        iter_index = 0
+
+        for freq in self.blink_freqs.sequence:   
+            self.core.break_realtime()   
+            period = 1e-6
+            self.monitor(period)
+            total_blinks = int(self.t_readout/period)
+            runN = 0
+            with parallel:
+                here = self.pmt.gate_rising(self.t_readout)
+                self.blink_laser(total_blinks, period)              
+                """                
+                while runN < total_blinks:
+                    self.laserUV.off()
+                    delay(0.5*period)
+                    self.laserUV.on()
+                    delay(0.5*period)
+                    runN = runN + 1
+                """
+            cuentas = self.pmt.count(here)
+            self.mutate_dataset("counts", iter_index, cuentas)
+            iter_index = iter_index + 1
+            delay(200*us)
+
+        delay(500*us)    
+
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        delay(1*ms)
+        self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser para ENFRIAR, el 1 va a ser para MEDIR
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR.set_frequency(self.IR_measurement_freq, self.IR_measurement_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_measurement_freq, self.UV_measurement_amp, profile=0)
+
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+
+
+
+
+
+
+
+
+

artiq_master/repository/Experiments/Spectrum/With_calibration/Motional/Motional_Spectrum_UV_blinking.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class MotionalSpectrum(EnvExperiment):
+    """Motional spectrum by blinking UV laser"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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"UV_measurement_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"UV_measurement_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Experiment params")
+
+        
+        self.setattr_argument(f"IR_measurement_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"IR_measurement_amp",
+                              NumberValue(0.3, min=0.01, max=0.35),
+                             "Experiment params")
+
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(2*s, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("blink_freqs", Scannable(
+                                       default=CenterScan(1*Hz, 10000*Hz, 0.01*Hz),
+                                        unit="Hz",
+                                        scale=Hz,
+                                       )
+                             )
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+
+    @rpc
+    def create_datasets(self):
+
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("IR_measurement_freq", self.IR_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_measurement_amp", self.IR_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_measurement_freq", self.UV_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_measurement_amp", self.UV_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("blink_freqs", self.blink_freqs.sequence, broadcast=True, archive=True)    
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        self.set_dataset("counts", np.zeros(len(self.blink_freqs.sequence), dtype=int), broadcast=True, archive=True)
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+
+        self.ccb.issue("create_applet", "Motional_spectrum",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts "
+                        "--x blink_freqs "
+                        "--update-delay 0.2")
+
+    @rpc(flags={"async"})
+    def monitor(self, period):
+        print(period)
+        
+    @kernel
+    def blink_laser(self, N, period):
+        runN = 0
+        self.core.break_realtime()
+        while runN < N:
+            #self.core.break_realtime()
+            self.laserUV.off()
+            delay(0.5*period)
+            self.laserUV.on()
+            delay(0.5*period)
+            runN = runN + 1        
+
+
+    @kernel
+    def run(self):
+
+        #t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserUV.on()
+
+        delay(1*ms)
+
+        iter_index = 0
+
+        for freq in self.blink_freqs.sequence:   
+            self.core.break_realtime()   
+            period = 1/freq
+            self.monitor(period)
+            total_blinks = 0.8*int(self.t_readout/period)
+            runN = 0
+            """
+            with parallel:
+                here = self.pmt.gate_rising(self.t_readout)
+                self.blink_laser(total_blinks, period)              
+                              
+                while runN < total_blinks:
+                    self.laserUV.off()
+                    delay(0.5*period)
+                    self.laserUV.on()
+                    delay(0.5*period)
+                    runN = runN + 1
+                
+            cuentas = self.pmt.count(here)
+            self.mutate_dataset("counts", iter_index, cuentas)
+            iter_index = iter_index + 1
+            delay(200*us)
+            """
+            t0 = now_mu()
+            t_fin = self.pmt.gate_rising(self.t_readout)
+            at_mu(t0)
+            self.core.break_realtime()
+            self.blink_laser(total_blinks, period)               
+            self.core.break_realtime()
+            cuentas = self.pmt.count(t_fin)
+            self.mutate_dataset("counts", iter_index, cuentas)
+            iter_index = iter_index + 1
+            delay(200*us)
+
+
+        delay(500*us)    
+
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        delay(1*ms)
+        #self.laserUV.initialize_channel()
+        #self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser para ENFRIAR, el 1 va a ser para MEDIR
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR.set_frequency(self.IR_measurement_freq, self.IR_measurement_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_measurement_freq, self.UV_measurement_amp, profile=0)
+
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+
+
+
+
+
+
+
+
+

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

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class UV_Scan_withcalib_Haeffner(EnvExperiment):
+    """DEBUG - 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"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(10000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument("cool_every",
+                              NumberValue(50, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR_cooling_amp",
+                              NumberValue(0.15, min=0.01, max=0.35),
+                             "Cooling params")
+
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Cooling params")
+
+        
+        self.setattr_argument(f"IR_measurement_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"IR_measurement_amp",
+                              NumberValue(0.35, min=0.01, max=0.35),
+                             "Experiment params")
+        
+        """
+        self.setattr_argument(f"UV_measurement_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+        """
+
+
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1*ms, unit='ms', scale=ms, min=0.01*ms),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_prepS",
+                              NumberValue(3*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(1*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument(f"IR_final_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR_final_amp",
+                              NumberValue(0.20, min=0.01, max=0.35),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Final params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+
+    @rpc
+    def create_datasets(self):
+
+        #self.set_dataset("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+        self.set_dataset("t_cool", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_prep_S", self.t_prepS, broadcast=False, archive=True)
+
+        self.set_dataset("cool_every", self.cool_every, broadcast=False, archive=True)
+
+
+        self.set_dataset("IR_measurement_freq", self.IR_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_measurement_amp", self.IR_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR_cooling_freq", self.IR_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_cooling_amp", self.IR_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_cooling_freq", self.UV_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_cooling_amp", self.UV_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR_final_freq", self.IR_final_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_final_amp", self.IR_final_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_final_freq", self.UV_final_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_final_amp", self.UV_final_amp, broadcast=False, archive=True)
+
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+
+        self.ccb.issue("create_applet", "Calib_UV_espectro_xy",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy_scan "
+                        "measurements "
+                        "no_freqs "
+                        "--x UV_Frequencies "
+                        "--update-delay 0.2")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_UV")
+        self.set_dataset("UV_Frequencies", np.array(Calibrated_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(Calibrated_Experiment_freqs), dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_UV"))
+        self.set_dataset("UV_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+
+    """ Dummy for testing
+
+    @rpc
+    def create_dataset_jejox(self, Freqs):
+        self.set_dataset("counts_spectrum", np.zeros(len(Freqs), dtype=int), broadcast=True, archive=True)        
+    """
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        Amps = self.Get_Calibrated_Amplitudes()
+
+        """ 
+        #Dummy for testing:
+        Freqs = [250*MHz, 350*MHz]
+        Amps = [0.30, 0.30]
+        #self.create_dataset_jejox(Freqs)
+        """
+
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserUV.on()
+
+        self.enfriar_ion()
+
+        iter_index = 0
+
+        while iter_index < len(Freqs):         
+            print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            Accumulated_counts = 0
+            delay(10000*us)
+            self.laserUV.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 % self.cool_every == 0:                
+                    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)
+            delay(5000*us)
+            iter_index = iter_index + 1
+
+        delay(500*us)    
+
+        self.laserUV.select_profile(0)
+        self.laserIR.select_profile(0)
+
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=0)
+        self.laserIR.set_frequency(self.IR_final_freq, self.IR_final_amp, profile=0)
+
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        delay(1*ms)
+        self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser para ENFRIAR, el 1 va a ser para MEDIR
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, self.IR_cooling_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserIR.set_frequency(self.IR_measurement_freq, self.IR_measurement_amp, profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        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:
+        """Registro de cuentas emitidas"""
+        self.laserIR.select_profile(1) # Paso al perfil que cambia
+        self.laserUV.select_profile(1) 
+        self.laserIR.on()
+        self.laserUV.off()
+        delay(self.t_prepS)    
+        delay(2*us)
+        self.laserIR.off()
+        self.laserUV.on()
+        delay(self.t_readout)
+        #here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        #if runN % self.cool_every == 0:
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+        #return self.pmt.count(here) # recupero las cuentas medidas
+        return 0
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil de enfriado        
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil de enfriado
+        self.laserIR.on()
+        self.laserUV.on()
+
+
+
+
+
+
+
+
+
+
+

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

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class UV_Scan(EnvExperiment):
+    """With Calib - UV frequency sweep - Inversed (first N freqs, then change freq). IR laser fixed, UV laser pulsing between two frequencies. Amp cooling uv: 0.2. Freq cooling uv: selectable. Amp exp uv: varying"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(10, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(100*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(3*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(1*ms, unit='ms', scale=ms, min=0.01*ms),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+        #self.setattr_argument("UV_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("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_transitory", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+
+        self.ccb.issue("create_applet", "Calib_UV_espectro_xy",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy_scan "
+                        "measurements "
+                        "no_freqs "
+                        "--x UV_Frequencies "
+                        "--update-delay 0.2")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_UV")
+        self.set_dataset("UV_Frequencies", np.array(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+        self.set_dataset("no_freqs", len(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+        self.set_dataset("measurements", np.zeros(len(Calibrated_Experiment_freqs)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_UV"))
+        self.set_dataset("UV_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+    
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        #Freqs = self.UV_Freqs.sequence
+        Amps = self.Get_Calibrated_Amplitudes()
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+        self.laserIR.on()
+        self.laserUV.on()
+        
+        iter_index = 0
+        save_index = 0
+
+        #for freq, amp in zip(Freqs, Amps):
+        #for amp in Amps:  
+        while iter_index < len(Freqs):         
+            print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            for runN in range(self.no_measures):
+                at_mu(self.core.get_rtio_counter_mu()) # espero lo que haya que esperar por el mutate
+                delay(150*us) # Agrego unos forros 200us porque si no no anda
+                delay(self.t_cool) # Mas el tiempo de cooling, ~ 50us
+
+                self.laserUV.set_frequency(Freqs[iter_index], Amps[iter_index], profile=1) # Cambio la frec del perfil 1 (estoy en el 0)
+                #self.laserUV.set_frequency(Freqs[iter_index], 0.25, profile=1) # Cambio la frec del perfil 1 (estoy en el 0)
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                self.mutate_dataset("measurements", save_index, cuentas)
+                save_index = save_index + 1
+            iter_index = iter_index + 1
+        #at_mu(self.core.get_rtio_counter_mu())        
+        #self.laserUV.set_frequency(self.UV_cooling_freq, 0.25)
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser la referencia, el 1 va a ser el que se mueve
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserUV.set_frequency(self.UV_cooling_freq, 0.2, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        # self.laserIR.set_frequency(self.IR_cooling_freq)
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

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

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+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"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(10000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument("cool_every",
+                              NumberValue(50, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR_cooling_amp",
+                              NumberValue(0.15, min=0.01, max=0.35),
+                             "Cooling params")
+
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Cooling params")
+
+        
+        self.setattr_argument(f"IR_measurement_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"IR_measurement_amp",
+                              NumberValue(0.35, min=0.01, max=0.35),
+                             "Experiment params")
+        
+        """
+        self.setattr_argument(f"UV_measurement_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+        """
+
+
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1*ms, unit='ms', scale=ms, min=0.01*ms),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_prepS",
+                              NumberValue(3*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(1*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(1*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument(f"IR_final_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR_final_amp",
+                              NumberValue(0.20, min=0.01, max=0.35),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Final params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+
+    @rpc
+    def create_datasets(self):
+
+        #self.set_dataset("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("t_transitory", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+        self.set_dataset("t_cool", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_prep_S", self.t_prepS, broadcast=False, archive=True)
+
+        self.set_dataset("cool_every", self.cool_every, broadcast=False, archive=True)
+
+
+        self.set_dataset("IR_measurement_freq", self.IR_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_measurement_amp", self.IR_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR_cooling_freq", self.IR_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_cooling_amp", self.IR_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_cooling_freq", self.UV_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_cooling_amp", self.UV_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR_final_freq", self.IR_final_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_final_amp", self.IR_final_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_final_freq", self.UV_final_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_final_amp", self.UV_final_amp, broadcast=False, archive=True)
+
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+
+        self.ccb.issue("create_applet", "Calib_UV_espectro_xy",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy_scan "
+                        "measurements "
+                        "no_freqs "
+                        "--x UV_Frequencies "
+                        "--update-delay 0.2")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_UV")
+        self.set_dataset("UV_Frequencies", np.array(Calibrated_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(Calibrated_Experiment_freqs), dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_UV"))
+        self.set_dataset("UV_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+
+    """ Dummy for testing
+
+    @rpc
+    def create_dataset_jejox(self, Freqs):
+        self.set_dataset("counts_spectrum", np.zeros(len(Freqs), dtype=int), broadcast=True, archive=True)        
+    """
+
+    @kernel
+    def run(self):
+
+        #t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        Amps = self.Get_Calibrated_Amplitudes()
+
+        """ 
+        #Dummy for testing:
+        Freqs = [105*MHz, 110*MHz]
+        Amps = [0.15, 0.20]
+        self.create_dataset_jejox(Freqs)
+        """
+
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserUV.on()
+
+        self.enfriar_ion()
+
+        iter_index = 0
+
+        while iter_index < len(Freqs):         
+            print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            Accumulated_counts = 0
+            delay(10000*us)
+            self.laserUV.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 % self.cool_every == 0:                
+                    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)
+            delay(5000*us)
+            iter_index = iter_index + 1
+
+        delay(500*us)    
+
+        self.laserUV.select_profile(0)
+        self.laserIR.select_profile(0)
+
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=0)
+        self.laserIR.set_frequency(self.IR_final_freq, self.IR_final_amp, profile=0)
+
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        delay(1*ms)
+        self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser para ENFRIAR, el 1 va a ser para MEDIR
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, self.IR_cooling_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserIR.set_frequency(self.IR_measurement_freq, self.IR_measurement_amp, profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        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:
+        """Registro de cuentas emitidas"""
+        self.laserIR.select_profile(1)
+        self.laserIR.on()
+        self.laserUV.off()
+        delay(self.t_prepS)    
+
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        delay(2*us)
+        self.laserIR.off()
+        #delay(2*us)
+        self.laserUV.on()
+        delay(2*us)
+        delay(self.t_trans)
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        #if runN % self.cool_every == 0:
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+        return self.pmt.count(here) # recupero las cuentas medidas
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil de enfriado        
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil de enfriado
+        self.laserIR.on()
+        self.laserUV.on()
+
+
+
+
+
+
+
+
+
+
+

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

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class UV_Scan_withcalib_bothlaserson(EnvExperiment):
+    """Both lasers on - With Calib - UV frequency sweep - First N freqs, then change freq - Measures with both 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())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(10000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument("cool_every",
+                              NumberValue(50, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(240*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR_cooling_amp",
+                              NumberValue(0.15, min=0.01, max=0.35),
+                             "Cooling params")
+
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Cooling params")
+
+        
+        self.setattr_argument(f"IR_measurement_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"IR_measurement_amp",
+                              NumberValue(0.35, min=0.01, max=0.35),
+                             "Experiment params")
+        
+        """
+        self.setattr_argument(f"UV_measurement_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+        """
+
+
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1*ms, unit='ms', scale=ms, min=0.01*ms),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_prepS",
+                              NumberValue(3*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(1*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(1*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument(f"IR_final_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR_final_amp",
+                              NumberValue(0.20, min=0.01, max=0.35),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Final params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+        
+
+    @rpc
+    def create_datasets(self):
+
+        #self.set_dataset("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        #self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_Frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        #self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("t_transitory", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+        self.set_dataset("t_cool", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_prep_S", self.t_prepS, broadcast=False, archive=True)
+
+        self.set_dataset("cool_every", self.cool_every, broadcast=False, archive=True)
+
+
+        self.set_dataset("IR_measurement_freq", self.IR_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_measurement_amp", self.IR_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR_cooling_freq", self.IR_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_cooling_amp", self.IR_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_cooling_freq", self.UV_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_cooling_amp", self.UV_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR_final_freq", self.IR_final_freq, broadcast=False, archive=True)
+        self.set_dataset("IR_final_amp", self.IR_final_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_final_freq", self.UV_final_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_final_amp", self.UV_final_amp, broadcast=False, archive=True)
+
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+
+        self.ccb.issue("create_applet", "Calib_UV_espectro_xy",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy_scan "
+                        "measurements "
+                        "no_freqs "
+                        "--x UV_Frequencies "
+                        "--update-delay 0.2")
+        
+    
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_UV")
+        self.set_dataset("UV_Frequencies", np.array(Calibrated_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(Calibrated_Experiment_freqs), dtype=int), broadcast=True, archive=True)
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_UV"))
+        self.set_dataset("UV_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+
+    """ Dummy for testing
+
+    @rpc
+    def create_dataset_jejox(self, Freqs):
+        self.set_dataset("counts_spectrum", np.zeros(len(Freqs), dtype=int), broadcast=True, archive=True)        
+    """
+
+    @kernel
+    def run(self):
+
+        #t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        Freqs = self.Get_Calibrated_Frequencies()
+        Amps = self.Get_Calibrated_Amplitudes()
+
+        """ 
+        #Dummy for testing:
+        Freqs = [105*MHz, 110*MHz]
+        Amps = [0.15, 0.20]
+        self.create_dataset_jejox(Freqs)
+        """
+
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR.on()
+        self.laserUV.on()
+
+        self.enfriar_ion()
+
+        iter_index = 0
+
+        while iter_index < len(Freqs):         
+            print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            Accumulated_counts = 0
+            delay(10000*us)
+            self.laserUV.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 % self.cool_every == 0:                
+                    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)
+            delay(5000*us)
+            iter_index = iter_index + 1
+
+        delay(500*us)    
+
+        self.laserUV.select_profile(0)
+        self.laserIR.select_profile(0)
+
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=0)
+        self.laserIR.set_frequency(self.IR_final_freq, self.IR_final_amp, profile=0)
+
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        delay(1*ms)
+        self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser para ENFRIAR, el 1 va a ser para MEDIR
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR.set_frequency(self.IR_cooling_freq, self.IR_cooling_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserIR.set_frequency(self.IR_measurement_freq, self.IR_measurement_amp, profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        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:
+        """Registro de cuentas emitidas"""
+        self.laserIR.select_profile(1)
+        self.laserIR.on()
+        self.laserUV.off()
+        delay(self.t_prepS)    
+
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        delay(2*us)
+        #self.laserIR.off()
+        #delay(2*us)
+        self.laserUV.on()
+        delay(2*us)
+        delay(self.t_trans)
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        #if runN % self.cool_every == 0:
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+        return self.pmt.count(here) # recupero las cuentas medidas
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil de enfriado        
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil de enfriado
+        self.laserIR.on()
+        self.laserUV.on()
+
+
+
+
+
+
+
+
+
+
+

artiq_master/repository/Experiments/Spectrum/Without_calibration/IR_spectrum_withoutcalib.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class IR_Scan_Without_calibration(EnvExperiment):
+    """IR frequency sweep without calibration - First N freqs, then change freq"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "IR_Freqs", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(10, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR_cooling_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(50*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(3*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+        self.setattr_argument("IR_Freqs", 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("measurements", np.zeros(len(self.IR_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        self.set_dataset("IR_frequencies", self.IR_Freqs.sequence, broadcast=True, archive=True)
+
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_transitory", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        self.set_dataset("no_frequencies", len(self.IR_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("current_freq", np.array([0.0]),
+                         broadcast=True, archive=False)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "output_frecuency",
+                        "${artiq_applet}big_number "
+                        "current_freq")
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+        self.laserIR.on()
+        self.laserUV.on()
+
+        save_index = 0
+        for freq in self.IR_Freqs.sequence:
+            for runN in range(self.no_measures):
+                at_mu(self.core.get_rtio_counter_mu()) # espero lo que haya que esperar por el mutate
+                delay(150*us) # Agrego unos forros 200us porque si no no anda
+                delay(self.t_cool) # Mas el tiempo de cooling, ~ 50us
+
+                self.laserIR.set_frequency(freq, profile=1) # Cambio la frec del perfil 1 (estoy en el 0)
+
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                self.mutate_dataset("measurements", save_index, cuentas)                    
+                save_index = save_index + 1
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser la referencia, el 1 va a ser el que se mueve
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        # self.laserIR.set_frequency(self.IR_cooling_freq)
+        self.laserIR.select_profile(0) # Pongo el laser en el perfil referencia
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+        self.laserIR.select_profile(1) # Paso al perfil que cambia
+        #delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

artiq_master/repository/Experiments/Spectrum/Without_calibration/UV_spectrum_withoutcalib.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+
+
+class UV_Scan(EnvExperiment):
+    """UV frequency sweep - Without calibration - First N freqs, then change freq"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        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("no_measures",
+                              NumberValue(10, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(100*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(3*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(1*ms, unit='ms', scale=ms, min=0.01*ms),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+        self.setattr_argument("UV_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("measurements", np.zeros(len(self.UV_Freqs.sequence)*self.no_measures, dtype=int), broadcast=True, archive=True)
+        self.set_dataset("UV_frequencies", self.UV_Freqs.sequence, broadcast=True, archive=True)
+        #self.set_dataset("UV_amplitudes", self.Test_Experiment_amps, broadcast=True, archive=True)
+        #freqs = self.get_dataset("UV_frequencies")
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, archive=True)
+        self.set_dataset("no_frequencies", len(self.UV_Freqs.sequence), broadcast=True, archive=True)
+
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_transitory", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+        #self.set_dataset("calibration", self.get_dataset())
+
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+        self.ccb.issue("create_applet", "UV_espectro_hist",
+                        "${python} -m pyLIAF.artiq.applets.histogram "
+                        "counts "
+                        "--update-delay 0.2")
+
+        
+        #self.ccb.issue("create_applet", "UV_espectro_xy",
+        #                "${python} -m pyLIAF.artiq.applets.plot_xy_scan "
+        #                "measurements "
+        #                "--no_frequencies "
+        #                "--x UV_frequencies "
+        #                "--update-delay 0.2")
+        
+    """
+    #@rpc(flags={"async"})
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs")
+        self.set_dataset("UV_Frequencies", Calibrated_Experiment_freqs, broadcast=True, archive=True)
+        self.set_dataset("measurements", np.zeros(len(Calibrated_Experiment_freqs)*self.no_measures, dtype=int), broadcast=True, archive=True)
+
+        return Calibrated_Experiment_freqs
+
+    
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps"))
+        self.set_dataset("UV_Amplitudes", Calibrated_Experiment_amps, broadcast=True, archive=True)
+        return Calibrated_Experiment_amps
+    """
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+        cuentas = 0
+        #Freqs = self.Get_Calibrated_Frequencies()
+        Freqs = self.UV_Freqs.sequence
+        #Amps = self.Get_Calibrated_Amplitudes()
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+        self.laserIR.on()
+        self.laserUV.on()
+        
+        iter_index = 0
+        save_index = 0
+
+        #for freq, amp in zip(Freqs, Amps):
+        #for amp in Amps:  
+        while iter_index < len(Freqs):         
+            print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            for runN in range(self.no_measures):
+                at_mu(self.core.get_rtio_counter_mu()) # espero lo que haya que esperar por el mutate
+                delay(150*us) # Agrego unos forros 200us porque si no no anda
+                delay(self.t_cool) # Mas el tiempo de cooling, ~ 50us
+
+                #self.laserUV.set_frequency(Freqs[iter_index], Amps[iter_index], profile=1) # Cambio la frec del perfil 1 (estoy en el 0)
+                self.laserUV.set_frequency(Freqs[iter_index], 0.25, profile=1) # Cambio la frec del perfil 1 (estoy en el 0)
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                self.mutate_dataset("measurements", save_index, cuentas)
+                save_index = save_index + 1
+            iter_index = iter_index + 1
+            
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        self.laserUV.initialize_channel()
+        self.laserIR.initialize_channel()
+
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser la referencia, el 1 va a ser el que se mueve
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.laserUV.set_frequency(self.UV_cooling_freq, 0.2, profile=0)
+        self.laserIR.set_channel(profile=1)
+        self.laserUV.set_channel(profile=1)
+
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        # self.laserIR.set_frequency(self.IR_cooling_freq)
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

artiq_master/repository/Experiments/Transitory/Stationary_fluorescence.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+import numpy as np
+
+# TODO:
+#     [ ] Revisar los tiempos
+#     [ ] Ver por que da overflow intermitentemente en las corrids
+#     [ ] Ver como esta guardando los resultados y guardar lo que falta
+#     [ ] Cambiarle los parametros a los laseres cuando arranca el exp
+
+class StationaryFluo(EnvExperiment):
+    """Transitory and stationary fluorescence with both lasers"""
+    def build(self):
+        self.setattr_device("core")
+        self.setattr_device("ccb")       
+
+        self.pmt = self.get_device("ttl0")
+        self.pmt_state = self.get_device("ttl4")
+
+        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("bin", NumberValue(50e-9, unit='us'), "Binning params")
+
+        self.setattr_argument("no_measures",
+                              NumberValue(100, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+
+        self.setattr_argument(f"t_prepS",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("counts", [],
+                            broadcast=True, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+        self.set_dataset("t_prep_S", self.t_prepS, broadcast=False, archive=True)
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("no_measures", self.no_measures, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments)
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+        #self.set_dataset("frec_UV",self.frec_UV, broadcast=False,archive=True)
+        #self.set_dataset("frec_IR",self.frec_IR, broadcast=False,archive=True)
+        # TODO: Agregar forma de guardar los datos de los canales del Urukul.
+        # o bien guardando todos aca, o armando un metodo apropiado en su controlador
+        
+        #self.set_dataset("binvector", np.arange(0, self.t_readout, self.bin*1e-6), broadcast=True, archive=False)
+
+
+    @rpc
+    def create_applets(self):
+        self.ccb.issue("create_applet", "cuentas",
+                        "${python} -m pyLIAF.artiq.applets.histogram "
+                        "counts "
+                        "--update-delay 0.2")
+
+
+    @kernel
+    def run(self):
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+
+        self.enfriar_ion()
+        for runN in range(self.no_measures):
+            # Aprovecho el tiempo que necesito para extraer datos
+            # par enfriar al ion con los dos laseres prendidos
+            at_mu(self.core.get_rtio_counter_mu() + self.core.seconds_to_mu(self.t_cool) )
+            self.prep_S()
+            t_end = self.readout()
+            self.save_counts(t_end)
+            #self.mutate_dataset("counts", runN, counts)
+
+        self.cleanup()
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        self.pmt_state.output()
+        self.laserIR.initialize_channel()
+        self.laserUV.initialize_channel()
+        # Quizas haya errores de tiempo.
+        self.pmt_state.off()
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Preparo el ion prendiendo ambos laseres"""
+        self.laserIR.on()
+        self.laserUV.on()
+        #delay(self.t_cool)
+
+    @kernel
+    def prep_S(self):
+        """Preparo el estado S prendiendo solamente el laser IR"""
+        self.laserIR.on()
+        self.laserUV.off()
+        delay(self.t_prepS)
+
+
+    @kernel
+    def readout(self):
+        """Registro cuentas emitidas con el laser UV prendido"""
+        self.laserUV.on()
+        
+        self.pmt.gate_rising(self.t_readout)
+
+        self.enfriar_ion()
+
+        #with parallel:
+        #self.laserIR.on()
+        #self.laserUV.off()
+        #self.pmt_state.pulse(self.t_readout)
+        #cuentas = self.pmt.count(here)
+        #delay(1*us)
+
+        return now_mu()
+
+    @kernel
+    def save_counts(self, t_end):
+        count = self.pmt.timestamp_mu(t_end)
+        t0 = t_end - self.core.seconds_to_mu(self.t_readout)
+        while count > 0:
+            self.append_to_dataset("counts", self.core.mu_to_seconds(count - t0) )
+            count = self.pmt.timestamp_mu(t_end)
+
+
+    @kernel
+    def cleanup(self):
+        self.core.break_realtime()
+        self.laserIR.off()
+        self.laserUV.off()
+        self.pmt_state.off()

artiq_master/repository/Experiments/Transitory/single_transition_DP.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+import numpy as np
+
+# TODO:
+#     [ ] Revisar los tiempos
+#     [ ] Ver por que da overflow intermitentemente en las corrids
+#     [ ] Ver como esta guardando los resultados y guardar lo que falta
+#     [ ] Cambiarle los parametros a los laseres cuando arranca el exp
+
+class SingleLine(EnvExperiment):
+    """DP Transition Emission Experiment"""
+    def build(self):
+        self.setattr_device("core")
+        self.setattr_device("ccb")       
+
+        self.pmt = self.get_device("ttl0")
+        self.pmt_state = self.get_device("ttl4")
+
+        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("bin", NumberValue(50e-9, unit='us'), "Binning params")
+
+        self.setattr_argument("no_measures",
+                              NumberValue(100, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"t_prepS",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("counts", [],
+                            broadcast=True, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+        self.set_dataset("t_prep_S", self.t_prepS, broadcast=False, archive=True)
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("no_measures", self.no_measures, broadcast=False, archive=True)
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+        #self.set_dataset("frec_UV",self.frec_UV, broadcast=False,archive=True)
+        #self.set_dataset("frec_IR",self.frec_IR, broadcast=False,archive=True)
+        # TODO: Agregar forma de guardar los datos de los canales del Urukul.
+        # o bien guardando todos aca, o armando un metodo apropiado en su controlador
+        
+        #self.set_dataset("binvector", np.arange(0, self.t_readout, self.bin*1e-6), broadcast=True, archive=False)
+
+
+    @rpc
+    def create_applets(self):
+        self.ccb.issue("create_applet", "cuentas",
+                        "${python} -m pyLIAF.artiq.applets.histogram "
+                        "counts "
+                        "--update-delay 0.2")
+
+
+    @kernel
+    def run(self):
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+
+        self.enfriar_ion()
+        for runN in range(self.no_measures):
+            # Aprovecho el tiempo que necesito para extraer datos
+            # par enfriar al ion con los dos laseres prendidos
+            at_mu(self.core.get_rtio_counter_mu() + self.core.seconds_to_mu(self.t_cool) )
+            self.prep_D()
+            t_end = self.readout()
+            self.save_counts(t_end)
+            #self.mutate_dataset("counts", runN, counts)
+
+        self.cleanup()
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        self.pmt_state.output()
+        self.laserIR.initialize_channel()
+        self.laserUV.initialize_channel()
+        # Quizas haya errores de tiempo.
+        self.pmt_state.off()
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Preparo el ion prendiendo ambos laseres"""
+        self.laserIR.on()
+        self.laserUV.on()
+        #delay(self.t_cool)
+
+    @kernel
+    def prep_D(self):
+        """Preparo el estado D prendiendo solamente el laser UV"""
+        self.laserUV.on()
+        self.laserIR.off()
+        delay(self.t_prepS)
+
+
+    @kernel
+    def readout(self):
+        """Registro cuentas emitidas con el laser IR prendido"""
+        self.laserUV.off()
+        delay(1*us)
+        self.laserIR.on()
+        
+        # Prendo y apago la TTL para ver en el osc.
+        self.pmt_state.on()
+        self.pmt.gate_rising(self.t_readout)
+        #with parallel:
+        self.pmt_state.off()
+        self.laserUV.on()
+        self.laserIR.off()
+
+        #self.pmt_state.pulse(self.t_readout)
+        #cuentas = self.pmt.count(here)
+        #delay(1*us)
+        self.enfriar_ion()
+        return now_mu()
+
+    @kernel
+    def save_counts(self, t_end):
+        count = self.pmt.timestamp_mu(t_end)
+        t0 = t_end - self.core.seconds_to_mu(self.t_readout)
+        while count > 0:
+            self.append_to_dataset("counts", self.core.mu_to_seconds(count - t0) )
+            count = self.pmt.timestamp_mu(t_end)
+
+
+    @kernel
+    def cleanup(self):
+        self.core.break_realtime()
+        self.laserIR.off()
+        self.laserUV.off()
+        self.pmt_state.off()

artiq_master/repository/Experiments/Transitory/single_transition_SP.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+import numpy as np
+
+# TODO:
+#     [ ] Revisar los tiempos
+#     [ ] Ver por que da overflow intermitentemente en las corrids
+#     [ ] Ver como esta guardando los resultados y guardar lo que falta
+#     [ ] Cambiarle los parametros a los laseres cuando arranca el exp
+
+class SingleLine(EnvExperiment):
+    """SP Transition Emission Experiment"""
+    def build(self):
+        self.setattr_device("core")
+        self.setattr_device("ccb")       
+
+        self.pmt = self.get_device("ttl0")
+        self.pmt_state = self.get_device("ttl4")
+
+        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("bin", NumberValue(50e-9, unit='us'), "Binning params")
+
+        self.setattr_argument("no_measures",
+                              NumberValue(100, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+
+        self.setattr_argument(f"t_prepS",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+        self.setattr_argument(f"UV_measurement_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_measurement_amp",
+                              NumberValue(0.3, min=0.01, max=0.3),
+                             "Laser params")
+
+        
+        self.setattr_argument(f"IR_measurement_freq",
+                              NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR_measurement_amp",
+                              NumberValue(0.35, min=0.01, max=0.35),
+                             "Laser params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("counts", [],
+                            broadcast=True, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+        self.set_dataset("t_prep_S", self.t_prepS, broadcast=False, archive=True)
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("no_measures", self.no_measures, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments)
+
+        self.laserIR.generate_dataset()
+        self.laserUV.generate_dataset()
+        #self.set_dataset("frec_UV",self.frec_UV, broadcast=False,archive=True)
+        #self.set_dataset("frec_IR",self.frec_IR, broadcast=False,archive=True)
+        # TODO: Agregar forma de guardar los datos de los canales del Urukul.
+        # o bien guardando todos aca, o armando un metodo apropiado en su controlador
+        
+        #self.set_dataset("binvector", np.arange(0, self.t_readout, self.bin*1e-6), broadcast=True, archive=False)
+
+
+    @rpc
+    def create_applets(self):
+        self.ccb.issue("create_applet", "cuentas",
+                        "${python} -m pyLIAF.artiq.applets.histogram "
+                        "counts "
+                        "--update-delay 0.2")
+
+
+    @kernel
+    def run(self):
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+
+        self.enfriar_ion()
+        for runN in range(self.no_measures):
+            # Aprovecho el tiempo que necesito para extraer datos
+            # par enfriar al ion con los dos laseres prendidos
+            at_mu(self.core.get_rtio_counter_mu() + self.core.seconds_to_mu(self.t_cool) )
+            self.prep_S()
+            t_end = self.readout()
+            self.save_counts(t_end)
+            #self.mutate_dataset("counts", runN, counts)
+
+        self.core.break_realtime()
+        self.enfriar_ion()
+        self.core.break_realtime()
+        
+        #self.cleanup()
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        self.pmt_state.output()
+        self.laserIR.initialize_channel()
+        self.laserUV.initialize_channel()
+        # Quizas haya errores de tiempo.
+        self.pmt_state.off()
+        self.laserIR.set_channel()
+        self.laserUV.set_channel()
+        self.core.wait_until_mu(now_mu())
+
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_measurement_freq, self.UV_measurement_amp, profile=0)
+        self.core.break_realtime()
+        self.laserIR.set_frequency(self.IR_measurement_freq, self.IR_measurement_amp, profile=0)
+
+        self.core.break_realtime()
+
+    @kernel
+    def enfriar_ion(self):
+        """Preparo el ion prendiendo ambos laseres"""
+        self.laserIR.on()
+        self.laserUV.on()
+        #delay(self.t_cool)
+
+    @kernel
+    def prep_S(self):
+        """Preparo el estado S prendiendo solamente el laser IR"""
+        self.laserIR.on()
+        self.laserUV.off()
+        delay(self.t_prepS)
+
+
+    @kernel
+    def readout(self):
+        """Registro cuentas emitidas con el laser UV prendido"""
+        self.laserIR.off()
+        self.laserUV.on()
+        
+        # Prendo y apago la TTL para ver en el osc.
+        #self.pmt_state.on()
+        self.pmt.gate_rising(self.t_readout)
+        #with parallel:
+        #self.pmt_state.off()
+        self.laserIR.on()
+        self.laserUV.on()
+
+        #self.pmt_state.pulse(self.t_readout)
+        #cuentas = self.pmt.count(here)
+        #delay(1*us)
+        #self.enfriar_ion()
+        return now_mu()
+
+    @kernel
+    def save_counts(self, t_end):
+        count = self.pmt.timestamp_mu(t_end)
+        t0 = t_end - self.core.seconds_to_mu(self.t_readout)
+        while count > 0:
+            self.append_to_dataset("counts", self.core.mu_to_seconds(count - t0) )
+            count = self.pmt.timestamp_mu(t_end)
+
+
+    @kernel
+    def cleanup(self):
+        self.core.break_realtime()
+        self.laserIR.off()
+        self.laserUV.off()
+        self.pmt_state.off()

artiq_master/repository/Experiments/Trapping/Blinking_IR_Trapping.py

+import numpy as np
+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+
+
+class PMTCalibration(EnvExperiment):
+    """Blinking IR laser for trapping"""
+
+    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(300*ms, unit='ms', scale=ms, min=1*ms),
+                             "PMT Calibration")
+
+        self.setattr_argument("Blink", BooleanValue(1==0), "PMT Calibration")
+
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("pmt_counts_diff", np.zeros(1, dtype=int), broadcast=True, archive=False)
+        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", "ON_OFF_calibration_pmt_blinking",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "40 "
+                        "pmt_counts_on "
+                        "--y2 pmt_counts_off")
+
+        self.ccb.issue("create_applet", "DIFF_calibration_pmt_blinking",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "40 "
+                        "pmt_counts_diff")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        #self.laserIR.initialize_channel()
+        #self.laserUV.channel.cpld.init()
+        #self.laserUV.channel.init()
+        #self.laserIR.channel.cpld.init()
+        #self.core.wait_until_mu(now_mu())
+        #self.laserIR.channel.init()
+        #self.laserUV.initialize_channel()
+
+
+        self.pmt.input()
+
+        delay(1000*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()
+        if self.Blink:
+            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)
+
+    @kernel
+    def cleanup(self):
+        self.core.break_realtime()
+        self.laserIR.off()
+        self.laserUV.off()
+

artiq_master/repository/Experiments/Trapping/Blinking_TiSa.py

+import numpy as np
+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+
+
+class PMTCalibration(EnvExperiment):
+    """Blinking TiSa for 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.laserTISA = UrukulCh(self, ch=3, freq=80.0, amp=0.35, name="TISA") #corresponde a 0.7 Vpp
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(300*ms, unit='ms', scale=ms, min=1*ms),
+                             "PMT Calibration")
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("pmt_counts_diff", np.zeros(1, dtype=int), broadcast=True, archive=False)
+        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", "ON_OFF_calibration_pmt_blinking",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "40 "
+                        "pmt_counts_on "
+                        "--y2 pmt_counts_off")
+
+        self.ccb.issue("create_applet", "DIFF_calibration_pmt_blinking",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "40 "
+                        "pmt_counts_diff")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        #self.laserIR.initialize_channel()
+        #self.laserUV.channel.cpld.init()
+        #self.laserUV.channel.init()
+        #self.laserIR.channel.cpld.init()
+        #self.core.wait_until_mu(now_mu())
+        #self.laserIR.channel.init()
+        #self.laserUV.initialize_channel()
+
+
+        self.pmt.input()
+
+        delay(1000*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.on()
+        self.laserTISA.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.laserTISA.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)
+
+    @kernel
+    def cleanup(self):
+        self.core.break_realtime()
+        self.laserIR.off()
+        self.laserUV.off()
+

artiq_master/repository/Experiments/Trapping/Fluorescence_in_time.py

+import numpy as np
+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+
+
+class PMTCalibration(EnvExperiment):
+    """Plotting fluorescence in time"""
+
+    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(300*ms, unit='ms', scale=ms, min=1*ms),
+                             "PMT Calibration")
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("pmt_counts", np.zeros(1, dtype=int), broadcast=True, archive=False)
+
+    @rpc
+    def create_applets(self):
+        self.ccb.issue("create_applet", "Fluorescence_pmt",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "40 "
+                        "pmt_counts")
+
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        #self.laserIR.initialize_channel()
+        #self.laserUV.channel.cpld.init()
+        #self.laserUV.channel.init()
+        #self.laserIR.channel.cpld.init()
+        #self.core.wait_until_mu(now_mu())
+        #self.laserIR.channel.init()
+        #self.laserUV.initialize_channel()
+
+
+        self.pmt.input()
+
+        delay(1000*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:
+            self.Turn_on_lasers()
+            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:
+            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()
+        delay(10*us)          
+        counts = self.readout()
+        self.mutate_dataset("pmt_counts", 0, counts)
+        at_mu(self.core.get_rtio_counter_mu() + 10000)        
+
+    @kernel
+    def Turn_on_lasers(self):
+        self.core.break_realtime()
+        self.laserUV.on()
+        self.laserIR.on()
+
+

artiq_master/repository/Experiments/Trapping/Turning_ON.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+import numpy as np
+
+class ControlAllRF(EnvExperiment):
+    """Turning on the lasers"""
+    def build(self):
+        self.setattr_device("core")
+        # global attenuation
+        self.setattr_argument("attenuation",
+                            NumberValue(0*dB, unit='dB', scale=dB, min=0*dB, max=31*dB),
+                            )
+
+        RF_ch0 = UrukulCh(self, ch=0, freq=100.0, amp=1)
+        RF_ch1 = UrukulCh(self, ch=1, freq=208.0, amp=0.35)
+        RF_ch2 = UrukulCh(self, ch=2, freq=110.0, amp=0.3)
+        RF_ch3 = UrukulCh(self, ch=3, freq=80.0, amp=0.37)
+
+        self.RF_chs = [RF_ch0, RF_ch1, RF_ch2, RF_ch3]
+
+        #self.set_dataset("Potencias", np.full(0., 10))
+
+    #@rpc
+    #def get_measurement(self, i):
+    #    val = self.RP.give_measurement()
+    #    self.mutate_dataset("Potencias", i, val)
+
+    @kernel
+    def run(self):
+        self.core.reset()
+        delay(1000*ms)
+        # initialises CPLD all the selected channels
+        for rf_ch in self.RF_chs:
+            rf_ch.initialize_channel()
+            self.core.break_realtime()
+
+        delay(100*ms)
+        
+        for rf_ch in self.RF_chs:
+            rf_ch.set_channel()
+            self.core.break_realtime()
+
+        for rf_ch in self.RF_chs:
+            rf_ch.channel.set_att(0.)
+            self.core.break_realtime()
+
+        #self.get_measurement(medN)
+#        self.core.break_realtime()
+    
+    

artiq_master/repository/Experiments/Trapping/Turning_ON_afterfirston.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+import numpy as np
+
+class ControlAllRF(EnvExperiment):
+    """Changing amp and freq of lasers"""
+    def build(self):
+        self.setattr_device("core")
+        # global attenuation
+        self.setattr_argument("attenuation",
+                            NumberValue(0*dB, unit='dB', scale=dB, min=0*dB, max=31*dB),
+                            )
+
+        RF_ch0 = UrukulCh(self, ch=0, freq=100.0, amp=1)
+        RF_ch1 = UrukulCh(self, ch=1, freq=208.0, amp=0.35)
+        RF_ch2 = UrukulCh(self, ch=2, freq=110.0, amp=0.3)
+        RF_ch3 = UrukulCh(self, ch=3, freq=80.0, amp=0.37)
+
+        self.RF_chs = [RF_ch0, RF_ch1, RF_ch2, RF_ch3]
+
+        #self.set_dataset("Potencias", np.full(0., 10))
+
+    #@rpc
+    #def get_measurement(self, i):
+    #    val = self.RP.give_measurement()
+    #    self.mutate_dataset("Potencias", i, val)
+
+    @kernel
+    def run(self):
+        self.core.reset()
+        delay(1000*ms)
+        # initialises CPLD all the selected channels
+        for rf_ch in self.RF_chs:
+            #rf_ch.initialize_channel()
+            self.core.break_realtime()
+
+        delay(100*ms)
+        
+        for rf_ch in self.RF_chs:
+            rf_ch.set_channel()
+            self.core.break_realtime()
+
+        for rf_ch in self.RF_chs:
+            rf_ch.channel.set_att(0.)
+            self.core.break_realtime()
+
+        #self.get_measurement(medN)
+#        self.core.break_realtime()
+    
+