agrego archivo que hace espectro pero midiendo N veces cada frecuenciua y...

agrego archivo que hace espectro pero midiendo N veces cada frecuenciua y luyego cambia de frecuencia. no com antes. por eso se llama inverse. ya se, es un nombre malisimo pero es viernes

artiq_master/repository/Experiments/IR_spectrum_inverse.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 - 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", "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", "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 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