todo

artiq_master/repository/Tests/Fluorescence_correlation.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 FluorescenceCorrelation(EnvExperiment):
+    """TEST - Fluorescence correlation"""
+    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.laserIR1 = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR1") #corresponde a 0.8 Vpp
+        self.laserIR2 = UrukulCh(self, ch=3, freq=80.0, amp=0.2, name="IR2") #corresponde a 0.8 Vpp
+        self.laserIR2shift = UrukulCh(self, ch=0, freq=270.0, amp=0.7, name="IR2shift") #corresponde a 0.8 Vpp
+
+#        self.setattr_argument("bin", NumberValue(50e-9, unit='us'), "Binning params")
+
+        self.setattr_argument("no_measures",
+                              NumberValue(1000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+
+        self.setattr_argument(f"t_prepDS",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1000*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_wait",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"UV_preparation_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_preparation_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_preparation_freq",
+                              NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_preparation_amp",
+                              NumberValue(0.19, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_preparation_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_preparation_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_measurement_freq",
+                              NumberValue(115*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.0, max=0.3),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_measurement_freq",
+                              NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_measurement_amp",
+                              NumberValue(0.19, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_measurement_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_measurement_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(115*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"IR1_cooling_freq",
+                              NumberValue(225*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR1_cooling_amp",
+                              NumberValue(0.25, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_cooling_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_cooling_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR1_final_freq",
+                              NumberValue(225*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR1_final_amp",
+                              NumberValue(0.25, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_final_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Cooling 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_prepDS", self.t_prepDS, broadcast=False, archive=True)
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_wait", self.t_wait, broadcast=False, archive=True)
+        self.set_dataset("no_measures", self.no_measures, broadcast=False, archive=True)
+
+
+        self.set_dataset("IR1_preparation_freq", self.IR1_preparation_freq, broadcast=False, archive=True)
+        self.set_dataset("IR1_preparation_amp", self.IR1_preparation_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR2_preparation_freq", self.IR2_preparation_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_preparation_amp", self.IR2_preparation_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_preparation_freq", self.UV_preparation_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_preparation_amp", self.UV_preparation_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR1_cooling_freq", self.IR1_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR1_cooling_amp", self.IR1_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR2_cooling_freq", self.IR2_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_cooling_amp", self.IR2_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("IR1_measurement_freq", self.IR1_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR1_measurement_amp", self.IR1_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR2_measurement_freq", self.IR2_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_measurement_amp", self.IR2_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.laserIR1.generate_dataset()
+        self.laserIR2.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("Comments", self.Comments)
+        #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):
+            if runN % 50 == 0:
+                at_mu(self.core.get_rtio_counter_mu() + self.core.seconds_to_mu(self.t_cool) )
+            else:
+                at_mu(self.core.get_rtio_counter_mu() + self.core.seconds_to_mu(100*us) )
+            self.prep_DS()
+            t_end = self.medicion_y_lectura()
+            self.save_counts(t_end)
+            #self.mutate_dataset("counts", runN, counts)
+
+        #self.cleanup()
+        self.core.break_realtime()
+        self.enfriar_ion()
+        self.core.break_realtime()
+
+        self.laserIR1.select_profile(3)
+        self.laserIR2.select_profile(3)
+        self.laserUV.select_profile(3)
+        self.laserIR2shift.select_profile(3)
+
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserUV.on()
+        self.laserIR2shift.on()
+
+
+
+    @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 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())
+        delay(1*ms)
+        self.laserIR1.set_channel()
+        delay(1*ms)
+        self.laserIR2.set_channel()
+        delay(1*ms)
+        self.laserIR2shift.set_channel()
+        delay(1*ms)
+        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.laserIR1.set_frequency(self.IR1_measurement_freq, self.IR1_measurement_amp, profile=0)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_measurement_freq, self.IR2_measurement_amp, profile=0)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=0)
+
+        self.core.break_realtime()
+
+        delay(1*ms)
+        self.laserIR1.set_channel(profile=1)
+        delay(1*ms)
+        self.laserIR2.set_channel(profile=1)
+        delay(1*ms)
+        self.laserIR2shift.set_channel(profile=1)
+        delay(1*ms)
+        self.laserUV.set_channel(profile=1)
+
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR1.set_frequency(self.IR1_cooling_freq, self.IR1_cooling_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_cooling_freq, self.IR2_cooling_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=1)
+
+        self.core.break_realtime()
+
+        delay(1*ms)
+        self.laserIR1.set_channel(profile=2)
+        delay(1*ms)
+        self.laserIR2.set_channel(profile=2)
+        delay(1*ms)
+        self.laserIR2shift.set_channel(profile=2)
+        delay(1*ms)
+        self.laserUV.set_channel(profile=2)
+
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_preparation_freq, self.UV_preparation_amp, profile=2)
+        self.core.break_realtime()
+        self.laserIR1.set_frequency(self.IR1_preparation_freq, self.IR1_preparation_amp, profile=2)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_preparation_freq, self.IR2_preparation_amp, profile=2)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=2)
+
+        self.core.break_realtime()
+
+        delay(1*ms)
+        self.laserIR1.set_channel(profile=3)
+        delay(1*ms)
+        self.laserIR2.set_channel(profile=3)
+        delay(1*ms)
+        self.laserIR2shift.set_channel(profile=3)
+        delay(1*ms)
+        self.laserUV.set_channel(profile=3)
+
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=3)
+        self.core.break_realtime()
+        self.laserIR1.set_frequency(self.IR1_final_freq, self.IR1_final_amp, profile=3)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_final_freq, self.IR2_final_amp, profile=3)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=3)
+
+        self.core.break_realtime()
+
+
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Preparo el ion prendiendo ambos laseres"""
+        self.laserUV.select_profile(1)
+        self.laserIR1.select_profile(1)
+        self.laserIR2.select_profile(1)
+        self.laserIR2shift.select_profile(1)
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserUV.on()
+        self.laserIR2shift.on()
+        #delay(self.t_cool)
+
+    @kernel
+    def prep_DS(self):
+        """Preparo el estado oscuro prendiendo los 3 laseres con las frecuencias correctas"""
+        self.core.break_realtime()
+        self.laserIR1.select_profile(2)
+        self.laserIR2.select_profile(2)
+        self.laserUV.select_profile(2)
+        self.laserIR2shift.select_profile(2)
+        self.laserUV.on()
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserIR2shift.on()
+        delay(self.t_prepDS)
+
+    @kernel
+    def medicion_y_lectura(self):
+        """Registro cuentas emitidas con el laser UV prendido"""
+        self.laserUV.off()
+        self.laserIR1.off()
+        self.laserIR2.off()
+        self.laserIR2shift.off()
+        #self.pmt.gate_rising(self.t_readout)        
+        self.laserIR1.select_profile(0)
+        self.laserIR2.select_profile(0)
+        self.laserUV.select_profile(0)
+        self.laserIR2shift.select_profile(0)
+        self.laserUV.on()
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserIR2shift.on()
+
+        #delay(self.t_wait)
+
+        # 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.enfriar_ion()
+
+        #self.pmt_state.pulse(self.t_readout)
+        #cuentas = self.pmt.count(here)
+        #delay(1*us)
+        #self.enfriar_ion()
+        return now_mu()
+
+
+    @kernel
+    def readout(self):
+        """NO SE USA ESTA FUNCION - Registro cuentas emitidas con el laser IR prendido"""
+        self.laserUV.off()
+        delay(1*us)
+        self.laserIR1.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.laserIR1.off()
+
+        #self.pmt_state.pulse(self.t_readout)
+        #cuentas = self.pmt.count(here)
+        #delay(1*us)
+        self.enfriar_ion()
+        return now_mu()
+
+    @kernel
+    def cleanup(self):
+        """NO SE USA ESTA FUNCION"""
+        self.core.break_realtime()
+        self.laserIR1.off()
+        self.laserIR2.off()
+        self.laserUV.off()
+        #self.pmt_state.off()