mediciones del 2207

analisis/plots/20250716_fluorescence_correlation/check_rffrequency.py

@@ -89,10 +89,8 @@ Esto deberia hacerse asi para ver la oscilacion a la RF (micromocion)
 BINW = 1e-3
 T0 = -0.4e-6
 
-#files = [20577,20578,20579,20580,20581] #el 19613 es el que muestra el pico en 48.5 Hz
 
-files = [22809,22813,22817,22818,22819,22820] 
-files  =  [22838]
+files  =  [22845]
 
 def bin_time_arrivals(arrival_times, tau):
     """
@@ -134,8 +132,8 @@ for i, fname in enumerate(files):
     Amplitud en funcion de la frecuencia de bineo de la rf
     """
     
-    freqrf = 7.186226e6
-    freqrfvec = np.arange(-4,4,0.01) + freqrf
+    freqrf =  7186226.67
+    freqrfvec = freqrf + np.arange(-5,5,0.01)
     
     amps = []
     
@@ -176,8 +174,8 @@ Grafico temporal replicado 3 veces a la frecuencia dada
 
 
 #freqrf = 7262766.13
-
-taurf = 1/(4e-7+freqrf)
+freqrf = 7186226.62
+taurf = 1/(freqrf)
 
 tiemposarreglados = bin_time_arrivals(counts, taurf)
 

analisis/plots/20250721_tickling_for_mm/check_rffrequency.py

+import h5py
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+import re
+import ast
+from scipy.optimize import curve_fit
+import os
+
+#os.chdir('/home/nico/Documents/artiq_experiments/analisis/plots/20221006_transitoriosv2')
+
+# os.chdir('/home/nico/Documents/artiq_experiments/analisis/plots/20250408_FluorescenceCorrelationsTests/Data1')
+
+def expo(T, tau, N0, C):
+    
+    global T0
+    return N0*np.exp(-(T-T0)/tau) + C
+
+def pow_from_amp(amp):
+    """Paso de amplitud urukul a potencia medida por Nico"""
+    # Forma altamente ineficiente de hacer esto, pero me salio asi
+    amplitudes_UV = np.flip(np.array([0.08, 0.10, 0.12, 0.14, 0.16, 0.18, 0.20, 0.22, 0.24, 0.26, 0.28, 0.30]))
+    assert amp in amplitudes_UV
+    potencias_UV = np.flip(np.array([4, 10, 19, 32, 49, 71, 96, 125, 155, 183, 208, 229]))
+    return potencias_UV[np.where(amplitudes_UV == amp)][0]
+
+
+def SP_Bkgr_builder(amp_in, amp_fin, derivadainicio, derivadafin, longbins):
+    CalibCurve = []
+    j=0
+    while j<longbins:
+        if j<=derivadainicio:
+            CalibCurve.append(amp_in)
+        elif j>=derivadainicio and j<=derivadafin:
+            pendiente=(amp_fin-amp_in)/(derivadafin-derivadainicio)
+            CalibCurve.append(amp_in+pendiente*(j-derivadainicio))
+        else:
+            CalibCurve.append(amp_fin)
+        j=j+1
+    return CalibCurve
+
+    
+
+"""
+plt.plot(amplitudes_UV, potencias_UV, 'ko-', lw=0.2)
+plt.xlabel("Amplitud Urukul")
+plt.ylabel("Potencia /uW")
+plt.grid()
+"""
+#%%
+import scipy.fftpack
+
+BINW = 1e-2
+T0 = -0.4e-6
+
+files = [22838]
+
+SP_Heigths = []
+SP_Bins = []
+
+for i, fname in enumerate(files):
+    #print(i)
+    #print(fname)
+    #data = h5py.File('0000'+str(fname)+'-MicromotionCompensation.h5', 'r')
+    data = h5py.File('./Data/0000'+str(fname)+'-FluorescenceCorrelation.h5', 'r')
+    # counts = np.array(data['datasets']['countsrf'])
+    counts = np.array(data['datasets']['time_stamps'])
+    bines = np.arange(counts.min(), counts.max()+BINW, BINW)
+
+    heigs, binsf  = np.histogram(counts, bines[bines>T0])
+    
+    SP_Heigths.append(heigs)
+    SP_Bins.append(binsf)
+
+
+#freq: 7.262 mhZ
+for k in range(len(counts)):
+    print(counts[k]-counts[k-1])
+    #print(1e-6/(counts[k]-counts[k-1]))
+
+
+
+#%%
+
+"""
+Esto deberia hacerse asi para ver la oscilacion a la RF (micromocion)
+"""
+
+BINW = 1e-3
+T0 = -0.4e-6
+
+#files = [20577,20578,20579,20580,20581] #el 19613 es el que muestra el pico en 48.5 Hz
+
+files = [22809,22813,22817,22818,22819,22820] 
+files  =  [22838]
+
+def bin_time_arrivals(arrival_times, tau):
+    """
+    Binea los tiempos de llegada de los fotones según el periodo tau.
+    
+    Parameters:
+        arrival_times (numpy array): Vector con los tiempos de llegada de los fotones.
+        tau (float): Periodo de bineado.
+        
+    Returns:
+        numpy array: Vector con los tiempos bienados.
+    """
+    return arrival_times - tau * (arrival_times // tau)
+
+
+SP_Heigths = []
+SP_Bins = []
+
+
+plt.figure()
+
+for i, fname in enumerate(files):
+    #print(i)
+    #print(fname)
+    data = h5py.File('./Data/0000'+str(fname)+'-FluorescenceCorrelation.h5', 'r')
+    counts = np.array(data['datasets']['time_stamps'])
+    bines = np.arange(counts.min(), counts.max()+BINW, BINW)
+
+    heigs, binsf  = np.histogram(counts, bines[bines>T0])
+    
+    SP_Heigths.append(heigs)
+    SP_Bins.append(binsf)
+    
+    
+
+    
+    
+    """
+    Amplitud en funcion de la frecuencia de bineo de la rf
+    """
+    
+    freqrf = 7.186226e6
+    freqrfvec = np.arange(-4,4,0.01) + freqrf
+    
+    amps = []
+    
+    
+    for freqrf in freqrfvec:
+        taurf = 1/freqrf
+        
+        tiemposarreglados = bin_time_arrivals(counts, taurf)
+        
+        b = taurf/500  # Ancho de bineo
+        bins = np.arange(0, taurf, b)
+        hist, bin_edges = np.histogram(tiemposarreglados, bins=bins)
+        
+        colors = ['b', 'g', 'r']  # Colores para cada repetición
+        
+        x_extended = np.concatenate([bin_edges[:-1] + i * taurf for i in range(3)])
+        y_extended = np.tile(hist, 3)
+        
+        def sinusoidal(x, A, C, D):
+            return A * np.sin(2*np.pi*freqrf * x + C) + D
+        
+        x_extended_dense = np.arange(np.min(x_extended),np.max(x_extended),0.1*(x_extended[1]-x_extended[0]))
+        
+        params, _ = curve_fit(sinusoidal, x_extended, y_extended, p0=[max(y_extended),  0, np.mean(y_extended)])
+        amps.append(np.abs(params[0]))
+
+
+    plt.plot([f*1e-6 for f in freqrfvec],amps,'o')
+    print(freqrfvec[np.argmax(amps)])
+plt.xlabel('Frecuencia RF (MHz)')
+plt.ylabel('Amplitud oscilacion')
+#plt.axvline(7262766.13*1e-6,linewidth=4,color='red',linestyle='dashed')
+#%%
+
+"""
+Grafico temporal replicado 3 veces a la frecuencia dada
+"""
+
+
+#freqrf = 7262766.13
+
+taurf = 1/(4e-7+freqrf)
+
+tiemposarreglados = bin_time_arrivals(counts, taurf)
+
+b = taurf/50  # Ancho de bineo
+bins = np.arange(0, taurf, b)
+hist, bin_edges = np.histogram(tiemposarreglados, bins=bins)
+
+colors = ['b', 'g', 'r']  # Colores para cada repetición
+
+x_extended = np.concatenate([bin_edges[:-1] + i * taurf for i in range(3)])
+y_extended = np.tile(hist, 3)
+
+def sinusoidal(x, A, C, D):
+    return A * np.sin(2*np.pi*freqrf * x + C) + D
+
+def lorentzian(x,A,b,C,det,fase,cte):
+    det = -10e6*2*np.pi
+    return A*((C**2)/(C**2 + (det-b*2*np.pi*freqrf*np.sin(2*np.pi*freqrf*x+fase))**2))+cte
+
+x_extended_dense = np.arange(np.min(x_extended),np.max(x_extended),0.1*(x_extended[1]-x_extended[0]))
+
+params, _ = curve_fit(sinusoidal, x_extended, y_extended, p0=[max(y_extended),  0, np.mean(y_extended)])
+#params, _ = curve_fit(lorentzian, x_extended, y_extended, p0=[1,1e-3,1e7,1e4,1,1])
+amps.append(np.abs(params[0]))
+
+
+# Graficar los datos y el ajuste
+plt.figure(figsize=(8, 4))
+
+#plt.plot(x_extended_dense, sinusoidal(x_extended_dense, *params), linestyle='--', label="Ajuste sinusoidal", color='black',linewidth=3,zorder=2)
+#plt.plot(x_extended_dense, lorentzian(x_extended_dense, *params), linestyle='--', label="Ajuste completo", color='black',linewidth=3,zorder=2)
+
+for i in range(3):
+    plt.plot(bin_edges[:-1] + i * taurf, hist, marker='o', linestyle='-', color=colors[i],markersize=3,zorder=1)
+
+plt.xlabel("Tiempo bineado (repetido 3 veces)")
+plt.ylabel("Frecuencia")
+plt.title("Distribución de tiempos bineados con ajuste completo")
+#plt.ylim(0,np.max(hist)*1.2)
+plt.ylim(0,400)
+plt.legend()
+plt.show()
+
+print(f'Amplitud normalizada: {np.abs(round(100*params[0]/params[2],3))}%')
+
+print(f'Beta: {np.abs(params[1])}')
+
+print(f'Amplitud: {params[0]}')

artiq_master/last_rid.pyon

-22886
+23015

artiq_master/repository/Tests/test_barrido_iseg.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Suppress specific pylance warnings 
+# pyright: reportMissingImports=false, reportUndefinedVariable=false
+
+
+"""
+Barrer un laser con la Iseg y adquirir
+"""
+
+from artiq.experiment import *
+
+from artiq.experiment import ( EnvExperiment, NumberValue, kernel,
+                               ms, us, delay, rpc )
+
+import numpy as np
+
+import time
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+
+import requests
+import re
+
+
+CAMERA_TTL_NUM = 5
+
+class BarridoIseg(EnvExperiment):
+    """
+    Barrido Iseg
+    """
+
+    def voltageupdate(self,channel,voltage):
+        BASE_URL = 'http://liaf-iseg/api/setItem/55005e1a49cad-69/0/0/'+f'{channel:.0f}'+'/Control.voltageSet/'+f'{voltage:.2f}'+'/V'
+        response = requests.post(f"{BASE_URL}")
+
+    def build(self):
+        self.setattr_device("core")
+
+
+        ## Defino las ttls #####################################################
+        #self.camera_trigger = self.get_device(f"ttl{CAMERA_TTL_NUM}")
+
+
+        ## Controles de GUI ####################################################
+        # número de pulsos a enviar
+        self.setattr_argument("number",
+                            NumberValue(80, unit='', ndecimals=0, scale=1, step=1, type='int')
+                            )
+        
+        
+        self.setattr_argument("Voltage_Down",
+                            NumberValue(100, unit='', ndecimals=0, scale=0.1, step=0.1)
+                            )
+    
+        self.setattr_argument("Voltage_Set",
+                    NumberValue(0, unit='', ndecimals=0, scale=0.1, step=0.1)
+                    )
+    
+
+        self.setattr_argument("time_exposure",
+                            NumberValue(500*ms, unit='ms', ndecimals=10, step=1*ms,)
+                            )
+        
+        self.setattr_argument("time_delay",
+                            NumberValue(500*ms, unit='ms', ndecimals=1, step=1*ms,),
+                            "Triggers Settings"
+                            )
+        
+        self.setattr_argument("time_width",
+                            NumberValue(10*ms, unit='ms', ndecimals=10, step=1*ms,),
+                            "Triggers Settings"
+                            )
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("count", np.zeros(self.number, dtype=float), broadcast=True, archive=True)
+
+    
+    @rpc
+    def run(self):
+        "Ejecución. Preparamos los dispositivos y llamamos al kernel."
+
+        self.create_datasets()
+
+        self.voltageupdate(2,self.Voltage_Set)
+
+        voltages=np.linspace(self.Voltage_Set,self.Voltage_Down,self.number)
+
+        #camera_set_exposure(self.time_exposure)
+        time.sleep(2)
+
+        # Reemplazo este código original por algo que usa GRAB
+
+
+        for jj in range(self.number):
+            self.voltageupdate(2,voltages[jj])
+            time.sleep(0.05)
+            #camera_snap_roi(gui=True,block=False)
+            time.sleep(self.time_delay)
+            #snap=cmd('get_response')
+            self.mutate_dataset("count", jj, 1 )
+
+        print('FIN')
+'''
+
+    @kernel
+    def conf(self):
+        "Configuración del dispositivo"
+        self.core.reset()
+        self.camera_trigger.output()
+        delay(16*ms)
+    
+    @kernel
+    def fire_trigger(self):
+        "Envío y medición de pulsos"
+        self.conf()
+
+        self.camera_trigger.on()
+        delay( self.time_width )
+        self.camera_trigger.off()
+        delay( self.time_delay )
+
+    @kernel
+    def fire(self):
+
+        self.conf()
+        delay(10*ms)
+
+        for _ in range(self.number+5):
+            self.fire_trigger()
+        
+'''
+  

my-artiq-env.nix

@@ -11,13 +11,13 @@ in
  
         artiq-full.artiq
         artiq-full.artiq-comtools 
- 
         ps.pandas
         ps.numpy
         ps.scipy
         ps.matplotlib.override { enableQt = true; }
         ps.ipython
         ps.setuptools
+        #ps.requests
         #ps.spyder # esto lo rompe
       ]))