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 IR_Scan(EnvExperiment):
    """IR frequency sweep"""
    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=False, 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=False, 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.laserIR.generate_dataset()
        self.laserUV.generate_dataset()

    @rpc(flags={"async"})
    def create_applets(self):

        self.ccb.issue("create_applet", "cuentas",
                        "${python} -m pyLIAF.artiq.applets.histogram "
                        "counts "
                        "--update-delay 0.2")

        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 runN in range(self.no_measures):
            for freq in self.IR_Freqs.sequence:
                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
            if runN % 1000 == 0:
                print(runN)
        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