tod

artiq_master/last_rid.pyon

-16533
+16638

artiq_master/repository/Experiments/Motor/Beam_profile.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
+from time import sleep
+
+import socket
+client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+address = ('10.99.34.95', 6001)
+ 
+
+class FrontalBeamProfile(EnvExperiment):
+    """Sweeps picomotor of frontal IR beam and measures fluorescence retrieving beam profile"""
+    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.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(f"IR2_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Measurement params")
+
+        self.setattr_argument(f"IR2_amp",
+                              NumberValue(0.3, min=0., max=0.8),
+                             "Measurement params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(300*ms, unit='ms', scale=ms, min=1*ms),
+                             "Measurement params")
+
+
+        self.setattr_argument(f"IR2_final_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR2_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Final params")
+
+
+        self.setattr_argument("Channel",
+                                  EnumerationValue(["1", "2"]),
+                              "Motor params")
+
+        self.setattr_argument(f"Steps",
+                              NumberValue(50, min=-1000, max=1000),
+                             "Motor params")
+
+        self.setattr_argument(f"Measurements",
+                              NumberValue(100, min=1, max=100000),
+                             "Motor params")
+
+
+        self.setattr_argument("Return", BooleanValue(1==0), "Motor params")
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+
+
+    @rpc
+    def create_datasets(self):
+
+
+        #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("IR2_freq", self.IR2_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_amp", self.IR2_amp, broadcast=False, archive=True)
+
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Channel", self.Channel, broadcast=False, archive=True)
+        self.set_dataset("Steps", self.Steps, broadcast=False, archive=True)
+        self.set_dataset("Measurements", self.Measurements, broadcast=False, archive=True)
+
+
+        self.set_dataset("array_steps", np.linspace(0,int(self.Steps*self.Measurements),int(self.Measurements)), broadcast=True, archive=True)
+        self.set_dataset("counts_spectrum", np.zeros(int(self.Measurements), dtype=int), broadcast=True, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "Beam_profile",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts_spectrum "
+                        "--x array_steps")
+
+    @rpc
+    def initialize_motor_com(self):
+        client_socket.connect(address)
+        print('motor comm initialized')
+        sleep(1)
+
+    @rpc
+    def change_motor_value(self):
+        client_socket.sendall(f"{self.Channel} {int(self.Steps)}".encode())
+             
+        response = client_socket.recv(1024)
+        sleep(0.2)
+
+
+    @rpc
+    def end_motor_com(self):
+        client_socket.sendall(b'exit')
+         
+        response = client_socket.recv(1024)
+        print(response.decode())
+         
+        client_socket.close()        
+
+        print('todo concluye al fin')        
+
+    @rpc
+    def return_motor_value(self):
+        client_socket.sendall(f"{self.Channel} {-1*int(self.Steps)}".encode())
+             
+        response = client_socket.recv(1024)
+        sleep(0.2)
+
+
+    @kernel
+    def run(self):
+
+        self.initialize_motor_com()
+
+        #t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues
+
+        self.create_datasets()
+        self.create_applets()
+        #self.init_kernel()
+        delay(10*ms)
+
+#        self.laserIR2.on()
+
+
+
+        for runN in range(int(self.Measurements)):
+            delay(10*ms)
+            self.change_motor_value()
+            cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+            self.mutate_dataset("counts_spectrum", runN, cuentas)
+
+        if self.Return:
+            for runN in range(int(self.Measurements)):
+                delay(10*ms)
+                self.return_motor_value()
+                #cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                #self.mutate_dataset("counts_spectrum", runN, cuentas)
+
+
+
+        self.core.break_realtime()
+        delay(50*ms)
+
+
+        self.end_motor_com()
+
+        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 y el 2 va a ser de CALENTAMIENTO
+        #self.laserIR1.set_channel()
+        #self.laserUV.set_channel()
+        #self.laserIR2.set_channel()
+        #self.laserIR2shift.set_channel()
+        #self.laserIR1.set_frequency(self.IR1_cooling_freq, self.IR1_cooling_amp, profile=0)
+        #self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=0)
+        #self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        #self.laserIR2.set_frequency(self.IR2_cooling_freq, self.IR2_cooling_amp, profile=0)
+        #self.laserIR1.set_channel(profile=1)
+        #self.core.break_realtime()
+        #self.laserUV.set_channel(profile=1)
+        #self.core.break_realtime()
+        #self.laserIR2shift.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserIR2.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.laserIR2.set_frequency(self.IR2_CPT_freq, self.IR2_CPT_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=1)
+        #self.laserTISA.set_frequency(self.TISA_CPT_freq, 0.035, profile=1)
+        self.core.break_realtime()
+        #self.laserIR1.set_channel(profile=2)
+        #self.core.break_realtime()
+        #self.laserUV.set_channel(profile=2)
+        #self.core.break_realtime()
+        #self.laserIR2.set_channel(profile=2)
+        #self.core.break_realtime()
+        #self.laserIR2shift.set_channel(profile=2)
+        #self.core.break_realtime()
+        #self.laserIR1.set_frequency(self.IR1_cooling_freq, self.IR1_cooling_amp, profile=2)
+        #self.core.break_realtime()
+        #self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=2)
+        #self.core.break_realtime()
+        #self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=2)
+        #self.core.break_realtime()
+        #self.laserIR2.set_frequency(self.IR2_cooling_freq, self.IR2_cooling_amp, profile=2)
+
+        # 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"""
+        self.core.break_realtime()        
+        delay(50*ms)
+        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/Motor/MICROMOTION_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
+from time import sleep
+
+PORT = 60000
+PASS = b'Secr3t Pa55W0rd'
+from multiprocessing.connection import Client
+
+class IR_Scan_withcal_optimized(EnvExperiment):
+    """Can change dc voltages - Two IR lasers - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays"""
+    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.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("Fine_scan", BooleanValue(1==0), "Experiment params")
+
+        self.setattr_argument("no_measures",
+                              NumberValue(2000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+        self.setattr_argument(f"IR1_cooling_freq",
+                              NumberValue(229*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"UV_cooling_freq",
+                              NumberValue(112*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.1, min=0.0, max=0.3),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_cooling_freq",
+                              NumberValue(80*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.8),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_CPT_freq",
+                              NumberValue(118*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"UV_CPT_amp",
+                              NumberValue(0.1, min=0.000, max=0.300, step=0.001),
+                             "CPT params")
+
+        self.setattr_argument(f"IR2_CPT_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"IR2_CPT_amp",
+                              NumberValue(0.3, min=0., max=0.8),
+                             "CPT params")
+
+        self.setattr_argument(f"IR1_final_freq",
+                              NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR1_final_amp",
+                              NumberValue(0.23, min=0.0, max=0.35),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.11, min=0.0, max=0.3),
+                             "Final params")
+
+        self.setattr_argument(f"IR2_final_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Final params")
+
+        self.setattr_argument(f"IR2_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.8),
+                             "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(f"t_heating",
+                              NumberValue(1*ms, unit='ms', scale=ms),
+                             "Experiment params")
+
+        self.setattr_argument("Heating", BooleanValue(1==0), "Experiment params")
+
+        self.setattr_argument("Scan_type",
+                                  EnumerationValue(["Calibrated_scan", "Defined_scan"]),
+                              "Scan params")
+
+
+        self.setattr_argument("Scanning_frequencies", Scannable(
+                                       default=CenterScan(210*MHz, 20*MHz, 0.1*MHz),
+                                        unit="MHz",
+                                        scale=MHz,
+                                        global_min = 1*MHz,
+                                        global_max = 400*MHz
+                                       ),
+                             "Scan params")
+
+
+        self.setattr_argument("Sweep_type",
+                                  EnumerationValue(["heating_time", "volt_dcA", "volt_dcB", "volt_compOven"]),
+                              "Scan params")
+
+        self.setattr_argument("Plot_type",
+                                  EnumerationValue(["relative_depths", "absolute_depths"]),
+                              "Scan params")
+
+        self.setattr_argument("Scanning_voltages", Scannable(
+                                       default=CenterScan(1, 0.1, 0.1),
+                                        global_min = -7,
+                                        global_max = 7
+                                       ),
+                             "Scan params")
+
+        self.setattr_argument("Scanning_heattimes", Scannable(
+                                       default=CenterScan(1*ms, 0.1*ms, 0.1*ms),
+                                        unit="ms",
+                                        scale=ms,
+                                        global_min = 0*ms,
+                                        global_max = 1000*ms
+                                       ),
+                             "Scan 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("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("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("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("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_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("IR2_CPT_freq", self.IR2_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_CPT_amp", self.IR2_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("scanning_heattimes", self.Scanning_heattimes.sequence, broadcast=True, archive=True)
+        self.set_dataset("scanning_voltages", self.Scanning_voltages.sequence, broadcast=True, 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("t_heating", self.t_heating, broadcast=False, archive=True)
+
+        if self.Sweep_type == 'heating_time':
+            self.set_dataset("plot_array", np.zeros(len(self.Scanning_heattimes.sequence)), broadcast=True, archive=True)
+        else:
+            self.set_dataset("plot_array", np.zeros(len(self.Scanning_voltages.sequence)), broadcast=True, archive=True)
+
+
+        self.set_dataset("scanned", self.Sweep_type, broadcast=False, archive=True)
+
+        self.set_dataset("initialvoltage_dcA", self.read_dcvoltage(cmd="volt_dcA")[0], broadcast=False, archive=True)
+        self.set_dataset("initialvoltage_dcB", self.read_dcvoltage(cmd="volt_dcB")[0], broadcast=False, archive=True)
+        self.set_dataset("initialvoltage_compOven", self.read_dcvoltage(cmd="volt_compOven")[0], broadcast=False, archive=True)
+
+        self.set_dataset("t_heating", self.t_heating, broadcast=False, archive=True)
+
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+
+    @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 IR1_Frequencies")
+
+        self.ccb.issue("create_applet", "DR_depth",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "plot_array "
+                        "--x scanning_heattimess")
+
+        self.ccb.issue("create_applet", "spectrum_realtime",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "freqplot_array "
+                        "--x IR1_Frequencies")
+
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+        if self.Fine_scan:
+            Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR_fine")
+        else:
+            Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
+        self.set_dataset("IR1_Frequencies_calibrated", np.array(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+
+        if self.Scan_type == "Calibrated_scan":
+            Experiment_freqs = Calibrated_Experiment_freqs
+        elif self.Scan_type == "Defined_scan":
+            Experiment_freqs = self.Scanning_frequencies.sequence
+        self.set_dataset("IR1_Frequencies", np.array(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(Experiment_freqs), dtype=int), broadcast=True, archive=True)
+
+        if self.Sweep_type == 'heating_time':
+            self.set_dataset("data_array", np.zeros(len(self.Scanning_heattimes.sequence)*len(Experiment_freqs), dtype=int), broadcast=False, archive=True)
+        else:
+            self.set_dataset("data_array", np.zeros(len(self.Scanning_voltages.sequence)*len(Experiment_freqs), dtype=int), broadcast=False, archive=True)
+        return Experiment_freqs
+
+
+    @rpc
+    def Get_Calibrated_Amplitudes(self)  -> TList(TFloat):
+        if self.Fine_scan:
+            Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR_fine"))
+        else:
+            Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR"))
+        self.set_dataset("IR1_Amplitudes_calibrated", Calibrated_Experiment_amps, broadcast=True, archive=True)
+
+        if self.Scan_type == "Calibrated_scan":
+            Experiment_amps = Calibrated_Experiment_amps
+        elif self.Scan_type == "Defined_scan":
+            Experiment_amps = []
+            Experiment_freqs = self.Scanning_frequencies.sequence
+            if self.Fine_scan:
+                Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR_fine")
+            else:
+                Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
+            for f in Experiment_freqs:
+                idx = (np.abs(np.asarray(Calibrated_Experiment_freqs) - f)).argmin() #busco el valor mas cercano en las freqs calibradas
+                Experiment_amps.append(Calibrated_Experiment_amps[idx])
+        self.set_dataset("IR1_Amplitudes", Experiment_amps, broadcast=True, archive=True)
+
+        return Experiment_amps
+
+    @rpc
+    def initialize_andor_com(self):
+        print('tuki')
+        address = ('localhost', PORT)
+        self.conn = Client(address, authkey=PASS)
+        sleep(0.1)
+
+    @rpc
+    def change_dcvoltage(self,volt,cmd='volt_compOven'):
+        self.conn.send(f'{cmd} {volt}')
+        rta = self.conn.recv()
+
+    @rpc
+    def read_dcvoltage(self,cmd='volt_compOven') -> TList(TFloat):
+        self.conn.send(f'{cmd}')
+        rta = self.conn.recv()
+        return [rta]
+
+    @kernel
+    def run(self):
+
+        initial_voltage = [0.2]
+        self.initialize_andor_com()
+        if not self.Sweep_type == "heating_time":
+            print('ojo')
+
+            initial_voltage = self.read_dcvoltage(cmd=self.Sweep_type)
+            print('initial voltage: ', initial_voltage[0])
+
+        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()
+
+        Heattimes = self.Scanning_heattimes.sequence
+        Voltages = self.Scanning_voltages.sequence
+
+        self.create_datasets()
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserIR2shift.on()
+        self.laserUV.on()
+
+        self.enfriar_ion()
+
+        if not self.Sweep_type == "heating_time":
+            voltage_index = 0
+            while voltage_index < len(Voltages):
+                if not self.Sweep_type == "heating_time":
+                    self.change_dcvoltage(Voltages[voltage_index], cmd=self.Sweep_type)
+                iter_index = 0
+                temporal_freq_list=[0]*len(Freqs)
+                while iter_index < len(Freqs):
+                    Accumulated_counts = 0
+                    self.core.break_realtime()
+                    delay(10000*us)
+                    self.laserIR1.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(200*us)
+                        if self.Heating:
+                            self.laserUV.off()
+                            delay(self.t_heating)
+                            self.laserUV.on()
+
+                        cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                        Accumulated_counts = Accumulated_counts + cuentas
+                    self.mutate_dataset("data_array", voltage_index*len(Freqs)+iter_index, Accumulated_counts)
+                    temporal_freq_list[iter_index] = Accumulated_counts
+                    delay(5000*us)
+                    self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
+                    iter_index = iter_index + 1
+
+                if self.Plot_type == 'relative_depths':
+                    self.mutate_dataset("plot_array", voltage_index, (temporal_freq_list[0]-temporal_freq_list[1])/temporal_freq_list[0])
+                elif self.Plot_type == 'absolute_depths':
+                    self.mutate_dataset("plot_array", voltage_index, temporal_freq_list[1])
+
+                voltage_index = voltage_index + 1
+            delay(500*us)
+
+        if self.Sweep_type == "heating_time":
+            voltage_index = 0
+            while voltage_index < len(Heattimes):
+                iter_index = 0
+                temporal_freq_list=[0]*len(Freqs)
+                while iter_index < len(Freqs):
+                    Accumulated_counts = 0
+                    self.core.break_realtime()
+                    delay(10000*us)
+                    self.laserIR1.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)
+
+                        self.laserUV.off()
+                        delay(Heattimes[voltage_index])
+                        self.laserUV.on()
+                        self.core.break_realtime()
+                        delay(20*us)
+                        cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                        Accumulated_counts = Accumulated_counts + cuentas
+                    self.mutate_dataset("data_array", voltage_index*len(Freqs)+iter_index, Accumulated_counts)
+                    temporal_freq_list[iter_index] = Accumulated_counts
+                    delay(5000*us)
+                    self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
+                    iter_index = iter_index + 1
+
+                print("done time")
+                if self.Plot_type == 'relative_depths':
+                    self.mutate_dataset("plot_array", voltage_index, (temporal_freq_list[0]-temporal_freq_list[1])/temporal_freq_list[0])
+                elif self.Plot_type == 'absolute_depths':
+                    self.mutate_dataset("plot_array", voltage_index, temporal_freq_list[1])
+
+                voltage_index = voltage_index + 1
+            delay(500*us)
+
+
+        self.core.break_realtime()
+        delay(50*us)
+        self.laserUV.select_profile(1)
+        self.laserIR1.select_profile(1)
+        self.laserIR2.select_profile(1)
+
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=1)
+        self.core.break_realtime()
+        delay(50*us)
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=1)
+        self.core.break_realtime()
+        delay(50*us)
+        self.laserIR1.set_frequency(self.IR1_final_freq, self.IR1_final_amp, profile=1)
+        self.core.break_realtime()
+        delay(50*us)
+        self.laserIR2.set_frequency(self.IR2_final_freq, self.IR2_final_amp, profile=1)
+        self.core.break_realtime()
+        delay(50*us)
+        if not self.Sweep_type == "heating_time":
+            self.change_dcvoltage(initial_voltage[0], cmd=self.Sweep_type)
+
+        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 y el 2 va a ser de CALENTAMIENTO
+        self.laserIR1.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR2.set_channel()
+        self.laserIR2shift.set_channel()
+        self.laserIR1.set_frequency(self.IR1_cooling_freq, self.IR1_cooling_amp, profile=0)
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserIR2.set_frequency(self.IR2_cooling_freq, self.IR2_cooling_amp, profile=0)
+        self.laserIR1.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserUV.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserIR2shift.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserIR2.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.laserIR2.set_frequency(self.IR2_CPT_freq, self.IR2_CPT_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=1)
+        #self.laserTISA.set_frequency(self.TISA_CPT_freq, 0.035, profile=1)
+        self.core.break_realtime()
+        #self.laserIR1.set_channel(profile=2)
+        #self.core.break_realtime()
+        #self.laserUV.set_channel(profile=2)
+        #self.core.break_realtime()
+        #self.laserIR2.set_channel(profile=2)
+        #self.core.break_realtime()
+        #self.laserIR2shift.set_channel(profile=2)
+        #self.core.break_realtime()
+        #self.laserIR1.set_frequency(self.IR1_cooling_freq, self.IR1_cooling_amp, profile=2)
+        #self.core.break_realtime()
+        #self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=2)
+        #self.core.break_realtime()
+        #self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=2)
+        #self.core.break_realtime()
+        #self.laserIR2.set_frequency(self.IR2_cooling_freq, self.IR2_cooling_amp, profile=2)
+
+        # 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.laserIR1.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserIR2.select_profile(0)
+        self.laserIR2shift.select_profile(0)
+
+    @kernel
+    def calentar_ion(self):
+        """Caliento el ion por un tiempo determinado apagando el laser UV"""
+        self.laserUV.off()
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        self.laserIR1.select_profile(1) # Paso al perfil que cambia
+        self.laserIR2.select_profile(1) # Paso al perfil que cambia
+        self.laserIR2shift.select_profile(1)
+        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