agrego codgos de analisis de cpt de blade trap

analisis/plots/20250516_CPT_bladetrap/CPT_plotter_20231123.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
+from scipy import interpolate
+
+"""
+Primero tengo mediciones de espectros cpt de un ion variando la tension dc_A
+"""
+
+
+#os.chdir('/home/nico/Documents/artiq_experiments/analisis/plots/20231123_CPTconmicromocion3/Data/')
+os.chdir('/home/nico/Documents/artiq_experiments/analisis/plots/20250516_CPT_bladetrap/Data')
+
+
+CPT_FILES = """000021278-IR_Scan_simple
+000021360-IR_Scan_simple
+000021390-IR_Scan_simple
+"""
+
+
+def SeeKeys(files):
+    for i, fname in enumerate(files.split()):
+        data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+        print(fname)
+        print(list(data['datasets'].keys()))
+
+print(SeeKeys(CPT_FILES))
+
+#carpeta pc nico labo escritorio:
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20211101_CPT_DosLaseres_v03\Data
+
+Counts = []
+Freqs = []
+
+AmpTisa = []
+UVCPTAmp = []
+No_measures = []
+Voltages = []
+
+for i, fname in enumerate(CPT_FILES.split()):
+    print(str(i) + ' - ' + fname)
+    #print(fname)
+    data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+
+    # Aca hago algo repugnante para poder levantar los strings que dejamos
+    # que además tenian un error de tipeo al final. Esto no deberá ser necesario
+    # cuando se solucione el error este del guardado.
+    Freqs.append(np.array(data['datasets']['IR1_Frequencies']))
+    Counts.append(np.array(data['datasets']['counts_spectrum']))
+    #AmpTisa.append(np.array(data['datasets']['TISA_CPT_amp']))
+    print(np.array(data['datasets']['no_measures']))
+
+
+#%%
+
+"""
+Ploteo curvas para ver que tal son
+"""
+
+jvec = [1] # de la 1 a la 9 vale la pena, despues no
+
+
+plt.figure()
+i = 0
+for j in jvec:
+    Frequencies = Freqs[j]
+    plt.errorbar([2*f*1e-6 for f in Frequencies], Counts[j], yerr=np.sqrt(Counts[j]), fmt='o', capsize=2, markersize=2)
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+# plt.legend()
+
+
+
+
+
+#%%
+"""
+HAGO SUPER AJUSTES O SEA CON OFFSETXPI Y DETDOPPLER INCLUIDOS
+
+ajusto una medicion con muy poca micromocion
+
+"""
+
+
+from EITfit.lolo_modelo_full_8niveles import PerformExperiment_8levels_MM
+from scipy.optimize import curve_fit
+import time
+
+"""
+SUPER AJUSTE (SA)
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*7.262*1e6
+
+
+SelectedCurveVec = [1]
+
+popt_SA_vec = []
+pcov_SA_vec = []
+Detuningsshort_vec = []
+Counts_vec = []
+Detuningslong_vec = []
+FittedCounts_vec = []
+
+Betas_vec = []
+ErrorBetas_vec = []
+Temp_vec = []
+ErrorTemp_vec = []
+
+DetuningsUV_vec = []
+ErrorDetuningsUV_vec = []
+
+for selectedcurve in SelectedCurveVec:
+
+    FreqsDR = Freqs[selectedcurve]
+    CountsDR = Counts[selectedcurve]
+
+    freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+    CircPr = 1
+    alpha = 0
+
+
+    def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP, U, plot=False):
+
+        freqs = [2*f*1e-6-offset for f in Freqs]
+        # BETA1=0
+        Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, U, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+        ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+        if plot:
+            return ScaledFluo1, Detunings
+        else:
+            return ScaledFluo1
+        #return ScaledFluo1
+
+    t1 = time.time()
+
+    print(f'Beginning {selectedcurve}')
+    popt_3_SA, pcov_3_SA = curve_fit(FitEIT_MM_single, FreqsDR[1:], CountsDR, p0=[440, -15, 0.3, 10, 1e4, 500, 2, (np.pi**2)*1e-3, 49.5e6], bounds=((0, -50, 0, 0, 0, 0, 0, 0, 48e6), (1000, 0, 2, 20, 5e4, 2e3, 3, (np.pi**2)*10e-3, 50e6)))
+    print(f'Ended {selectedcurve}, time elapsed: {round(time.time()-t1)} s')
+
+    #popt_3_SA, pcov_3_SA = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[430, -25, 0.9, 6.2, 3e4, 1.34e3, 2, (np.pi**2)*1e-3, 32e6], bounds=((0, -50, 0, 0, 0, 0, 0, 0, 25e6), (1000, 0, 2, 20, 5e4, 5e4, 10, (np.pi**2)*10e-3, 40e6)))
+
+    popt_SA_vec.append(popt_3_SA)
+    pcov_SA_vec.append(pcov_3_SA)
+
+
+#offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP, U
+
+    FittedEITpi_3_SA_short, Detunings_3_SA_short = FitEIT_MM_single(FreqsDR, *np.array([popt_3_SA[0],popt_3_SA[1],popt_3_SA[2],popt_3_SA[3],popt_3_SA[4],popt_3_SA[5],popt_3_SA[6],popt_3_SA[7],popt_3_SA[8]]), plot=True)
+    freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+    
+    # popt_3_SA[4]=1
+    # popt_3_SA[5]=0
+    # popt_3_SA[6]=0
+    FittedEITpi_3_SA_long, Detunings_3_SA_long = FitEIT_MM_single(freqslong, *np.array([popt_3_SA[0],popt_3_SA[1],popt_3_SA[2],popt_3_SA[3],popt_3_SA[4],popt_3_SA[5],popt_3_SA[6],popt_3_SA[7],popt_3_SA[8]]), plot=True)
+    corri = 0
+    DetuningsUV_vec.append(popt_3_SA[1])
+    ErrorDetuningsUV_vec.append(np.sqrt(pcov_3_SA[1,1]))
+
+    Betas_vec.append(popt_3_SA[6])
+    ErrorBetas_vec.append(np.sqrt(pcov_3_SA[6,6]))
+    Temp_vec.append(popt_3_SA[7])
+    ErrorTemp_vec.append(np.sqrt(pcov_3_SA[7,7]))
+
+    Detuningsshort_vec.append(Detunings_3_SA_short)
+    Counts_vec.append(CountsDR)
+    Detuningslong_vec.append(Detunings_3_SA_long)
+    FittedCounts_vec.append(FittedEITpi_3_SA_long)
+
+    plt.figure()
+    plt.errorbar(Detunings_3_SA_short[:], CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+    plt.plot([c-corri for c in Detunings_3_SA_long], FittedEITpi_3_SA_long, color='darkolivegreen', linewidth=3, label=f'med {selectedcurve}')
+    #plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+    plt.xlabel('Detuning (MHz)')
+    plt.ylabel('Counts')
+    # plt.legend(loc='upper left', fontsize=20)
+    plt.grid()
+
+    print(f'listo med {selectedcurve}')
+    print(popt_3_SA)
+    
+
+
+#%%
+"""
+HAGO SUPER AJUSTES O SEA CON OFFSETXPI Y DETDOPPLER INCLUIDOS
+
+Ajusto med 2, con un poco mas de micromocion supuestamente
+
+"""
+
+
+from EITfit.lolo_modelo_full_8niveles import PerformExperiment_8levels_MM
+from scipy.optimize import curve_fit
+import time
+
+"""
+SUPER AJUSTE (SA)
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*7.262*1e6
+
+
+SelectedCurveVec = [2]
+
+popt_SA_vec = []
+pcov_SA_vec = []
+Detuningsshort_vec = []
+Counts_vec = []
+Detuningslong_vec = []
+FittedCounts_vec = []
+
+Betas_vec = []
+ErrorBetas_vec = []
+Temp_vec = []
+ErrorTemp_vec = []
+
+DetuningsUV_vec = []
+ErrorDetuningsUV_vec = []
+
+for selectedcurve in SelectedCurveVec:
+
+    FreqsDR = Freqs[selectedcurve]
+    CountsDR = Counts[selectedcurve]
+
+    freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+    CircPr = 1
+    alpha = 0
+
+
+    def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP, U, plot=False):
+
+        freqs = [2*f*1e-6-offset for f in Freqs]
+        # BETA1=0
+        Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, U, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+        ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+        if plot:
+            return ScaledFluo1, Detunings
+        else:
+            return ScaledFluo1
+        #return ScaledFluo1
+
+    t1 = time.time()
+
+    print(f'Beginning {selectedcurve}')
+    popt_3_SA, pcov_3_SA = curve_fit(FitEIT_MM_single, FreqsDR[1:], CountsDR, p0=[440, -15, 0.3, 10, 1e4, 500, 2, (np.pi**2)*1e-3, 49.5e6], bounds=((0, -50, 0, 0, 0, 0, 0, 0, 48e6), (1000, 0, 2, 20, 5e4, 2e3, 3, (np.pi**2)*10e-3, 50e6)))
+    print(f'Ended {selectedcurve}, time elapsed: {round(time.time()-t1)} s')
+
+    #popt_3_SA, pcov_3_SA = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[430, -25, 0.9, 6.2, 3e4, 1.34e3, 2, (np.pi**2)*1e-3, 32e6], bounds=((0, -50, 0, 0, 0, 0, 0, 0, 25e6), (1000, 0, 2, 20, 5e4, 5e4, 10, (np.pi**2)*10e-3, 40e6)))
+
+    popt_SA_vec.append(popt_3_SA)
+    pcov_SA_vec.append(pcov_3_SA)
+
+
+#offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP, U
+
+    FittedEITpi_3_SA_short, Detunings_3_SA_short = FitEIT_MM_single(FreqsDR, *np.array([popt_3_SA[0],popt_3_SA[1],popt_3_SA[2],popt_3_SA[3],popt_3_SA[4],popt_3_SA[5],popt_3_SA[6],popt_3_SA[7],popt_3_SA[8]]), plot=True)
+    freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+    
+    # popt_3_SA[4]=1
+    # popt_3_SA[5]=0
+    # popt_3_SA[6]=0
+    FittedEITpi_3_SA_long, Detunings_3_SA_long = FitEIT_MM_single(freqslong, *np.array([popt_3_SA[0],popt_3_SA[1],popt_3_SA[2],popt_3_SA[3],popt_3_SA[4],popt_3_SA[5],popt_3_SA[6],popt_3_SA[7],popt_3_SA[8]]), plot=True)
+    corri = 0
+    DetuningsUV_vec.append(popt_3_SA[1])
+    ErrorDetuningsUV_vec.append(np.sqrt(pcov_3_SA[1,1]))
+
+    Betas_vec.append(popt_3_SA[6])
+    ErrorBetas_vec.append(np.sqrt(pcov_3_SA[6,6]))
+    Temp_vec.append(popt_3_SA[7])
+    ErrorTemp_vec.append(np.sqrt(pcov_3_SA[7,7]))
+
+    Detuningsshort_vec.append(Detunings_3_SA_short)
+    Counts_vec.append(CountsDR)
+    Detuningslong_vec.append(Detunings_3_SA_long)
+    FittedCounts_vec.append(FittedEITpi_3_SA_long)
+
+    plt.figure()
+    plt.errorbar(Detunings_3_SA_short[:], CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+    plt.plot([c-corri for c in Detunings_3_SA_long], FittedEITpi_3_SA_long, color='darkolivegreen', linewidth=3, label=f'med {selectedcurve}')
+    #plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+    plt.xlabel('Detuning (MHz)')
+    plt.ylabel('Counts')
+    # plt.legend(loc='upper left', fontsize=20)
+    plt.grid()
+
+    print(f'listo med {selectedcurve}')
+    print(popt_3_SA)
+    
+    
\ No newline at end of file

analisis/plots/20250516_CPT_bladetrap/Data/EITfit/MM_eightLevel_2repumps_AnalysisFunctions.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jul  2 16:30:09 2020
+
+@author: oem
+"""
+
+"""
+ESTE ES EL CODIGO QUE PLOTEA CPT CON MICROMOCION BIEN
+"""
+
+import os
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from scipy.signal import argrelextrema
+#from EITfit.MM_eightLevel_2repumps_python_scripts import CPTspectrum8levels_MM
+import random
+from scipy.signal import savgol_filter as sf
+
+
+def PerformExperiment_8levels_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobe, beta, drivefreq, freqMin, freqMax, freqStep, circularityprobe=1, plot=False, solvemode=1, detpvec=None):
+    """
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+    #tinicial = time.time()
+    ProbeDetuningVectorL, Fluovector = CPTspectrum8levels_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobe, circularityprobe, beta, drivefreq, freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=False, solvemode=1)
+    #tfinal = time.time()
+    
+    #print('Done, Total time: ', round((tfinal-tinicial), 2), "s")   
+          
+    return ProbeDetuningVectorL, Fluovector
+
+
+def GenerateNoisyCPT_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, kg, kr, v0, drivefreq, freqMin, freqMax, freqStep, circularityprobe=1, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    Frequencyvector, Fluovector = PerformExperiment_8levels_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, kg, kr, v0, drivefreq, freqMin, freqMax, freqStep, circularityprobe, plot=False, solvemode=1, detpvec=None)
+    NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, NoisyFluovector
+
+def GenerateNoisyCPT_MM_fit(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, beta, drivefreq, freqs, circularityprobe=1, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    
+    Frequencyvector, Fluovector = PerformExperiment_8levels_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, beta, drivefreq, freqs[0], freqs[-1], freqs[1]-freqs[0], circularityprobe, plot=False, solvemode=1, detpvec=None)
+    #NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, Fluovector
+
+
+def SmoothNoisyCPT(Fluo, window=11, poly=3):
+    SmoothenFluo = sf(Fluo, window, poly)
+    return SmoothenFluo
+
+
+
+
+
+

analisis/plots/20250516_CPT_bladetrap/Data/EITfit/MM_eightLevel_2repumps_CPTPlotter.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Sep  1 17:58:39 2020
+
+@author: nico
+"""
+
+
+
+import os
+import numpy as np
+#os.chdir('/home/oem/Nextcloud/G_liaf/liaf-TrampaAnular/Código General/EIT-CPT/Buenos Aires/Experiment Simulations/CPT scripts/Eight Level 2 repumps')
+#from MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels, GenerateNoisyCPT, SmoothNoisyCPT
+import matplotlib.pyplot as plt
+import time
+#from threeLevel_2repumps_AnalysisFunctions import MeasureRelativeFluorescenceFromCPT, IdentifyPolarizationCoincidences, RetrieveAbsoluteCoincidencesBetweenMaps, GetClosestIndex
+import seaborn as sns
+
+#C:\Users\Usuario\Nextcloud\G_liaf\liaf-TrampaAnular\Código General\EIT-CPT\Buenos Aires\Experiment Simulations\CPT scripts\Eight Level 2 repumps
+
+ub = 9.27e-24 #magneton de bohr
+h = 6.63e-34 #cte de planck
+c = (ub/h)*1e-4 #en unidades de MHz/G
+
+u = 2e6 #proportional to the magnetic field of around 5 G
+
+B = (u/(2*np.pi))/c
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6 #anchos de linea de las transiciones
+
+lw = 0. #linewidth of the lasers, 0.1 MHz are the actual linewidths of both lasers
+DopplerLaserLinewidth, ProbeLaserLinewidth = lw, lw #ancho de linea de los laseres
+
+
+TempVec = [0e-3] #Temperature vector
+alpha = 0 #angle between lasers, which is zero
+
+#Polarization angles (we can keep it fixed in 90)
+phidoppler, titadoppler = 0, 90
+titaprobe = 90
+phiprobe = 0
+
+#este es el desfasaje exp(i.phi) de la componente de la polarizacion y respecto a la x. Con 1 la polarizacion es lineal
+CircPr = 1  #this has to do with the circularity of the polarizations and since both are linear it is one
+
+#Simulation parameters
+center = -10
+span = 200
+freqMin = center-span*0.5
+freqMax = center+span*0.5
+freqStep = 2e-1
+
+noiseamplitude = 0 #i dont know what it is
+
+#parametros de saturacion de los laseres. g: doppler. p: probe (un rebombeo que scanea), r: repump (otro rebombeo fijo)
+
+"""
+Good case: sg=0.6, sp=9, DetDoppler=-15
+"""
+
+DetDoppler = -25 #nice range: -30 to 0 
+sgvec = [0.6] #nice range: 0.1 to 10 #g is for green but is the doppler
+sp = 8 #nice range: 0.1 to 20 #p is for probe but is the repump
+
+
+
+drivefreq=2*np.pi*22.135*1e6 #ignore it
+#betavec = np.arange(0,1.1,0.1) #ignore it
+betavec=[0] #ignore it
+alphavec = [0] #ignore it
+
+
+
+fig1, ax1 = plt.subplots()
+
+FrequenciesVec = []
+FluorescencesVec = []
+
+for sg in sgvec:
+    for T in TempVec:
+        for alpha in alphavec:
+            for beta in betavec:
+                Frequencies, Fluorescence = PerformExperiment_8levels(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  beta, drivefreq, freqMin, freqMax, freqStep, circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+                
+                FrequenciesVec.append(Frequencies)
+                FluorescencesVec.append(Fluorescence)
+                
+                ax1.plot(Frequencies, [100*f for f in Fluorescence], label=fr'$\alpha={int(alpha*180/np.pi)}°$')  
+                ax1.set_xlabel('Detuning Rebombeo (MHz)')
+                ax1.set_ylabel('Fluorescencia (AU)')
+                ax1.set_title(f'Sdop: {sg}, Spr: {sp}, Temp: {int(T*1e3)} mK')
+                #ax1.legend()
+ax1.grid()
+
+#%%
+import seaborn as sns
+
+paleta=sns.color_palette('mako')
+
+plt.figure()
+plt.plot(Frequencies, [100*f for f in Fluorescence], color=paleta[1], linewidth=3)  
+plt.grid()
+plt.axvline(-25,color=paleta[2], linestyle='dashed')
+plt.xlabel(r'$\Delta_2$ (MHz)', fontsize=25, fontname='STIXgeneral')
+plt.ylabel('Fluorescence', fontsize=18, fontname='STIXgeneral')
+#%%
+#Este bloque ajusta a las curvas con un beta de micromocion de 0
+
+from scipy.optimize import curve_fit
+
+def FitEIT_MM(freqs, Temp):
+    BETA = 0
+    scale=1
+    offset=0
+    Detunings, Fluorescence = PerformExperiment_8levels(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA, drivefreq, freqMin, freqMax, freqStep, circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    ScaledFluo = [f*scale + offset for f in Fluorescence]
+    return ScaledFluo
+
+TempMedidas = []
+FittedEIT_fluosVec = []
+
+for j in range(len(betavec)):
+    SelectedFluo = FluorescencesVec[j]
+    SelectedFreqs = FrequenciesVec[j]
+    
+    popt_mm, pcov_mm = curve_fit(FitEIT_MM, SelectedFreqs, SelectedFluo, p0=[1e-3], bounds=((0), (10e-3)))
+    
+    TempMedidas.append(1e3*popt_mm[2])
+    
+    print(popt_mm)
+    
+    FittedEIT_fluo = FitEIT_MM(SelectedFreqs, *popt_mm)
+    
+    FittedEIT_fluosVec.append(FittedEIT_fluo)
+    
+    plt.figure()
+    plt.plot(SelectedFreqs, SelectedFluo, 'o')
+    plt.plot(SelectedFreqs, FittedEIT_fluo)
+
+plt.figure()
+for i in range(len(FluorescencesVec)):
+    plt.plot(SelectedFreqs, FluorescencesVec[i], 'o', markersize=3)
+    plt.plot(SelectedFreqs, FittedEIT_fluosVec[i])    
+
+
+plt.figure()
+plt.plot(betavec, TempMedidas, 'o', markersize=10)
+plt.xlabel('Beta')
+plt.ylabel('Temperatura medida (mK)')
+plt.axhline(T*1e3, label='Temperatura real', linestyle='--', color='red')
+plt.legend()
+plt.grid()
\ No newline at end of file

analisis/plots/20250516_CPT_bladetrap/Data/EITfit/MM_eightLevel_2repumps_python_scripts.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Apr  7 22:30:01 2020
+
+@author: nico
+"""
+
+"""
+ESTE ES EL CODIGO QUE PLOTEA CPT CON MICROMOCION BIEN
+"""
+
+#ESTE CODIGO ES EL PRINCIPAL PARA PLOTEAR CPT TEORICOS
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from scipy.signal import argrelextrema
+
+
+"""
+Scripts para el calculo de la curva CPT
+"""
+
+
+def H0matrix(Detg, Detp, u): 
+    """
+    Calcula la matriz H0 en donde dr es el detuning del doppler, dp es el retuning del repump y u es el campo magnético en Hz/Gauss.
+    Para esto se toma la energía del nivel P como 0
+    """
+    
+    eigenEnergies = (Detg-u, Detg+u, -u/3, u/3, Detp-6*u/5, Detp-2*u/5, Detp+2*u/5, Detp+6*u/5) #pagina 26 de Oberst. los lande del calcio son iguales a Bario.
+    H0 = np.diag(eigenEnergies)
+    
+    return H0
+
+
+def HImatrix(rabG, rabP, phidoppler, titadoppler, phiprobe, titaprobe, circularityprobe=1):
+    """
+    Calcula la matriz de interacción Hsp + Hpd, en donde rabR es la frecuencia de rabi de la transición Doppler SP, 
+    rabP es la frecuencia de rabi de la transición repump DP, y las componentes ei_r y ei_p son las componentes de la polarización
+    del campo eléctrico incidente de doppler y repump respectivamente. Deben estar normalizadas a 1
+    """
+    HI = np.zeros((8, 8), dtype=np.complex_)
+    
+    
+    i, j = 1, 3
+    HI[i-1, j-1] = (rabG/np.sqrt(3)) * np.cos(titadoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1]) 
+    
+    i, j = 1, 4
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.sin(titadoppler)*np.exp(1j*phidoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 2, 3
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.sin(titadoppler)*np.exp(-1j*phidoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+     
+    i, j = 2, 4
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.cos(titadoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])   
+    
+    i, j = 3, 5
+    HI[i-1, j-1] = -(rabP/2) * np.sin(titaprobe)*(np.cos(phiprobe)-1j*np.sin(phiprobe)*circularityprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 3, 6
+    HI[i-1, j-1] = -(rabP/np.sqrt(3)) * np.cos(titaprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 3, 7
+    HI[i-1, j-1] = rabP/np.sqrt(12) * np.sin(titaprobe)*(np.cos(phiprobe)+1j*np.sin(phiprobe)*circularityprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    
+    i, j = 4, 6
+    HI[i-1, j-1] = -(rabP/np.sqrt(12)) * np.sin(titaprobe)*(np.cos(phiprobe)-1j*np.sin(phiprobe)*circularityprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 4, 7
+    HI[i-1, j-1] = -(rabP/np.sqrt(3)) * np.cos(titaprobe) 
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 4, 8
+    HI[i-1, j-1] = (rabP/2) * np.sin(titaprobe)*(np.cos(phiprobe)+1j*np.sin(phiprobe)*circularityprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    
+    return HI
+
+
+def LtempCalculus(beta, drivefreq, forma=1):
+    Hint = np.zeros((8, 8), dtype=np.complex_)
+    
+    ampg=beta*drivefreq
+    ampr=beta*drivefreq*(397/866)        
+    #ampr=beta*drivefreq
+    Hint[0,0] = ampg
+    Hint[1,1] = ampg
+    Hint[4,4] = ampr
+    Hint[5,5] = ampr
+    Hint[6,6] = ampr
+    Hint[7,7] = ampr
+    
+    if forma==1:
+        Ltemp = np.zeros((64, 64), dtype=np.complex_)
+        """
+        for r in range(8):
+            for q in range(8):
+                for k in range(8):
+                    for j in range(8):
+                        Ltemp[r*8+q][k*8+j] = (-1j)*(Hint[r,k]*int(j==q) - Hint[j,q]*int(r==k))
+        """
+        """
+        for r in range(8):
+            for q in range(8):
+                for k in range(8):
+                    for j in range(8):
+                        if r==k and j==q:
+                            Ltemp[r*8+q][k*8+j] = (-1j)*(Hint[r,k] - Hint[j,q])
+        """
+
+        
+        for r in range(8):
+            for q in range(8):
+                if r!=q:
+                    Ltemp[r*8+q][r*8+q] = (-1j)*(Hint[r,r] - Hint[q,q])
+        
+        
+    if forma==2:
+        deltaKro = np.diag([1, 1, 1, 1, 1, 1, 1, 1])
+        Ltemp = (-1j)*(np.kron(Hint, deltaKro) - np.kron(deltaKro, Hint))
+
+    Omega = np.zeros((64, 64), dtype=np.complex_)
+    
+    for i in range(64):
+        Omega[i, i] = (1j)*drivefreq
+    
+
+    return np.matrix(Ltemp), np.matrix(Omega)
+
+
+def GetL1(Ltemp, L0, Omega, nmax):
+    """
+    Devuelve Splus0 y Sminus0
+    """
+    
+    Sp = (-1)*(np.matrix(np.linalg.inv(L0 - (nmax+1)*Omega))*0.5*np.matrix(Ltemp))
+    Sm = (-1)*(np.matrix(np.linalg.inv(L0 + (nmax+1)*Omega))*0.5*np.matrix(Ltemp))
+    
+    for n in list(range(nmax+1))[(nmax+1)::-1][0:len(list(range(nmax+1))[(nmax+1)::-1])-1]: #jaja esto solo es para que vaya de nmax a 1 bajando. debe haber algo mas facil pero kcio
+        Sp = (-1)*(np.matrix(np.linalg.inv(L0 - n*Omega + (0.5*Ltemp*np.matrix(Sp))))*0.5*np.matrix(Ltemp))
+        Sm = (-1)*(np.matrix(np.linalg.inv(L0 + n*Omega + (0.5*Ltemp*np.matrix(Sm))))*0.5*np.matrix(Ltemp))
+    L1 = 0.5*np.matrix(Ltemp)*(np.matrix(Sp) + np.matrix(Sm))
+    
+    return L1
+
+
+def EffectiveL(gPS, gPD, lwg, lwp):
+
+    """
+    Siendo Heff = H + EffectiveL, calcula dicho EffectiveL que es (-0.5j)*sumatoria(CmDaga*Cm) que luego sirve para calcular el Liouvilliano
+    """
+    Leff = np.zeros((8, 8), dtype=np.complex_)
+    
+    Leff[0, 0] = 2*lwg
+    Leff[1, 1] = 2*lwg
+    Leff[2, 2] = ((2/3)+(1/3))*gPS + ((1/2) + (1/6) + (1/3))*gPD
+    Leff[3, 3] = ((2/3)+(1/3))*gPS + ((1/2) + (1/6) + (1/3))*gPD
+    Leff[4, 4] = 2*lwp
+    Leff[5, 5] = 2*lwp
+    Leff[6, 6] = 2*lwp
+    Leff[7, 7] = 2*lwp
+    
+    return (-0.5j)*Leff
+
+
+def CalculateSingleMmatrix(gPS, gPD, lwg, lwp):
+    """
+    Si tomamos el Liuvilliano como L = (-j)*(Heff*deltak - Heffdaga*deltak) + sum(Mm),
+    esta funcion calcula dichos Mm, que tienen dimensión 64x64 ya que esa es la dimensión del L. Estas componentes
+    salen de hacer la cuenta a mano conociendo los Cm y considerando que Mm[8*(r-1)+s, 8*(k-1)+j] = Cm[r,l] + Cmdaga[j,s] = Cm[r,l] + Cm[s,j]
+    ya que los componentes de Cm son reales.
+    Esta M es la suma de las 8 matrices M.
+    
+    """
+    
+    M = np.matrix(np.zeros((64, 64), dtype=np.complex_))
+    
+    M[0,27] = (2/3)*gPS
+    
+    M[9,18] = (2/3)*gPS
+    
+    M[0,18] = (1/3)*gPS
+    M[1,19] = -(1/3)*gPS
+    M[8,26] = -(1/3)*gPS
+    M[9,27] = (1/3)*gPS
+    
+    M[36,18] = (1/2)*gPD
+    M[37,19] = (1/np.sqrt(12))*gPD
+    M[44,26] = (1/np.sqrt(12))*gPD
+    M[45,27] = (1/6)*gPD
+    
+    M[54,18] = (1/6)*gPD
+    M[55,19] = (1/np.sqrt(12))*gPD
+    M[62,26] = (1/np.sqrt(12))*gPD
+    M[63,27] = (1/2)*gPD
+    
+    M[45,18] = (1/3)*gPD
+    M[46,19] = (1/3)*gPD
+    M[53,26] = (1/3)*gPD
+    M[54,27] = (1/3)*gPD
+    
+    M[0,0] = 2*lwg
+    M[1,1] = 2*lwg
+    M[8,8] = 2*lwg
+    M[9,9] = 2*lwg
+
+    
+    #M[36, 45] = lwp
+    
+    
+    for k in [36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63]:
+        M[k,k]=2*lwp
+     
+    return M
+
+def dopplerBroadening(wlg, wlp, alpha, T, mcalcio = 6.655e-23*1e-3):
+    """
+    Calcula el broadening extra semiclásico por temperatura considerando que el ion atrapado se mueve.
+    wlg es la longitud de onda doppler, wlp la longitud de onda repump, T la temperatura del ion en kelvin, y alpha (en rads) el ángulo
+    que forman ambos láseres.
+    """
+    
+    kboltzmann = 1.38e-23 #J/K
+    
+    gammaD = (2*np.pi)*np.sqrt((1/(wlg*wlg)) + (1/(wlp*wlp)) - 2*(1/(wlg*wlp))*np.cos(alpha))*np.sqrt(kboltzmann*T/(2*mcalcio))
+
+    return gammaD
+    
+
+def FullL_MM(rabG, rabP, gPS = 0, gPD = 0, Detg = 0, Detp = 0, u = 0, lwg = 0, lwp = 0, 
+          phidoppler=0, titadoppler=0, phiprobe=0, titaprobe=0, beta=0, drivefreq=2*np.pi*22.135*1e6, T = 0, alpha = 0, circularityprobe=1):
+
+    """
+    Calcula el Liouvilliano total de manera explícita índice a índice. Suma aparte las componentes de las matrices M.
+    Es la más eficiente hasta ahora.
+    """
+    
+    
+    db = dopplerBroadening(0.397e-6, 0.866e-6, alpha, T)
+    
+    lwg = np.sqrt(lwg**2 + db**2)
+    lwp = np.sqrt(lwp**2 + db**2)    
+    
+    CC = EffectiveL(gPS, gPD, lwg, lwp)
+    
+    Heff = H0matrix(Detg, Detp, u) + HImatrix(rabG, rabP, phidoppler, titadoppler, phiprobe, titaprobe, circularityprobe) + CC
+    
+    Heffdaga = np.matrix(Heff).getH()
+    
+    Lfullpartial = np.zeros((64, 64), dtype=np.complex_)
+    
+    for r  in range(8):
+        for q in range(8):
+            for k in range(8):
+                for j in range(8):
+                    if j!=q and r!=k:
+                        pass
+                    elif j==q and r!=k:
+                        if (r < 2 and k > 3) or (k < 2 and r > 3) or (r > 3 and k > 3) or (r==0 and k==1) or (r==1 and k==0) or (r==2 and k==3) or (r==3 and k==2): #todo esto sale de analizar explicitamente la matriz y tratar de no calcular cosas de más que dan cero
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(Heff[r,k])
+                    elif j!=q and r==k:
+                        if (j < 2 and q > 3) or (q < 2 and j > 3) or (j > 3 and q > 3) or (j==0 and q==1) or (j==1 and q==0) or (j==2 and q==3) or (j==3 and q==2):
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(-Heffdaga[j,q])
+                    else:
+                        if Heff[r,k] == Heffdaga[j,q]:
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(Heff[r,k]-Heffdaga[j,q])
+
+    M = CalculateSingleMmatrix(gPS, gPD, lwg, lwp) 
+    L0 = np.array(np.matrix(Lfullpartial) + M)
+    
+    #ESTA PARTE ES CUANDO AGREGAS MICROMOCION
+    nmax = 3
+    
+    #print(nmax)
+    Ltemp, Omega = LtempCalculus(beta, drivefreq)
+    #print(factor)
+    L1 = GetL1(Ltemp, L0, Omega, nmax)
+    Lfull = L0 + L1 #ESA CORRECCION ESTA EN L1
+    #HASTA ACA
+    
+    #NORMALIZACION DE RHO
+    i = 0 
+    while i < 64:
+        if i%9 == 0:
+            Lfull[0, i] = 1
+        else:
+            Lfull[0, i] = 0
+        i = i + 1    
+    
+    return Lfull 
+
+
+"""
+Scripts para correr un experimento y hacer el análisis de los datos
+"""
+
+
+def CPTspectrum8levels_MM(sg, sp, gPS, gPD, Detg, u, lwg, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, Circularityprobe, beta, drivefreq, freqMin=-100, freqMax=100, freqStep=1e-1, plot=False, solvemode=1):
+
+    """
+    ESTA ES LA FUNCION QUE ESTAMOS USANDO
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+    
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+    phidoppler, titadoppler = phidoppler*(np.pi/180), titadoppler*(np.pi/180) 
+    phiprobe, titaprobe = phiprobe*(np.pi/180), titaprobe*(np.pi/180)
+    
+    DetProbeVector = 2*np.pi*np.arange(freqMin*1e6, freqMax*1e6+0*freqStep*1e6, freqStep*1e6)
+    Detg = 2*np.pi*Detg*1e6
+    #lwg, lwr, lwp = 2*np.pi*lwg*1e6, 2*np.pi*lwr*1e6, 2*np.pi*lwp*1e6
+    lwg, lwp = lwg*1e6, lwp*1e6
+
+    rabG = sg*gPS
+    rabP = sp*gPD
+    #u = 2*np.pi*u*1e6
+    
+    Fluovector = []
+    
+    tinicial = time.time()
+    
+    for Detp in DetProbeVector:
+        L = FullL_MM(rabG, rabP, gPS, gPD, Detg, Detp, u, lwg, lwp, phidoppler, titadoppler, phiprobe, titaprobe, beta, drivefreq, Temp, alpha, Circularityprobe)
+        if solvemode == 1:
+            rhovectorized = np.linalg.solve(L, np.array([int(i==0) for i in range(64)]))
+            Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27]))
+            Fluovector.append(Fluo)                
+
+        if solvemode == 2:
+            Linv = np.linalg.inv(L) 
+            rhovectorized = [Linv[j][0] for j in range(len(Linv))]
+            Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+            Fluovector.append(Fluo)
+        
+    tfinal = time.time()
+        
+    print('Done, Total time: ', round((tfinal-tinicial), 2), "s")   
+    
+    DetProbeVectorMHz = np.arange(freqMin, freqMax, freqStep)
+    
+    if plot:
+        plt.xlabel('Probe detuning (MHz)')
+        plt.ylabel('Fluorescence (A.U.)')
+        plt.plot(DetProbeVectorMHz, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+        plt.legend()
+        
+    return DetProbeVectorMHz, Fluovector
+
+#%%
+if __name__ == "__main__":
+    ub = 9.27e-24
+    h = 6.63e-34
+    c = (ub/h)*1e-4 #en unidades de MHz/G
+    
+    B = 25 #campo magnetico en gauss
+    
+    u = c*B
+    
+    
+    sg, sr, sp = 0.5, 1.5, 4 #parámetros de saturación del doppler y repump
+    gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6 #anchos de linea de las transiciones
+    rabG, rabR, rabP = sg*gPS, sr*gPD, sp*gPD #frecuencias de rabi
+    
+    lwg, lwr, lwp = 0.3, 0.3, 0.3 #ancho de linea de los laseres
+    
+    Detg = -25
+    Detr = 20 #detuning del doppler y repump
+    
+    Temp = 0.0e-3 #temperatura en K
+    alpha = 0*(np.pi/180) #angulo entre los láseres
+    
+    phidoppler, titadoppler = 0, 90
+    phirepump, titarepump = 0, 90
+    
+    phiprobe, titaprobe = 0, 90
+    
+    
+    plotCPT = False
+    
+    freqMin = -50
+    freqMax = 50
+    freqStep = 5e-2
+    
+    Frequencyvector, Fluovector = CPTspectrum8levels_MM(rabG, rabR, rabP, gPS, gPD, Detg, Detr, u, lwg, lwr, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=plotCPT, solvemode=1)
+    
+    plt.plot(Frequencyvector, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+    plt.xlabel('Probe detuning (MHz)')
+    plt.ylabel('Fluorescence (A.U.)')
+    
+

analisis/plots/20250516_CPT_bladetrap/Data/EITfit/lolo_modelo_full_3niveles.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+4 de ene 2024
+
+@author: lolo
+
+reingenieria del código que anda
+
+Surge de fusionar
+Data/EITfit/threeLevel_2repumps_AnalysisFunctions.py
+Data/EITfit/threeLevel_2repumps_linealpol_python_scripts.py
+
+MAPA de FUNCIONES
+
+
+GenerateNoisyCPT_fit
+ |--> PerformExperiment_8levels_fixedRabi
+   |--> CPTspectrum8levels_fixedRabi --> ndarray,ndarray
+     |--> FullL_efficient --> ndarray
+       |--> dopplerBroadening --> float
+       |--> EffectiveL --> ndarray
+       |--> H0matrix --> ndarray
+       |--> HImatrix --> ndarray
+       |--> CalculateSingleMmatrix --> ndarray
+       |--> Lplusminus --> ndarray,ndarray,ndarray
+       |--> GetL1 --> ndarray
+
+"""
+
+# pylint: disable=C0301,R0913,R0914,W0621
+
+
+
+import os
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from scipy.signal import argrelextrema
+# from EITfit.threeLevel_2repumps_linealpol_python_scripts import CPTspectrum8levels, CPTspectrum8levels_fixedRabi
+import random
+from scipy.signal import savgol_filter as sf
+
+from  numba import jit,njit
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+@njit
+def make_diag(vec):
+    "Construye matris diagonal desde una lista o vector"
+    return np.eye(len(vec))*np.array(vec).reshape(-1,1)
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+"""
+Scripts para el calculo de la curva CPT
+"""
+
+@njit
+def H0matrix(Detg, Detp, u):
+    """
+    Calcula la matriz H0 en donde dr es el detuning del doppler, dp es el retuning
+    del repump y u es el campo magnético en Hz/Gauss.
+    Para esto se toma la energía del nivel P como 0
+    """
+
+    eigenEnergies = (Detg-u, Detg+u, -u/3, u/3, Detp-6*u/5,
+                    Detp-2*u/5, Detp+2*u/5, Detp+6*u/5)
+    #pagina 26 de Oberst. los lande del calcio son iguales a Bario.
+    # H0 = np.diag(eigenEnergies)
+    # H0 = np.eye(len(eigenEnergies))*np.array(eigenEnergies).reshape(-1,1)
+    H0 = make_diag(eigenEnergies)
+    return H0
+
+@njit
+def HImatrix(rabG, rabP, phidoppler, titadoppler, phiprobe, titaprobe):
+    """
+    Calcula la matriz de interacción Hsp + Hpd, en donde rabR es la frecuencia de rabi de la transición Doppler SP,
+    rabP es la frecuencia de rabi de la transición repump DP, y las componentes ei_r y ei_p son las componentes de la polarización
+    del campo eléctrico incidente de doppler y repump respectivamente. Deben estar normalizadas a 1
+    """
+    HI = np.zeros((8, 8), dtype=np.complex_)
+
+    i, j = 1, 3
+    HI[i-1, j-1] = (rabG/np.sqrt(3)) * np.cos(titadoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 1, 4
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.sin(titadoppler)*np.exp(1j*phidoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 2, 3
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.sin(titadoppler)*np.exp(-1j*phidoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 2, 4
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.cos(titadoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+
+    i, j = 3, 5
+    HI[i-1, j-1] = -(rabP/2) * np.sin(titaprobe)*np.exp(-1j*phiprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 3, 6
+    HI[i-1, j-1] = -(rabP/np.sqrt(3)) * np.cos(titaprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 3, 7
+    HI[i-1, j-1] = rabP/np.sqrt(12) * np.sin(titaprobe)*np.exp(1j*phiprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+
+    i, j = 4, 6
+    HI[i-1, j-1] = -(rabP/np.sqrt(12)) * np.sin(titaprobe)*np.exp(-1j*phiprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 4, 7
+    HI[i-1, j-1] = -(rabP/np.sqrt(3)) * np.cos(titaprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 4, 8
+    HI[i-1, j-1] = (rabP/2) * np.sin(titaprobe)*np.exp(1j*phiprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    return HI
+
+
+@njit
+def Lplusminus(detr, detp, phirepump, titarepump, forma=1):
+    Hintplus = np.zeros((8, 8), dtype=np.complex_)
+    Hintminus = np.zeros((8, 8), dtype=np.complex_)
+
+
+    Hintplus[4, 2] = (-1/2)*np.sin(titarepump)*np.exp(1j*phirepump)
+    Hintplus[5, 2] = (-1/np.sqrt(3))*np.cos(titarepump)
+    Hintplus[6, 2] = (1/(2*np.sqrt(3)))*np.sin(titarepump)*np.exp(-1j*phirepump)
+
+    Hintplus[5, 3] = (-1/(2*np.sqrt(3)))*np.sin(titarepump)*np.exp(1j*phirepump)
+    Hintplus[6, 3] = (-1/np.sqrt(3))*np.cos(titarepump)
+    Hintplus[7, 3] = (1/2)*np.sin(titarepump)*np.exp(-1j*phirepump)
+
+
+    Hintminus[2, 4] = (-1/2)*np.sin(titarepump)*np.exp(-1j*phirepump)
+    Hintminus[2, 5] = (-1/np.sqrt(3))*np.cos(titarepump)
+    Hintminus[2, 6] = (1/(2*np.sqrt(3)))*np.sin(titarepump)*np.exp(1j*phirepump)
+
+    Hintminus[3, 5] = (-1/(2*np.sqrt(3)))*np.sin(titarepump)*np.exp(-1j*phirepump)
+    Hintminus[3, 6] = (-1/np.sqrt(3))*np.cos(titarepump)
+    Hintminus[3, 7] = (1/2)*np.sin(titarepump)*np.exp(1j*phirepump)
+
+    # if forma==1:
+    if True:
+        Lplus = np.zeros((64, 64), dtype=np.complex_)
+        Lminus = np.zeros((64, 64), dtype=np.complex_)
+        DeltaBar = np.zeros((64, 64), dtype=np.complex_)
+
+        for r  in range(8):
+            for q in range(8):
+                for k in range(8):
+                    for j in range(8):
+                        if j==q:
+                            if (k==2 or k==3) and r > 3:
+                                Lplus[r*8+q][k*8+j] = (-1j)*(Hintplus[r,k])
+                            if (r==2 or r==3) and k > 3:
+                                Lminus[r*8+q][k*8+j] = (-1j)*(Hintminus[r,k])
+                        elif r==k:
+                            if (q==2 or q==3) and j > 3:
+                                Lplus[r*8+q][k*8+j] = (-1j)*(- Hintplus[j,q])
+                            if (j==2 or j==3) and q > 3:
+                                Lminus[r*8+q][k*8+j] = (-1j)*(- Hintminus[j,q])
+    # if forma==2:
+    #     deltaKro = np.diag([1, 1, 1, 1, 1, 1, 1, 1])
+    #     Lplus = (-1j)*(np.kron(Hintplus, deltaKro) - np.kron(deltaKro, Hintplus))
+    #     Lminus = (-1j)*(np.kron(Hintminus, deltaKro) - np.kron(deltaKro, Hintminus))
+
+    DeltaBar = np.zeros((64, 64), dtype=np.complex_)
+    for i in range(64):
+
+        DeltaBar[i, i] = (1j)*(detr - detp)
+
+    # return np.matrix(Lminus), np.matrix(Lplus), np.matrix(DeltaBar)
+    return Lminus, Lplus, DeltaBar
+
+@njit
+def GetL1(Lplus, Lminus, DeltaBar, L0, rabR, nmax):
+    """
+    Devuelve Splus0 y Sminus0
+    """
+
+    # Sp = (-1)*(0.5*rabR)*(np.matrix(np.linalg.inv(L0 - (nmax+1)*DeltaBar))*np.matrix(Lplus))
+    # Sm = (-1)*(0.5*rabR)*(np.matrix(np.linalg.inv(L0 + (nmax+1)*DeltaBar))*np.matrix(Lminus))
+
+    Sp = (-1)*(0.5*rabR)*(np.linalg.inv(L0 - (nmax+1)*DeltaBar)).dot(Lplus)
+    Sm = (-1)*(0.5*rabR)*(np.linalg.inv(L0 + (nmax+1)*DeltaBar)).dot(Lminus)
+
+    for n in list(range(nmax+1))[(nmax+1)::-1][0:len(list(range(nmax+1))[(nmax+1)::-1])-1]: #jaja esto solo es para que vaya de nmax a 1 bajando. debe haber algo mas facil pero kcio
+        # Sp = (-1)*(rabR)*(np.matrix(np.linalg.inv(L0 - n*DeltaBar + rabR*(Lminus*np.matrix(Sp))))*np.matrix(Lplus))
+        # Sm = (-1)*(rabR)*(np.matrix(np.linalg.inv(L0 + n*DeltaBar + rabR*(Lplus*np.matrix(Sm))))*np.matrix(Lminus))
+
+        Sp = (-1)*(rabR)*((np.linalg.inv(L0 - n*DeltaBar + rabR*(Lminus.dot(Sp)))).dot(Lplus))
+        Sm = (-1)*(rabR)*((np.linalg.inv(L0 + n*DeltaBar + rabR*(Lplus.dot(Sm)))).dot(Lminus))
+
+    L1 = 0.5*rabR*(Lminus.dot(Sp) + Lplus.dot(Sm))
+
+    return L1
+
+@njit
+def EffectiveL(gPS, gPD, lwg, lwr, lwp):
+
+    """
+    Siendo Heff = H + EffectiveL, calcula dicho EffectiveL que es (-0.5j)*sumatoria(CmDaga*Cm) que luego sirve para calcular el Liouvilliano
+    """
+    Leff = np.zeros((8, 8), dtype=np.complex_)
+
+    Leff[0, 0] = 2*lwg
+    Leff[1, 1] = 2*lwg
+    Leff[2, 2] = ((2/3)+(1/3))*gPS + ((1/2) + (1/6) + (1/3))*gPD
+    Leff[3, 3] = ((2/3)+(1/3))*gPS + ((1/2) + (1/6) + (1/3))*gPD
+    Leff[4, 4] = 2*(lwr + lwp)
+    Leff[5, 5] = 2*(lwr + lwp)
+    Leff[6, 6] = 2*(lwr + lwp)
+    Leff[7, 7] = 2*(lwr + lwp)
+
+    return (-0.5j)*Leff
+
+@njit
+def CalculateSingleMmatrix(gPS, gPD, lwg, lwr, lwp):
+    """
+    Si tomamos el Liuvilliano como L = (-j)*(Heff*deltak - Heffdaga*deltak) + sum(Mm),
+    esta funcion calcula dichos Mm, que tienen dimensión 64x64 ya que esa es la dimensión del L. Estas componentes
+    salen de hacer la cuenta a mano conociendo los Cm y considerando que Mm[8*(r-1)+s, 8*(k-1)+j] = Cm[r,l] + Cmdaga[j,s] = Cm[r,l] + Cm[s,j]
+    ya que los componentes de Cm son reales.
+    Esta M es la suma de las 8 matrices M.
+
+    """
+
+    M =np.zeros((64, 64), dtype=np.complex_)
+
+    M[0,27] = (2/3)*gPS
+
+    M[9,18] = (2/3)*gPS
+
+    M[0,18] = (1/3)*gPS
+    M[1,19] = -(1/3)*gPS
+    M[8,26] = -(1/3)*gPS
+    M[9,27] = (1/3)*gPS
+
+    M[36,18] = (1/2)*gPD
+    M[37,19] = (1/np.sqrt(12))*gPD
+    M[44,26] = (1/np.sqrt(12))*gPD
+    M[45,27] = (1/6)*gPD
+
+    M[54,18] = (1/6)*gPD
+    M[55,19] = (1/np.sqrt(12))*gPD
+    M[62,26] = (1/np.sqrt(12))*gPD
+    M[63,27] = (1/2)*gPD
+
+    M[45,18] = (1/3)*gPD
+    M[46,19] = (1/3)*gPD
+    M[53,26] = (1/3)*gPD
+    M[54,27] = (1/3)*gPD
+
+    M[0,0] = 2*lwg
+    M[1,1] = 2*lwg
+    M[8,8] = 2*lwg
+    M[9,9] = 2*lwg
+
+    factor1 = 1
+    factor2 = 1
+    factor3 = 1
+    factor4 = 1
+
+
+    #M[36, 45] = lwp
+
+
+    M[36,36] = 2*(lwr + factor1*lwp)
+    M[37,37] = 2*(lwr + factor1*lwp)
+    M[38,38] = 2*(lwr + factor1*lwp)
+    M[39,39] = 2*(lwr + factor1*lwp)
+    M[44,44] = 2*(lwr + factor2*lwp)
+    M[45,45] = 2*(lwr + factor2*lwp)
+    M[46,46] = 2*(lwr + factor2*lwp)
+    M[47,47] = 2*(lwr + factor2*lwp)
+    M[52,52] = 2*(lwr + factor3*lwp)
+    M[53,53] = 2*(lwr + factor3*lwp)
+    M[54,54] = 2*(lwr + factor3*lwp)
+    M[55,55] = 2*(lwr + factor3*lwp)
+    M[60,60] = 2*(lwr + factor4*lwp)
+    M[61,61] = 2*(lwr + factor4*lwp)
+    M[62,62] = 2*(lwr + factor4*lwp)
+    M[63,63] = 2*(lwr + factor4*lwp)
+
+    return M
+
+
+@njit
+def dopplerBroadening(wlg, wlp, alpha, T, mcalcio = 6.655e-23*1e-3):
+    """
+    Calcula el broadening extra semiclásico por temperatura considerando que el ion atrapado se mueve.
+    wlg es la longitud de onda doppler, wlp la longitud de onda repump, T la temperatura del ion en kelvin, y alpha (en rads) el ángulo
+    que forman ambos láseres.
+    """
+
+    kboltzmann = 1.38e-23 #J/K
+
+    gammaD = (2*np.pi)*np.sqrt((1/(wlg*wlg)) + (1/(wlp*wlp)) - 2*(1/(wlg*wlp))*np.cos(alpha))*np.sqrt(kboltzmann*T/(2*mcalcio))
+
+    return gammaD
+
+@njit
+def FullL_efficient(rabG, rabR, rabP, gPS = 0, gPD = 0, Detg = 0, Detr = 0, Detp = 0, u = 0, lwg = 0, lwr=0, lwp = 0,
+          phidoppler=0, titadoppler=0, phiprobe=0, titaprobe=0, phirepump=0, titarepump=0, T = 0, alpha = 0):
+
+    """
+    Calcula el Liouvilliano total de manera explícita índice a índice. Suma aparte las componentes de las matrices M.
+    Es la más eficiente hasta ahora.
+    """
+
+
+    db = dopplerBroadening(0.397e-6, 0.866e-6, alpha, T)
+
+    #lwr = np.sqrt(lwr**2 + dopplerBroadening(0.397e-6, 0.866e-6, alpha, T)**2)
+    lwg = np.sqrt(lwg**2 + db**2)
+    lwr = np.sqrt(lwr**2 + db**2)
+
+    CC = EffectiveL(gPS, gPD, lwg, lwr, lwp)
+
+    Heff = H0matrix(Detg, Detp, u) + HImatrix(rabG, rabP, phidoppler, titadoppler, phiprobe, titaprobe) + CC
+
+    # Heffdaga = np.matrix(Heff).getH()
+    Heffdaga = Heff.transpose().conj()
+
+    Lfullpartial = np.zeros((64, 64), dtype=np.complex_)
+
+    for r  in range(8):
+        for q in range(8):
+            for k in range(8):
+                for j in range(8):
+                    if j!=q and r!=k:
+                        pass
+                    elif j==q and r!=k:
+                        if (r < 2 and k > 3) or (k < 2 and r > 3) or (r > 3 and k > 3) or (r==0 and k==1) or (r==1 and k==0) or (r==2 and k==3) or (r==3 and k==2): #todo esto sale de analizar explicitamente la matriz y tratar de no calcular cosas de más que dan cero
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(Heff[r,k])
+                    elif j!=q and r==k:
+                        if (j < 2 and q > 3) or (q < 2 and j > 3) or (j > 3 and q > 3) or (j==0 and q==1) or (j==1 and q==0) or (j==2 and q==3) or (j==3 and q==2):
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(-Heffdaga[j,q])
+                    else:
+                        if Heff[r,k] == Heffdaga[j,q]:
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(Heff[r,k]-Heffdaga[j,q])
+
+    M = CalculateSingleMmatrix(gPS, gPD, lwg, lwr, lwp)
+    L0 = Lfullpartial + M
+
+    nmax = 1
+    Lminus, Lplus, DeltaBar = Lplusminus(Detr, Detp, phirepump, titarepump)
+    factor1 = np.exp(1j*0.2*np.pi)
+    factor2 = np.exp(-1j*0.2*np.pi)
+    #print(factor)
+    L1 = GetL1(factor1*Lplus, factor2*Lminus, DeltaBar, L0, rabR, nmax)
+    Lfull = L0 + L1
+
+
+    #NORMALIZACION DE RHO
+    i = 0
+    while i < 64:
+        if i%9 == 0:
+            Lfull[0, i] = 1
+        else:
+            Lfull[0, i] = 0
+        i = i + 1
+
+    return Lfull
+
+
+"""
+Scripts para correr un experimento y hacer el análisis de los datos
+"""
+
+def CalculoTeoricoDarkResonances(u, titadoppler):
+    if titadoppler==0:
+        NegativeDR = [(-7/5)*u, (-3/5)*u, (-1/5)*u, (1/5)*u, (3/5)*u, (7/5)*u]
+    elif titadoppler==90:
+        NegativeDR = [(-11/5)*u, (-7/5)*u, (-3/5)*u, (3/5)*u, (7/5)*u, (11/5)*u]
+
+    PositiveDR = [(-8/5)*u, (-4/5)*u, 0, (4/5)*u, (8/5)*u]
+
+    return NegativeDR, PositiveDR
+
+
+def CPTspectrum8levels(rabG, rabR, rabP, gPS, gPD, Detg, Detr, u, lwg, lwr, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump,
+                      freqMin=-100, freqMax=100, freqStep=1e-1, plot=False, solvemode=1):
+    """
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+
+    phidoppler, titadoppler = phidoppler*(np.pi/180), titadoppler*(np.pi/180)
+    phiprobe, titaprobe = phiprobe*(np.pi/180), titaprobe*(np.pi/180)
+    phirepump, titarepump = phirepump*(np.pi/180), titarepump*(np.pi/180)
+
+    DetProbeVector = 2*np.pi*np.arange(freqMin*1e6, freqMax*1e6, freqStep*1e6)
+    Detg, Detr = 2*np.pi*Detg*1e6, 2*np.pi*Detr*1e6
+    lwg, lwr, lwp = 2*np.pi*lwg*1e6, 2*np.pi*lwr*1e6, 2*np.pi*lwp*1e6
+
+    #u = 2*np.pi*u*1e6
+
+    Fluovector = []
+
+    tinicial = time.time()
+
+    for Detp in DetProbeVector:
+        L = FullL_efficient(rabG, rabR, rabP, gPS, gPD, Detg, Detr, Detp, u, lwg, lwr, lwp, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, Temp, alpha)
+
+        # if solvemode == 1:
+        if True:
+            rhovectorized = np.linalg.solve(L, np.array([int(i==0) for i in range(64)],dtype=np.complex_))
+            Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+            Fluovector.append(Fluo)
+
+        # if solvemode == 2:
+        #     Linv = np.linalg.inv(L)
+        #     rhovectorized = [Linv[j][0] for j in range(len(Linv))]
+        #     Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+        #     Fluovector.append(Fluo)
+
+    tfinal = time.time()
+
+    print('Done, Total time: ', round((tfinal-tinicial), 2), "s")
+
+    DetProbeVectorMHz = np.arange(freqMin, freqMax, freqStep)
+
+    if plot:
+        plt.xlabel('Probe detuning (MHz)')
+        plt.ylabel('Fluorescence (A.U.)')
+        plt.plot(DetProbeVectorMHz, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+        plt.legend()
+
+    return DetProbeVectorMHz, Fluovector
+
+@njit
+def CPTspectrum8levels_fixedRabi(sg, sr, sp, gPS, gPD, Detg, Detr, u, lwg, lwr, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump,
+                      freqMin=-100, freqMax=100, freqStep=1e-1, plot=False, solvemode=1):
+    """
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+
+
+
+
+    phidoppler, titadoppler = phidoppler*(np.pi/180), titadoppler*(np.pi/180)
+    phiprobe, titaprobe = phiprobe*(np.pi/180), titaprobe*(np.pi/180)
+    phirepump, titarepump = phirepump*(np.pi/180), titarepump*(np.pi/180)
+
+    DetProbeVector = 2*np.pi*np.arange(freqMin*1e6, freqMax*1e6, freqStep*1e6)
+    Detg, Detr = 2*np.pi*Detg*1e6, 2*np.pi*Detr*1e6
+    #lwg, lwr, lwp = 2*np.pi*lwg*1e6, 2*np.pi*lwr*1e6, 2*np.pi*lwp*1e6
+    lwg, lwr, lwp = lwg*1e6, lwr*1e6, lwp*1e6
+
+    rabG = sg*gPS
+    rabR = sr*gPD
+    rabP = sp*gPD
+    #u = 2*np.pi*u*1e6
+
+    Fluovector = []
+
+    # tinicial = time.time()
+
+    for Detp in DetProbeVector:
+
+        L = FullL_efficient(rabG, rabR, rabP, gPS, gPD, Detg, Detr, Detp, u, lwg, lwr, lwp, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, Temp, alpha)
+
+        # if solvemode == 1:
+        if True:
+            coh = 5
+            rhovectorized = np.linalg.solve(L, np.array([int(i==0) for i in range(64)],dtype=np.complex_))
+            #Fluo = np.abs(rhovectorized[coh])
+            Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+            Fluovector.append(Fluo)
+
+        # if solvemode == 2:
+        #     Linv = np.linalg.inv(L)
+        #     rhovectorized = [Linv[j][0] for j in range(len(Linv))]
+        #     Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+        #     Fluovector.append(Fluo)
+
+    # tfinal = time.time()
+
+    # print('Done, Total time: ', round((tfinal-tinicial), 2), "s")
+
+    DetProbeVectorMHz = np.arange(freqMin, freqMax, freqStep)
+
+    # if plot:
+    #     plt.xlabel('Probe detuning (MHz)')
+    #     plt.ylabel('Fluorescence (A.U.)')
+    #     plt.plot(DetProbeVectorMHz, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+    #     plt.legend()
+
+    return DetProbeVectorMHz, Fluovector
+#%%
+
+if __name__ == "__main__":
+    ub = 9.27e-24
+    h = 6.63e-34
+    c = (ub/h)*1e-4 #en unidades de MHz/G
+
+    B = 25 #campo magnetico en gauss
+
+    u = c*B
+
+
+    sg, sr, sp = 0.5, 1.5, 4 #parámetros de saturación del doppler y repump
+    gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6 #anchos de linea de las transiciones
+    rabG, rabR, rabP = sg*gPS, sr*gPD, sp*gPD #frecuencias de rabi
+
+    lwg, lwr, lwp = 0.3, 0.3, 0.3 #ancho de linea de los laseres
+
+    Detg = -25
+    Detr = 20 #detuning del doppler y repump
+
+    Temp = 0.0e-3 #temperatura en K
+    alpha = 0*(np.pi/180) #angulo entre los láseres
+
+    phidoppler, titadoppler = 0, 90
+    phirepump, titarepump = 0, 90
+
+    phiprobe, titaprobe = 0, 90
+
+
+    plotCPT = False
+
+    freqMin = -50
+    freqMax = 50
+    freqStep = 5e-2
+
+    Frequencyvector, Fluovector = CPTspectrum8levels(rabG, rabR, rabP, gPS, gPD, Detg, Detr, u, lwg, lwr, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=plotCPT, solvemode=1)
+
+    NegativeDR, PositiveDR = CalculoTeoricoDarkResonances(u/(2*np.pi*1e6), titadoppler)
+
+    plt.plot(Frequencyvector, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+    plt.xlabel('Probe detuning (MHz)')
+    plt.ylabel('Fluorescence (A.U.)')
+
+    for PDR in PositiveDR:
+        plt.axvline(Detr+PDR, linestyle='--', linewidth=0.5, color='red')
+    for NDR in NegativeDR:
+        plt.axvline(Detg+NDR, linestyle='--', linewidth=0.5, color='blue')
+
+
+
+
+    #parametros que andan piola:
+
+
+    """
+    ub = 9.27e-24
+    h = 6.63e-34
+    c = (ub/h)*1e-4 #en unidades de MHz/G
+
+    B = 17 #campo magnetico en gauss
+
+    u = c*B
+    #u = 80e6
+
+    sr, sp = 0.53, 4.2
+    gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+    rabR, rabP = sr*gPS, sp*gPD
+    lw = 2*np.pi * 0.33e6
+    lwr, lwp = lw, lw #ancho de linea de los laseres
+    dr_spec = - 2*np.pi* 26e6
+
+
+    freqSteps = 500
+    freqMin = -100e6
+    freqMax = 100e6
+
+    dps = 2*np.pi*np.linspace(freqMin, freqMax, freqSteps)
+
+    #dps = [-30e6]
+
+    alfar = 90*(np.pi/180)
+    ex_r, ey_r, ez_r = np.sin(alfar)*np.cos(0), np.sin(alfar)*np.sin(0), np.cos(alfar)
+
+
+    alfap = 90*(np.pi/180)
+    ex_p, ey_p, ez_p = np.sin(alfap)*np.cos(0), np.sin(alfap)*np.sin(0), np.cos(alfap)
+
+    """
+
+
+
+
+
+
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+
+
+
+
+def CalculoTeoricoDarkResonances_8levels(u, titadoppler, detuningdoppler, detuningrepump):
+
+    if titadoppler==0:
+        NegativeDR = [(-7/5)*u, (-3/5)*u, (-1/5)*u, (1/5)*u, (3/5)*u, (7/5)*u]
+    elif titadoppler==90:
+        NegativeDR = [(-11/5)*u, (-7/5)*u, (-3/5)*u, (3/5)*u, (7/5)*u, (11/5)*u]
+    else:
+        NegativeDR = [(-11/5)*u, (-7/5)*u, (-3/5)*u, (-1/5)*u, (1/5)*u, (3/5)*u, (7/5)*u, (11/5)*u]
+
+    PositiveDR = [(-8/5)*u, (-4/5)*u, 0, (4/5)*u, (8/5)*u]
+
+    return [detuningdoppler + dr for dr in NegativeDR], [detuningrepump + dr for dr in PositiveDR]
+
+
+def GetClosestIndex(Vector, value, tolerance=1e-3):
+
+    i = 0
+    while i<len(Vector):
+        if abs(Vector[i] - value) < tolerance:
+            return i
+        else:
+            i = i + 1
+    return GetClosestIndex(Vector, value, tolerance=2*tolerance)
+
+
+def FindDRFrequencies(Freq, Fluo, TeoDR, entorno=3):
+    """
+    Busca los indices y la frecuencia de los minimos en un entorno cercano al de la DR.
+    Si no encuentra, devuelve el valor teórico.
+    """
+
+    IndiceDRteo1, IndiceEntornoinicialDRteo1, IndiceEntornofinalDRteo1 = GetClosestIndex(Freq, TeoDR[0]), GetClosestIndex(Freq, TeoDR[0]-entorno), GetClosestIndex(Freq, TeoDR[0]+entorno)
+    IndiceDRteo2, IndiceEntornoinicialDRteo2, IndiceEntornofinalDRteo2 = GetClosestIndex(Freq, TeoDR[1]), GetClosestIndex(Freq, TeoDR[1]-entorno), GetClosestIndex(Freq, TeoDR[1]+entorno)
+    IndiceDRteo3, IndiceEntornoinicialDRteo3, IndiceEntornofinalDRteo3 = GetClosestIndex(Freq, TeoDR[2]), GetClosestIndex(Freq, TeoDR[2]-entorno), GetClosestIndex(Freq, TeoDR[2]+entorno)
+    IndiceDRteo4, IndiceEntornoinicialDRteo4, IndiceEntornofinalDRteo4 = GetClosestIndex(Freq, TeoDR[3]), GetClosestIndex(Freq, TeoDR[3]-entorno), GetClosestIndex(Freq, TeoDR[3]+entorno)
+    IndiceDRteo5, IndiceEntornoinicialDRteo5, IndiceEntornofinalDRteo5 = GetClosestIndex(Freq, TeoDR[4]), GetClosestIndex(Freq, TeoDR[4]-entorno), GetClosestIndex(Freq, TeoDR[4]+entorno)
+    IndiceDRteo6, IndiceEntornoinicialDRteo6, IndiceEntornofinalDRteo6 = GetClosestIndex(Freq, TeoDR[5]), GetClosestIndex(Freq, TeoDR[5]-entorno), GetClosestIndex(Freq, TeoDR[5]+entorno)
+
+    EntornoFreqDR1, EntornoFreqDR2 = Freq[IndiceEntornoinicialDRteo1:IndiceEntornofinalDRteo1], Freq[IndiceEntornoinicialDRteo2:IndiceEntornofinalDRteo2]
+    EntornoFreqDR3, EntornoFreqDR4 = Freq[IndiceEntornoinicialDRteo3:IndiceEntornofinalDRteo3], Freq[IndiceEntornoinicialDRteo4:IndiceEntornofinalDRteo4]
+    EntornoFreqDR5, EntornoFreqDR6 = Freq[IndiceEntornoinicialDRteo5:IndiceEntornofinalDRteo5], Freq[IndiceEntornoinicialDRteo6:IndiceEntornofinalDRteo6]
+
+    EntornoFluoDR1, EntornoFluoDR2 = Fluo[IndiceEntornoinicialDRteo1:IndiceEntornofinalDRteo1], Fluo[IndiceEntornoinicialDRteo2:IndiceEntornofinalDRteo2]
+    EntornoFluoDR3, EntornoFluoDR4 = Fluo[IndiceEntornoinicialDRteo3:IndiceEntornofinalDRteo3], Fluo[IndiceEntornoinicialDRteo4:IndiceEntornofinalDRteo4]
+    EntornoFluoDR5, EntornoFluoDR6 = Fluo[IndiceEntornoinicialDRteo5:IndiceEntornofinalDRteo5], Fluo[IndiceEntornoinicialDRteo6:IndiceEntornofinalDRteo6]
+
+    IndiceFluoMinimaEntorno1, IndiceFluoMinimaEntorno2 = argrelextrema(np.array(EntornoFluoDR1), np.less)[0], argrelextrema(np.array(EntornoFluoDR2), np.less)[0]
+    IndiceFluoMinimaEntorno3, IndiceFluoMinimaEntorno4 = argrelextrema(np.array(EntornoFluoDR3), np.less)[0], argrelextrema(np.array(EntornoFluoDR4), np.less)[0]
+    IndiceFluoMinimaEntorno5, IndiceFluoMinimaEntorno6 = argrelextrema(np.array(EntornoFluoDR5), np.less)[0], argrelextrema(np.array(EntornoFluoDR6), np.less)[0]
+
+    try:
+        FreqDR1 = EntornoFreqDR1[int(IndiceFluoMinimaEntorno1)]
+        IndiceDR1 = GetClosestIndex(Freq, FreqDR1)
+    except:
+        FreqDR1 = TeoDR[0]
+        IndiceDR1 = IndiceDRteo1
+    try:
+        FreqDR2 = EntornoFreqDR2[int(IndiceFluoMinimaEntorno2)]
+        IndiceDR2 = GetClosestIndex(Freq, FreqDR2)
+    except:
+        FreqDR2 = TeoDR[1]
+        IndiceDR2 = IndiceDRteo2
+    try:
+        FreqDR3 = EntornoFreqDR3[int(IndiceFluoMinimaEntorno3)]
+        IndiceDR3 = GetClosestIndex(Freq, FreqDR3)
+    except:
+        FreqDR3 = TeoDR[2]
+        IndiceDR3 = IndiceDRteo3
+    try:
+        FreqDR4 = EntornoFreqDR4[int(IndiceFluoMinimaEntorno4)]
+        IndiceDR4 = GetClosestIndex(Freq, FreqDR4)
+    except:
+        FreqDR4 = TeoDR[3]
+        IndiceDR4 = IndiceDRteo4
+    try:
+        FreqDR5 = EntornoFreqDR5[int(IndiceFluoMinimaEntorno5)]
+        IndiceDR5 = GetClosestIndex(Freq, FreqDR5)
+    except:
+        FreqDR5 = TeoDR[4]
+        IndiceDR5 = IndiceDRteo5
+    try:
+        FreqDR6 = EntornoFreqDR6[int(IndiceFluoMinimaEntorno6)]
+        IndiceDR6 = GetClosestIndex(Freq, FreqDR6)
+    except:
+        FreqDR6 = TeoDR[5]
+        IndiceDR6 = IndiceDRteo6
+
+    return [IndiceDR1, IndiceDR2, IndiceDR3, IndiceDR4, IndiceDR5, IndiceDR6], [FreqDR1, FreqDR2, FreqDR3, FreqDR4, FreqDR5, FreqDR6]
+
+
+def FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=1, frecuenciareferenciacriterioasintotico=-100, getindices=False):
+    """
+    Toma los indices donde estan las DR y evalua su fluorescencia. Esos indices son minimos locales en un entorno
+    cercano a las DR teoricas y, si no hay ningun minimo, toma la teorica.
+    Luego, hace el cociente de esa fluorescencia y un factor de normalización segun NormalizationCriterium:
+        1: Devuelve la fluorescencia absoluta de los minimos
+        2: Devuelve el cociente entre la fluorescencia del minimo y un valor medio entre dos puntos lejanos, como si no
+        hubiera una resonancia oscura y hubiera una recta. Ese valor esta a  DistanciaFrecuenciaCociente del detuning del azul (el punto medio entre las dos DR en este caso)
+        3: Devuelve el cociente entre la fluorescencia del minimo y el valor a -100 MHz (si se hizo de -100 a 100),
+        o el valor limite por izquierda de la curva
+        4: Deuelve el cociente entre la fluorescencia del minimo y el valor de fluorescencia a detuning 0 MHz
+
+    """
+    IndiceDR1, IndiceDR2, IndiceDR3, IndiceDR4, IndiceDR5, IndiceDR6 = IndicesDR[0], IndicesDR[1], IndicesDR[2], IndicesDR[3], IndicesDR[4], IndicesDR[5]
+    FluorescenceOfMinimums = [Fluo[IndiceDR1], Fluo[IndiceDR2], Fluo[IndiceDR3], Fluo[IndiceDR4], Fluo[IndiceDR5], Fluo[IndiceDR6]]
+    FrequencyOfMinimums = [Freq[IndiceDR1], Freq[IndiceDR2], Freq[IndiceDR3], Freq[IndiceDR4], Freq[IndiceDR5], Freq[IndiceDR6]]
+    DistanciaFrecuenciaCociente = 25
+
+    if NormalizationCriterium==0:
+        print('che')
+        return FrequencyOfMinimums, FluorescenceOfMinimums
+
+    if NormalizationCriterium==1:
+        Fluorescenciacerodetuning = Fluo[GetClosestIndex(Freq, 0)]
+        Fluorescenciaasintotica = Fluo[GetClosestIndex(Freq, frecuenciareferenciacriterioasintotico)]
+        return FrequencyOfMinimums, np.array([Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica])
+
+    if NormalizationCriterium==2:
+        k = 0
+        while k < len(Freq):
+            if Freq[k] < detuningdoppler-DistanciaFrecuenciaCociente + 2 and Freq[k] > detuningdoppler-DistanciaFrecuenciaCociente - 2:
+                FluoIzquierda = Fluo[k]
+                indiceizquierda = k
+                print('Izq:', Freq[k])
+                break
+            else:
+                k = k + 1
+
+        l = 0
+        while l < len(Freq):
+            if Freq[l] < detuningdoppler+DistanciaFrecuenciaCociente + 2 and Freq[l] > detuningdoppler+DistanciaFrecuenciaCociente - 2:
+                FluoDerecha = Fluo[l]
+                indicederecha = l
+                print('Der: ', Freq[l])
+                break
+            else:
+                l = l + 1
+        FluoNormDivisor = 0.5*(FluoDerecha+FluoIzquierda)
+        print(FluoNormDivisor)
+
+    if NormalizationCriterium==3:
+        #asintotico
+        FluoNormDivisor = Fluo[GetClosestIndex(Freq, frecuenciareferenciacriterioasintotico)]
+
+    if NormalizationCriterium==4:
+        #este te tira la fluorescencia de detuning 0
+        FluoNormDivisor = Fluo[GetClosestIndex(Freq, 0)]
+
+
+    RelativeFluorescenceOfMinimums = np.array([Fluore/FluoNormDivisor for Fluore in FluorescenceOfMinimums])
+    print('Esto: ', RelativeFluorescenceOfMinimums)
+
+    if NormalizationCriterium==2 and getindices==True:
+        return FrequencyOfMinimums, RelativeFluorescenceOfMinimums, indiceizquierda, indicederecha
+
+    return FrequencyOfMinimums, RelativeFluorescenceOfMinimums
+
+
+def GetFinalMaps(MapasDR1, MapasDR2, MapasDR3, MapasDR4, MapasDR5, MapasDR6):
+    """
+    Nota: esto vale para polarizacion del 397 sigma+ + sigma-. Sino hay que cambiar los coeficientes.
+    La estructura es:
+        MapasDRi = [MapaMedido_criterio1_DRi, MapaMedido_criterio2_DRi, MapaMedido_criterio3_DRi, MapaMedido_criterio4_DRi]
+    """
+    Mapa1 = MapasDR1[0]
+
+    Mapa2pi = np.sqrt(3)*(MapasDR2[1] + MapasDR5[1])
+    Mapa2smas = np.sqrt(12/2)*MapasDR3[1] + (2/np.sqrt(2))*MapasDR6[1]
+    Mapa2smenos = (2/np.sqrt(2))*MapasDR1[1] + np.sqrt(12/2)*MapasDR4[1]
+
+    Mapa3pi = np.sqrt(3)*(MapasDR2[2] + MapasDR5[2])
+    Mapa3smas = np.sqrt(12/2)*MapasDR3[2] + (2/np.sqrt(2))*MapasDR6[2]
+    Mapa3smenos = (2/np.sqrt(2))*MapasDR1[2] + np.sqrt(12/2)*MapasDR4[2]
+
+    return Mapa1, [Mapa2pi, Mapa2smas, Mapa2smenos], [Mapa3pi, Mapa3smas, Mapa3smenos]
+
+
+def CombinateDRwithCG(RelMinMedido1, RelMinMedido2, RelMinMedido3, RelMinMedido4):
+    Fluo1 = RelMinMedido1[0]
+
+    Fluo2pi = np.sqrt(3)*(RelMinMedido2[1] + RelMinMedido2[4])
+    Fluo2smas = np.sqrt(12/2)*RelMinMedido2[2] + (2/np.sqrt(2))*RelMinMedido2[5]
+    Fluo2smenos = (2/np.sqrt(2))*RelMinMedido2[0] + np.sqrt(12/2)*RelMinMedido2[3]
+
+    Fluo3pi = np.sqrt(3)*(RelMinMedido3[1] + RelMinMedido3[4])
+    Fluo3smas = np.sqrt(12/2)*RelMinMedido3[2] + (2/np.sqrt(2))*RelMinMedido3[5]
+    Fluo3smenos = (2/np.sqrt(2))*RelMinMedido3[0] + np.sqrt(12/2)*RelMinMedido3[3]
+
+    return Fluo1, [Fluo2pi, Fluo2smas, Fluo2smenos], [Fluo3pi, Fluo3smas, Fluo3smenos]
+
+
+
+def IdentifyPolarizationCoincidences(theoricalmap, target, tolerance=1e-1):
+    """
+    Busca en un mapa 2D la presencia de un valor target (medido) con tolerancia tolerance.
+    Si lo encuentra, pone un 1. Sino, un 0. Al plotear con pcolor se verá
+    en blanco la zona donde el valor medido se puede hallar.
+    """
+    CoincidenceMatrix = np.zeros((len(theoricalmap), len(theoricalmap[0])))
+
+    i = 0
+    while i<len(theoricalmap):
+        j = 0
+        while j<len(theoricalmap[0]):
+            if abs(theoricalmap[i][j]-target) < tolerance:
+                CoincidenceMatrix[i][j] = 1
+            j=j+1
+        i=i+1
+    return CoincidenceMatrix
+
+def RetrieveAbsoluteCoincidencesBetweenMaps(MapsVectors):
+
+    MatrixSum = np.zeros((len(MapsVectors[0]), len(MapsVectors[0][0])))
+    AbsoluteCoincidencesMatrix = np.zeros((len(MapsVectors[0]), len(MapsVectors[0][0])))
+
+
+    MatrixMapsVectors = []
+
+    for i in range(len(MapsVectors)):
+        MatrixMapsVectors.append(np.matrix(MapsVectors[i]))
+
+    for i in range(len(MatrixMapsVectors)):
+        MatrixSum = MatrixSum + MatrixMapsVectors[i]
+
+    MaxNumberOfCoincidences = np.max(MatrixSum)
+
+    ListMatrixSum = [list(i) for i in list(np.array(MatrixSum))]
+
+    for i in range(len(ListMatrixSum)):
+        for j in range(len(ListMatrixSum[0])):
+            if ListMatrixSum[i][j] == MaxNumberOfCoincidences:
+                AbsoluteCoincidencesMatrix[i][j] = 1
+
+    return AbsoluteCoincidencesMatrix, MaxNumberOfCoincidences
+
+
+def MeasureMeanValueOfEstimatedArea(AbsoluteCoincidencesMap, X, Y):
+    NonZeroIndices = np.nonzero(AbsoluteCoincidencesMap)
+
+    Xsum = 0
+    Xvec = []
+    Ysum = 0
+    Yvec = []
+    N = len(NonZeroIndices[0])
+    for i in range(N):
+        Xsum = Xsum + X[NonZeroIndices[1][i]]
+        Xvec.append(X[NonZeroIndices[1][i]])
+        Ysum = Ysum + Y[NonZeroIndices[0][i]]
+        Yvec.append(Y[NonZeroIndices[0][i]])
+    Xaverage = Xsum/N
+    Yaverage = Ysum/N
+    Xspread = np.std(Xvec)
+    Yspread = np.std(Yvec)
+    return Xaverage, Yaverage, N, Xspread, Yspread
+
+
+def MeasureRelativeFluorescenceFromCPT(Freq, Fluo, u, titadoppler, detuningrepump, detuningdoppler, frefasint=-100, entorno=3):
+    ResonanciasTeoricas, ResonanciasPositivas = CalculoTeoricoDarkResonances_8levels(u, titadoppler, detuningdoppler, detuningrepump)
+    IndicesDR, FreqsDR = FindDRFrequencies(Freq, Fluo, ResonanciasTeoricas, entorno=entorno)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums0 = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=0, frecuenciareferenciacriterioasintotico=frefasint)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums1 = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=1, frecuenciareferenciacriterioasintotico=frefasint)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums2, indiceizquierda, indicederecha = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=2, frecuenciareferenciacriterioasintotico=frefasint, getindices=True)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums3 = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=3, frecuenciareferenciacriterioasintotico=frefasint)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums4 = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=4, frecuenciareferenciacriterioasintotico=frefasint)
+    print('hola')
+    print(RelativeFluorescenceOfMinimums0)
+    return RelativeFluorescenceOfMinimums0, RelativeFluorescenceOfMinimums1, RelativeFluorescenceOfMinimums2, RelativeFluorescenceOfMinimums3, RelativeFluorescenceOfMinimums4, IndicesDR, [indiceizquierda, indicederecha]
+
+
+def GenerateNoisyCPT(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    Frequencyvector, Fluovector = PerformExperiment_8levels(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None)
+    NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, NoisyFluovector
+
+
+def GenerateNoisyCPT_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    Frequencyvector, Fluovector = PerformExperiment_8levels_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None)
+    NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, NoisyFluovector
+
+def GenerateNoisyCPT_fit(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqs, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    Frequencyvector, Fluovector = PerformExperiment_8levels_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, min(freqs), max(freqs) + freqs[1]-freqs[0], freqs[1]-freqs[0], plot=False, solvemode=1, detpvec=None)
+    NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, NoisyFluovector
+
+
+def AddNoiseToCPT(Fluo, noisefactor):
+    return [f+noisefactor*(2*random.random()-1) for f in Fluo]
+
+
+def SmoothNoisyCPT(Fluo, window=11, poly=3):
+    SmoothenFluo = sf(Fluo, window, poly)
+    return SmoothenFluo
+
+
+def GetMinimaInfo(Freq, Fluo, u, titadoppler, detuningdoppler, detuningrepump, MinimumCriterium=2, NormalizationCriterium=1):
+    """
+    FUNCION VIEJA
+
+    Esta funcion devuelve valores de frecuencias y fluorescencia relativa de los minimos.
+    Minimumcriterion:
+        1: Saca los minimos con funcion argelextrema
+        2: Directamente con las frecuencias teoricas busca las fluorescencias
+
+    Normalizationcriterium:
+        1: Devuelve la fluorescencia absoluta de los minimos
+        2: Devuelve el cociente entre la fluorescencia del minimo y un valor medio entre dos puntos lejanos, como si no
+        hubiera una resonancia oscura y hubiera una recta. Ese valor esta a  DistanciaFrecuenciaCociente del detuning del azul (el punto medio entre las dos DR en este caso)
+        3: Devuelve el cociente entre la fluorescencia del minimo y el valor a -100 MHz (si se hizo de -100 a 100),
+        o el valor limite por izquierda de la curva
+
+    """
+    FluorescenceOfMaximum = max(Fluo)
+    FrequencyOfMaximum = Freq[Fluo.index(FluorescenceOfMaximum)]
+
+
+    #criterio para encontrar los minimos
+    #criterio usando minimos de la fluorescencia calculados con la curva
+    if MinimumCriterium == 1:
+        LocationOfMinimums = argrelextrema(np.array(Fluo), np.less)[0]
+        FluorescenceOfMinimums = np.array([Fluo[i] for i in LocationOfMinimums])
+        FrequencyOfMinimums = np.array([Freq[j] for j in LocationOfMinimums])
+
+
+    #criterio con las DR teoricas
+    if MinimumCriterium == 2:
+        FrecuenciasDRTeoricas, FrecuenciasDRTeoricasPositivas = [darkresonance for darkresonance in CalculoTeoricoDarkResonances_8levels(u, titadoppler, detuningdoppler, detuningrepump)[0]]
+        FrequencyOfMinimums = []
+        FluorescenceOfMinimums =[]
+        print(FrecuenciasDRTeoricas)
+        k=0
+
+        ventanita = 0.001
+        while k < len(Freq):
+            if Freq[k] < FrecuenciasDRTeoricas[0] + ventanita and Freq[k] > FrecuenciasDRTeoricas[0] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[1] + ventanita and Freq[k] > FrecuenciasDRTeoricas[1] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[2] + ventanita and Freq[k] > FrecuenciasDRTeoricas[2] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[3] + ventanita and Freq[k] > FrecuenciasDRTeoricas[3] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[4] + ventanita and Freq[k] > FrecuenciasDRTeoricas[4] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[5] + ventanita and Freq[k] > FrecuenciasDRTeoricas[5] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            k = k + 1
+        print(FrequencyOfMinimums)
+        if len(FrequencyOfMinimums) !=  len(FrecuenciasDRTeoricas):
+            print('NO ANDA BIEN ESTO PAPI, revisalo')
+
+
+    #esto es para establecer un criterio para la fluorescencia relativa
+    DistanciaFrecuenciaCociente = 15
+
+    if NormalizationCriterium==1:
+        FluoNormDivisor = 1
+
+    if NormalizationCriterium==2:
+        k = 0
+        while k < len(Freq):
+            if Freq[k] < detuningdoppler-DistanciaFrecuenciaCociente + 2 and Freq[k] > detuningdoppler-DistanciaFrecuenciaCociente - 2:
+                FluoIzquierda = Fluo[k]
+                print('Izq:', Freq[k])
+                break
+            else:
+                k = k + 1
+
+        l = 0
+        while l < len(Freq):
+            if Freq[l] < detuningdoppler+DistanciaFrecuenciaCociente + 2 and Freq[l] > detuningdoppler+DistanciaFrecuenciaCociente - 2:
+                FluoDerecha = Fluo[l]
+                print('Der: ', Freq[l])
+                break
+            else:
+                l = l + 1
+        FluoNormDivisor = 0.5*(FluoDerecha+FluoIzquierda)
+        print(FluoNormDivisor)
+
+    if NormalizationCriterium==3:
+        FluoNormDivisor = Fluo[0]
+
+    RelativeFluorescenceOfMinimums = np.array([Fluore/FluoNormDivisor for Fluore in FluorescenceOfMinimums])
+
+    return FrequencyOfMinimums, RelativeFluorescenceOfMinimums
+
+
+def GetPlotsofFluovsAngle_8levels(FrequencyOfMinimumsVector, RelativeFluorescenceOfMinimumsVector, u, titadoppler, detuningdoppler, detuningrepump, ventana=0.25, taketheoricalDR=False):
+
+    #primero buscamos las frecuencias referencia que se parezcan a las 6:
+    i = 0
+    FrecuenciasReferenciaBase = FrequencyOfMinimumsVector[0]
+
+    FrecuenciasDRTeoricas = [darkresonance for darkresonance in CalculoTeoricoDarkResonances_8levels(u, titadoppler, detuningdoppler, detuningrepump)[0]]
+
+    while i < len(FrequencyOfMinimumsVector):
+        if len(FrequencyOfMinimumsVector[i])==len(FrecuenciasDRTeoricas):
+            FrecuenciasReferenciaBase = FrequencyOfMinimumsVector[i]
+            print('Cool! Taking the DR identified with any curve')
+            break
+        else:
+            i = i + 1
+            if i==len(FrequencyOfMinimumsVector):
+                print('No hay ningun plot con 5 resonancias oscuras. Tomo las teóricas')
+                FrecuenciasReferenciaBase = FrecuenciasDRTeoricas
+
+    if taketheoricalDR:
+        FrecuenciasReferenciaBase = FrecuenciasDRTeoricas
+
+
+
+    Ventana = abs(ventana*(FrecuenciasReferenciaBase[1] - FrecuenciasReferenciaBase[0])) #ventana separadora de resonancias
+
+    print('Ventana = ', Ventana)
+    DarkResonance1Frequency = []
+    DarkResonance1Fluorescence = []
+
+    DarkResonance2Frequency = []
+    DarkResonance2Fluorescence = []
+
+    DarkResonance3Frequency = []
+    DarkResonance3Fluorescence = []
+
+    DarkResonance4Frequency = []
+    DarkResonance4Fluorescence = []
+
+    DarkResonance5Frequency = []
+    DarkResonance5Fluorescence = []
+
+    DarkResonance6Frequency = []
+    DarkResonance6Fluorescence = []
+
+    i = 0
+
+
+    while i < len(FrequencyOfMinimumsVector):
+        j = 0
+        FrecuenciasReferencia = [i for i in FrecuenciasReferenciaBase]
+
+
+        while j < len(FrequencyOfMinimumsVector[i]):
+
+
+            if abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[0])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[0])-Ventana):
+                DarkResonance1Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance1Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[0] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[1])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[1])-Ventana):
+                DarkResonance2Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance2Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[1] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[2])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[2])-Ventana):
+                DarkResonance3Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance3Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[2] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[3])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[3])-Ventana):
+                DarkResonance4Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance4Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[3] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[4])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[4])-Ventana):
+                DarkResonance5Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance5Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[4] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[5])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[5])-Ventana):
+                DarkResonance6Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance6Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[5] = 0
+
+            else:
+                #print('Algo anduvo mal, por ahi tenes que cambiar la ventana che')
+                pass
+            j = j + 1
+
+        if np.count_nonzero(FrecuenciasReferencia) > 0:
+            if FrecuenciasReferencia[0] != 0:
+                DarkResonance1Frequency.append(FrecuenciasReferencia[0])
+                DarkResonance1Fluorescence.append()
+
+            if FrecuenciasReferencia[1] != 0:
+                DarkResonance2Frequency.append(FrecuenciasReferencia[1])
+                DarkResonance2Fluorescence.append(0)
+
+            if FrecuenciasReferencia[2] != 0:
+                DarkResonance3Frequency.append(FrecuenciasReferencia[2])
+                DarkResonance3Fluorescence.append(0)
+
+            if FrecuenciasReferencia[3] != 0:
+                DarkResonance4Frequency.append(FrecuenciasReferencia[3])
+                DarkResonance4Fluorescence.append(0)
+
+            if FrecuenciasReferencia[4] != 0:
+                DarkResonance5Frequency.append(FrecuenciasReferencia[4])
+                DarkResonance5Fluorescence.append(0)
+
+            if FrecuenciasReferencia[5] != 0:
+                DarkResonance6Frequency.append(FrecuenciasReferencia[5])
+                DarkResonance6Fluorescence.append(0)
+
+        i = i + 1
+
+    return DarkResonance1Frequency, DarkResonance1Fluorescence, DarkResonance2Frequency, DarkResonance2Fluorescence, DarkResonance3Frequency, DarkResonance3Fluorescence, DarkResonance4Frequency, DarkResonance4Fluorescence, DarkResonance5Frequency, DarkResonance5Fluorescence, DarkResonance6Frequency, DarkResonance6Fluorescence, FrecuenciasReferenciaBase
+
+
+
+def PerformExperiment_8levels(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None):
+
+    """
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+
+    Fluovectors = []
+
+    for titaprobe in titaprobeVec:
+
+        tinicial = time.time()
+
+        ProbeDetuningVectorL, Fluovector = CPTspectrum8levels(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=False, solvemode=1)
+
+        tfinal = time.time()
+
+        print('Done angle ', titarepump, ' Total time: ', round((tfinal-tinicial), 2), "s")
+
+        if plot:
+            plt.figure()
+            plt.xlabel('Repump detuning (MHz')
+            plt.ylabel('Fluorescence (A.U.)')
+            plt.plot(ProbeDetuningVectorL, Fluovector, label=str(titarepump)+'º tita repump, T: ' + str(T*1e3) + ' mK')
+            plt.legend()
+
+        Fluovectors.append(Fluovector)
+
+        if len(titaprobeVec) == 1: #esto es para que no devuelva un vector de vectores si solo fijamos un angulo
+            Fluovectors = Fluovector
+
+    return ProbeDetuningVectorL, Fluovectors
+
+
+
+def PerformExperiment_8levels_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None):
+
+    """
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+
+    Fluovectors = []
+
+    for titaprobe in titaprobeVec:
+
+        tinicial = time.time()
+
+        ProbeDetuningVectorL, Fluovector = CPTspectrum8levels_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=False, solvemode=1)
+
+        tfinal = time.time()
+
+        print('Done angle ', titarepump, ' Total time: ', round((tfinal-tinicial), 2), "s")
+
+        if plot:
+            plt.figure()
+            plt.xlabel('Repump detuning (MHz')
+            plt.ylabel('Fluorescence (A.U.)')
+            plt.plot(ProbeDetuningVectorL, Fluovector, label=str(titarepump)+'º tita repump, T: ' + str(T*1e3) + ' mK')
+            plt.legend()
+
+        Fluovectors.append(Fluovector)
+
+        if len(titaprobeVec) == 1: #esto es para que no devuelva un vector de vectores si solo fijamos un angulo
+            Fluovectors = Fluovector
+
+    return ProbeDetuningVectorL, Fluovectors

analisis/plots/20250516_CPT_bladetrap/Data/EITfit/lolo_modelo_full_8niveles.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+20 de dic 2023
+
+@author: lolo
+
+reingenieria del código que anda
+
+Surge de fusionar
+Data/EITfit/MM_eightLevel_2repumps_AnalysisFunctions.py
+Data/EITfit/MM_eightLevel_2repumps_python_scripts.py
+
+
+MAPA de FUNCIONES
+
+CPTspectrum8levels_MM
+ |--> FullL_MM => ndarray(64,64,np.complex_)
+       |--> dopplerBroadening => float
+       |--> EffectiveL => ndarray(8,8,np.complex_)
+       |--> H0matrix => ndarray(8,8,np.complex_)
+       |--> HImatrix => ndarray(8,8,np.complex_)
+       |--> CalculateSingleMmatrix => ndarray(64,64,np.complex_)
+       |--> LtempCalculus => ndarray,ndarray
+       |--> GetL1 => ndarray
+
+"""
+
+# pylint: disable=C0301,R0913,R0914,W0621
+
+import time
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.signal import savgol_filter as sf
+
+from  numba import jit,njit
+
+@njit
+def PerformExperiment_8levels_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobe, beta, drivefreq, freqMin, freqMax, freqStep, circularityprobe=1, plot=False, solvemode=1, detpvec=None):
+    """
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+    rta = CPTspectrum8levels_MM(sg, sp, gPS, gPD, DetDoppler, u,
+                                DopplerLaserLinewidth, ProbeLaserLinewidth,
+                                T, alpha, phidoppler, titadoppler, phiprobe,
+                                titaprobe, circularityprobe, beta, drivefreq,
+                                freqMin=freqMin, freqMax=freqMax, freqStep=freqStep,
+                                plot=False, solvemode=1)
+    ProbeDetuningVectorL, Fluovector = rta
+    return ProbeDetuningVectorL, Fluovector
+
+
+def GenerateNoisyCPT_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, kg, kr, v0, drivefreq, freqMin, freqMax, freqStep, circularityprobe=1, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    """
+    Genera un resultado de PerformExperiment_8levels_MM con ruido normal agregado
+    """
+    nFrequencyvector, Fluovector = PerformExperiment_8levels_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, kg, kr, v0, drivefreq, freqMin, freqMax, freqStep, circularityprobe, plot=False, solvemode=1, detpvec=None)
+    NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return nFrequencyvector, NoisyFluovector
+
+def GenerateNoisyCPT_MM_fit(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, beta, drivefreq, freqs, circularityprobe=1, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    """
+    Este no se qué hace
+    """
+    Frequencyvector, Fluovector = PerformExperiment_8levels_MM(sg, sp, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, beta, drivefreq, freqs[0], freqs[-1], freqs[1]-freqs[0], circularityprobe, plot=False, solvemode=1, detpvec=None)
+    #NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, Fluovector
+
+
+def SmoothNoisyCPT(Fluo, window=11, poly=3):
+    SmoothenFluo = sf(Fluo, window, poly)
+    return SmoothenFluo
+
+
+
+#%% Estos son los auxiliares ###################################################
+
+"""
+Esta parte es la del modelo
+"""
+
+@njit
+def make_diag(vec):
+    "Construye matris diagonal desde una lista o vector"
+    return np.eye(len(vec))*np.array(vec).reshape(-1,1)
+
+# @njit
+# def kron(a,b):
+#     "Hago el producto de Kronecker a mano"
+#     return np.vstack( [  np.hstack( [ a[k,j]*b for j in range(a.shape[1]) ] )  for k in range(a.shape[0])])
+
+# @njit
+# def kron(A, B):
+#     cola = A.shape[1]
+#     rowa = A.shape[0]
+#     colb = B.shape[1]
+#     rowb = B.shape[0]
+#
+#     C = [[0] * (cola * colb)  for _ in range(rowa * rowb) ]
+#
+#     for i in range(rowa):
+#         for k in range(cola):
+#             for j in range(rowb):
+#                 for l in range(colb):
+#                     C[i * rowb + k][j * colb + l]  = A[i][j] * B[k][l]
+#     return np.array(C)
+import numba
+
+@jit
+def kron(A,B):
+    out=np.empty((A.shape[0],B.shape[0],A.shape[1],B.shape[1]),dtype=A.dtype)
+    for i in numba.prange(A.shape[0]):
+        for j in range(B.shape[0]):
+            for k in range(A.shape[1]):
+                for l in range(B.shape[1]):
+                    out[i,j,k,l]=A[i,k]*B[j,l]
+    return out
+
+
+@njit
+def H0matrix(Detg, Detp, u):
+    """
+    Calcula la matriz H0 en donde dr es el detuning del doppler, dp es el retuning
+    del repump y u es el campo magnético en Hz/Gauss.
+    Para esto se toma la energía del nivel P como 0
+    """
+
+    eigenEnergies = (Detg-u, Detg+u, -u/3, u/3, Detp-6*u/5,
+                    Detp-2*u/5, Detp+2*u/5, Detp+6*u/5)
+    #pagina 26 de Oberst. los lande del calcio son iguales a Bario.
+    # H0 = np.diag(eigenEnergies)
+    # H0 = np.eye(len(eigenEnergies))*np.array(eigenEnergies).reshape(-1,1)
+    H0 = make_diag(eigenEnergies)
+    return H0
+
+@njit
+def HImatrix(rabG, rabP, phidoppler, titadoppler, phiprobe, titaprobe, circularityprobe=1):
+    """
+    Calcula la matriz de interacción Hsp + Hpd, en donde rabR es la frecuencia de rabi de
+    la transición Doppler SP, rabP es la frecuencia de rabi de la transición repump DP,
+    y las componentes ei_r y ei_p son las componentes de la polarización
+    del campo eléctrico incidente de doppler y repump respectivamente. Deben
+    estar normalizadas a 1
+    """
+    HI = np.zeros((8, 8), dtype=np.complex_)
+
+
+    i, j = 1, 3
+    HI[i-1, j-1] = (rabG/np.sqrt(3)) * np.cos(titadoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 1, 4
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.sin(titadoppler)*np.exp(1j*phidoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 2, 3
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.sin(titadoppler)*np.exp(-1j*phidoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 2, 4
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.cos(titadoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 3, 5
+    HI[i-1, j-1] = -(rabP/2) * np.sin(titaprobe)*(np.cos(phiprobe)-1j*np.sin(phiprobe)*circularityprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 3, 6
+    HI[i-1, j-1] = -(rabP/np.sqrt(3)) * np.cos(titaprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 3, 7
+    HI[i-1, j-1] = rabP/np.sqrt(12) * np.sin(titaprobe)*(np.cos(phiprobe)+1j*np.sin(phiprobe)*circularityprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+
+    i, j = 4, 6
+    HI[i-1, j-1] = -(rabP/np.sqrt(12)) * np.sin(titaprobe)*(np.cos(phiprobe)-1j*np.sin(phiprobe)*circularityprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 4, 7
+    HI[i-1, j-1] = -(rabP/np.sqrt(3)) * np.cos(titaprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+    i, j = 4, 8
+    HI[i-1, j-1] = (rabP/2) * np.sin(titaprobe)*(np.cos(phiprobe)+1j*np.sin(phiprobe)*circularityprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+
+
+    return HI
+
+# @jit
+# def LtempCalculus(beta:float, drivefreq:float, forma=1):
+#     Hint = np.zeros((8, 8), dtype=np.complex_)
+
+#     ampg=beta*drivefreq
+#     ampr=beta*drivefreq*(397/866)
+#     Hint[0,0] = ampg
+#     Hint[1,1] = ampg
+#     Hint[4,4] = ampr
+#     Hint[5,5] = ampr
+#     Hint[6,6] = ampr
+#     Hint[7,7] = ampr
+
+#     if forma==1:
+#         Ltemp = np.zeros((64, 64), dtype=np.complex_)
+
+#         for r in range(8):
+#             for q in range(8):
+#                 if r!=q:
+#                     Ltemp[r*8+q][r*8+q] = (-1j)*(Hint[r,r] - Hint[q,q])
+
+#     if forma==2:
+#         # deltaKro = np.diag([1, 1, 1, 1, 1, 1, 1, 1])
+#         deltaKro = make_diag([1., 1., 1., 1., 1., 1., 1., 1.]).astype(np.complex_)
+#         # Ltemp = (-1j)*(np.kron(Hint, deltaKro) - np.kron(deltaKro, Hint))
+#         Ltemp = (-1j)*(kron(Hint, deltaKro) - kron(deltaKro, Hint))
+
+#     Omega = np.zeros((64, 64), dtype=np.complex_)
+
+#     for i in range(64):
+#         Omega[i, i] = (1j)*drivefreq
+
+#     return Ltemp, Omega
+
+@njit
+def LtempCalculus(beta:float, drivefreq:float, forma=1):
+    Hint = np.zeros((8, 8), dtype=np.complex_)
+
+    ampg=beta*drivefreq
+    ampr=beta*drivefreq*(397/866)
+    Hint[0,0] = ampg
+    Hint[1,1] = ampg
+    Hint[4,4] = ampr
+    Hint[5,5] = ampr
+    Hint[6,6] = ampr
+    Hint[7,7] = ampr
+
+    Ltemp = np.zeros((64, 64), dtype=np.complex_)
+
+    for r in range(8):
+        for q in range(8):
+            if r!=q:
+                Ltemp[r*8+q][r*8+q] = (-1j)*(Hint[r,r] - Hint[q,q])
+
+    Omega = np.zeros((64, 64), dtype=np.complex_)
+
+    for i in range(64):
+        Omega[i, i] = (1j)*drivefreq
+
+    return Ltemp, Omega
+
+# LtempCalculus(0,1)
+# raise ValueError('aaa')
+
+
+
+
+
+
+@njit
+def GetL1(Ltemp, L0, Omega, nmax):
+    """
+    Devuelve Splus0 y Sminus0
+    """
+
+    # Sp = (-1)*(np.matrix(np.linalg.inv(L0 - (nmax+1)*Omega))*0.5*np.matrix(Ltemp))
+    # Sm = (-1)*(np.matrix(np.linalg.inv(L0 + (nmax+1)*Omega))*0.5*np.matrix(Ltemp))
+
+    Sp = (-1)*np.linalg.inv(L0 - (nmax+1)*Omega).dot(0.5*Ltemp)
+    Sm = (-1)*np.linalg.inv(L0 + (nmax+1)*Omega).dot(0.5*Ltemp)
+
+    for n in list(range(nmax+1))[(nmax+1)::-1][0:len(list(range(nmax+1))[(nmax+1)::-1])-1]: #jaja esto solo es para que vaya de nmax a 1 bajando. debe haber algo mas facil pero kcio
+        # Sp = (-1)*(np.matrix(np.linalg.inv(L0 - n*Omega + (0.5*Ltemp*np.matrix(Sp))))*0.5*np.matrix(Ltemp))
+        # Sm = (-1)*(np.matrix(np.linalg.inv(L0 + n*Omega + (0.5*Ltemp*np.matrix(Sm))))*0.5*np.matrix(Ltemp))
+
+        Sp = (-1)*np.linalg.inv(L0 - n*Omega + (0.5*Ltemp.dot(Sp))).dot(0.5*Ltemp)
+        Sm = (-1)*np.linalg.inv(L0 + n*Omega + (0.5*Ltemp.dot(Sm))).dot(0.5*Ltemp)
+
+    # L1 = 0.5*np.matrix(Ltemp)*(np.matrix(Sp) + np.matrix(Sm))
+    L1 = 0.5*Ltemp.dot(Sp + Sm)
+
+    return L1
+
+@njit
+def EffectiveL(gPS, gPD, lwg, lwp):
+
+    """
+    Siendo Heff = H + EffectiveL, calcula dicho EffectiveL que es (-0.5j)*sumatoria(CmDaga*Cm) que luego sirve para calcular el Liouvilliano
+    """
+    Leff = np.zeros((8, 8), dtype=np.complex_)
+
+    Leff[0, 0] = 2*lwg
+    Leff[1, 1] = 2*lwg
+    Leff[2, 2] = ((2/3)+(1/3))*gPS + ((1/2) + (1/6) + (1/3))*gPD
+    Leff[3, 3] = ((2/3)+(1/3))*gPS + ((1/2) + (1/6) + (1/3))*gPD
+    Leff[4, 4] = 2*lwp
+    Leff[5, 5] = 2*lwp
+    Leff[6, 6] = 2*lwp
+    Leff[7, 7] = 2*lwp
+
+    return (-0.5j)*Leff
+
+@njit
+def CalculateSingleMmatrix(gPS, gPD, lwg, lwp):
+    """
+    Si tomamos el Liuvilliano como L = (-j)*(Heff*deltak - Heffdaga*deltak) + sum(Mm),
+    esta funcion calcula dichos Mm, que tienen dimensión 64x64 ya que esa es la dimensión del L. Estas componentes
+    salen de hacer la cuenta a mano conociendo los Cm y considerando que Mm[8*(r-1)+s, 8*(k-1)+j] = Cm[r,l] + Cmdaga[j,s] = Cm[r,l] + Cm[s,j]
+    ya que los componentes de Cm son reales.
+    Esta M es la suma de las 8 matrices M.
+
+    """
+
+    M = np.zeros((64, 64), dtype=np.complex_)
+
+    M[0,27] = (2/3)*gPS
+
+    M[9,18] = (2/3)*gPS
+
+    M[0,18] = (1/3)*gPS
+    M[1,19] = -(1/3)*gPS
+    M[8,26] = -(1/3)*gPS
+    M[9,27] = (1/3)*gPS
+
+    M[36,18] = (1/2)*gPD
+    M[37,19] = (1/np.sqrt(12))*gPD
+    M[44,26] = (1/np.sqrt(12))*gPD
+    M[45,27] = (1/6)*gPD
+
+    M[54,18] = (1/6)*gPD
+    M[55,19] = (1/np.sqrt(12))*gPD
+    M[62,26] = (1/np.sqrt(12))*gPD
+    M[63,27] = (1/2)*gPD
+
+    M[45,18] = (1/3)*gPD
+    M[46,19] = (1/3)*gPD
+    M[53,26] = (1/3)*gPD
+    M[54,27] = (1/3)*gPD
+
+    M[0,0] = 2*lwg
+    M[1,1] = 2*lwg
+    M[8,8] = 2*lwg
+    M[9,9] = 2*lwg
+
+    for k in [36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63]:
+        M[k,k]=2*lwp
+
+    return M
+
+@njit
+def dopplerBroadening(wlg, wlp, alpha, T, mcalcio = 6.655e-23*1e-3):
+    """
+    Calcula el broadening extra semiclásico por temperatura considerando que el ion atrapado se mueve.
+    wlg es la longitud de onda doppler, wlp la longitud de onda repump, T la temperatura del ion en kelvin, y alpha (en rads) el ángulo
+    que forman ambos láseres.
+    """
+
+    kboltzmann = 1.38e-23 #J/K
+
+    gammaD = (2*np.pi)*np.sqrt((1/(wlg*wlg)) + (1/(wlp*wlp)) - 2*(1/(wlg*wlp))*np.cos(alpha))*np.sqrt(kboltzmann*T/(1*mcalcio))
+
+    return gammaD
+
+@njit
+def FullL_MM(rabG, rabP, gPS = 0, gPD = 0, Detg = 0, Detp = 0, u = 0, lwg = 0, lwp = 0,
+          phidoppler=0, titadoppler=0, phiprobe=0, titaprobe=0, beta=0,
+          drivefreq=2*np.pi*22.135*1e6, T = 0, alpha = 0, circularityprobe=1):
+
+    """
+    Calcula el Liouvilliano total de manera explícita índice a índice. Suma aparte las componentes de las matrices M.
+    Es la más eficiente hasta ahora.
+    """
+
+
+    db = dopplerBroadening(0.397e-6, 0.866e-6, alpha, T)
+
+    lwg = np.sqrt(lwg**2 + (0.83*db)**2)
+    lwp = np.sqrt(lwp**2 + (0.17*db)**2)
+
+    CC = EffectiveL(gPS, gPD, lwg, lwp)
+
+    Heff = H0matrix(Detg, Detp, u) + HImatrix(rabG, rabP, phidoppler, titadoppler, phiprobe, titaprobe, circularityprobe) + CC
+
+    # Heffdaga = np.matrix(Heff).getH()
+    Heffdaga = np.conj(np.transpose(Heff))
+
+    Lfullpartial = np.zeros((64, 64), dtype=np.complex_)
+
+    for r  in range(8):
+        for q in range(8):
+            for k in range(8):
+                for j in range(8):
+                    if j!=q and r!=k:
+                        pass
+                    elif j==q and r!=k:
+                        if (r < 2 and k > 3) or (k < 2 and r > 3) or (r > 3 and k > 3) or (r==0 and k==1) or (r==1 and k==0) or (r==2 and k==3) or (r==3 and k==2):
+                            #todo esto sale de analizar explicitamente la matriz y tratar de no calcular cosas de más que dan cero
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(Heff[r,k])
+                    elif j!=q and r==k:
+                        if (j < 2 and q > 3) or (q < 2 and j > 3) or (j > 3 and q > 3) or (j==0 and q==1) or (j==1 and q==0) or (j==2 and q==3) or (j==3 and q==2):
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(-Heffdaga[j,q])
+                    else:
+                        if Heff[r,k] == Heffdaga[j,q]:
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(Heff[r,k]-Heffdaga[j,q])
+
+    M = CalculateSingleMmatrix(gPS, gPD, lwg, lwp)
+    # L0 = np.array(np.matrix(Lfullpartial) + M)
+    L0 = Lfullpartial + M
+
+    #ESTA PARTE ES CUANDO AGREGAS MICROMOCION
+    nmax = 3
+
+    #print(nmax)
+    Ltemp, Omega = LtempCalculus(beta, drivefreq)
+    #print(factor)
+    L1 = GetL1(Ltemp, L0, Omega, nmax)
+    Lfull = L0 + L1 #ESA CORRECCION ESTA EN L1
+    #HASTA ACA
+
+    #NORMALIZACION DE RHO
+    i = 0
+    while i < 64:
+        if i%9 == 0:
+            Lfull[0, i] = 1
+        else:
+            Lfull[0, i] = 0
+        i = i + 1
+
+    return Lfull
+
+
+"""
+Scripts para correr un experimento y hacer el análisis de los datos
+"""
+
+@njit
+def CPTspectrum8levels_MM(sg, sp, gPS, gPD, Detg, u, lwg, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, Circularityprobe, beta, drivefreq, freqMin=-100, freqMax=100, freqStep=1e-1, plot=False, solvemode=1):
+
+    """
+    ESTA ES LA FUNCION QUE ESTAMOS USANDO
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+    phidoppler, titadoppler = phidoppler*(np.pi/180), titadoppler*(np.pi/180)
+    phiprobe, titaprobe = phiprobe*(np.pi/180), titaprobe*(np.pi/180)
+
+    DetProbeVector = 2*np.pi*np.arange(freqMin*1e6, freqMax*1e6+0*freqStep*1e6, freqStep*1e6)
+    Detg = 2*np.pi*Detg*1e6
+    #lwg, lwr, lwp = 2*np.pi*lwg*1e6, 2*np.pi*lwr*1e6, 2*np.pi*lwp*1e6
+    lwg, lwp = lwg*1e6, lwp*1e6
+
+    rabG = sg*gPS
+    rabP = sp*gPD
+    #u = 2*np.pi*u*1e6
+
+    Fluovector = []
+
+    # tinicial = time.time()
+
+    for Detp in DetProbeVector:
+        L = FullL_MM(rabG, rabP, gPS, gPD, Detg, Detp, u, lwg, lwp, phidoppler, titadoppler, phiprobe, titaprobe, beta, drivefreq, Temp, alpha, Circularityprobe)
+        # if solvemode == 1:
+        rhovectorized = np.linalg.solve(L, np.array([int(i==0) for i in range(64)],dtype=np.complex_))
+        Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27]))
+        Fluovector.append(Fluo)
+
+        # if solvemode == 2:
+        #     Linv = np.linalg.inv(L)
+        #     rhovectorized = [Linv[j][0] for j in range(len(Linv))]
+        #     Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+        #     Fluovector.append(Fluo)
+
+    # tfinal = time.time()
+
+    # print('Done, Total time: ', round((tfinal-tinicial), 2), "s")
+
+    DetProbeVectorMHz = np.arange(freqMin, freqMax, freqStep)
+
+    # if plot:
+    #     plt.xlabel('Probe detuning (MHz)')
+    #     plt.ylabel('Fluorescence (A.U.)')
+    #     plt.plot(DetProbeVectorMHz, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+    #     plt.legend()
+
+    return DetProbeVectorMHz, Fluovector
+
+
+# @njit
+# def lolo():
+#     L = FullL_MM(100,200,12,123,14)
+#     return np.linalg.solve(L, np.array([int(i==0) for i in range(64)],dtype=np.complex_))
+
+# lolo()
+
+# raise ValueError('áaa')
+
+#%%
+if __name__ == "__main__":
+    ub = 9.27e-24
+    h = 6.63e-34
+    c = (ub/h)*1e-4 #en unidades de MHz/G
+
+    B = 25 #campo magnetico en gauss
+
+    u = c*B
+
+
+    sg, sr, sp = 0.5, 1.5, 4 #parámetros de saturación del doppler y repump
+    gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6 #anchos de linea de las transiciones
+    rabG, rabR, rabP = sg*gPS, sr*gPD, sp*gPD #frecuencias de rabi
+
+    lwg, lwr, lwp = 0.3, 0.3, 0.3 #ancho de linea de los laseres
+
+    Detg = -25
+    Detr = 20 #detuning del doppler y repump
+
+    Temp = 0.0e-3 #temperatura en K
+    alpha = 0*(np.pi/180) #angulo entre los láseres
+
+    phidoppler, titadoppler = 0, 90
+    phirepump, titarepump = 0, 90
+
+    phiprobe, titaprobe = 0, 90
+
+
+    plotCPT = False
+
+    freqMin = -50
+    freqMax = 50
+    freqStep = 5e-2
+
+    # Frequencyvector, Fluovector = CPTspectrum8levels_MM(rabG, rabR, rabP, gPS, gPD, Detg, Detr,   u,  lwg,   lwr,        lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe,    phirepump, titarepump,             freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=plotCPT, solvemode=1)
+    Frequencyvector, Fluovector = PerformExperiment_8levels_MM(0.9,6.2,135591138.92893547,8482300.164692441,-24.5,32500000.0,0.1,0.1,0.001,0,0,90,0,90,2.0,139078306.77442014,-54.39999999999998,26.26666666666671,0.6666666666666856,circularityprobe=1,plot=False,solvemode=1,detpvec=None)
+
+
+    plt.plot(Frequencyvector, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+    plt.xlabel('Probe detuning (MHz)')
+    plt.ylabel('Fluorescence (A.U.)')

analisis/plots/20250516_CPT_bladetrap/Data/EITfit/threeLevel_2repumps_AnalysisFunctions.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jul  2 16:30:09 2020
+
+@author: oem
+"""
+
+
+import os
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from scipy.signal import argrelextrema
+from EITfit.threeLevel_2repumps_linealpol_python_scripts import CPTspectrum8levels, CPTspectrum8levels_fixedRabi
+import random
+from scipy.signal import savgol_filter as sf
+
+
+def CalculoTeoricoDarkResonances_8levels(u, titadoppler, detuningdoppler, detuningrepump):
+    
+    if titadoppler==0:
+        NegativeDR = [(-7/5)*u, (-3/5)*u, (-1/5)*u, (1/5)*u, (3/5)*u, (7/5)*u]
+    elif titadoppler==90:
+        NegativeDR = [(-11/5)*u, (-7/5)*u, (-3/5)*u, (3/5)*u, (7/5)*u, (11/5)*u]
+    else:
+        NegativeDR = [(-11/5)*u, (-7/5)*u, (-3/5)*u, (-1/5)*u, (1/5)*u, (3/5)*u, (7/5)*u, (11/5)*u]
+    
+    PositiveDR = [(-8/5)*u, (-4/5)*u, 0, (4/5)*u, (8/5)*u]
+    
+    return [detuningdoppler + dr for dr in NegativeDR], [detuningrepump + dr for dr in PositiveDR]
+
+
+def GetClosestIndex(Vector, value, tolerance=1e-3):
+
+    i = 0
+    while i<len(Vector):
+        if abs(Vector[i] - value) < tolerance:
+            return i
+        else:
+            i = i + 1
+    return GetClosestIndex(Vector, value, tolerance=2*tolerance)
+    
+
+def FindDRFrequencies(Freq, Fluo, TeoDR, entorno=3):
+    """
+    Busca los indices y la frecuencia de los minimos en un entorno cercano al de la DR.
+    Si no encuentra, devuelve el valor teórico.
+    """
+    
+    IndiceDRteo1, IndiceEntornoinicialDRteo1, IndiceEntornofinalDRteo1 = GetClosestIndex(Freq, TeoDR[0]), GetClosestIndex(Freq, TeoDR[0]-entorno), GetClosestIndex(Freq, TeoDR[0]+entorno)
+    IndiceDRteo2, IndiceEntornoinicialDRteo2, IndiceEntornofinalDRteo2 = GetClosestIndex(Freq, TeoDR[1]), GetClosestIndex(Freq, TeoDR[1]-entorno), GetClosestIndex(Freq, TeoDR[1]+entorno)
+    IndiceDRteo3, IndiceEntornoinicialDRteo3, IndiceEntornofinalDRteo3 = GetClosestIndex(Freq, TeoDR[2]), GetClosestIndex(Freq, TeoDR[2]-entorno), GetClosestIndex(Freq, TeoDR[2]+entorno)
+    IndiceDRteo4, IndiceEntornoinicialDRteo4, IndiceEntornofinalDRteo4 = GetClosestIndex(Freq, TeoDR[3]), GetClosestIndex(Freq, TeoDR[3]-entorno), GetClosestIndex(Freq, TeoDR[3]+entorno)
+    IndiceDRteo5, IndiceEntornoinicialDRteo5, IndiceEntornofinalDRteo5 = GetClosestIndex(Freq, TeoDR[4]), GetClosestIndex(Freq, TeoDR[4]-entorno), GetClosestIndex(Freq, TeoDR[4]+entorno)
+    IndiceDRteo6, IndiceEntornoinicialDRteo6, IndiceEntornofinalDRteo6 = GetClosestIndex(Freq, TeoDR[5]), GetClosestIndex(Freq, TeoDR[5]-entorno), GetClosestIndex(Freq, TeoDR[5]+entorno)
+
+    EntornoFreqDR1, EntornoFreqDR2 = Freq[IndiceEntornoinicialDRteo1:IndiceEntornofinalDRteo1], Freq[IndiceEntornoinicialDRteo2:IndiceEntornofinalDRteo2]
+    EntornoFreqDR3, EntornoFreqDR4 = Freq[IndiceEntornoinicialDRteo3:IndiceEntornofinalDRteo3], Freq[IndiceEntornoinicialDRteo4:IndiceEntornofinalDRteo4]
+    EntornoFreqDR5, EntornoFreqDR6 = Freq[IndiceEntornoinicialDRteo5:IndiceEntornofinalDRteo5], Freq[IndiceEntornoinicialDRteo6:IndiceEntornofinalDRteo6]
+
+    EntornoFluoDR1, EntornoFluoDR2 = Fluo[IndiceEntornoinicialDRteo1:IndiceEntornofinalDRteo1], Fluo[IndiceEntornoinicialDRteo2:IndiceEntornofinalDRteo2]
+    EntornoFluoDR3, EntornoFluoDR4 = Fluo[IndiceEntornoinicialDRteo3:IndiceEntornofinalDRteo3], Fluo[IndiceEntornoinicialDRteo4:IndiceEntornofinalDRteo4]
+    EntornoFluoDR5, EntornoFluoDR6 = Fluo[IndiceEntornoinicialDRteo5:IndiceEntornofinalDRteo5], Fluo[IndiceEntornoinicialDRteo6:IndiceEntornofinalDRteo6]
+    
+    IndiceFluoMinimaEntorno1, IndiceFluoMinimaEntorno2 = argrelextrema(np.array(EntornoFluoDR1), np.less)[0], argrelextrema(np.array(EntornoFluoDR2), np.less)[0]
+    IndiceFluoMinimaEntorno3, IndiceFluoMinimaEntorno4 = argrelextrema(np.array(EntornoFluoDR3), np.less)[0], argrelextrema(np.array(EntornoFluoDR4), np.less)[0]
+    IndiceFluoMinimaEntorno5, IndiceFluoMinimaEntorno6 = argrelextrema(np.array(EntornoFluoDR5), np.less)[0], argrelextrema(np.array(EntornoFluoDR6), np.less)[0]
+        
+    try:
+        FreqDR1 = EntornoFreqDR1[int(IndiceFluoMinimaEntorno1)]
+        IndiceDR1 = GetClosestIndex(Freq, FreqDR1)
+    except:
+        FreqDR1 = TeoDR[0]
+        IndiceDR1 = IndiceDRteo1
+    try:
+        FreqDR2 = EntornoFreqDR2[int(IndiceFluoMinimaEntorno2)]
+        IndiceDR2 = GetClosestIndex(Freq, FreqDR2)
+    except:
+        FreqDR2 = TeoDR[1]
+        IndiceDR2 = IndiceDRteo2
+    try:
+        FreqDR3 = EntornoFreqDR3[int(IndiceFluoMinimaEntorno3)]
+        IndiceDR3 = GetClosestIndex(Freq, FreqDR3)
+    except:
+        FreqDR3 = TeoDR[2]
+        IndiceDR3 = IndiceDRteo3
+    try:
+        FreqDR4 = EntornoFreqDR4[int(IndiceFluoMinimaEntorno4)]
+        IndiceDR4 = GetClosestIndex(Freq, FreqDR4)
+    except:
+        FreqDR4 = TeoDR[3]
+        IndiceDR4 = IndiceDRteo4
+    try:
+        FreqDR5 = EntornoFreqDR5[int(IndiceFluoMinimaEntorno5)]
+        IndiceDR5 = GetClosestIndex(Freq, FreqDR5)
+    except:
+        FreqDR5 = TeoDR[4]
+        IndiceDR5 = IndiceDRteo5
+    try:
+        FreqDR6 = EntornoFreqDR6[int(IndiceFluoMinimaEntorno6)]
+        IndiceDR6 = GetClosestIndex(Freq, FreqDR6)
+    except:
+        FreqDR6 = TeoDR[5]
+        IndiceDR6 = IndiceDRteo6
+                
+    return [IndiceDR1, IndiceDR2, IndiceDR3, IndiceDR4, IndiceDR5, IndiceDR6], [FreqDR1, FreqDR2, FreqDR3, FreqDR4, FreqDR5, FreqDR6]
+
+
+def FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=1, frecuenciareferenciacriterioasintotico=-100, getindices=False):
+    """
+    Toma los indices donde estan las DR y evalua su fluorescencia. Esos indices son minimos locales en un entorno
+    cercano a las DR teoricas y, si no hay ningun minimo, toma la teorica.
+    Luego, hace el cociente de esa fluorescencia y un factor de normalización segun NormalizationCriterium:
+        1: Devuelve la fluorescencia absoluta de los minimos
+        2: Devuelve el cociente entre la fluorescencia del minimo y un valor medio entre dos puntos lejanos, como si no 
+        hubiera una resonancia oscura y hubiera una recta. Ese valor esta a  DistanciaFrecuenciaCociente del detuning del azul (el punto medio entre las dos DR en este caso)
+        3: Devuelve el cociente entre la fluorescencia del minimo y el valor a -100 MHz (si se hizo de -100 a 100),
+        o el valor limite por izquierda de la curva
+        4: Deuelve el cociente entre la fluorescencia del minimo y el valor de fluorescencia a detuning 0 MHz        
+    
+    """
+    IndiceDR1, IndiceDR2, IndiceDR3, IndiceDR4, IndiceDR5, IndiceDR6 = IndicesDR[0], IndicesDR[1], IndicesDR[2], IndicesDR[3], IndicesDR[4], IndicesDR[5]
+    FluorescenceOfMinimums = [Fluo[IndiceDR1], Fluo[IndiceDR2], Fluo[IndiceDR3], Fluo[IndiceDR4], Fluo[IndiceDR5], Fluo[IndiceDR6]]
+    FrequencyOfMinimums = [Freq[IndiceDR1], Freq[IndiceDR2], Freq[IndiceDR3], Freq[IndiceDR4], Freq[IndiceDR5], Freq[IndiceDR6]]
+    DistanciaFrecuenciaCociente = 25
+
+    if NormalizationCriterium==0:
+        print('che')
+        return FrequencyOfMinimums, FluorescenceOfMinimums
+    
+    if NormalizationCriterium==1:      
+        Fluorescenciacerodetuning = Fluo[GetClosestIndex(Freq, 0)]
+        Fluorescenciaasintotica = Fluo[GetClosestIndex(Freq, frecuenciareferenciacriterioasintotico)]
+        return FrequencyOfMinimums, np.array([Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica, Fluorescenciacerodetuning/Fluorescenciaasintotica])
+        
+    if NormalizationCriterium==2:
+        k = 0
+        while k < len(Freq):
+            if Freq[k] < detuningdoppler-DistanciaFrecuenciaCociente + 2 and Freq[k] > detuningdoppler-DistanciaFrecuenciaCociente - 2:
+                FluoIzquierda = Fluo[k]
+                indiceizquierda = k
+                print('Izq:', Freq[k])
+                break
+            else:
+                k = k + 1
+        
+        l = 0
+        while l < len(Freq):
+            if Freq[l] < detuningdoppler+DistanciaFrecuenciaCociente + 2 and Freq[l] > detuningdoppler+DistanciaFrecuenciaCociente - 2:
+                FluoDerecha = Fluo[l]
+                indicederecha = l
+                print('Der: ', Freq[l])
+                break
+            else:
+                l = l + 1
+        FluoNormDivisor = 0.5*(FluoDerecha+FluoIzquierda)
+        print(FluoNormDivisor)
+    
+    if NormalizationCriterium==3:
+        #asintotico
+        FluoNormDivisor = Fluo[GetClosestIndex(Freq, frecuenciareferenciacriterioasintotico)]
+
+    if NormalizationCriterium==4:
+        #este te tira la fluorescencia de detuning 0
+        FluoNormDivisor = Fluo[GetClosestIndex(Freq, 0)]
+
+   
+    RelativeFluorescenceOfMinimums = np.array([Fluore/FluoNormDivisor for Fluore in FluorescenceOfMinimums])
+    print('Esto: ', RelativeFluorescenceOfMinimums)
+
+    if NormalizationCriterium==2 and getindices==True:
+        return FrequencyOfMinimums, RelativeFluorescenceOfMinimums, indiceizquierda, indicederecha
+    
+    return FrequencyOfMinimums, RelativeFluorescenceOfMinimums
+
+
+def GetFinalMaps(MapasDR1, MapasDR2, MapasDR3, MapasDR4, MapasDR5, MapasDR6):
+    """
+    Nota: esto vale para polarizacion del 397 sigma+ + sigma-. Sino hay que cambiar los coeficientes.
+    La estructura es:
+        MapasDRi = [MapaMedido_criterio1_DRi, MapaMedido_criterio2_DRi, MapaMedido_criterio3_DRi, MapaMedido_criterio4_DRi]
+    """
+    Mapa1 = MapasDR1[0]
+    
+    Mapa2pi = np.sqrt(3)*(MapasDR2[1] + MapasDR5[1])
+    Mapa2smas = np.sqrt(12/2)*MapasDR3[1] + (2/np.sqrt(2))*MapasDR6[1]
+    Mapa2smenos = (2/np.sqrt(2))*MapasDR1[1] + np.sqrt(12/2)*MapasDR4[1]
+    
+    Mapa3pi = np.sqrt(3)*(MapasDR2[2] + MapasDR5[2])
+    Mapa3smas = np.sqrt(12/2)*MapasDR3[2] + (2/np.sqrt(2))*MapasDR6[2]
+    Mapa3smenos = (2/np.sqrt(2))*MapasDR1[2] + np.sqrt(12/2)*MapasDR4[2]
+        
+    return Mapa1, [Mapa2pi, Mapa2smas, Mapa2smenos], [Mapa3pi, Mapa3smas, Mapa3smenos]
+
+
+def CombinateDRwithCG(RelMinMedido1, RelMinMedido2, RelMinMedido3, RelMinMedido4):
+    Fluo1 = RelMinMedido1[0]
+    
+    Fluo2pi = np.sqrt(3)*(RelMinMedido2[1] + RelMinMedido2[4])
+    Fluo2smas = np.sqrt(12/2)*RelMinMedido2[2] + (2/np.sqrt(2))*RelMinMedido2[5]
+    Fluo2smenos = (2/np.sqrt(2))*RelMinMedido2[0] + np.sqrt(12/2)*RelMinMedido2[3]
+    
+    Fluo3pi = np.sqrt(3)*(RelMinMedido3[1] + RelMinMedido3[4])
+    Fluo3smas = np.sqrt(12/2)*RelMinMedido3[2] + (2/np.sqrt(2))*RelMinMedido3[5]
+    Fluo3smenos = (2/np.sqrt(2))*RelMinMedido3[0] + np.sqrt(12/2)*RelMinMedido3[3]
+    
+    return Fluo1, [Fluo2pi, Fluo2smas, Fluo2smenos], [Fluo3pi, Fluo3smas, Fluo3smenos]
+
+
+
+def IdentifyPolarizationCoincidences(theoricalmap, target, tolerance=1e-1):
+    """
+    Busca en un mapa 2D la presencia de un valor target (medido) con tolerancia tolerance.
+    Si lo encuentra, pone un 1. Sino, un 0. Al plotear con pcolor se verá
+    en blanco la zona donde el valor medido se puede hallar.
+    """
+    CoincidenceMatrix = np.zeros((len(theoricalmap), len(theoricalmap[0])))
+    
+    i = 0
+    while i<len(theoricalmap):
+        j = 0
+        while j<len(theoricalmap[0]):
+            if abs(theoricalmap[i][j]-target) < tolerance:
+                CoincidenceMatrix[i][j] = 1
+            j=j+1
+        i=i+1
+    return CoincidenceMatrix
+
+def RetrieveAbsoluteCoincidencesBetweenMaps(MapsVectors):
+    
+    MatrixSum = np.zeros((len(MapsVectors[0]), len(MapsVectors[0][0])))
+    AbsoluteCoincidencesMatrix = np.zeros((len(MapsVectors[0]), len(MapsVectors[0][0])))
+
+    
+    MatrixMapsVectors = []
+    
+    for i in range(len(MapsVectors)):
+        MatrixMapsVectors.append(np.matrix(MapsVectors[i]))
+
+    for i in range(len(MatrixMapsVectors)):
+        MatrixSum = MatrixSum + MatrixMapsVectors[i]
+        
+    MaxNumberOfCoincidences = np.max(MatrixSum)
+    
+    ListMatrixSum = [list(i) for i in list(np.array(MatrixSum))]
+    
+    for i in range(len(ListMatrixSum)):
+        for j in range(len(ListMatrixSum[0])):
+            if ListMatrixSum[i][j] == MaxNumberOfCoincidences:
+                AbsoluteCoincidencesMatrix[i][j] = 1
+    
+    return AbsoluteCoincidencesMatrix, MaxNumberOfCoincidences
+
+
+def MeasureMeanValueOfEstimatedArea(AbsoluteCoincidencesMap, X, Y):
+    NonZeroIndices = np.nonzero(AbsoluteCoincidencesMap)
+    
+    Xsum = 0
+    Xvec = []
+    Ysum = 0
+    Yvec = []
+    N = len(NonZeroIndices[0])
+    for i in range(N):
+        Xsum = Xsum + X[NonZeroIndices[1][i]]
+        Xvec.append(X[NonZeroIndices[1][i]])
+        Ysum = Ysum + Y[NonZeroIndices[0][i]]
+        Yvec.append(Y[NonZeroIndices[0][i]])
+    Xaverage = Xsum/N
+    Yaverage = Ysum/N
+    Xspread = np.std(Xvec)
+    Yspread = np.std(Yvec)
+    return Xaverage, Yaverage, N, Xspread, Yspread
+    
+
+def MeasureRelativeFluorescenceFromCPT(Freq, Fluo, u, titadoppler, detuningrepump, detuningdoppler, frefasint=-100, entorno=3):
+    ResonanciasTeoricas, ResonanciasPositivas = CalculoTeoricoDarkResonances_8levels(u, titadoppler, detuningdoppler, detuningrepump)
+    IndicesDR, FreqsDR = FindDRFrequencies(Freq, Fluo, ResonanciasTeoricas, entorno=entorno)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums0 = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=0, frecuenciareferenciacriterioasintotico=frefasint)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums1 = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=1, frecuenciareferenciacriterioasintotico=frefasint)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums2, indiceizquierda, indicederecha = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=2, frecuenciareferenciacriterioasintotico=frefasint, getindices=True)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums3 = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=3, frecuenciareferenciacriterioasintotico=frefasint)
+    FrequencyOfMinimums, RelativeFluorescenceOfMinimums4 = FindRelativeFluorescencesOfDR(Freq, Fluo, IndicesDR, detuningdoppler, NormalizationCriterium=4, frecuenciareferenciacriterioasintotico=frefasint)
+    print('hola')
+    print(RelativeFluorescenceOfMinimums0)
+    return RelativeFluorescenceOfMinimums0, RelativeFluorescenceOfMinimums1, RelativeFluorescenceOfMinimums2, RelativeFluorescenceOfMinimums3, RelativeFluorescenceOfMinimums4, IndicesDR, [indiceizquierda, indicederecha]
+
+
+def GenerateNoisyCPT(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    Frequencyvector, Fluovector = PerformExperiment_8levels(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None)
+    NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, NoisyFluovector
+
+
+def GenerateNoisyCPT_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    Frequencyvector, Fluovector = PerformExperiment_8levels_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None)
+    NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, NoisyFluovector
+
+def GenerateNoisyCPT_fit(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqs, plot=False, solvemode=1, detpvec=None, noiseamplitude=0.001):
+    Frequencyvector, Fluovector = PerformExperiment_8levels_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, min(freqs), max(freqs) + freqs[1]-freqs[0], freqs[1]-freqs[0], plot=False, solvemode=1, detpvec=None)
+    NoisyFluovector = [fluo+noiseamplitude*(2*random.random()-1) for fluo in Fluovector]
+    return Frequencyvector, NoisyFluovector
+
+
+def AddNoiseToCPT(Fluo, noisefactor):
+    return [f+noisefactor*(2*random.random()-1) for f in Fluo]
+
+
+def SmoothNoisyCPT(Fluo, window=11, poly=3):
+    SmoothenFluo = sf(Fluo, window, poly)
+    return SmoothenFluo
+
+
+def GetMinimaInfo(Freq, Fluo, u, titadoppler, detuningdoppler, detuningrepump, MinimumCriterium=2, NormalizationCriterium=1):
+    """
+    FUNCION VIEJA
+    
+    Esta funcion devuelve valores de frecuencias y fluorescencia relativa de los minimos.
+    Minimumcriterion:
+        1: Saca los minimos con funcion argelextrema
+        2: Directamente con las frecuencias teoricas busca las fluorescencias
+    
+    Normalizationcriterium:
+        1: Devuelve la fluorescencia absoluta de los minimos
+        2: Devuelve el cociente entre la fluorescencia del minimo y un valor medio entre dos puntos lejanos, como si no 
+        hubiera una resonancia oscura y hubiera una recta. Ese valor esta a  DistanciaFrecuenciaCociente del detuning del azul (el punto medio entre las dos DR en este caso)
+        3: Devuelve el cociente entre la fluorescencia del minimo y el valor a -100 MHz (si se hizo de -100 a 100),
+        o el valor limite por izquierda de la curva
+    
+    """
+    FluorescenceOfMaximum = max(Fluo)
+    FrequencyOfMaximum = Freq[Fluo.index(FluorescenceOfMaximum)]
+
+
+    #criterio para encontrar los minimos
+    #criterio usando minimos de la fluorescencia calculados con la curva
+    if MinimumCriterium == 1:
+        LocationOfMinimums = argrelextrema(np.array(Fluo), np.less)[0]
+        FluorescenceOfMinimums = np.array([Fluo[i] for i in LocationOfMinimums])
+        FrequencyOfMinimums = np.array([Freq[j] for j in LocationOfMinimums])
+
+
+    #criterio con las DR teoricas
+    if MinimumCriterium == 2:
+        FrecuenciasDRTeoricas, FrecuenciasDRTeoricasPositivas = [darkresonance for darkresonance in CalculoTeoricoDarkResonances_8levels(u, titadoppler, detuningdoppler, detuningrepump)[0]]
+        FrequencyOfMinimums = []
+        FluorescenceOfMinimums =[]
+        print(FrecuenciasDRTeoricas)
+        k=0
+        
+        ventanita = 0.001
+        while k < len(Freq):
+            if Freq[k] < FrecuenciasDRTeoricas[0] + ventanita and Freq[k] > FrecuenciasDRTeoricas[0] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[1] + ventanita and Freq[k] > FrecuenciasDRTeoricas[1] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[2] + ventanita and Freq[k] > FrecuenciasDRTeoricas[2] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[3] + ventanita and Freq[k] > FrecuenciasDRTeoricas[3] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[4] + ventanita and Freq[k] > FrecuenciasDRTeoricas[4] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            elif Freq[k] < FrecuenciasDRTeoricas[5] + ventanita and Freq[k] > FrecuenciasDRTeoricas[5] - ventanita:
+                FrequencyOfMinimums.append(Freq[k])
+                FluorescenceOfMinimums.append(Fluo[k])
+            k = k + 1
+        print(FrequencyOfMinimums)
+        if len(FrequencyOfMinimums) !=  len(FrecuenciasDRTeoricas):
+            print('NO ANDA BIEN ESTO PAPI, revisalo')
+        
+            
+    #esto es para establecer un criterio para la fluorescencia relativa
+    DistanciaFrecuenciaCociente = 15
+    
+    if NormalizationCriterium==1:      
+        FluoNormDivisor = 1 
+        
+    if NormalizationCriterium==2:
+        k = 0
+        while k < len(Freq):
+            if Freq[k] < detuningdoppler-DistanciaFrecuenciaCociente + 2 and Freq[k] > detuningdoppler-DistanciaFrecuenciaCociente - 2:
+                FluoIzquierda = Fluo[k]
+                print('Izq:', Freq[k])
+                break
+            else:
+                k = k + 1
+        
+        l = 0
+        while l < len(Freq):
+            if Freq[l] < detuningdoppler+DistanciaFrecuenciaCociente + 2 and Freq[l] > detuningdoppler+DistanciaFrecuenciaCociente - 2:
+                FluoDerecha = Fluo[l]
+                print('Der: ', Freq[l])
+                break
+            else:
+                l = l + 1
+        FluoNormDivisor = 0.5*(FluoDerecha+FluoIzquierda)
+        print(FluoNormDivisor)
+    
+    if NormalizationCriterium==3:
+        FluoNormDivisor = Fluo[0]
+    
+    RelativeFluorescenceOfMinimums = np.array([Fluore/FluoNormDivisor for Fluore in FluorescenceOfMinimums])
+    
+    return FrequencyOfMinimums, RelativeFluorescenceOfMinimums
+
+
+def GetPlotsofFluovsAngle_8levels(FrequencyOfMinimumsVector, RelativeFluorescenceOfMinimumsVector, u, titadoppler, detuningdoppler, detuningrepump, ventana=0.25, taketheoricalDR=False):
+    
+    #primero buscamos las frecuencias referencia que se parezcan a las 6:
+    i = 0
+    FrecuenciasReferenciaBase = FrequencyOfMinimumsVector[0]
+    
+    FrecuenciasDRTeoricas = [darkresonance for darkresonance in CalculoTeoricoDarkResonances_8levels(u, titadoppler, detuningdoppler, detuningrepump)[0]]
+    
+    while i < len(FrequencyOfMinimumsVector):
+        if len(FrequencyOfMinimumsVector[i])==len(FrecuenciasDRTeoricas):
+            FrecuenciasReferenciaBase = FrequencyOfMinimumsVector[i]
+            print('Cool! Taking the DR identified with any curve')
+            break
+        else:
+            i = i + 1
+            if i==len(FrequencyOfMinimumsVector):
+                print('No hay ningun plot con 5 resonancias oscuras. Tomo las teóricas')
+                FrecuenciasReferenciaBase = FrecuenciasDRTeoricas
+    
+    if taketheoricalDR:
+        FrecuenciasReferenciaBase = FrecuenciasDRTeoricas
+        
+        
+            
+    Ventana = abs(ventana*(FrecuenciasReferenciaBase[1] - FrecuenciasReferenciaBase[0])) #ventana separadora de resonancias
+    
+    print('Ventana = ', Ventana)
+    DarkResonance1Frequency = []
+    DarkResonance1Fluorescence = []
+    
+    DarkResonance2Frequency = []
+    DarkResonance2Fluorescence = []
+    
+    DarkResonance3Frequency = []
+    DarkResonance3Fluorescence = []
+   
+    DarkResonance4Frequency = []
+    DarkResonance4Fluorescence = []
+    
+    DarkResonance5Frequency = []
+    DarkResonance5Fluorescence = []
+    
+    DarkResonance6Frequency = []
+    DarkResonance6Fluorescence = []    
+    
+    i = 0
+    
+   
+    while i < len(FrequencyOfMinimumsVector):
+        j = 0
+        FrecuenciasReferencia = [i for i in FrecuenciasReferenciaBase]
+
+
+        while j < len(FrequencyOfMinimumsVector[i]):
+            
+            
+            if abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[0])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[0])-Ventana):
+                DarkResonance1Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance1Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[0] = 0
+            
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[1])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[1])-Ventana):
+                DarkResonance2Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance2Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[1] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[2])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[2])-Ventana):
+                DarkResonance3Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance3Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[2] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[3])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[3])-Ventana):
+                DarkResonance4Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance4Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[3] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[4])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[4])-Ventana):
+                DarkResonance5Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance5Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[4] = 0
+
+            elif abs(FrequencyOfMinimumsVector[i][j]) < (abs(FrecuenciasReferencia[5])+Ventana) and abs(FrequencyOfMinimumsVector[i][j]) >= (abs(FrecuenciasReferencia[5])-Ventana):
+                DarkResonance6Frequency.append(FrequencyOfMinimumsVector[i][j])
+                DarkResonance6Fluorescence.append(RelativeFluorescenceOfMinimumsVector[i][j])
+                FrecuenciasReferencia[5] = 0
+                
+            else:
+                #print('Algo anduvo mal, por ahi tenes que cambiar la ventana che')
+                pass
+            j = j + 1
+        
+        if np.count_nonzero(FrecuenciasReferencia) > 0:
+            if FrecuenciasReferencia[0] != 0:
+                DarkResonance1Frequency.append(FrecuenciasReferencia[0])
+                DarkResonance1Fluorescence.append()
+                
+            if FrecuenciasReferencia[1] != 0:
+                DarkResonance2Frequency.append(FrecuenciasReferencia[1])
+                DarkResonance2Fluorescence.append(0)
+
+            if FrecuenciasReferencia[2] != 0:
+                DarkResonance3Frequency.append(FrecuenciasReferencia[2])
+                DarkResonance3Fluorescence.append(0)
+
+            if FrecuenciasReferencia[3] != 0:
+                DarkResonance4Frequency.append(FrecuenciasReferencia[3])
+                DarkResonance4Fluorescence.append(0)
+
+            if FrecuenciasReferencia[4] != 0:
+                DarkResonance5Frequency.append(FrecuenciasReferencia[4])
+                DarkResonance5Fluorescence.append(0)
+
+            if FrecuenciasReferencia[5] != 0:
+                DarkResonance6Frequency.append(FrecuenciasReferencia[5])
+                DarkResonance6Fluorescence.append(0)            
+            
+        i = i + 1
+
+    return DarkResonance1Frequency, DarkResonance1Fluorescence, DarkResonance2Frequency, DarkResonance2Fluorescence, DarkResonance3Frequency, DarkResonance3Fluorescence, DarkResonance4Frequency, DarkResonance4Fluorescence, DarkResonance5Frequency, DarkResonance5Fluorescence, DarkResonance6Frequency, DarkResonance6Fluorescence, FrecuenciasReferenciaBase
+
+
+
+def PerformExperiment_8levels(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None):
+    
+    """
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+    
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+    
+    Fluovectors = []
+    
+    for titaprobe in titaprobeVec:
+        
+        tinicial = time.time()
+
+        ProbeDetuningVectorL, Fluovector = CPTspectrum8levels(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=False, solvemode=1)
+
+        tfinal = time.time()
+        
+        print('Done angle ', titarepump, ' Total time: ', round((tfinal-tinicial), 2), "s")   
+        
+        if plot:
+            plt.figure()
+            plt.xlabel('Repump detuning (MHz')
+            plt.ylabel('Fluorescence (A.U.)')
+            plt.plot(ProbeDetuningVectorL, Fluovector, label=str(titarepump)+'º tita repump, T: ' + str(T*1e3) + ' mK')
+            plt.legend()
+            
+        Fluovectors.append(Fluovector)
+        
+        if len(titaprobeVec) == 1: #esto es para que no devuelva un vector de vectores si solo fijamos un angulo
+            Fluovectors = Fluovector
+   
+    return ProbeDetuningVectorL, Fluovectors
+
+
+
+def PerformExperiment_8levels_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobeVec, phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None):
+    
+    """
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+    
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+    
+    Fluovectors = []
+    
+    for titaprobe in titaprobeVec:
+        
+        tinicial = time.time()
+
+        ProbeDetuningVectorL, Fluovector = CPTspectrum8levels_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=False, solvemode=1)
+
+        tfinal = time.time()
+        
+        print('Done angle ', titarepump, ' Total time: ', round((tfinal-tinicial), 2), "s")   
+        
+        if plot:
+            plt.figure()
+            plt.xlabel('Repump detuning (MHz')
+            plt.ylabel('Fluorescence (A.U.)')
+            plt.plot(ProbeDetuningVectorL, Fluovector, label=str(titarepump)+'º tita repump, T: ' + str(T*1e3) + ' mK')
+            plt.legend()
+            
+        Fluovectors.append(Fluovector)
+        
+        if len(titaprobeVec) == 1: #esto es para que no devuelva un vector de vectores si solo fijamos un angulo
+            Fluovectors = Fluovector
+   
+    return ProbeDetuningVectorL, Fluovectors
+
+
+

analisis/plots/20250516_CPT_bladetrap/Data/EITfit/threeLevel_2repumps_CPTPlotter.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Sep  1 17:58:39 2020
+
+@author: oem
+"""
+
+
+
+import os
+import numpy as np
+#os.chdir('/home/oem/Nextcloud/G_liaf/liaf-TrampaAnular/Código General/EIT-CPT/Buenos Aires/Experiment Simulations/CPT scripts/Eight Level 2 repumps')
+from threeLevel_2repumps_AnalysisFunctions import CalculoTeoricoDarkResonances_8levels, GetMinimaInfo, GetPlotsofFluovsAngle_8levels, PerformExperiment_8levels, FindDRFrequencies, FindRelativeFluorescencesOfDR, GenerateNoisyCPT, SmoothNoisyCPT, GetFinalMaps, GenerateNoisyCPT_fixedRabi, GenerateNoisyCPT_fit
+import matplotlib.pyplot as plt
+import time
+from threeLevel_2repumps_AnalysisFunctions import MeasureRelativeFluorescenceFromCPT, IdentifyPolarizationCoincidences, RetrieveAbsoluteCoincidencesBetweenMaps, GetClosestIndex
+
+#C:\Users\Usuario\Nextcloud\G_liaf\liaf-TrampaAnular\Código General\EIT-CPT\Buenos Aires\Experiment Simulations\CPT scripts\Eight Level 2 repumps
+
+ub = 9.27e-24
+h = 6.63e-34
+c = (ub/h)*1e-4 #en unidades de MHz/G
+
+#u = 1e6
+u = 33.5e6
+
+B = (u/(2*np.pi))/c
+
+
+#sg, sp = 0.6, 5  #parámetros de control, saturación del doppler y repump
+#rabG, rabP = sg*gPS, sp*gPD #frecuencias de rabi
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6 #anchos de linea de las transiciones
+
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+DetDoppler = -36 #42
+DetRepumpVec = [DetDoppler+29.6]
+
+Tvec = [0.7] #temperatura en mK
+alpha = 0*(np.pi/180) #angulo entre los láseres
+
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+#Calculo las resonancias oscuras teóricas
+#ResonanciasTeoricas, DRPositivas = CalculoTeoricoDarkResonances_8levels(u/(2*np.pi*1e6), titadoppler, DetDoppler, DetRepump)
+
+#Parametros de la simulacion cpt
+center = -45
+span = 80
+freqMin = center-span*0.5
+freqMax = center+span*0.5
+
+""" parametros para tener espectros coherentes
+freqMin = -56
+freqMax = 14
+"""
+freqStep = 1e-1
+
+noiseamplitude = 0
+
+RelMinMedido0Vector = []
+RelMinMedido1Vector = []
+RelMinMedido2Vector = []
+RelMinMedido3Vector = []
+RelMinMedido4Vector = []
+
+#Sr = np.arange(0, 10, 0.2)
+
+#Sg = np.arange(0.01, 1, 0.05)
+#Sp = np.arange(0.1, 6.1, 1)
+
+#Sg = [0.6**2]
+#Sp = [2.3**2]
+
+
+Sg = [1.4]
+Sp = [6]
+
+Sr = [11]
+
+
+
+
+i = 0
+
+save = False
+
+
+showFigures = True
+
+if not showFigures:
+    plt.ioff()
+else:
+    plt.ion()
+    
+fig1, ax1 = plt.subplots()
+
+offsetx = 464
+
+ax1.plot([f-offsetx for f in FreqsDR], CountsDR, 'o')
+
+run = True
+
+Scale = 730
+Offset = 600 #600 para 20k cuentas aprox
+
+MaxCoherenceValue = []
+
+for sg in Sg:
+    for sp in Sp:
+        rabG, rabP = sg*gPS, sp*gPD
+        for Ti in Tvec:
+            T = Ti*1e-3
+            for DetRepump in DetRepumpVec:
+                print(T)
+                for sr in Sr:
+                
+                    rabR = sr*gPD
+                    
+                    #MeasuredFreq, MeasuredFluo = GenerateNoisyCPT(rabG, rabR, rabP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, [titaprobe], phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None, noiseamplitude=noiseamplitude)
+                    if run:
+                        MeasuredFreq4, MeasuredFluo4 = GenerateNoisyCPT_fixedRabi(sg, sr, sp, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, [titaprobe], phirepump, titarepump, freqMin, freqMax, freqStep, plot=False, solvemode=1, detpvec=None, noiseamplitude=noiseamplitude)
+                    
+                    #SmoothFluo = SmoothNoisyCPT(MeasuredFluo, window=9, poly=2)
+                    SmoothFluo4 = MeasuredFluo4
+                    
+                    #Scale = max(BestC)/max([100*s for s in SmoothFluo4])
+                    ax1.plot(MeasuredFreq4, [Scale*100*f + Offset for f in SmoothFluo4], label=f'Sr = {sr}')
+                    ax1.axvline(DetDoppler, linestyle='--', linewidth=1)
+                    #if sr != 0:
+                        #ax1.axvline(DetRepump, linestyle='--', linewidth=1)
+
+                    MaxCoherenceValue.append(np.max(SmoothFluo4))
+
+                    #print(titaprobe)
+                    ax1.set_xlabel('Detuning Rebombeo (MHz)')
+                    ax1.set_ylabel('Fluorescencia (AU)')
+                    ax1.set_title(f'B: {round(B, 2)} G, Sdop: {round(sg, 2)}, Sp: {round(sp, 2)}, Sr: {round(sr, 2)}, lw: {lw} MHz, T: {Ti} mK')
+                    #ax1.set_ylim(0, 8)
+                    #ax1.axvline(DetDoppler, linestyle='dashed', color='red', linewidth=1)
+                    #ax1.axvline(DetRepump, linestyle='dashed', color='black', linewidth=1)
+                    #ax1.set_title('Pol Doppler y Repump: Sigma+ Sigma-, Pol Probe: PI')
+                    #ax1.legend()
+                    ax1.grid()
+                    print (f'{i+1}/{len(Sg)*len(Sp)}')
+                    i = i + 1
+                    if save:
+                        plt.savefig(f'Mapa_plots_100k_1mk/CPT_SMSM_sdop{round(sg, 2)}_sp{round(sp, 2)}_sr{round(sr, 2)}.jpg')
+                    ax1.legend()
+                    
+"""
+plt.figure()
+plt.plot(Sr, MaxCoherenceValue, 'o')
+plt.xlabel('Sr')
+plt.ylabel('Coherence')
+"""
+
+"""
+                        
+plt.figure()
+plt.plot(MeasuredFreq, [100*f for f in SmoothFluo], color='darkred')
+plt.xlabel('Desintonía 866 (MHz)')
+plt.ylabel('Fluorescencia (A.U.)')
+plt.axvline(-30, color='darkblue', linewidth=1.2, linestyle='--')
+plt.yticks(np.arange(0.4, 1.8, 0.2))
+plt.ylim(0.5, 1.6)
+plt.grid()
+              
+
+
+plt.figure()
+plt.plot(MeasuredFreq4, [100*f for f in SmoothFluo4], color='darkred')
+plt.xlabel('Desintonía 866 (MHz)')
+plt.ylabel('Fluorescencia (A.U.)')
+plt.axvline(-30, color='darkblue', linewidth=1.2, linestyle='--')
+plt.yticks(np.arange(0.8, 2.4, 0.4))
+plt.grid()
+              
+"""
+
+
+
+
+#%%
+from scipy.optimize import curve_fit
+
+T = 0.5e-3
+
+sg = 0.7
+sp = 6
+sr = 0
+DetDoppler = -14
+DetRepump = 0
+
+FitsSp = []
+FitsOffset = []
+
+Sg = [0.87]
+
+def FitEIT(freqs, SP, offset):
+    MeasuredFreq, MeasuredFluo = GenerateNoisyCPT_fit(0.87, sr, SP, gPS, gPD, DetDoppler, DetRepump, u, DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth, T, alpha, phidoppler, titadoppler, phiprobe, [titaprobe], phirepump, titarepump, freqs, plot=False, solvemode=1, detpvec=None, noiseamplitude=noiseamplitude)
+    FinalFluo = [f*43000 + 2685 for f in MeasuredFluo]
+    return FinalFluo
+
+freqs = [f-offsetx+32 for f in FreqsDR]
+freqslong = np.arange(min(freqs), max(freqs)+freqs[1]-freqs[0], 0.1*(freqs[1]-freqs[0]))
+
+popt, pcov = curve_fit(FitEIT, freqs, CountsDR, p0=[5, 700], bounds=(0, [10, 1e6]))
+
+FitsSp.append(popt[0])
+FitsOffset.append(popt[1])
+
+print(popt)
+
+FittedEIT = FitEIT(freqslong, *popt)
+
+
+plt.figure()
+plt.errorbar(freqs, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', capsize=2, markersize=2)
+plt.plot(freqslong, FitEIT(freqslong, *popt))
+plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {T*1e3} mK, detDop: {DetDoppler} MHz')
+
+np.savetxt('CPT_measured.txt', np.transpose([freqs, CountsDR]))
+np.savetxt('CPT_fitted.txt', np.transpose([freqslong, FittedEIT]))

analisis/plots/20250516_CPT_bladetrap/Data/EITfit/threeLevel_2repumps_linealpol_python_scripts.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Apr  7 22:30:01 2020
+
+@author: nico
+"""
+
+
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from scipy.signal import argrelextrema
+
+
+"""
+Scripts para el calculo de la curva CPT
+"""
+
+
+def H0matrix(Detg, Detp, u): 
+    """
+    Calcula la matriz H0 en donde dr es el detuning del doppler, dp es el retuning del repump y u es el campo magnético en Hz/Gauss.
+    Para esto se toma la energía del nivel P como 0
+    """
+    
+    eigenEnergies = (Detg-u, Detg+u, -u/3, u/3, Detp-6*u/5, Detp-2*u/5, Detp+2*u/5, Detp+6*u/5) #pagina 26 de Oberst. los lande del calcio son iguales a Bario.
+    H0 = np.diag(eigenEnergies)
+    
+    return H0
+
+
+def HImatrix(rabG, rabP, phidoppler, titadoppler, phiprobe, titaprobe):
+    """
+    Calcula la matriz de interacción Hsp + Hpd, en donde rabR es la frecuencia de rabi de la transición Doppler SP, 
+    rabP es la frecuencia de rabi de la transición repump DP, y las componentes ei_r y ei_p son las componentes de la polarización
+    del campo eléctrico incidente de doppler y repump respectivamente. Deben estar normalizadas a 1
+    """
+    HI = np.zeros((8, 8), dtype=np.complex_)
+    
+    i, j = 1, 3
+    HI[i-1, j-1] = (rabG/np.sqrt(3)) * np.cos(titadoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1]) 
+    
+    i, j = 1, 4
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.sin(titadoppler)*np.exp(1j*phidoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 2, 3
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.sin(titadoppler)*np.exp(-1j*phidoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+     
+    i, j = 2, 4
+    HI[i-1, j-1] = -(rabG/np.sqrt(3)) * np.cos(titadoppler)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])   
+    
+    
+    i, j = 3, 5
+    HI[i-1, j-1] = -(rabP/2) * np.sin(titaprobe)*np.exp(-1j*phiprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 3, 6
+    HI[i-1, j-1] = -(rabP/np.sqrt(3)) * np.cos(titaprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 3, 7
+    HI[i-1, j-1] = rabP/np.sqrt(12) * np.sin(titaprobe)*np.exp(1j*phiprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    
+    i, j = 4, 6
+    HI[i-1, j-1] = -(rabP/np.sqrt(12)) * np.sin(titaprobe)*np.exp(-1j*phiprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 4, 7
+    HI[i-1, j-1] = -(rabP/np.sqrt(3)) * np.cos(titaprobe) 
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    i, j = 4, 8
+    HI[i-1, j-1] = (rabP/2) * np.sin(titaprobe)*np.exp(1j*phiprobe)
+    HI[j-1, i-1] = np.conjugate(HI[i-1, j-1])
+    
+    return HI
+
+
+def Lplusminus(detr, detp, phirepump, titarepump, forma=1):
+    Hintplus = np.zeros((8, 8), dtype=np.complex_)
+    Hintminus = np.zeros((8, 8), dtype=np.complex_)
+
+
+    Hintplus[4, 2] = (-1/2)*np.sin(titarepump)*np.exp(1j*phirepump)
+    Hintplus[5, 2] = (-1/np.sqrt(3))*np.cos(titarepump)
+    Hintplus[6, 2] = (1/(2*np.sqrt(3)))*np.sin(titarepump)*np.exp(-1j*phirepump)
+    
+    Hintplus[5, 3] = (-1/(2*np.sqrt(3)))*np.sin(titarepump)*np.exp(1j*phirepump)
+    Hintplus[6, 3] = (-1/np.sqrt(3))*np.cos(titarepump)
+    Hintplus[7, 3] = (1/2)*np.sin(titarepump)*np.exp(-1j*phirepump)
+    
+
+    Hintminus[2, 4] = (-1/2)*np.sin(titarepump)*np.exp(-1j*phirepump)
+    Hintminus[2, 5] = (-1/np.sqrt(3))*np.cos(titarepump)
+    Hintminus[2, 6] = (1/(2*np.sqrt(3)))*np.sin(titarepump)*np.exp(1j*phirepump)
+    
+    Hintminus[3, 5] = (-1/(2*np.sqrt(3)))*np.sin(titarepump)*np.exp(-1j*phirepump)
+    Hintminus[3, 6] = (-1/np.sqrt(3))*np.cos(titarepump)
+    Hintminus[3, 7] = (1/2)*np.sin(titarepump)*np.exp(1j*phirepump)
+
+    if forma==1:
+        Lplus = np.zeros((64, 64), dtype=np.complex_)
+        Lminus = np.zeros((64, 64), dtype=np.complex_)
+        DeltaBar = np.zeros((64, 64), dtype=np.complex_)
+    
+        for r  in range(8):
+            for q in range(8):
+                for k in range(8):
+                    for j in range(8):
+                        if j==q:
+                            if (k==2 or k==3) and r > 3:
+                                Lplus[r*8+q][k*8+j] = (-1j)*(Hintplus[r,k]) 
+                            if (r==2 or r==3) and k > 3:
+                                Lminus[r*8+q][k*8+j] = (-1j)*(Hintminus[r,k])
+                        elif r==k:
+                            if (q==2 or q==3) and j > 3:
+                                Lplus[r*8+q][k*8+j] = (-1j)*(- Hintplus[j,q]) 
+                            if (j==2 or j==3) and q > 3:
+                                Lminus[r*8+q][k*8+j] = (-1j)*(- Hintminus[j,q])
+    if forma==2:
+        deltaKro = np.diag([1, 1, 1, 1, 1, 1, 1, 1])
+        Lplus = (-1j)*(np.kron(Hintplus, deltaKro) - np.kron(deltaKro, Hintplus))
+        Lminus = (-1j)*(np.kron(Hintminus, deltaKro) - np.kron(deltaKro, Hintminus))
+    
+    DeltaBar = np.zeros((64, 64), dtype=np.complex_)   
+    for i in range(64):
+        
+        DeltaBar[i, i] = (1j)*(detr - detp)
+
+    return np.matrix(Lminus), np.matrix(Lplus), np.matrix(DeltaBar)
+
+
+def GetL1(Lplus, Lminus, DeltaBar, L0, rabR, nmax):
+    """
+    Devuelve Splus0 y Sminus0
+    """
+    
+    Sp = (-1)*(0.5*rabR)*(np.matrix(np.linalg.inv(L0 - (nmax+1)*DeltaBar))*np.matrix(Lplus))
+    Sm = (-1)*(0.5*rabR)*(np.matrix(np.linalg.inv(L0 + (nmax+1)*DeltaBar))*np.matrix(Lminus))
+    
+    for n in list(range(nmax+1))[(nmax+1)::-1][0:len(list(range(nmax+1))[(nmax+1)::-1])-1]: #jaja esto solo es para que vaya de nmax a 1 bajando. debe haber algo mas facil pero kcio
+        Sp = (-1)*(rabR)*(np.matrix(np.linalg.inv(L0 - n*DeltaBar + rabR*(Lminus*np.matrix(Sp))))*np.matrix(Lplus))
+        Sm = (-1)*(rabR)*(np.matrix(np.linalg.inv(L0 + n*DeltaBar + rabR*(Lplus*np.matrix(Sm))))*np.matrix(Lminus))
+    L1 = 0.5*rabR*(np.matrix(Lminus)*np.matrix(Sp) + np.matrix(Lplus)*np.matrix(Sm))
+    
+    return L1
+
+
+def EffectiveL(gPS, gPD, lwg, lwr, lwp):
+
+    """
+    Siendo Heff = H + EffectiveL, calcula dicho EffectiveL que es (-0.5j)*sumatoria(CmDaga*Cm) que luego sirve para calcular el Liouvilliano
+    """
+    Leff = np.zeros((8, 8), dtype=np.complex_)
+    
+    Leff[0, 0] = 2*lwg
+    Leff[1, 1] = 2*lwg
+    Leff[2, 2] = ((2/3)+(1/3))*gPS + ((1/2) + (1/6) + (1/3))*gPD
+    Leff[3, 3] = ((2/3)+(1/3))*gPS + ((1/2) + (1/6) + (1/3))*gPD
+    Leff[4, 4] = 2*(lwr + lwp)
+    Leff[5, 5] = 2*(lwr + lwp)
+    Leff[6, 6] = 2*(lwr + lwp)
+    Leff[7, 7] = 2*(lwr + lwp)
+    
+    return (-0.5j)*Leff
+
+
+def CalculateSingleMmatrix(gPS, gPD, lwg, lwr, lwp):
+    """
+    Si tomamos el Liuvilliano como L = (-j)*(Heff*deltak - Heffdaga*deltak) + sum(Mm),
+    esta funcion calcula dichos Mm, que tienen dimensión 64x64 ya que esa es la dimensión del L. Estas componentes
+    salen de hacer la cuenta a mano conociendo los Cm y considerando que Mm[8*(r-1)+s, 8*(k-1)+j] = Cm[r,l] + Cmdaga[j,s] = Cm[r,l] + Cm[s,j]
+    ya que los componentes de Cm son reales.
+    Esta M es la suma de las 8 matrices M.
+    
+    """
+    
+    M = np.matrix(np.zeros((64, 64), dtype=np.complex_))
+    
+    M[0,27] = (2/3)*gPS
+    
+    M[9,18] = (2/3)*gPS
+    
+    M[0,18] = (1/3)*gPS
+    M[1,19] = -(1/3)*gPS
+    M[8,26] = -(1/3)*gPS
+    M[9,27] = (1/3)*gPS
+    
+    M[36,18] = (1/2)*gPD
+    M[37,19] = (1/np.sqrt(12))*gPD
+    M[44,26] = (1/np.sqrt(12))*gPD
+    M[45,27] = (1/6)*gPD
+    
+    M[54,18] = (1/6)*gPD
+    M[55,19] = (1/np.sqrt(12))*gPD
+    M[62,26] = (1/np.sqrt(12))*gPD
+    M[63,27] = (1/2)*gPD
+    
+    M[45,18] = (1/3)*gPD
+    M[46,19] = (1/3)*gPD
+    M[53,26] = (1/3)*gPD
+    M[54,27] = (1/3)*gPD
+    
+    M[0,0] = 2*lwg
+    M[1,1] = 2*lwg
+    M[8,8] = 2*lwg
+    M[9,9] = 2*lwg
+    
+    factor1 = 1
+    factor2 = 1
+    factor3 = 1
+    factor4 = 1
+    
+    
+    #M[36, 45] = lwp
+    
+    
+    M[36,36] = 2*(lwr + factor1*lwp)
+    M[37,37] = 2*(lwr + factor1*lwp)
+    M[38,38] = 2*(lwr + factor1*lwp)
+    M[39,39] = 2*(lwr + factor1*lwp)
+    M[44,44] = 2*(lwr + factor2*lwp)
+    M[45,45] = 2*(lwr + factor2*lwp)
+    M[46,46] = 2*(lwr + factor2*lwp)
+    M[47,47] = 2*(lwr + factor2*lwp)
+    M[52,52] = 2*(lwr + factor3*lwp)
+    M[53,53] = 2*(lwr + factor3*lwp)
+    M[54,54] = 2*(lwr + factor3*lwp)
+    M[55,55] = 2*(lwr + factor3*lwp)
+    M[60,60] = 2*(lwr + factor4*lwp)
+    M[61,61] = 2*(lwr + factor4*lwp)
+    M[62,62] = 2*(lwr + factor4*lwp)
+    M[63,63] = 2*(lwr + factor4*lwp)
+
+    return M
+
+def dopplerBroadening(wlg, wlp, alpha, T, mcalcio = 6.655e-23*1e-3):
+    """
+    Calcula el broadening extra semiclásico por temperatura considerando que el ion atrapado se mueve.
+    wlg es la longitud de onda doppler, wlp la longitud de onda repump, T la temperatura del ion en kelvin, y alpha (en rads) el ángulo
+    que forman ambos láseres.
+    """
+    
+    kboltzmann = 1.38e-23 #J/K
+    
+    gammaD = (2*np.pi)*np.sqrt((1/(wlg*wlg)) + (1/(wlp*wlp)) - 2*(1/(wlg*wlp))*np.cos(alpha))*np.sqrt(kboltzmann*T/(2*mcalcio))
+
+    return gammaD
+    
+
+def FullL_efficient(rabG, rabR, rabP, gPS = 0, gPD = 0, Detg = 0, Detr = 0, Detp = 0, u = 0, lwg = 0, lwr=0, lwp = 0, 
+          phidoppler=0, titadoppler=0, phiprobe=0, titaprobe=0, phirepump=0, titarepump=0, T = 0, alpha = 0):
+
+    """
+    Calcula el Liouvilliano total de manera explícita índice a índice. Suma aparte las componentes de las matrices M.
+    Es la más eficiente hasta ahora.
+    """
+    
+    
+    db = dopplerBroadening(0.397e-6, 0.866e-6, alpha, T)
+    
+    #lwr = np.sqrt(lwr**2 + dopplerBroadening(0.397e-6, 0.866e-6, alpha, T)**2)
+    lwg = np.sqrt(lwg**2 + db**2)
+    lwr = np.sqrt(lwr**2 + db**2)    
+    
+    CC = EffectiveL(gPS, gPD, lwg, lwr, lwp)
+    
+    Heff = H0matrix(Detg, Detp, u) + HImatrix(rabG, rabP, phidoppler, titadoppler, phiprobe, titaprobe) + CC
+    
+    Heffdaga = np.matrix(Heff).getH()
+    
+    Lfullpartial = np.zeros((64, 64), dtype=np.complex_)
+    
+    for r  in range(8):
+        for q in range(8):
+            for k in range(8):
+                for j in range(8):
+                    if j!=q and r!=k:
+                        pass
+                    elif j==q and r!=k:
+                        if (r < 2 and k > 3) or (k < 2 and r > 3) or (r > 3 and k > 3) or (r==0 and k==1) or (r==1 and k==0) or (r==2 and k==3) or (r==3 and k==2): #todo esto sale de analizar explicitamente la matriz y tratar de no calcular cosas de más que dan cero
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(Heff[r,k])
+                    elif j!=q and r==k:
+                        if (j < 2 and q > 3) or (q < 2 and j > 3) or (j > 3 and q > 3) or (j==0 and q==1) or (j==1 and q==0) or (j==2 and q==3) or (j==3 and q==2):
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(-Heffdaga[j,q])
+                    else:
+                        if Heff[r,k] == Heffdaga[j,q]:
+                            pass
+                        else:
+                            Lfullpartial[r*8+q][k*8+j] = (-1j)*(Heff[r,k]-Heffdaga[j,q])
+
+    M = CalculateSingleMmatrix(gPS, gPD, lwg, lwr, lwp) 
+    L0 = np.array(np.matrix(Lfullpartial) + M)
+    
+    nmax = 1
+    Lminus, Lplus, DeltaBar = Lplusminus(Detr, Detp, phirepump, titarepump)
+    factor1 = np.exp(1j*0.2*np.pi)
+    factor2 = np.exp(-1j*0.2*np.pi)
+    #print(factor)
+    L1 = GetL1(factor1*Lplus, factor2*Lminus, DeltaBar, L0, rabR, nmax)
+    Lfull = L0 + L1    
+    
+    
+    #NORMALIZACION DE RHO
+    i = 0 
+    while i < 64:
+        if i%9 == 0:
+            Lfull[0, i] = 1
+        else:
+            Lfull[0, i] = 0
+        i = i + 1    
+    
+    return Lfull 
+
+
+"""
+Scripts para correr un experimento y hacer el análisis de los datos
+"""
+
+def CalculoTeoricoDarkResonances(u, titadoppler):
+    if titadoppler==0:
+        NegativeDR = [(-7/5)*u, (-3/5)*u, (-1/5)*u, (1/5)*u, (3/5)*u, (7/5)*u]
+    elif titadoppler==90:
+        NegativeDR = [(-11/5)*u, (-7/5)*u, (-3/5)*u, (3/5)*u, (7/5)*u, (11/5)*u]
+    
+    PositiveDR = [(-8/5)*u, (-4/5)*u, 0, (4/5)*u, (8/5)*u]
+    
+    return NegativeDR, PositiveDR
+
+
+def CPTspectrum8levels(rabG, rabR, rabP, gPS, gPD, Detg, Detr, u, lwg, lwr, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, 
+                      freqMin=-100, freqMax=100, freqStep=1e-1, plot=False, solvemode=1):
+    """
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+    
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+    
+    phidoppler, titadoppler = phidoppler*(np.pi/180), titadoppler*(np.pi/180) 
+    phiprobe, titaprobe = phiprobe*(np.pi/180), titaprobe*(np.pi/180)
+    phirepump, titarepump = phirepump*(np.pi/180), titarepump*(np.pi/180)
+    
+    DetProbeVector = 2*np.pi*np.arange(freqMin*1e6, freqMax*1e6, freqStep*1e6)
+    Detg, Detr = 2*np.pi*Detg*1e6, 2*np.pi*Detr*1e6
+    lwg, lwr, lwp = 2*np.pi*lwg*1e6, 2*np.pi*lwr*1e6, 2*np.pi*lwp*1e6
+    
+    #u = 2*np.pi*u*1e6
+    
+    Fluovector = []
+    
+    tinicial = time.time()
+    
+    for Detp in DetProbeVector:
+        L = FullL_efficient(rabG, rabR, rabP, gPS, gPD, Detg, Detr, Detp, u, lwg, lwr, lwp, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, Temp, alpha)
+        
+        if solvemode == 1:
+            rhovectorized = np.linalg.solve(L, np.array([int(i==0) for i in range(64)]))
+            Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+            Fluovector.append(Fluo)                
+
+        if solvemode == 2:
+            Linv = np.linalg.inv(L) 
+            rhovectorized = [Linv[j][0] for j in range(len(Linv))]
+            Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+            Fluovector.append(Fluo)
+        
+    tfinal = time.time()
+        
+    print('Done, Total time: ', round((tfinal-tinicial), 2), "s")   
+    
+    DetProbeVectorMHz = np.arange(freqMin, freqMax, freqStep)
+    
+    if plot:
+        plt.xlabel('Probe detuning (MHz)')
+        plt.ylabel('Fluorescence (A.U.)')
+        plt.plot(DetProbeVectorMHz, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+        plt.legend()
+        
+    return DetProbeVectorMHz, Fluovector
+
+
+def CPTspectrum8levels_fixedRabi(sg, sr, sp, gPS, gPD, Detg, Detr, u, lwg, lwr, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, 
+                      freqMin=-100, freqMax=100, freqStep=1e-1, plot=False, solvemode=1):
+    """
+    Hace un experimento barriendo ángulos de repump con el angulo de doppler fijo.
+    
+    solvemode=1: resuelve con np.linalg.solve
+    solvemode=2: resuelve invirtiendo L con la funcion np.linalg.inv
+    """
+
+
+
+    
+    phidoppler, titadoppler = phidoppler*(np.pi/180), titadoppler*(np.pi/180) 
+    phiprobe, titaprobe = phiprobe*(np.pi/180), titaprobe*(np.pi/180)
+    phirepump, titarepump = phirepump*(np.pi/180), titarepump*(np.pi/180)
+    
+    DetProbeVector = 2*np.pi*np.arange(freqMin*1e6, freqMax*1e6, freqStep*1e6)
+    Detg, Detr = 2*np.pi*Detg*1e6, 2*np.pi*Detr*1e6
+    #lwg, lwr, lwp = 2*np.pi*lwg*1e6, 2*np.pi*lwr*1e6, 2*np.pi*lwp*1e6
+    lwg, lwr, lwp = lwg*1e6, lwr*1e6, lwp*1e6
+
+    rabG = sg*gPS
+    rabR = sr*gPD
+    rabP = sp*gPD
+    #u = 2*np.pi*u*1e6
+    
+    Fluovector = []
+    
+    tinicial = time.time()
+    
+    for Detp in DetProbeVector:
+
+        L = FullL_efficient(rabG, rabR, rabP, gPS, gPD, Detg, Detr, Detp, u, lwg, lwr, lwp, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, Temp, alpha)
+        
+        if solvemode == 1:
+            coh = 5
+            rhovectorized = np.linalg.solve(L, np.array([int(i==0) for i in range(64)]))
+            #Fluo = np.abs(rhovectorized[coh])
+            Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+            Fluovector.append(Fluo)                
+
+        if solvemode == 2:
+            Linv = np.linalg.inv(L) 
+            rhovectorized = [Linv[j][0] for j in range(len(Linv))]
+            Fluo = np.real(rhovectorized[18] + np.real(rhovectorized[27])) #estos son los rho33 + rho44
+            Fluovector.append(Fluo)
+        
+    tfinal = time.time()
+        
+    print('Done, Total time: ', round((tfinal-tinicial), 2), "s")   
+    
+    DetProbeVectorMHz = np.arange(freqMin, freqMax, freqStep)
+    
+    if plot:
+        plt.xlabel('Probe detuning (MHz)')
+        plt.ylabel('Fluorescence (A.U.)')
+        plt.plot(DetProbeVectorMHz, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+        plt.legend()
+        
+    return DetProbeVectorMHz, Fluovector
+#%%
+
+if __name__ == "__main__":
+    ub = 9.27e-24
+    h = 6.63e-34
+    c = (ub/h)*1e-4 #en unidades de MHz/G
+    
+    B = 25 #campo magnetico en gauss
+    
+    u = c*B
+    
+    
+    sg, sr, sp = 0.5, 1.5, 4 #parámetros de saturación del doppler y repump
+    gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6 #anchos de linea de las transiciones
+    rabG, rabR, rabP = sg*gPS, sr*gPD, sp*gPD #frecuencias de rabi
+    
+    lwg, lwr, lwp = 0.3, 0.3, 0.3 #ancho de linea de los laseres
+    
+    Detg = -25
+    Detr = 20 #detuning del doppler y repump
+    
+    Temp = 0.0e-3 #temperatura en K
+    alpha = 0*(np.pi/180) #angulo entre los láseres
+    
+    phidoppler, titadoppler = 0, 90
+    phirepump, titarepump = 0, 90
+    
+    phiprobe, titaprobe = 0, 90
+    
+    
+    plotCPT = False
+    
+    freqMin = -50
+    freqMax = 50
+    freqStep = 5e-2
+    
+    Frequencyvector, Fluovector = CPTspectrum8levels(rabG, rabR, rabP, gPS, gPD, Detg, Detr, u, lwg, lwr, lwp, Temp, alpha, phidoppler, titadoppler, phiprobe, titaprobe, phirepump, titarepump, freqMin=freqMin, freqMax=freqMax, freqStep=freqStep, plot=plotCPT, solvemode=1)
+    
+    NegativeDR, PositiveDR = CalculoTeoricoDarkResonances(u/(2*np.pi*1e6), titadoppler)
+
+    plt.plot(Frequencyvector, [100*f for f in Fluovector], label=str(titaprobe) + 'º, T: ' + str(Temp*1e3) + ' mK')
+    plt.xlabel('Probe detuning (MHz)')
+    plt.ylabel('Fluorescence (A.U.)')
+    
+    for PDR in PositiveDR:
+        plt.axvline(Detr+PDR, linestyle='--', linewidth=0.5, color='red')
+    for NDR in NegativeDR:
+        plt.axvline(Detg+NDR, linestyle='--', linewidth=0.5, color='blue')
+
+
+
+    
+    #parametros que andan piola:
+        
+    
+    """
+    ub = 9.27e-24
+    h = 6.63e-34
+    c = (ub/h)*1e-4 #en unidades de MHz/G
+    
+    B = 17 #campo magnetico en gauss
+    
+    u = c*B
+    #u = 80e6
+    
+    sr, sp = 0.53, 4.2
+    gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+    rabR, rabP = sr*gPS, sp*gPD
+    lw = 2*np.pi * 0.33e6
+    lwr, lwp = lw, lw #ancho de linea de los laseres
+    dr_spec = - 2*np.pi* 26e6
+    
+    
+    freqSteps = 500
+    freqMin = -100e6
+    freqMax = 100e6
+    
+    dps = 2*np.pi*np.linspace(freqMin, freqMax, freqSteps)
+    
+    #dps = [-30e6]
+    
+    alfar = 90*(np.pi/180)
+    ex_r, ey_r, ez_r = np.sin(alfar)*np.cos(0), np.sin(alfar)*np.sin(0), np.cos(alfar)
+    
+    
+    alfap = 90*(np.pi/180)
+    ex_p, ey_p, ez_p = np.sin(alfap)*np.cos(0), np.sin(alfap)*np.sin(0), np.cos(alfap)
+    
+    """

analisis/plots/20250516_CPT_bladetrap/analisis_superajuste.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Ploteo de datos y ajustes
+@author: lolo
+"""
+
+
+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
+# from scipy import interpolate
+
+
+
+
+#%% Importaciones extra
+
+# /home/lolo/Dropbox/marce/LIAF/Trampa_anular/artiq_experiments/analisis/plots/20231123_CPTconmicromocion3/Data/EITfit/MM_eightLevel_2repumps_AnalysisFunctions.py
+
+from Data.EITfit.lolo_modelo_full_8niveles import PerformExperiment_8levels_MM
+
+
+PARAMETROS = np.load('PARAMETROS.npz',allow_pickle=True)
+for var_name in PARAMETROS.keys():
+    globals()[var_name] = PARAMETROS[var_name]
+    print(f'loaded: {var_name}')
+
+
+#%%
+
+"""
+Primero tengo mediciones de espectros cpt de un ion variando la tension dc_A
+"""
+
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20220106_CPT_DosLaseres_v08_TISA_DR\Data
+
+folder = '../20231123_CPTconmicromocion3/Data/'
+CPT_FILES = f"""
+{folder}/000016262-IR_Scan_withcal_optimized
+{folder}/000016239-IR_Scan_withcal_optimized
+{folder}/000016240-IR_Scan_withcal_optimized
+{folder}/000016241-IR_Scan_withcal_optimized
+{folder}/000016244-IR_Scan_withcal_optimized
+{folder}/000016255-IR_Scan_withcal_optimized
+{folder}/000016256-IR_Scan_withcal_optimized
+{folder}/000016257-IR_Scan_withcal_optimized
+"""
+
+
+def SeeKeys(files):
+    for i, fname in enumerate(files.split()):
+        data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+        print(fname)
+        print(list(data['datasets'].keys()))
+
+print(SeeKeys(CPT_FILES))
+
+#carpeta pc nico labo escritorio:
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20211101_CPT_DosLaseres_v03\Data
+
+Counts = []
+Freqs = []
+
+AmpTisa = []
+UVCPTAmp = []
+No_measures = []
+Voltages = []
+
+for i, fname in enumerate(CPT_FILES.split()):
+    print(str(i) + ' - ' + fname)
+    #print(fname)
+    data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+
+    # Aca hago algo repugnante para poder levantar los strings que dejamos
+    # que además tenian un error de tipeo al final. Esto no deberá ser necesario
+    # cuando se solucione el error este del guardado.
+    Freqs.append(np.array(data['datasets']['IR1_Frequencies']))
+    Counts.append(np.array(data['datasets']['data_array']))
+    #AmpTisa.append(np.array(data['datasets']['TISA_CPT_amp']))
+    UVCPTAmp.append(np.array(data['datasets']['UV_CPT_amp']))
+    No_measures.append(np.array(data['datasets']['no_measures']))
+    Voltages.append(np.array(data['datasets']['scanning_voltages']))
+
+def Split(array,n):
+    length=len(array)/n
+    splitlist = []
+    jj = 0
+    while jj<length:
+        partial = []
+        ii = 0
+        while ii < n:
+            partial.append(array[jj*n+ii])
+            ii = ii + 1
+        splitlist.append(partial)
+        jj = jj + 1
+    return splitlist
+
+
+CountsSplit = []
+CountsSplit.append(Split(Counts[0],len(Freqs[0])))
+
+
+CountsSplit_2ions = []
+CountsSplit_2ions.append(Split(Counts[4],len(Freqs[4])))
+
+
+
+#%%
+"""
+AHORA INTENTO SUPER AJUSTES O SEA CON OFFSETXPI Y DETDOPPLER INCLUIDOS
+
+La 0 no ajusta bien incluso con todos los parametros libres
+De la 1 a la 11 ajustan bien
+"""
+
+
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+SUPER AJUSTE (SA)
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+#DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+SelectedCurveVec = [1,2,3,4,5,6,7,8,9,10,11]
+#SelectedCurveVec = [10]
+
+# if not 'popt_SA_vec' in globals().keys() or len(popt_SA_vec)==0:
+
+popt_SA_vec = []
+pcov_SA_vec = []
+Detuningsshort_vec = []
+Counts_vec = []
+Detuningslong_vec = []
+FittedCounts_vec = []
+
+Betas_vec = []
+ErrorBetas_vec = []
+Temp_vec = []
+ErrorTemp_vec = []
+
+DetuningsUV_vec = []
+ErrorDetuningsUV_vec = []
+
+for selectedcurve in SelectedCurveVec: 
+
+#selectedcurve = 2 #IMPORTANTE: SELECCIONA LA MEDICION
+
+    FreqsDR = Freqs[0]
+    CountsDR = CountsSplit[0][selectedcurve]
+
+
+    if selectedcurve==1:
+        CountsDR[100]=0.5*(CountsDR[99]+CountsDR[101])
+        CountsDR[105]=0.5*(CountsDR[104]+CountsDR[106])
+    if selectedcurve==2:
+        CountsDR[67]=0.5*(CountsDR[66]+CountsDR[68])
+        CountsDR[71]=0.5*(CountsDR[70]+CountsDR[72])
+    if selectedcurve==6:
+        CountsDR[1]=0.5*(CountsDR[0]+CountsDR[2])
+        CountsDR[76]=0.5*(CountsDR[75]+CountsDR[77])
+    if selectedcurve==7:
+        CountsDR[117]=0.5*(CountsDR[116]+CountsDR[118])
+        
+    freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+    CircPr = 1
+    alpha = 0
+    
+
+    def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP, U, plot=False):
+    #def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+        #BETA = 1.8
+        # SG = 0.6
+        # SP = 8.1
+        # TEMP = 0.2e-3
+    
+        freqs = [2*f*1e-6-offset for f in Freqs]
+      
+        Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, U, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    
+        ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+        if plot:
+            return ScaledFluo1, Detunings
+        else:
+            return ScaledFluo1
+        #return ScaledFluo1
+    
+    do_fit = True
+    if do_fit:
+        popt_3_SA, pcov_3_SA = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[430, -25, 0.9, 6.2, 3e4, 1.34e3, 2, (np.pi**2)*1e-3, 32e6], bounds=((0, -50, 0, 0, 0, 0, 0, 0, 25e6), (1000, 0, 2, 20, 5e4, 5e4, 10, (np.pi**2)*10e-3, 40e6)))
+        
+        popt_SA_vec.append(popt_3_SA)
+        pcov_SA_vec.append(pcov_3_SA)
+    
+        FittedEITpi_3_SA_short, Detunings_3_SA_short = FitEIT_MM_single(FreqsDR, *popt_3_SA, plot=True)
+        freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+        FittedEITpi_3_SA_long, Detunings_3_SA_long = FitEIT_MM_single(freqslong, *popt_3_SA, plot=True)
+    
+    DetuningsUV_vec.append(popt_3_SA[1])
+    ErrorDetuningsUV_vec.append(np.sqrt(pcov_3_SA[1,1]))
+    
+    Betas_vec.append(popt_3_SA[6])
+    ErrorBetas_vec.append(np.sqrt(pcov_3_SA[6,6]))
+    Temp_vec.append(popt_3_SA[7])
+    ErrorTemp_vec.append(np.sqrt(pcov_3_SA[7,7]))
+    
+    Detuningsshort_vec.append(Detunings_3_SA_short)
+    Counts_vec.append(CountsDR)
+    Detuningslong_vec.append(Detunings_3_SA_long)
+    FittedCounts_vec.append(FittedEITpi_3_SA_long)
+    
+    
+    plt.figure()
+    plt.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+    plt.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, color='darkolivegreen', linewidth=3, label=f'med {selectedcurve}')
+    #plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+    plt.xlabel('Detuning (MHz)')
+    plt.ylabel('Counts')
+    plt.legend(loc='upper left', fontsize=20)
+    plt.grid()
+    
+    print(f'listo med {selectedcurve}')
+    print(popt_3_SA)
+
+    
+#%%
+"""
+Grafico distintas variables que salieron del SUper ajuste
+"""
+
+import seaborn as sns
+paleta = sns.color_palette("rocket")
+
+medfin = 12
+
+
+voltages_dcA = Voltages[0][1:medfin]
+
+def lineal(x,a,b):
+    return a*x+b
+
+def hiperbola(x,a,b,c,x0):
+    return a*np.sqrt(((x-x0)**2+c**2))+b
+
+hiperbola_or_linear = True
+
+if hiperbola_or_linear:
+    popthip,pcovhip = curve_fit(hiperbola,voltages_dcA,Betas_vec[:medfin-1],p0=(100,0.1,1,-0.15))
+    
+    xhip = np.linspace(-0.23,0.005,200)
+    
+    plt.figure()
+    plt.errorbar(voltages_dcA,Betas_vec[0:medfin-1],yerr=ErrorBetas_vec[:medfin-1],fmt='o',capsize=5,markersize=5,color=paleta[1])
+    plt.plot(xhip,hiperbola(xhip,*popthip))
+    plt.xlabel('Endcap voltage (V)')
+    plt.ylabel('Modulation factor')
+    plt.grid()
+
+else:
+    poptini,pcovini = curve_fit(lineal,voltages_dcA[0:3],Betas_vec[0:3])
+    poptfin,pcovfin = curve_fit(lineal,voltages_dcA[4:],Betas_vec[4:])
+    
+    minimum_voltage = -(poptini[1]-poptfin[1])/(poptini[0]-poptfin[0]) #voltaje donde se intersectan las rectas, es decir, donde deberia estar el minimo de micromocion
+    minimum_modulationfactor = lineal(minimum_voltage,*poptini) #es lo mismo si pongo *poptfin
+    
+    xini = np.linspace(-0.23,-0.13,100)
+    xfin = np.linspace(-0.15,0.005,100)
+    
+    plt.figure()
+    plt.errorbar(voltages_dcA,Betas_vec,yerr=ErrorBetas_vec,fmt='o',capsize=5,markersize=5,color=paleta[1])
+    plt.plot(xini,lineal(xini,*poptini))
+    plt.plot(xfin,lineal(xfin,*poptfin))
+    plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+    plt.xlabel('Endcap voltage (V)')
+    plt.ylabel('Modulation factor')
+    plt.grid()
+
+
+print([t*1e3 for t in Temp_vec])
+
+plt.figure()
+plt.errorbar(voltages_dcA,[t*1e3 for t in Temp_vec[:medfin-1]],yerr=[t*1e3 for t in ErrorTemp_vec[:medfin-1]],fmt='o',capsize=5,markersize=5,color=paleta[3])
+#plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+plt.axhline(0.538)
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+#plt.ylim(0,2)
+
+#%%
+"""
+Ahora hago un ajuste con una hiperbola porque tiene mas sentido, por el hecho
+de que en el punto optimo el ion no esta en el centro de la trampa
+sino que esta a una distancia d
+"""
+def hiperbola(x,a,b,c,x0):
+    return a*np.sqrt(((x-x0)**2+c**2))+b
+
+popthip,pcovhip = curve_fit(hiperbola,voltages_dcA,Betas_vec[:10],p0=(100,0.1,1,-0.15))
+
+xhip = np.linspace(-0.23,0.005,200)
+
+plt.figure()
+plt.errorbar(voltages_dcA,Betas_vec[:10],yerr=ErrorBetas_vec[:10],fmt='o',capsize=5,markersize=5,color=paleta[1])
+plt.plot(xhip,hiperbola(xhip,*popthip))
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Modulation factor')
+plt.grid()
+
+
+
+
+#%%
+from scipy.special import jv
+
+
+def expo(x,tau,A,B):
+    return A*np.exp(x/tau)+B
+
+def cuadratica(x,a,c):
+    return a*(x**2)+c
+
+def InverseMicromotionSpectra(beta, A, det, x0, gamma, B):
+    ftrap=22.1
+    #gamma=30
+    P = ((jv(0, beta)**2)/((((det-x0)**2)+(0.5*gamma)**2)**2))*(-2*(det-x0))
+    i = 1
+    #print(P)
+    while i <= 5:
+        P = P + (-2*(det-x0))*((jv(i, beta))**2)/(((((det-x0)+i*ftrap)**2)+(0.5*gamma)**2)**2) + (-2*(det-x0))*(((jv(-i, beta))**2)/((((det-x0)-i*ftrap)**2)+(0.5*gamma)**2)**2)
+        i = i + 1
+        #print(P)
+    #return 1/(A*P+B)
+    return 1/(A*P+B)
+
+
+def InverseMicromotionSpectra_raw(beta, A, det, B):
+    ftrap=22.1
+    gamma=21
+    P = ((jv(0, beta)**2)/((((det)**2)+(0.5*gamma)**2)**2))*(-2*(det))
+    i = 1
+    #print(P)
+    while i <= 3:
+        P = P + (-2*(det))*((jv(i, beta))**2)/(((((det)+i*ftrap)**2)+(0.5*gamma)**2)**2) + (-2*(det))*(((jv(-i, beta))**2)/((((det)-i*ftrap)**2)+(0.5*gamma)**2)**2)
+        i = i + 1
+        #print(P)
+    return A/P+B
+
+
+"""
+Temperatura vs beta con un ajuste exponencial 
+"""
+
+popt_exp, pcov_exp = curve_fit(expo,Betas_vec[:10],[t*1e3 for t in Temp_vec[:10]])
+popt_quad, pcov_quad = curve_fit(cuadratica,Betas_vec[:10],[t*1e3 for t in Temp_vec[:10]],p0=(1,10))
+#popt_rho22, pcov_rho22 = curve_fit(InverseMicromotionSpectra,Betas_vec,[t*1e3 for t in Temp_vec],p0=(10,10,-10,1,20)) #esto ajusta muy bien
+#popt_rho22, pcov_rho22 = curve_fit(InverseMicromotionSpectra,Betas_vec, [t*1e3 for t in Temp_vec],p0=(-10,-10,10,1,20)) #esto ajusta muy bien
+popt_rho22_raw, pcov_rho22_raw = curve_fit(InverseMicromotionSpectra_raw,Betas_vec[:10], [t*1e3 for t in Temp_vec[:10]],p0=(-10, -10, 1)) #esto ajusta muy bien
+
+
+print(popt_rho22_raw)
+
+betaslong = np.arange(0,2*2.7,0.01)
+
+print(f'Min temp predicted: {InverseMicromotionSpectra_raw(betaslong,*popt_rho22_raw)[100]}')
+
+plt.figure()
+plt.errorbar(Betas_vec[:10],[t*1e3 for t in Temp_vec[:10]],xerr=ErrorBetas_vec[:10], yerr=[t*1e3 for t in ErrorTemp_vec[:10]],fmt='o',capsize=5,markersize=5,color=paleta[3])
+#plt.plot(betaslong,expo(betaslong,*popt_exp),label='Ajuste exponencial')
+#plt.plot(betaslong,cuadratica(betaslong,*popt_quad),label='Ajuste cuadratico')
+#plt.plot(betaslong,InverseMicromotionSpectra(betaslong,*popt_rho22),label='Ajuste cuadratico')
+plt.plot(betaslong,InverseMicromotionSpectra_raw(betaslong,*popt_rho22_raw),label='Ajuste cuadratico')
+
+#plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+#plt.axhline(0.538)
+plt.xlabel('Modulation factor')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+
+
+#%%
+"""
+Esto no es del super ajuste sino de los ajustes anteriores en donde DetDoppler y offset son puestos a mano
+Aca grafico los betas con su error en funcion de la tension variada.
+Ademas, hago ajuste lineal para primeros y ultimos puntos, ya que espero que
+si la tension hace que la posicion del ion varie linealmente, el beta varia proporcional a dicha posicion.
+"""
+
+import seaborn as sns
+
+def lineal(x,a,b):
+    return a*x+b
+
+paleta = sns.color_palette("rocket")
+
+betavector = [beta1,beta2,beta3,beta4,beta5,beta6,beta7,beta8,beta9]
+errorbetavector = [errorbeta1,errorbeta2,errorbeta3,errorbeta4,errorbeta5,errorbeta6,errorbeta7,errorbeta8,errorbeta9]
+voltages_dcA = Voltages[0][1:10]
+
+poptini,pcovini = curve_fit(lineal,voltages_dcA[0:3],betavector[0:3])
+poptfin,pcovfin = curve_fit(lineal,voltages_dcA[4:],betavector[4:])
+
+minimum_voltage = -(poptini[1]-poptfin[1])/(poptini[0]-poptfin[0]) #voltaje donde se intersectan las rectas, es decir, donde deberia estar el minimo de micromocion
+minimum_modulationfactor = lineal(minimum_voltage,*poptini) #es lo mismo si pongo *poptfin
+
+xini = np.linspace(-0.23,-0.13,100)
+xfin = np.linspace(-0.15,0.005,100)
+
+plt.figure()
+plt.errorbar(voltages_dcA,betavector,yerr=errorbetavector,fmt='o',capsize=5,markersize=5,color=paleta[1])
+plt.plot(xini,lineal(xini,*poptini))
+plt.plot(xfin,lineal(xfin,*poptfin))
+plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Modulation factor')
+plt.grid()
+
+
+#%%
+"""
+Aca veo la temperatura del ion en funcion del voltaje del endcap, ya que
+al cambiar la cantidad de micromocion, cambia la calidad del enfriado
+"""
+tempvector = np.array([temp1,temp2,temp3,temp4,temp5,temp6,temp7,temp8,temp9])*1e3
+errortempvector = np.array([errortemp1,errortemp2,errortemp3,errortemp4,errortemp5,errortemp6,errortemp7,errortemp8,errortemp9])*1e3
+
+voltages_dcA = Voltages[0][1:10]
+
+plt.figure()
+plt.errorbar(voltages_dcA,tempvector,yerr=errortempvector,fmt='o',capsize=5,markersize=5,color=paleta[3])
+plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+plt.ylim(0,2)
+
+
+#%%
+"""
+Por las dudas, temperatura en funcion de beta
+"""
+plt.figure()
+plt.errorbar(betavector,tempvector,yerr=errortempvector,xerr=errorbetavector,fmt='o',capsize=5,markersize=5)
+plt.xlabel('Modulation factor')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+
+
+
+#%%
+"""
+Si quiero ver algun parametro del ajuste puntual. el orden es: 0:SG, 1:SP, 2:SCALE1, 3:OFFSET
+"""
+ki=2
+plt.errorbar(np.arange(0,9,1),[popt_1[ki],popt_2[ki],popt_3[ki],popt_4[ki],popt_5[ki],popt_6[ki],popt_7[ki],popt_8[ki],popt_9[ki]],yerr=[np.sqrt(pcov_1[ki,ki]),np.sqrt(pcov_2[ki,ki]),np.sqrt(pcov_3[ki,ki]),np.sqrt(pcov_4[ki,ki]),np.sqrt(pcov_5[ki,ki]),np.sqrt(pcov_6[ki,ki]),np.sqrt(pcov_7[ki,ki]),np.sqrt(pcov_8[ki,ki]),np.sqrt(pcov_9[ki,ki])], fmt='o',capsize=3,markersize=3)
+
+
+#%%
+
+if False:
+    GUARDAR = {}
+    for var in [ kk for kk in globals().keys() if kk.startswith('pop') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.startswith('pcov') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.startswith('Fitted') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.endswith('_vec') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+
+
+    np.savez('PARAMETROS.npz', **GUARDAR )
+
+

analisis/plots/20250516_CPT_bladetrap/lolo_CPT_plotter_20231123.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Ploteo de datos y ajustes
+@author: lolo
+"""
+
+
+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
+# from scipy import interpolate
+
+
+
+
+#%% Importaciones extra
+
+# /home/lolo/Dropbox/marce/LIAF/Trampa_anular/artiq_experiments/analisis/plots/20231123_CPTconmicromocion3/Data/EITfit/MM_eightLevel_2repumps_AnalysisFunctions.py
+
+from Data.EITfit.lolo_modelo_full_8niveles import PerformExperiment_8levels_MM
+
+
+PARAMETROS = np.load('PARAMETROS.npz',allow_pickle=True)
+for var_name in PARAMETROS.keys():
+    globals()[var_name] = PARAMETROS[var_name]
+    print(f'loaded: {var_name}')
+
+
+#%%
+
+"""
+Primero tengo mediciones de espectros cpt de un ion variando la tension dc_A
+"""
+
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20220106_CPT_DosLaseres_v08_TISA_DR\Data
+# os.chdir('../20231123_CPTconmicromocion3/Data/')
+
+folder = '../20231123_CPTconmicromocion3/Data/'
+CPT_FILES = f"""
+{folder}/000016262-IR_Scan_withcal_optimized
+{folder}/000016239-IR_Scan_withcal_optimized
+{folder}/000016240-IR_Scan_withcal_optimized
+{folder}/000016241-IR_Scan_withcal_optimized
+{folder}/000016244-IR_Scan_withcal_optimized
+{folder}/000016255-IR_Scan_withcal_optimized
+{folder}/000016256-IR_Scan_withcal_optimized
+{folder}/000016257-IR_Scan_withcal_optimized
+"""
+
+
+def SeeKeys(files):
+    for i, fname in enumerate(files.split()):
+        data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+        print(fname)
+        print(list(data['datasets'].keys()))
+
+print(SeeKeys(CPT_FILES))
+
+#carpeta pc nico labo escritorio:
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20211101_CPT_DosLaseres_v03\Data
+
+Counts = []
+Freqs = []
+
+AmpTisa = []
+UVCPTAmp = []
+No_measures = []
+Voltages = []
+
+for i, fname in enumerate(CPT_FILES.split()):
+    print(str(i) + ' - ' + fname)
+    #print(fname)
+    data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+
+    # Aca hago algo repugnante para poder levantar los strings que dejamos
+    # que además tenian un error de tipeo al final. Esto no deberá ser necesario
+    # cuando se solucione el error este del guardado.
+    Freqs.append(np.array(data['datasets']['IR1_Frequencies']))
+    Counts.append(np.array(data['datasets']['data_array']))
+    #AmpTisa.append(np.array(data['datasets']['TISA_CPT_amp']))
+    UVCPTAmp.append(np.array(data['datasets']['UV_CPT_amp']))
+    No_measures.append(np.array(data['datasets']['no_measures']))
+    Voltages.append(np.array(data['datasets']['scanning_voltages']))
+
+def Split(array,n):
+    length=len(array)/n
+    splitlist = []
+    jj = 0
+    while jj<length:
+        partial = []
+        ii = 0
+        while ii < n:
+            partial.append(array[jj*n+ii])
+            ii = ii + 1
+        splitlist.append(partial)
+        jj = jj + 1
+    return splitlist
+
+
+CountsSplit = []
+CountsSplit.append(Split(Counts[0],len(Freqs[0])))
+
+
+CountsSplit_2ions = []
+CountsSplit_2ions.append(Split(Counts[4],len(Freqs[4])))
+
+#%%
+
+"""
+Ploteo la cpt de referencia / plotting the reference CPT
+"""
+
+jvec = [9] # de la 1 a la 9 vale la pena, despues no
+
+drs = [390.5, 399.5, 406, 413.5]
+
+drive=22.1
+
+Frequencies = Freqs[0]
+
+plt.figure()
+i = 0
+for j in jvec:
+    plt.errorbar([2*f*1e-6 for f in Frequencies], CountsSplit[0][j], yerr=np.sqrt(CountsSplit[0][j]), fmt='o', capsize=2, markersize=2)
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+#for dr in drs:
+#    plt.axvline(dr)
+    #plt.axvline(dr+drive)
+plt.legend()
+
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 1
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+offsetxpi = 419+correccion+3*0.8
+DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+selectedcurve = 1
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+CountsDR[100]=0.5*(CountsDR[99]+CountsDR[101])
+CountsDR[105]=0.5*(CountsDR[104]+CountsDR[106])
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+    t0 = time.time()
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    # print(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], dict(circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None))
+
+    print('Done, Total time: ', round((time.time()-t0), 2), "s")
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+if not 'popt_1' in globals().keys():
+    popt_1, pcov_1 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 3e4, 1.34e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10, 10e-3)))
+    FittedEITpi_1 = FitEIT_MM_single(freqslong, *popt_1)
+
+beta1 = popt_1[4]
+errorbeta1 = np.sqrt(pcov_1[4,4])
+temp1 = popt_1[5]
+errortemp1 = np.sqrt(pcov_1[5,5])
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_1, color='darkolivegreen', linewidth=3, label='med 1')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 2
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+offsetxpi = 419+correccion+1.6
+DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+
+selectedcurve = 2
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+if not 'popt_2' in globals().keys():
+    popt_2, pcov_2 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 3e4, 1.34e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10, 10e-3)))
+    FittedEITpi_2 = FitEIT_MM_single(freqslong, *popt_2)
+
+beta2 = popt_2[4]
+errorbeta2 = np.sqrt(pcov_2[4,4])
+temp2 = popt_2[5]
+errortemp2 = np.sqrt(pcov_2[5,5])
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_2, color='darkolivegreen', linewidth=3, label='med 2')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 3
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+offsetxpi = 419+correccion+0.8
+DetDoppler = -11.5-correccion
+
+print(offsetxpi,DetDoppler)
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+selectedcurve = 3
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+if not 'popt_3' in globals().keys():
+    popt_3, pcov_3 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 3e4, 1.34e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10, 10e-3)))
+    FittedEITpi_3 = FitEIT_MM_single(freqslong, *popt_3)
+
+beta3 = popt_3[4]
+errorbeta3 = np.sqrt(pcov_3[4,4])
+temp3 = popt_3[5]
+errortemp3 = np.sqrt(pcov_3[5,5])
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_3, color='darkolivegreen', linewidth=3, label='med 3')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 4
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+offsetxpi = 419+correccion
+DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+selectedcurve = 4
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+
+if not 'popt_4' in globals().keys():
+    popt_4, pcov_4 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 3e4, 1.34e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10, 10e-3)))
+    FittedEITpi_4 = FitEIT_MM_single(freqslong, *popt_4)
+
+beta4 = popt_4[4]
+errorbeta4 = np.sqrt(pcov_4[4,4])
+temp4 = popt_4[5]
+errortemp4 = np.sqrt(pcov_4[5,5])
+
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_4, color='darkolivegreen', linewidth=3, label='med 4')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 5
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+offsetxpi = 419+correccion-1
+DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+selectedcurve = 5
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    #TEMP = 0.2e-3
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+if not 'popt_5' in globals().keys():
+    popt_5, pcov_5 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 3e4, 1.34e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10, 10e-3)))
+    FittedEITpi_5 = FitEIT_MM_single(freqslong, *popt_5)
+
+beta5 = popt_5[4]
+errorbeta5 = np.sqrt(pcov_5[4,4])
+temp5 = popt_5[5]
+errortemp5 = np.sqrt(pcov_5[5,5])
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_5, color='darkolivegreen', linewidth=3, label='med 5')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 6
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+offsetxpi = 419+correccion-2.2
+DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+selectedcurve = 6
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+CountsDR[76]=0.5*(CountsDR[75]+CountsDR[77])
+CountsDR[1]=0.5*(CountsDR[0]+CountsDR[2])
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+if not 'popt_6' in globals().keys():
+    popt_6, pcov_6 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 5e4, 1e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10, 10e-3)))
+    FittedEITpi_6 = FitEIT_MM_single(freqslong, *popt_6)
+
+beta6 = popt_6[4]
+errorbeta6 = np.sqrt(pcov_6[4,4])
+temp6 = popt_6[5]
+errortemp6 = np.sqrt(pcov_6[5,5])
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_6, color='darkolivegreen', linewidth=3, label='med 6')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 7
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+offsetxpi = 419+correccion-3.7
+DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+selectedcurve = 7
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+if not 'popt_7' in globals().keys():
+    popt_7, pcov_7 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 3e4, 1.34e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10, 10e-3)))
+    FittedEITpi_7 = FitEIT_MM_single(freqslong, *popt_7)
+
+beta7 = popt_7[4]
+errorbeta7 = np.sqrt(pcov_7[4,4])
+temp7 = popt_7[5]
+errortemp7 = np.sqrt(pcov_7[5,5])
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_7, color='darkolivegreen', linewidth=3, label='med 7')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 8
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+offsetxpi = 419+correccion-4.9
+DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+selectedcurve = 8
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+if not 'popt_8' in globals().keys():
+    popt_8, pcov_8 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 3e4, 1.34e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10, 10e-3)))
+    FittedEITpi_8 = FitEIT_MM_single(freqslong, *popt_8)
+
+beta8 = popt_8[4]
+errorbeta8 = np.sqrt(pcov_8[4,4])
+temp8 = popt_8[5]
+errortemp8 = np.sqrt(pcov_8[5,5])
+
+print()
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_8, color='darkolivegreen', linewidth=3, label='med 8')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+MEDICION 9
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 16
+
+offsetxpi = 419+correccion-6
+DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+selectedcurve = 9
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[0]]
+CountsDR = CountsSplit[0][selectedcurve]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM_single(freqs, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    #TEMP = 0.2e-3
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1
+    #return ScaledFluo1
+
+if not 'popt_9' in globals().keys():
+    popt_9, pcov_9 = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[0.9, 6.2, 3e4, 1.34e3, 2, 1e-3], bounds=((0, 0, 0, 0, 0, 0), (2, 20, 5e4, 5e4, 10,10e-3)))
+    FittedEITpi_9 = FitEIT_MM_single(freqslong, *popt_9)
+
+beta9 = popt_9[4]
+errorbeta9 = np.sqrt(pcov_9[4,4])
+temp9 = popt_9[5]
+errortemp9 = np.sqrt(pcov_9[5,5])
+
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_9, color='darkolivegreen', linewidth=3, label='med 9')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+
+#%%
+"""
+AHORA INTENTO SUPER AJUSTES O SEA CON OFFSETXPI Y DETDOPPLER INCLUIDOS
+
+La 0 no ajusta bien incluso con todos los parametros libres
+De la 1 a la 11 ajustan bien
+"""
+
+
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+SUPER AJUSTE (SA)
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+#DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+SelectedCurveVec = [1,2,3,4,5,6,7,8,9,10,11]
+#SelectedCurveVec = [10]
+
+if not 'popt_SA_vec' in globals().keys() or len(popt_SA_vec)==0:
+
+    popt_SA_vec = []
+    pcov_SA_vec = []
+    Detuningsshort_vec = []
+    Counts_vec = []
+    Detuningslong_vec = []
+    FittedCounts_vec = []
+
+    Betas_vec = []
+    ErrorBetas_vec = []
+    Temp_vec = []
+    ErrorTemp_vec = []
+
+    DetuningsUV_vec = []
+    ErrorDetuningsUV_vec = []
+
+    for selectedcurve in SelectedCurveVec:
+
+    #selectedcurve = 2 #IMPORTANTE: SELECCIONA LA MEDICION
+
+        FreqsDR = Freqs[0]
+        CountsDR = CountsSplit[0][selectedcurve]
+
+
+        if selectedcurve==1:
+            CountsDR[100]=0.5*(CountsDR[99]+CountsDR[101])
+            CountsDR[105]=0.5*(CountsDR[104]+CountsDR[106])
+        if selectedcurve==2:
+            CountsDR[67]=0.5*(CountsDR[66]+CountsDR[68])
+            CountsDR[71]=0.5*(CountsDR[70]+CountsDR[72])
+        if selectedcurve==6:
+            CountsDR[1]=0.5*(CountsDR[0]+CountsDR[2])
+            CountsDR[76]=0.5*(CountsDR[75]+CountsDR[77])
+        if selectedcurve==7:
+            CountsDR[117]=0.5*(CountsDR[116]+CountsDR[118])
+
+        freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+        CircPr = 1
+        alpha = 0
+
+
+        def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP, plot=False):
+        #def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+            #BETA = 1.8
+            # SG = 0.6
+            # SP = 8.1
+            # TEMP = 0.2e-3
+
+            freqs = [2*f*1e-6-offset for f in Freqs]
+
+            Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+            ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+            if plot:
+                return ScaledFluo1, Detunings
+            else:
+                return ScaledFluo1
+            #return ScaledFluo1
+
+        if True:
+            popt_3_SA, pcov_3_SA = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[430, -25, 0.9, 6.2, 3e4, 1.34e3, 2, (np.pi**2)*1e-3], bounds=((0, -50, 0, 0, 0, 0, 0, 0), (1000, 0, 2, 20, 5e4, 5e4, 10, (np.pi**2)*10e-3)))
+
+            popt_SA_vec.append(popt_3_SA)
+            pcov_SA_vec.append(pcov_3_SA)
+
+            FittedEITpi_3_SA_short, Detunings_3_SA_short = FitEIT_MM_single(FreqsDR, *popt_3_SA, plot=True)
+            freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+            FittedEITpi_3_SA_long, Detunings_3_SA_long = FitEIT_MM_single(freqslong, *popt_3_SA, plot=True)
+
+        DetuningsUV_vec.append(popt_3_SA[1])
+        ErrorDetuningsUV_vec.append(np.sqrt(pcov_3_SA[1,1]))
+
+        Betas_vec.append(popt_3_SA[6])
+        ErrorBetas_vec.append(np.sqrt(pcov_3_SA[6,6]))
+        Temp_vec.append(popt_3_SA[7])
+        ErrorTemp_vec.append(np.sqrt(pcov_3_SA[7,7]))
+
+        Detuningsshort_vec.append(Detunings_3_SA_short)
+        Counts_vec.append(CountsDR)
+        Detuningslong_vec.append(Detunings_3_SA_long)
+        FittedCounts_vec.append(FittedEITpi_3_SA_long)
+
+
+tmp_datos=(Detuningsshort_vec,Counts_vec,Detuningslong_vec,FittedCounts_vec,SelectedCurveVec)
+
+for Detunings_3_SA_short,CountsDR,Detunings_3_SA_long,FittedEITpi_3_SA_long,selectedcurve in zip(*tmp_datos):
+    plt.figure()
+    plt.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+    plt.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, color='darkolivegreen', linewidth=3, label=f'med {selectedcurve}')
+    #plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+    plt.xlabel('Detuning (MHz)')
+    plt.ylabel('Counts')
+    plt.legend(loc='upper left', fontsize=20)
+    plt.grid()
+
+    print(f'listo med {selectedcurve}')
+    print(popt_3_SA)
+
+
+#%%
+"""
+Grafico distintas variables que salieron del SUper ajuste
+"""
+
+import seaborn as sns
+paleta = sns.color_palette("rocket")
+
+voltages_dcA = Voltages[0][1:10]
+
+def lineal(x,a,b):
+    return a*x+b
+
+def hiperbola(x,a,b,c,x0):
+    return a*np.sqrt(((x-x0)**2+c**2))+b
+
+hiperbola_or_linear = True
+
+if hiperbola_or_linear:
+    popthip,pcovhip = curve_fit(hiperbola,voltages_dcA,Betas_vec,p0=(100,0.1,1,-0.15))
+
+    xhip = np.linspace(-0.23,0.005,200)
+
+    plt.figure()
+    plt.errorbar(voltages_dcA,Betas_vec,yerr=ErrorBetas_vec,fmt='o',capsize=5,markersize=5,color=paleta[1])
+    plt.plot(xhip,hiperbola(xhip,*popthip))
+    plt.xlabel('Endcap voltage (V)')
+    plt.ylabel('Modulation factor')
+    plt.grid()
+
+else:
+    poptini,pcovini = curve_fit(lineal,voltages_dcA[0:3],Betas_vec[0:3])
+    poptfin,pcovfin = curve_fit(lineal,voltages_dcA[4:],Betas_vec[4:])
+
+    minimum_voltage = -(poptini[1]-poptfin[1])/(poptini[0]-poptfin[0]) #voltaje donde se intersectan las rectas, es decir, donde deberia estar el minimo de micromocion
+    minimum_modulationfactor = lineal(minimum_voltage,*poptini) #es lo mismo si pongo *poptfin
+
+    xini = np.linspace(-0.23,-0.13,100)
+    xfin = np.linspace(-0.15,0.005,100)
+
+    plt.figure()
+    plt.errorbar(voltages_dcA,Betas_vec,yerr=ErrorBetas_vec,fmt='o',capsize=5,markersize=5,color=paleta[1])
+    plt.plot(xini,lineal(xini,*poptini))
+    plt.plot(xfin,lineal(xfin,*poptfin))
+    plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+    plt.xlabel('Endcap voltage (V)')
+    plt.ylabel('Modulation factor')
+    plt.grid()
+
+
+print([t*1e3 for t in Temp_vec])
+
+plt.figure()
+plt.errorbar(voltages_dcA,[t*1e3 for t in Temp_vec],yerr=[t*1e3 for t in ErrorTemp_vec],fmt='o',capsize=5,markersize=5,color=paleta[3])
+# plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+print(f'\n\nTE FALTA DEFINIR LA VARIABLE minimum_voltage\n\n')
+plt.axhline(0.538)
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+#plt.ylim(0,2)
+
+#%%
+"""
+Ahora hago un ajuste con una hiperbola porque tiene mas sentido, por el hecho
+de que en el punto optimo el ion no esta en el centro de la trampa
+sino que esta a una distancia d
+"""
+def hiperbola(x,a,b,c,x0):
+    return a*np.sqrt(((x-x0)**2+c**2))+b
+
+popthip,pcovhip = curve_fit(hiperbola,voltages_dcA,Betas_vec,p0=(100,0.1,1,-0.15))
+
+xhip = np.linspace(-0.23,0.005,200)
+
+plt.figure()
+plt.errorbar(voltages_dcA,Betas_vec,yerr=ErrorBetas_vec,fmt='o',capsize=5,markersize=5,color=paleta[1])
+plt.plot(xhip,hiperbola(xhip,*popthip))
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Modulation factor')
+plt.grid()
+
+
+
+
+#%%
+from scipy.special import jv
+
+
+def expo(x,tau,A,B):
+    return A*np.exp(x/tau)+B
+
+def cuadratica(x,a,c):
+    return a*(x**2)+c
+
+def InverseMicromotionSpectra(beta, A, det, x0, gamma, B):
+    ftrap=22.1
+    #gamma=30
+    P = ((jv(0, beta)**2)/((((det-x0)**2)+(0.5*gamma)**2)**2))*(-2*(det-x0))
+    i = 1
+    #print(P)
+    while i <= 5:
+        P = P + (-2*(det-x0))*((jv(i, beta))**2)/(((((det-x0)+i*ftrap)**2)+(0.5*gamma)**2)**2) + (-2*(det-x0))*(((jv(-i, beta))**2)/((((det-x0)-i*ftrap)**2)+(0.5*gamma)**2)**2)
+        i = i + 1
+        #print(P)
+    #return 1/(A*P+B)
+    return 1/(A*P+B)
+
+
+def InverseMicromotionSpectra_raw(beta, A, det, B):
+    ftrap=22.1
+    gamma=21
+    P = ((jv(0, beta)**2)/((((det)**2)+(0.5*gamma)**2)**2))*(-2*(det))
+    i = 1
+    #print(P)
+    while i <= 3:
+        P = P + (-2*(det))*((jv(i, beta))**2)/(((((det)+i*ftrap)**2)+(0.5*gamma)**2)**2) + (-2*(det))*(((jv(-i, beta))**2)/((((det)-i*ftrap)**2)+(0.5*gamma)**2)**2)
+        i = i + 1
+        #print(P)
+    return A/P+B
+
+
+"""
+Temperatura vs
+"""
+
+popt_exp, pcov_exp = curve_fit(expo,Betas_vec,[t*1e3 for t in Temp_vec])
+
+betaslong = np.arange(0,2.7,0.01)
+
+plt.figure()
+plt.errorbar(Betas_vec,[t*1e3 for t in Temp_vec],xerr=ErrorBetas_vec, yerr=[t*1e3 for t in ErrorTemp_vec],fmt='o',capsize=5,markersize=5,color=paleta[3])
+plt.plot(betaslong,expo(betaslong,*popt_exp))
+#plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+#plt.axhline(0.538)
+plt.xlabel('Modulation factor')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+
+
+#%%
+"""
+Esto no es del super ajuste sino de los ajustes anteriores en donde DetDoppler y offset son puestos a mano
+Aca grafico los betas con su error en funcion de la tension variada.
+Ademas, hago ajuste lineal para primeros y ultimos puntos, ya que espero que
+si la tension hace que la posicion del ion varie linealmente, el beta varia proporcional a dicha posicion.
+"""
+
+import seaborn as sns
+
+def lineal(x,a,b):
+    return a*x+b
+
+paleta = sns.color_palette("rocket")
+
+betavector = [beta1,beta2,beta3,beta4,beta5,beta6,beta7,beta8,beta9]
+errorbetavector = [errorbeta1,errorbeta2,errorbeta3,errorbeta4,errorbeta5,errorbeta6,errorbeta7,errorbeta8,errorbeta9]
+voltages_dcA = Voltages[0][1:10]
+
+poptini,pcovini = curve_fit(lineal,voltages_dcA[0:3],betavector[0:3])
+poptfin,pcovfin = curve_fit(lineal,voltages_dcA[4:],betavector[4:])
+
+minimum_voltage = -(poptini[1]-poptfin[1])/(poptini[0]-poptfin[0]) #voltaje donde se intersectan las rectas, es decir, donde deberia estar el minimo de micromocion
+minimum_modulationfactor = lineal(minimum_voltage,*poptini) #es lo mismo si pongo *poptfin
+
+xini = np.linspace(-0.23,-0.13,100)
+xfin = np.linspace(-0.15,0.005,100)
+
+plt.figure()
+plt.errorbar(voltages_dcA,betavector,yerr=errorbetavector,fmt='o',capsize=5,markersize=5,color=paleta[1])
+plt.plot(xini,lineal(xini,*poptini))
+plt.plot(xfin,lineal(xfin,*poptfin))
+plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Modulation factor')
+plt.grid()
+
+
+#%%
+"""
+Aca veo la temperatura del ion en funcion del voltaje del endcap, ya que
+al cambiar la cantidad de micromocion, cambia la calidad del enfriado
+"""
+tempvector = np.array([temp1,temp2,temp3,temp4,temp5,temp6,temp7,temp8,temp9])*1e3
+errortempvector = np.array([errortemp1,errortemp2,errortemp3,errortemp4,errortemp5,errortemp6,errortemp7,errortemp8,errortemp9])*1e3
+
+voltages_dcA = Voltages[0][1:10]
+
+plt.figure()
+plt.errorbar(voltages_dcA,tempvector,yerr=errortempvector,fmt='o',capsize=5,markersize=5,color=paleta[3])
+plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+plt.ylim(0,2)
+
+
+#%%
+"""
+Por las dudas, temperatura en funcion de beta
+"""
+plt.figure()
+plt.errorbar(betavector,tempvector,yerr=errortempvector,xerr=errorbetavector,fmt='o',capsize=5,markersize=5)
+plt.xlabel('Modulation factor')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+
+
+
+#%%
+"""
+Si quiero ver algun parametro del ajuste puntual. el orden es: 0:SG, 1:SP, 2:SCALE1, 3:OFFSET
+"""
+ki=2
+plt.errorbar(np.arange(0,9,1),[popt_1[ki],popt_2[ki],popt_3[ki],popt_4[ki],popt_5[ki],popt_6[ki],popt_7[ki],popt_8[ki],popt_9[ki]],yerr=[np.sqrt(pcov_1[ki,ki]),np.sqrt(pcov_2[ki,ki]),np.sqrt(pcov_3[ki,ki]),np.sqrt(pcov_4[ki,ki]),np.sqrt(pcov_5[ki,ki]),np.sqrt(pcov_6[ki,ki]),np.sqrt(pcov_7[ki,ki]),np.sqrt(pcov_8[ki,ki]),np.sqrt(pcov_9[ki,ki])], fmt='o',capsize=3,markersize=3)
+
+#%%
+"""
+AHORA VAMOS A MEDICIONES CON MAS DE UN ION!!!
+"""
+
+"""
+Ploteo la cpt de referencia / plotting the reference CPT
+
+1: 2 iones, -100 mV dcA
+2: 2 iones, -150 mV dcA
+3: 2 iones, -50 mV dcA
+4: 2 iones, 5 voltajes (el ion se va en la 4ta medicion y en la 5ta ni esta)
+5, 6 y 7: 3 iones en donde el scaneo esta centrado en distintos puntos
+
+"""
+
+jvec = [3] # desde la 1, pero la 4 no porque es un merge de curvitas
+
+plt.figure()
+i = 0
+for j in jvec:
+    plt.errorbar([2*f*1e-6 for f in Freqs[j]], Counts[j], yerr=np.sqrt(Counts[j]), fmt='o', capsize=2, markersize=2)
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+#for dr in drs:
+#    plt.axvline(dr)
+    #plt.axvline(dr+drive)
+plt.legend()
+
+
+#%%
+"""
+Mergeo la 5, 6 y 7
+"""
+
+Freqs5 = [2*f*1e-6 for f in Freqs[5]]
+Freqs6 = [2*f*1e-6 for f in Freqs[6]]
+Freqs7 = [2*f*1e-6 for f in Freqs[7]]
+
+Counts5 = Counts[5]
+Counts6 = Counts[6]
+Counts7 = Counts[7]
+
+i_1_ini = 0
+i_1 = 36
+i_2_ini = 0
+i_2 = 24
+
+f_1 = 18
+f_2 = 30
+
+
+scale_1 = 0.92
+scale_2 = 0.98
+
+#Merged_freqs_test = [f-f_2 for f in Freqs6[i_2_ini:i_2]]+[f-f_1 for f in Freqs5[i_1_ini:i_1]]+Freqs7
+
+#plt.plot(Merged_freqs_test,'o')
+
+
+
+Merged_freqs = [f-f_2 for f in Freqs6[0:i_2]]+[f-f_1 for f in Freqs5[0:i_1]]+Freqs7
+Merged_counts = [scale_2*c for c in Counts6[0:i_2]]+[scale_1*c for c in Counts5[0:i_1]]+list(Counts7)
+
+Merged_freqs_rescaled = np.linspace(np.min(Merged_freqs),np.max(Merged_freqs),len(Merged_freqs))
+
+#drs = [391.5, 399.5, 405.5, 414]
+drs = [370,379,385,391.5]
+
+plt.figure()
+i = 0
+for j in jvec:
+    plt.plot([f-f_1 for f in Freqs5[0:i_1]], [scale_1*c for c in Counts5[0:i_1]],'o')
+    plt.plot([f-f_2 for f in Freqs6[0:i_2]], [scale_2*c for c in Counts6[0:i_2]],'o')
+    plt.plot(Freqs7, Counts7,'o')
+    plt.errorbar(Merged_freqs, Merged_counts, yerr=np.sqrt(Merged_counts), fmt='o', capsize=2, markersize=2)
+
+
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+for dr in drs:
+    plt.axvline(dr)
+    plt.axvline(dr+drive, color='red', linestyle='dashed', alpha=0.3)
+    plt.axvline(dr-drive, color='red', linestyle='dashed', alpha=0.3)
+
+plt.legend()
+
+#%%
+"""
+ajusto la mergeada de 3 iones
+"""
+
+raise ValueError('STOP')
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = -20
+
+offsetxpi = 438+correccion
+DetDoppler = -35-correccion-22
+
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+FreqsDR = [f-offsetxpi for f in Merged_freqs]
+CountsDR = Merged_counts
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+import numba
+
+
+@numba.jit
+def FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+
+
+    #BETA1, BETA2, BETA3 = 0, 0, 2
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence3 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA3, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+
+    ScaledFluo1 = np.array([f*SCALE1 for f in Fluorescence1])
+    ScaledFluo2 = np.array([f*SCALE2 for f in Fluorescence2])
+    ScaledFluo3 = np.array([f*SCALE3 for f in Fluorescence3])
+    return ScaledFluo1+ScaledFluo2+ScaledFluo3+OFFSET
+    #return ScaledFluo1
+
+
+if not 'popt_3ions' in globals().keys():
+    popt_3ions, pcov_3ions = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.6, 6.2, 3.5e5, 3.5e5, 3.5e5, 2e3, 1, 1, 1], bounds=((0, 0, 0, 0, 0, 0, 0, 0, 0), (2, 20, 5e8, 5e8, 5e8, 7e3, 10, 10, 10)))
+#popt, pcov = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.8, 8, 4e4, 3.5e3, 0], bounds=((0, 0, 0, 0, 0), (2, 15, 1e5, 1e5, 10)))
+
+#array([7.12876797e-01, 7.92474752e+00, 4.29735308e+04, 1.74240582e+04,
+       #1.53401696e+03, 1.17073206e-06, 2.53804151e+00])
+
+
+FittedEITpi_3ions = FitEIT_MM(freqslong, *popt_3ions)
+#FittedEITpi_3ions = FitEIT_MM(freqslong, popt_3ions[0],popt_3ions[1],popt_3ions[2],popt_3ions[3],popt_3ions[4],popt_3ions[5],4,2,0)
+
+#FittedEITpi_3ions = FitEIT_MM(freqslong, *popt_3ions)
+
+
+print(popt_3ions)
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_3ions, color='darkgreen', linewidth=3)
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.title(f'Corr:{correccion},DetD:{DetDoppler}')
+plt.grid()
+
+
+
+
+
+#%%
+"""
+Veo la medicion de varios voltajes uno atras de otro
+Se va en medio de la medicion 4, y en la 5 ni esta
+"""
+
+jvec = [2] # desde la 1, pero la 4 no porque es un merge de curvitas
+
+Freqs
+
+plt.figure()
+i = 0
+for j in jvec:
+    plt.errorbar([2*f*1e-6 for f in Freqs[4]], CountsSplit_2ions[0][j], yerr=np.sqrt(CountsSplit_2ions[0][j]), fmt='o', capsize=2, markersize=2)
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+#for dr in drs:
+#    plt.axvline(dr)
+    #plt.axvline(dr+drive)
+plt.legend()
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+AJUSTO LA CPT DE 2 IONES CON UN MODELO EN DONDE SUMO DOS ESPECTROS CON BETAS DISTINTOS
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 27
+
+offsetxpi = 421+correccion
+DetDoppler = -16-correccion+5
+
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[1]]
+CountsDR = Counts[1]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, OFFSET):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+
+    BETA1, BETA2 = 3, 0
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    ScaledFluo2 = np.array([f*SCALE2 + OFFSET for f in Fluorescence2])
+    return ScaledFluo1+ScaledFluo2
+    #return ScaledFluo1
+
+
+if not 'popt_2ions_1' in globals().keys():
+    popt_2ions_1, pcov_2ions_1 = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.9, 6.2, 3.5e3, 2.9e3, 3e3], bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 5e8, 8e3)))
+#popt, pcov = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.8, 8, 4e4, 3.5e3, 0], bounds=((0, 0, 0, 0, 0), (2, 15, 1e5, 1e5, 10)))
+
+#array([7.12876797e-01, 7.92474752e+00, 4.29735308e+04, 1.74240582e+04,
+       #1.53401696e+03, 1.17073206e-06, 2.53804151e+00])
+
+FittedEITpi_2sp = FitEIT_MM(freqslong, *popt_2ions_1)
+#FittedEITpi = FitEIT_MM(freqslong, 0.8, 8, 4e4, 3.5e3, 0)
+
+# beta1_2ions = popt_2ions_1[5]
+# beta2_2ions = popt_2ions_1[6]
+
+# errbeta1_2ions = np.sqrt(pcov_2ions_1[5,5])
+# errbeta2_2ions = np.sqrt(pcov_2ions_1[6,6])
+
+"""
+Estos params dan bien poniendo beta2=0 y correccion=0 y son SG, SP, SCALE1, SCALE2, OFFSET, BETA1
+#array([9.03123248e-01, 6.25865542e+00, 3.47684055e+04, 2.92076804e+04, 1.34556420e+03, 3.55045904e+00])
+"""
+
+"""
+Ahora considerando ambos betas, con los parametros iniciales dados por los que se obtuvieron con beta2=0
+y correccion=0 dan estos parametros que son los de antes pero con BETA2 incluido:
+array([8.52685426e-01, 7.42939084e+00, 3.61998310e+04, 3.40160472e+04, 8.62651715e+02, 3.89756335e+00, 7.64867601e-01])
+"""
+
+#arreglito = np.array([8.52685426e-01, 7.42939084e+00, 3.61998310e+04, 3.40160472e+04, 8.62651715e+02, 3.89756335e+00, 7.64867601e-01])
+
+FittedEITpi_2ions_1 = FitEIT_MM(freqslong, *popt_2ions_1)
+
+
+print(popt_2ions_1)
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_2ions_1, color='darkgreen', linewidth=3)
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.title(f'Corr:{correccion},DetD:{DetDoppler}')
+plt.grid()
+
+
+#%%
+"""
+SUPER AJUSTE PARA MED DE 2 IONES
+"""
+
+
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+#DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+SelectedCurveVec = [3]
+
+
+if not 'popt_SA_vec_2ions' in globals().keys():
+
+    popt_SA_vec_2ions = []
+    pcov_SA_vec_2ions = []
+
+    for selectedcurve in SelectedCurveVec:
+
+        FreqsDR = Freqs[selectedcurve]
+        CountsDR = Counts[selectedcurve]
+
+        freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+        CircPr = 1
+        alpha = 0
+
+
+        def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, TEMP, plot=False):
+        #def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+            #BETA = 1.8
+            #SG = 0.6
+            #SP = 8.1
+            # TEMP = 0.2e-3
+
+            freqs = [2*f*1e-6-offset for f in Freqs]
+
+            Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+            Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+            ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+            ScaledFluo2 = np.array([f*SCALE2 for f in Fluorescence2])
+            if plot:
+                return ScaledFluo1+ScaledFluo2, Detunings
+            else:
+                return ScaledFluo1+ScaledFluo2
+            #return ScaledFluo1
+
+        if True:
+            popt_3_SA_2ions, pcov_3_SA_2ions = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[448, -42, 0.6, 8.1, 4e4, 4e4, 6e3, 1, 1.2, 0.5e-3], bounds=((0, -100,0, 0, 0,0,0,0,0, 0), (1000, 0, 2, 20,5e6, 5e6,5e4, 10, 10,10e-3)))
+
+            #popt_3_SA_2ions = [448, -42, 8e4, 6e3, 2, 0.5e-3]
+
+
+            popt_SA_vec_2ions.append(popt_3_SA_2ions)
+            pcov_SA_vec_2ions.append(pcov_3_SA_2ions)
+
+            FittedEITpi_3_SA_short, Detunings_3_SA_short = FitEIT_MM_single(FreqsDR, *popt_3_SA_2ions, plot=True)
+            freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+            FittedEITpi_3_SA_long, Detunings_3_SA_long = FitEIT_MM_single(freqslong, *popt_3_SA_2ions, plot=True)
+
+raise ValueError('Acá tenes que levantar de nuevo los valores que van')
+
+
+plt.figure()
+plt.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, color='darkolivegreen', linewidth=3, label=f'med {selectedcurve}')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+print(f'listo med {selectedcurve}')
+print(popt_3_SA_2ions)
+#print(f'Detdop:{popt_3_SA[1]},popt_3_SA:{popt[0]}')
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+AJUSTO LA CPT DE 2 IONES CON UN MODELO EN DONDE SUMO DOS ESPECTROS CON BETAS DISTINTOS
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 27
+
+offsetxpi = 421+correccion
+DetDoppler = -16-correccion+5
+
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[1]]
+CountsDR = Counts[1]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, OFFSET):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+
+    BETA1, BETA2 = 3, 0
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    ScaledFluo2 = np.array([f*SCALE2 + OFFSET for f in Fluorescence2])
+    return ScaledFluo1+ScaledFluo2
+    #return ScaledFluo1
+
+
+if not 'popt_2ions_1' in globals().keys():
+    popt_2ions_1, pcov_2ions_1 = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.9, 6.2, 3.5e3, 2.9e3, 3e3], bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 5e8, 8e3)))
+#popt, pcov = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.8, 8, 4e4, 3.5e3, 0], bounds=((0, 0, 0, 0, 0), (2, 15, 1e5, 1e5, 10)))
+
+#array([7.12876797e-01, 7.92474752e+00, 4.29735308e+04, 1.74240582e+04,
+       #1.53401696e+03, 1.17073206e-06, 2.53804151e+00])
+
+FittedEITpi_2sp = FitEIT_MM(freqslong, *popt_2ions_1)
+#FittedEITpi = FitEIT_MM(freqslong, 0.8, 8, 4e4, 3.5e3, 0)
+
+# beta1_2ions = popt_2ions_1[5]
+# beta2_2ions = popt_2ions_1[6]
+
+# errbeta1_2ions = np.sqrt(pcov_2ions_1[5,5])
+# errbeta2_2ions = np.sqrt(pcov_2ions_1[6,6])
+
+"""
+Estos params dan bien poniendo beta2=0 y correccion=0 y son SG, SP, SCALE1, SCALE2, OFFSET, BETA1
+#array([9.03123248e-01, 6.25865542e+00, 3.47684055e+04, 2.92076804e+04, 1.34556420e+03, 3.55045904e+00])
+"""
+
+"""
+Ahora considerando ambos betas, con los parametros iniciales dados por los que se obtuvieron con beta2=0
+y correccion=0 dan estos parametros que son los de antes pero con BETA2 incluido:
+array([8.52685426e-01, 7.42939084e+00, 3.61998310e+04, 3.40160472e+04, 8.62651715e+02, 3.89756335e+00, 7.64867601e-01])
+"""
+
+#arreglito = np.array([8.52685426e-01, 7.42939084e+00, 3.61998310e+04, 3.40160472e+04, 8.62651715e+02, 3.89756335e+00, 7.64867601e-01])
+
+FittedEITpi_2ions_1 = FitEIT_MM(freqslong, *popt_2ions_1)
+
+
+print(popt_2ions_1)
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_2ions_1, color='darkgreen', linewidth=3)
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.title(f'Corr:{correccion},DetD:{DetDoppler}')
+plt.grid()
+
+
+
+
+#%%
+
+if False:
+    GUARDAR = {}
+    for var in [ kk for kk in globals().keys() if kk.startswith('pop') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.startswith('pcov') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.startswith('Fitted') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.endswith('_vec') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+
+
+    np.savez('PARAMETROS.npz', **GUARDAR )

analisis/plots/20250516_CPT_bladetrap/lolo_CPT_plotter_20231123_multi.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Ploteo de datos y ajustes
+@author: lolo
+"""
+
+
+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
+# from scipy import interpolate
+
+
+
+
+
+#%% Funciones auxiliares
+
+from scipy.stats.distributions import  t,chi2
+
+def estadistica(datos_x,datos_y,modelo,pcov,parametros,nombres=None,alpha=0.05):
+    
+    if nombres is None:
+        nombres = [ f'{j}' for j in range(len(parametros)) ]
+    
+    # Cantidad de parámetros
+    P = len(parametros)
+    
+    # Número de datos
+    N = len(datos_x)
+    
+    # Grados de libertas (Degrees Of Freedom)
+    dof = N-P-1
+
+    # Cauculamos coordenadas del modelo
+    # modelo_x    = datos_x if modelo_x_arr is None else modelo_x_arr
+    # modelo_y    = modelo( modelo_x, *parametros )
+    
+    # Predicción del modelo para los datos_x medidos
+    prediccion_modelo = modelo( datos_x, *parametros )
+    
+    # Calculos de cantidades estadísticas relevantes
+    COV       = pcov                                      # Matriz de Covarianza
+    SE        = np.sqrt(np.diag( COV  ))                        # Standar Error / Error estandar de los parámetros
+    residuos  = datos_y - prediccion_modelo               # diferencia enrte el modelo y los datos
+    
+    SSE       = sum(( residuos )**2 )                     # Resitual Sum of Squares
+    SST       = sum(( datos_y - np.mean(datos_y))**2)        # Total Sum of Squares
+    
+    # http://en.wikipedia.org/wiki/Coefficient_of_determination
+    # Expresa el porcentaje de la varianza que logra explicar el modelos propuesto
+    Rsq       =  1 - SSE/SST                               # Coeficiente de determinación
+    Rsq_adj   = 1-(1-Rsq) * (N-1)/(N-P-1)                  # Coeficiente de determinación Ajustado   
+    
+    # https://en.wikipedia.org/wiki/Pearson_correlation_coefficient#In_least_squares_regression_analysis
+    # Expresa la correlación que hay entre los datos y la predicción del modelo
+    r_pearson = np.corrcoef( datos_y ,  prediccion_modelo )[0,1]
+    
+    # Reduced chi squared
+    # https://en.wikipedia.org/wiki/Reduced_chi-squared_statistic
+    chi2_     = sum( residuos**2 )/N
+    chi2_red  = sum( residuos**2 )/(N-P)
+    
+    # Chi squared test
+    chi2_test = sum( residuos**2 / abs(prediccion_modelo) )
+    # p-value del ajuste
+    p_val  = chi2(dof).cdf( chi2_test )
+    
+    
+    sT = t.ppf(1.0 - alpha/2.0, N - P ) # student T multiplier
+    CI = sT * SE                        # Confidence Interval
+    
+    print('R-squared    ',Rsq)
+    print('R-sq_adjusted',Rsq_adj)
+    print('chi2         ',chi2_)
+    print('chi2_reduced ',chi2_red)
+    print('chi2_test    ',chi2_test)
+    print('r-pearson    ',r_pearson)
+    print('p-value      ',p_val)
+    print('')
+    print('Error Estandard (SE):')
+    for i in range(P):
+        print(f'parametro[{nombres[i]:>5s}]: ' , parametros[i], ' ± ' , SE[i])
+    print('')
+    print('Intervalo de confianza al '+str((1-alpha)*100)+'%:')
+    for i in range(P):
+        print(f'parametro[{nombres[i]:>5s}]: ' , parametros[i], ' ± ' , CI[i])
+    
+    return dict(R2=Rsq,R2_adj=Rsq_adj,chi2=chi2_,chi2_red=chi2_red,
+                chi2_test=chi2_test,r=r_pearson,pvalue=p_val,
+                SE=SE,CI=CI)
+
+
+
+
+
+#%% Importaciones extra
+
+# /home/lolo/Dropbox/marce/LIAF/Trampa_anular/artiq_experiments/analisis/plots/20231123_CPTconmicromocion3/Data/EITfit/MM_eightLevel_2repumps_AnalysisFunctions.py
+
+from Data.EITfit.lolo_modelo_full_8niveles import PerformExperiment_8levels_MM
+
+
+PARAMETROS = np.load('PARAMETROS.npz',allow_pickle=True)
+for var_name in PARAMETROS.keys():
+    globals()[var_name] = PARAMETROS[var_name]
+    print(f'loaded: {var_name}')
+
+
+#%%
+
+"""
+Primero tengo mediciones de espectros cpt de un ion variando la tension dc_A
+"""
+
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20220106_CPT_DosLaseres_v08_TISA_DR\Data
+# os.chdir('../20231123_CPTconmicromocion3/Data/')
+
+folder = '../20231123_CPTconmicromocion3/Data/'
+CPT_FILES = f"""
+{folder}/000016262-IR_Scan_withcal_optimized
+{folder}/000016239-IR_Scan_withcal_optimized
+{folder}/000016240-IR_Scan_withcal_optimized
+{folder}/000016241-IR_Scan_withcal_optimized
+{folder}/000016244-IR_Scan_withcal_optimized
+{folder}/000016255-IR_Scan_withcal_optimized
+{folder}/000016256-IR_Scan_withcal_optimized
+{folder}/000016257-IR_Scan_withcal_optimized
+"""
+
+
+def SeeKeys(files):
+    for i, fname in enumerate(files.split()):
+        data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+        print(fname)
+        print(list(data['datasets'].keys()))
+
+print(SeeKeys(CPT_FILES))
+
+#carpeta pc nico labo escritorio:
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20211101_CPT_DosLaseres_v03\Data
+
+Counts = []
+Freqs = []
+
+AmpTisa = []
+UVCPTAmp = []
+No_measures = []
+Voltages = []
+
+for i, fname in enumerate(CPT_FILES.split()):
+    print(str(i) + ' - ' + fname)
+    #print(fname)
+    data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+
+    # Aca hago algo repugnante para poder levantar los strings que dejamos
+    # que además tenian un error de tipeo al final. Esto no deberá ser necesario
+    # cuando se solucione el error este del guardado.
+    Freqs.append(np.array(data['datasets']['IR1_Frequencies']))
+    Counts.append(np.array(data['datasets']['data_array']))
+    #AmpTisa.append(np.array(data['datasets']['TISA_CPT_amp']))
+    UVCPTAmp.append(np.array(data['datasets']['UV_CPT_amp']))
+    No_measures.append(np.array(data['datasets']['no_measures']))
+    Voltages.append(np.array(data['datasets']['scanning_voltages']))
+
+def Split(array,n):
+    length=len(array)/n
+    splitlist = []
+    jj = 0
+    while jj<length:
+        partial = []
+        ii = 0
+        while ii < n:
+            partial.append(array[jj*n+ii])
+            ii = ii + 1
+        splitlist.append(partial)
+        jj = jj + 1
+    return splitlist
+
+
+CountsSplit = []
+CountsSplit.append(Split(Counts[0],len(Freqs[0])))
+
+
+CountsSplit_2ions = []
+CountsSplit_2ions.append(Split(Counts[4],len(Freqs[4])))
+
+#%%
+
+"""
+Ploteo la cpt de referencia / plotting the reference CPT
+"""
+
+jvec = [2] # de la 1 a la 9 vale la pena, despues no
+
+drs = [390.5, 399.5, 406, 413.5]
+
+drive=22.1
+
+Frequencies = Freqs[0]
+
+plt.figure()
+i = 0
+for j in jvec:
+    plt.errorbar([2*f*1e-6 for f in Frequencies], CountsSplit[0][j], yerr=np.sqrt(CountsSplit[0][j]), fmt='o', capsize=2, markersize=2)
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+#for dr in drs:
+#    plt.axvline(dr)
+    #plt.axvline(dr+drive)
+plt.legend()
+
+#%%
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+
+#%%
+"""
+AHORA VAMOS A MEDICIONES CON MAS DE UN ION!!!
+
+Las mediciones estan buenas, habria que ver de ajustarlas bien, yo no lo logre.
+
+"""
+
+"""
+Ploteo la cpt de referencia / plotting the reference CPT
+
+1: 2 iones, -100 mV dcA
+2: 2 iones, -150 mV dcA
+3: 2 iones, -50 mV dcA
+4: 2 iones, 5 voltajes (el ion se va en la 4ta medicion y en la 5ta ni esta)
+5, 6 y 7: 3 iones en donde el scaneo esta centrado en distintos puntos
+
+"""
+
+jvec = [3] # desde la 1, pero la 4 no porque es un merge de curvitas
+
+plt.figure()
+i = 0
+for j in jvec:
+    plt.errorbar([2*f*1e-6 for f in Freqs[j]], Counts[j], yerr=np.sqrt(Counts[j]), fmt='o', capsize=2, markersize=2)
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+#for dr in drs:
+#    plt.axvline(dr)
+    #plt.axvline(dr+drive)
+plt.legend()
+
+
+#%%
+"""
+Mergeo la 5, 6 y 7
+"""
+
+Freqs5 = [2*f*1e-6 for f in Freqs[5]]
+Freqs6 = [2*f*1e-6 for f in Freqs[6]]
+Freqs7 = [2*f*1e-6 for f in Freqs[7]]
+
+Counts5 = Counts[5]
+Counts6 = Counts[6]
+Counts7 = Counts[7]
+
+i_1_ini = 0
+i_1 = 36
+i_2_ini = 0
+i_2 = 24
+
+f_1 = 18
+f_2 = 30
+
+
+scale_1 = 0.92
+scale_2 = 0.98
+
+#Merged_freqs_test = [f-f_2 for f in Freqs6[i_2_ini:i_2]]+[f-f_1 for f in Freqs5[i_1_ini:i_1]]+Freqs7
+
+#plt.plot(Merged_freqs_test,'o')
+
+
+
+Merged_freqs = [f-f_2 for f in Freqs6[0:i_2]]+[f-f_1 for f in Freqs5[0:i_1]]+Freqs7
+Merged_counts = [scale_2*c for c in Counts6[0:i_2]]+[scale_1*c for c in Counts5[0:i_1]]+list(Counts7)
+
+Merged_freqs_rescaled = np.linspace(np.min(Merged_freqs),np.max(Merged_freqs),len(Merged_freqs))
+
+#drs = [391.5, 399.5, 405.5, 414]
+drs = [370,379,385,391.5]
+
+plt.figure()
+i = 0
+for j in jvec:
+    plt.plot([f-f_1 for f in Freqs5[0:i_1]], [scale_1*c for c in Counts5[0:i_1]],'o')
+    plt.plot([f-f_2 for f in Freqs6[0:i_2]], [scale_2*c for c in Counts6[0:i_2]],'o')
+    plt.plot(Freqs7, Counts7,'o')
+    plt.errorbar(Merged_freqs, Merged_counts, yerr=np.sqrt(Merged_counts), fmt='o', capsize=2, markersize=2)
+
+
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+for dr in drs:
+    plt.axvline(dr)
+    plt.axvline(dr+drive, color='red', linestyle='dashed', alpha=0.3)
+    plt.axvline(dr-drive, color='red', linestyle='dashed', alpha=0.3)
+
+plt.legend()
+
+#%%
+"""
+ajusto la mergeada de 3 iones
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = -20
+
+offsetxpi = 438+correccion
+DetDoppler = -35-correccion-22
+
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+FreqsDR = [f-offsetxpi for f in Merged_freqs]
+CountsDR = Merged_counts
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+import numba
+
+
+
+@numba.jit
+def FitEIT_MM1(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+
+    #BETA1, BETA2, BETA3 = 0, 0, 2
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 for f in Fluorescence1])
+
+    return ScaledFluo1+OFFSET
+    #return ScaledFluo1
+
+
+@numba.jit
+def FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+    freqs = np.array(freqs)
+
+    #BETA1, BETA2, BETA3 = 0, 0, 2
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence3 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA3, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+
+    # ScaledFluo1 = np.array([f*SCALE1 for f in Fluorescence1])
+    # ScaledFluo2 = np.array([f*SCALE2 for f in Fluorescence2])
+    # ScaledFluo3 = np.array([f*SCALE3 for f in Fluorescence3])
+    # return ScaledFluo1+ScaledFluo2+ScaledFluo3+OFFSET
+    Fluorescence1 = np.array(Fluorescence1)
+    Fluorescence2 = np.array(Fluorescence2)
+    Fluorescence3 = np.array(Fluorescence3)
+    return SCALE1*Fluorescence1+SCALE2*Fluorescence2+SCALE3*Fluorescence3+OFFSET
+
+
+
+
+if not 'popt_1ions' in globals().keys():
+    t0 = time.time()
+    print("Arranamos FIT 1")
+
+    par_ini = [0.65, 7.06, 86070, 3917,  1.64]
+    
+    popt_1ions, pcov_1ions = curve_fit(FitEIT_MM1, FreqsDR, CountsDR, p0=par_ini, bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 7e3, 10)))
+    
+    pp1 = estadistica(FreqsDR,CountsDR,FitEIT_MM1,pcov_1ions,popt_1ions,nombres=None,alpha=0.05)
+    
+    print(f"time: {round(time.time()-t0,1)} seg")
+
+
+
+if not 'popt_3ions' in globals().keys():
+    t0 = time.time()
+    print("Arranamos FIT 1")
+    
+    par_ini = [0.65, 7.06, 86070, 3917,  1.64]
+    popt_1ions, pcov_1ions = curve_fit(FitEIT_MM1, FreqsDR, CountsDR, p0=par_ini, bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 7e3, 10)))
+    print(f"time: {round(time.time()-t0,1)} seg")
+    
+    print("Arranamos FIT 3")
+    def fun(freqs, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3):
+        SCALE3 = max(1-SCALE2-SCALE1-OFFSET,0)
+        Fluorescence3 = FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3)
+        return Fluorescence3/sum(Fluorescence3)
+    
+    par_ini = popt_1ions.tolist()[:2]+[1/3]*2 + [0.1] +popt_1ions.tolist()[-1:]*3
+    bounds  = ((0, 0,  0, 0, 0, 0, 0, 0), 
+               (2, 20, 1, 1, 1, 10, 10, 10))
+    
+    popt_3ions, pcov_3ions = curve_fit(fun, FreqsDR, CountsDR, p0=par_ini,bounds=bounds )
+   
+    
+    print(f"time: {round(time.time()-t0,1)} seg")
+    
+    freqs = np.array(FreqsDR)
+    SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3 = popt_3ions
+    SCALE3 = max(1-SCALE2-SCALE1-OFFSET,0)
+    # Fluorescence= FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3)
+    Fluorescence= fun(freqs, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3)
+    
+    
+    plt.figure()
+    plt.errorbar(freqs, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+    
+    plt.plot(freqs, Fluorescence*sum(CountsDR))
+    
+    plt.plot(freqs, fun(freqs, *par_ini )*sum(CountsDR))
+    
+    
+#%% Acá hay un ajuste del de 3 iones que da razonable
+
+FreqsDR, CountsDR = np.array(FreqsDR) , np.array(CountsDR)
+
+t0 = time.time()
+print("Arranamos FIT 1")
+
+par_ini = [0.65, 7.06, 86070, 3917,  1.64]
+popt_1ions, pcov_1ions = curve_fit(FitEIT_MM1, FreqsDR, CountsDR, p0=par_ini, bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 7e3, 10)))
+print(f"time: {round(time.time()-t0,1)} seg")
+
+
+
+
+par_ini = popt_1ions.tolist()[:2]+[1/3]*2 + [0.1] +popt_1ions.tolist()[-1:]*3
+bounds  = ((0, 0,  0, 0, 0, 0, 0, 0), 
+           (2, 20, 1, 1, 1, 10, 10, 10))
+
+# bounds = (-np.inf, np.inf)
+
+plt.figure()
+plt.errorbar(freqs, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+l1, =plt.plot(freqs, fun(freqs, *par_ini )*sum(CountsDR))
+plt.draw()
+
+print("Arranamos FIT 3")
+def fun(freqs, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3):
+    SCALE3 = max(1-SCALE2-SCALE1-OFFSET,0)
+    Fluorescence3 = FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3)
+    
+    l1.set_ydata(Fluorescence3/sum(Fluorescence3)*sum(CountsDR))
+    print(SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3)
+    plt.pause(0.1)
+    return Fluorescence3/sum(Fluorescence3)
+
+
+popt_3ions, pcov_3ions = curve_fit(fun, FreqsDR, CountsDR/CountsDR.sum(), p0=par_ini,bounds=bounds )
+   
+
+print(f"time: {round(time.time()-t0,1)} seg")
+
+freqs = np.array(FreqsDR)
+SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3 = popt_3ions
+SCALE3 = max(1-SCALE2-SCALE1-OFFSET,0)
+# Fluorescence= FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3)
+Fluorescence= fun(freqs, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3)
+
+plt.plot(freqs, Fluorescence*sum(CountsDR))
+
+if False:
+    popt_3ions = np.array([0.70790618, 7.41165226, 0.1707309 , 0.13974759, 0.02322333,
+                           3.69298275, 3.68847693, 1.36216489])
+    
+
+#%%
+    
+    
+    
+    
+    
+#popt, pcov = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.8, 8, 4e4, 3.5e3, 0], bounds=((0, 0, 0, 0, 0), (2, 15, 1e5, 1e5, 10)))
+
+#array([7.12876797e-01, 7.92474752e+00, 4.29735308e+04, 1.74240582e+04,
+       #1.53401696e+03, 1.17073206e-06, 2.53804151e+00])
+
+
+if False:
+    # Ejemplo 3 iones
+    t0 = time.time()
+    freqs, SG, SP = np.array(FreqsDR), 0.65, 7.06
+    SCALE1, SCALE2, SCALE3, OFFSET = 1,1,1,1
+    BETA1, BETA2, BETA3 = 1.64, 2, 3
+    TEMP = 0.1e-3
+    Fluorescence3= FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3)
+    print(f"time: {round(time.time()-t0,1)} seg")
+    Detunings, Fluorescence = np.array(freqs), np.array(Fluorescence3)
+    plt.figure()
+    plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+    plt.plot(Detunings, Fluorescence*sum(CountsDR)/sum(Fluorescence))
+    
+
+if False:
+    # Ejemplo 1 ion
+    t0 = time.time()
+    freqs, SG, SP, BETA1 = FreqsDR, 0.65, 7.06, 1.64
+    TEMP = 0.1e-3
+    Detunings, Fluorescence1 =PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    print(f"time: {round(time.time()-t0,1)} seg")
+    Detunings, Fluorescence1 = np.array(Detunings), np.array(Fluorescence1)
+    plt.figure()
+    plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+    plt.plot(Detunings, Fluorescence1*sum(CountsDR)/sum(Fluorescence1))
+    
+
+FittedEITpi_3ions = FitEIT_MM(freqslong, *popt_3ions)
+#FittedEITpi_3ions = FitEIT_MM(freqslong, popt_3ions[0],popt_3ions[1],popt_3ions[2],popt_3ions[3],popt_3ions[4],popt_3ions[5],4,2,0)
+
+#FittedEITpi_3ions = FitEIT_MM(freqslong, *popt_3ions)
+
+
+print(popt_3ions)
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_3ions, color='darkgreen', linewidth=3)
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.title(f'Corr:{correccion},DetD:{DetDoppler}')
+plt.grid()
+
+
+
+
+
+#%%
+"""
+Veo la medicion de varios voltajes uno atras de otro
+Se va en medio de la medicion 4, y en la 5 ni esta
+"""
+
+jvec = [2] # desde la 1, pero la 4 no porque es un merge de curvitas
+
+Freqs
+
+plt.figure()
+i = 0
+for j in jvec:
+    plt.errorbar([2*f*1e-6 for f in Freqs[4]], CountsSplit_2ions[0][j], yerr=np.sqrt(CountsSplit_2ions[0][j]), fmt='o', capsize=2, markersize=2)
+    i = i + 1
+plt.xlabel('Frecuencia (MHz)')
+plt.ylabel('counts')
+plt.grid()
+#for dr in drs:
+#    plt.axvline(dr)
+    #plt.axvline(dr+drive)
+plt.legend()
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+AJUSTO LA CPT DE 2 IONES CON UN MODELO EN DONDE SUMO DOS ESPECTROS CON BETAS DISTINTOS
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 27
+
+offsetxpi = 421+correccion
+DetDoppler = -16-correccion+5
+
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[1]]
+CountsDR = Counts[1]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, OFFSET):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+
+    BETA1, BETA2 = 3, 0
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    ScaledFluo2 = np.array([f*SCALE2 + OFFSET for f in Fluorescence2])
+    return ScaledFluo1+ScaledFluo2
+    #return ScaledFluo1
+
+
+if not 'popt_2ions_1' in globals().keys():
+    popt_2ions_1, pcov_2ions_1 = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.9, 6.2, 3.5e3, 2.9e3, 3e3], bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 5e8, 8e3)))
+#popt, pcov = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.8, 8, 4e4, 3.5e3, 0], bounds=((0, 0, 0, 0, 0), (2, 15, 1e5, 1e5, 10)))
+
+#array([7.12876797e-01, 7.92474752e+00, 4.29735308e+04, 1.74240582e+04,
+       #1.53401696e+03, 1.17073206e-06, 2.53804151e+00])
+
+FittedEITpi_2sp = FitEIT_MM(freqslong, *popt_2ions_1)
+#FittedEITpi = FitEIT_MM(freqslong, 0.8, 8, 4e4, 3.5e3, 0)
+
+# beta1_2ions = popt_2ions_1[5]
+# beta2_2ions = popt_2ions_1[6]
+
+# errbeta1_2ions = np.sqrt(pcov_2ions_1[5,5])
+# errbeta2_2ions = np.sqrt(pcov_2ions_1[6,6])
+
+"""
+Estos params dan bien poniendo beta2=0 y correccion=0 y son SG, SP, SCALE1, SCALE2, OFFSET, BETA1
+#array([9.03123248e-01, 6.25865542e+00, 3.47684055e+04, 2.92076804e+04, 1.34556420e+03, 3.55045904e+00])
+"""
+
+"""
+Ahora considerando ambos betas, con los parametros iniciales dados por los que se obtuvieron con beta2=0
+y correccion=0 dan estos parametros que son los de antes pero con BETA2 incluido:
+array([8.52685426e-01, 7.42939084e+00, 3.61998310e+04, 3.40160472e+04, 8.62651715e+02, 3.89756335e+00, 7.64867601e-01])
+"""
+
+#arreglito = np.array([8.52685426e-01, 7.42939084e+00, 3.61998310e+04, 3.40160472e+04, 8.62651715e+02, 3.89756335e+00, 7.64867601e-01])
+
+FittedEITpi_2ions_1 = FitEIT_MM(freqslong, *popt_2ions_1)
+
+
+print(popt_2ions_1)
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_2ions_1, color='darkgreen', linewidth=3)
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.title(f'Corr:{correccion},DetD:{DetDoppler}')
+plt.grid()
+
+
+#%%
+"""
+SUPER AJUSTE PARA MED DE 2 IONES
+"""
+
+
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+#DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+SelectedCurveVec = [3]
+
+
+if not 'popt_SA_vec_2ions' in globals().keys():
+
+    popt_SA_vec_2ions = []
+    pcov_SA_vec_2ions = []
+
+    for selectedcurve in SelectedCurveVec:
+
+        FreqsDR = Freqs[selectedcurve]
+        CountsDR = Counts[selectedcurve]
+
+        freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+        CircPr = 1
+        alpha = 0
+
+
+        def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, TEMP, plot=False):
+        #def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+            #BETA = 1.8
+            #SG = 0.6
+            #SP = 8.1
+            # TEMP = 0.2e-3
+
+            freqs = [2*f*1e-6-offset for f in Freqs]
+
+            Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+            Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+            ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+            ScaledFluo2 = np.array([f*SCALE2 for f in Fluorescence2])
+            if plot:
+                return ScaledFluo1+ScaledFluo2, Detunings
+            else:
+                return ScaledFluo1+ScaledFluo2
+            #return ScaledFluo1
+
+        if True:
+            popt_3_SA_2ions, pcov_3_SA_2ions = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[448, -42, 0.6, 8.1, 4e4, 4e4, 6e3, 1, 1.2, 0.5e-3], bounds=((0, -100,0, 0, 0,0,0,0,0, 0), (1000, 0, 2, 20,5e6, 5e6,5e4, 10, 10,10e-3)))
+
+            #popt_3_SA_2ions = [448, -42, 8e4, 6e3, 2, 0.5e-3]
+
+
+            popt_SA_vec_2ions.append(popt_3_SA_2ions)
+            pcov_SA_vec_2ions.append(pcov_3_SA_2ions)
+
+            FittedEITpi_3_SA_short, Detunings_3_SA_short = FitEIT_MM_single(FreqsDR, *popt_3_SA_2ions, plot=True)
+            freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+            FittedEITpi_3_SA_long, Detunings_3_SA_long = FitEIT_MM_single(freqslong, *popt_3_SA_2ions, plot=True)
+
+raise ValueError('Acá tenes que levantar de nuevo los valores que van')
+
+
+plt.figure()
+plt.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, color='darkolivegreen', linewidth=3, label=f'med {selectedcurve}')
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.legend(loc='upper left', fontsize=20)
+plt.grid()
+
+print(f'listo med {selectedcurve}')
+print(popt_3_SA_2ions)
+#print(f'Detdop:{popt_3_SA[1]},popt_3_SA:{popt[0]}')
+
+
+#%%
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+import time
+
+"""
+AJUSTO LA CPT DE 2 IONES CON UN MODELO EN DONDE SUMO DOS ESPECTROS CON BETAS DISTINTOS
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 27
+
+offsetxpi = 421+correccion
+DetDoppler = -16-correccion+5
+
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+FreqsDR = [2*f*1e-6-offsetxpi for f in Freqs[1]]
+CountsDR = Counts[1]
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+def FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, OFFSET):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+
+    BETA1, BETA2 = 3, 0
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    ScaledFluo2 = np.array([f*SCALE2 + OFFSET for f in Fluorescence2])
+    return ScaledFluo1+ScaledFluo2
+    #return ScaledFluo1
+
+
+if not 'popt_2ions_1' in globals().keys():
+    popt_2ions_1, pcov_2ions_1 = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.9, 6.2, 3.5e3, 2.9e3, 3e3], bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 5e8, 8e3)))
+#popt, pcov = curve_fit(FitEIT_MM, FreqsDR, CountsDR, p0=[0.8, 8, 4e4, 3.5e3, 0], bounds=((0, 0, 0, 0, 0), (2, 15, 1e5, 1e5, 10)))
+
+#array([7.12876797e-01, 7.92474752e+00, 4.29735308e+04, 1.74240582e+04,
+       #1.53401696e+03, 1.17073206e-06, 2.53804151e+00])
+
+FittedEITpi_2sp = FitEIT_MM(freqslong, *popt_2ions_1)
+#FittedEITpi = FitEIT_MM(freqslong, 0.8, 8, 4e4, 3.5e3, 0)
+
+# beta1_2ions = popt_2ions_1[5]
+# beta2_2ions = popt_2ions_1[6]
+
+# errbeta1_2ions = np.sqrt(pcov_2ions_1[5,5])
+# errbeta2_2ions = np.sqrt(pcov_2ions_1[6,6])
+
+"""
+Estos params dan bien poniendo beta2=0 y correccion=0 y son SG, SP, SCALE1, SCALE2, OFFSET, BETA1
+#array([9.03123248e-01, 6.25865542e+00, 3.47684055e+04, 2.92076804e+04, 1.34556420e+03, 3.55045904e+00])
+"""
+
+"""
+Ahora considerando ambos betas, con los parametros iniciales dados por los que se obtuvieron con beta2=0
+y correccion=0 dan estos parametros que son los de antes pero con BETA2 incluido:
+array([8.52685426e-01, 7.42939084e+00, 3.61998310e+04, 3.40160472e+04, 8.62651715e+02, 3.89756335e+00, 7.64867601e-01])
+"""
+
+#arreglito = np.array([8.52685426e-01, 7.42939084e+00, 3.61998310e+04, 3.40160472e+04, 8.62651715e+02, 3.89756335e+00, 7.64867601e-01])
+
+FittedEITpi_2ions_1 = FitEIT_MM(freqslong, *popt_2ions_1)
+
+
+print(popt_2ions_1)
+
+plt.figure()
+plt.errorbar(FreqsDR, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+plt.plot(freqslong, FittedEITpi_2ions_1, color='darkgreen', linewidth=3)
+#plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+plt.xlabel('Detuning (MHz)')
+plt.ylabel('Counts')
+plt.title(f'Corr:{correccion},DetD:{DetDoppler}')
+plt.grid()
+
+
+#%%
+"""
+AHORA INTENTO SUPER AJUSTES O SEA CON OFFSETXPI Y DETDOPPLER INCLUIDOS
+"""
+
+
+#%%
+
+"""
+SUPER AJUSTE (SA)
+
+
+"""
+
+if False:
+    GUARDAR = {}
+    for var in [ kk for kk in globals().keys() if kk.startswith('pop') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.startswith('pcov') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.startswith('Fitted') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+    print('')
+    for var in [ kk for kk in globals().keys() if kk.endswith('_vec') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+#DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+#SelectedCurveVec = [1,2,3,4,5,6,7,8,9]
+SelectedCurveVec = [0]
+
+# popt_SA_vec = []
+# pcov_SA_vec = []
+# Detuningsshort_vec = []
+# Counts_vec = []
+# Detuningslong_vec = []
+# FittedCounts_vec = []
+
+# Betas_vec = []
+# ErrorBetas_vec = []
+# Temp_vec = []
+# ErrorTemp_vec = []
+
+# DetuningsUV_vec = []
+# ErrorDetuningsUV_vec = []
+
+for selectedcurve in SelectedCurveVec:
+
+#selectedcurve = 2 #IMPORTANTE: SELECCIONA LA MEDICION
+
+    FreqsDR = Freqs[0]
+    CountsDR = CountsSplit[0][selectedcurve]
+
+
+    if selectedcurve==1:
+        CountsDR[100]=0.5*(CountsDR[99]+CountsDR[101])
+        CountsDR[105]=0.5*(CountsDR[104]+CountsDR[106])
+    if selectedcurve==2:
+        CountsDR[67]=0.5*(CountsDR[66]+CountsDR[68])
+        CountsDR[71]=0.5*(CountsDR[70]+CountsDR[72])
+    if selectedcurve==6:
+        CountsDR[1]=0.5*(CountsDR[0]+CountsDR[2])
+        CountsDR[76]=0.5*(CountsDR[75]+CountsDR[77])
+    if selectedcurve==7:
+        CountsDR[117]=0.5*(CountsDR[116]+CountsDR[118])
+
+    freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+    CircPr = 1
+    alpha = 0
+
+
+    def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP, U, plot=False):
+    #def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+        #BETA = 1.8
+        # SG = 0.6
+        # SP = 8.1
+        # TEMP = 0.2e-3
+
+        freqs = [2*f*1e-6-offset for f in Freqs]
+
+        Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, U, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+        ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+        if plot:
+            return ScaledFluo1, Detunings
+        else:
+            return ScaledFluo1
+        #return ScaledFluo1
+
+    do_fit = True
+    if do_fit:
+        popt_3_SA, pcov_3_SA = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[430, -25, 0.9, 6.2, 3e4, 1.34e3, 2, (np.pi**2)*1e-3, 32e6], bounds=((0, -50, 0, 0, 0, 0, 0, 0, 25e6), (1000, 0, 2, 20, 5e4, 5e4, 10, (np.pi**2)*10e-3, 40e6)))
+
+        # popt_SA_vec.append(popt_3_SA)
+        # pcov_SA_vec.append(pcov_3_SA)
+
+        FittedEITpi_3_SA_short, Detunings_3_SA_short = FitEIT_MM_single(FreqsDR, *popt_3_SA, plot=True)
+        freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+        FittedEITpi_3_SA_long, Detunings_3_SA_long = FitEIT_MM_single(freqslong, *popt_3_SA, plot=True)
+
+    # DetuningsUV_vec.append(popt_3_SA[1])
+    # ErrorDetuningsUV_vec.append(np.sqrt(pcov_3_SA[1,1]))
+
+    # Betas_vec.append(popt_3_SA[6])
+    # ErrorBetas_vec.append(np.sqrt(pcov_3_SA[6,6]))
+    # Temp_vec.append(popt_3_SA[7])
+    # ErrorTemp_vec.append(np.sqrt(pcov_3_SA[7,7]))
+
+    # Detuningsshort_vec.append(Detunings_3_SA_short)
+    # Counts_vec.append(CountsDR)
+    # Detuningslong_vec.append(Detunings_3_SA_long)
+    # FittedCounts_vec.append(FittedEITpi_3_SA_long)
+
+
+    plt.figure()
+    plt.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+    plt.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, color='darkolivegreen', linewidth=3, label=f'med {selectedcurve}')
+    #plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+    plt.xlabel('Detuning (MHz)')
+    plt.ylabel('Counts')
+    plt.legend(loc='upper left', fontsize=20)
+    plt.grid()
+
+    print(f'listo med {selectedcurve}')
+    print(popt_3_SA)

analisis/plots/20250516_CPT_bladetrap/lolo_ajuste_3iones_A.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Acá hacemos el ajuste de 3 iones del archivo 
+    artiq_experiments/analisis/plots/20231123_CPTconmicromocion3/CPT_plotter_20231123.py
+sacado de la parte que dice:
+    "ajusto la mergeada de 3 iones"
+
+@author: lolo
+"""
+
+import h5py
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.optimize import curve_fit
+
+from Data.EITfit.lolo_modelo_full_8niveles import PerformExperiment_8levels_MM
+
+import time
+
+
+#%% Funciones auxiliares para información estadística
+
+from scipy.stats.distributions import  t,chi2
+import inspect
+    
+def estadistica(datos_x,datos_y,modelo,pcov,parametros,nombres=None,alpha=0.05):
+    
+    if nombres is None:
+        nombres = inspect.getfullargspec(modelo).args[1:]
+    
+    # Cantidad de parámetros
+    P = len(parametros)
+    
+    # Número de datos
+    N = len(datos_x)
+    
+    # Grados de libertas (Degrees Of Freedom)
+    dof = N-P-1
+
+    # Cauculamos coordenadas del modelo
+    # modelo_x    = datos_x if modelo_x_arr is None else modelo_x_arr
+    # modelo_y    = modelo( modelo_x, *parametros )
+    
+    # Predicción del modelo para los datos_x medidos
+    prediccion_modelo = modelo( datos_x, *parametros )
+    
+    # Calculos de cantidades estadísticas relevantes
+    COV       = pcov                                      # Matriz de Covarianza
+    SE        = np.sqrt(np.diag( COV  ))                        # Standar Error / Error estandar de los parámetros
+    residuos  = datos_y - prediccion_modelo               # diferencia enrte el modelo y los datos
+    
+    SSE       = sum(( residuos )**2 )                     # Resitual Sum of Squares
+    SST       = sum(( datos_y - np.mean(datos_y))**2)        # Total Sum of Squares
+    
+    # http://en.wikipedia.org/wiki/Coefficient_of_determination
+    # Expresa el porcentaje de la varianza que logra explicar el modelos propuesto
+    Rsq       =  1 - SSE/SST                               # Coeficiente de determinación
+    Rsq_adj   = 1-(1-Rsq) * (N-1)/(N-P-1)                  # Coeficiente de determinación Ajustado   
+    
+    # https://en.wikipedia.org/wiki/Pearson_correlation_coefficient#In_least_squares_regression_analysis
+    # Expresa la correlación que hay entre los datos y la predicción del modelo
+    r_pearson = np.corrcoef( datos_y ,  prediccion_modelo )[0,1]
+    
+    # Reduced chi squared
+    # https://en.wikipedia.org/wiki/Reduced_chi-squared_statistic
+    chi2_     = sum( residuos**2 )/N
+    chi2_red  = sum( residuos**2 )/(N-P)
+    
+    # Chi squared test
+    chi2_test = sum( residuos**2 / abs(prediccion_modelo) )
+    # p-value del ajuste
+    p_val  = chi2(dof).cdf( chi2_test )
+    
+    
+    sT = t.ppf(1.0 - alpha/2.0, N - P ) # student T multiplier
+    CI = sT * SE                        # Confidence Interval
+    
+
+    return dict(R2=Rsq,R2_adj=Rsq_adj,chi2=chi2_,chi2_red=chi2_red,
+                chi2_test=chi2_test,r=r_pearson,pvalue=p_val,
+                SE=SE,CI=CI,parametros=parametros,nombres=nombres,alpha=alpha,N=N)
+
+
+def print_estadistica(dic):
+    
+    pars = 'N,pvalue,R2,R2_adj,chi2,chi2_red,chi2_test,r,SE,CI,parametros,nombres,alpha'.split(',') 
+    
+    N,pvalue,R2,R2_adj,chi2,chi2_red,chi2_test,r,SE,CI,parametros,nombres,alpha = [ dic[k] for k in pars  ]
+    P = len(parametros)
+    
+    
+    print('R-squared    ',R2)
+    print('R-sq_adjusted',R2_adj)
+    print('chi2         ',chi2)
+    print('chi2_reduced ',chi2_red)
+    print('chi2_test    ',chi2_test)
+    print('r-pearson    ',r)
+    print('p-value      ',pvalue)
+    print('')
+    print('Error Estandard (SE):')
+    for i in range(P):
+        print(f'parametro[{nombres[i]:>5s}]: ' , parametros[i], ' ± ' , SE[i])
+    print('')
+    print('Intervalo de confianza al '+str((1-alpha)*100)+'%:')
+    for i in range(P):
+        print(f'parametro[{nombres[i]:>5s}]: ' , parametros[i], ' ± ' , CI[i])
+
+
+
+def fit(model,x_data, y_data, fixed=None, plot=False, **kwargs):
+    """Usa los mismos argumentos que curve_fit pero permite fixear parámetros y 
+    visualizar el ajuste
+        fixed: nombres de los parametros fijos, con espacios
+        plot: si plotea o no el ajuste
+    """
+    
+    # Extraemos los parámetros del modelo
+    param_names = inspect.getfullargspec(model).args[1:]
+    
+    if not 'p0' in kwargs.keys():
+        kwargs['p0'] = np.ones(len(param_names))
+    params_initial = kwargs['p0']
+    
+    # Nos fijamos si hay que fijar algo
+    if isinstance(fixed, str):
+        fixed = fixed.split()
+    
+    if fixed is None:
+        fixed = []
+    
+    # Armoa lista de True/False de los parametros fijos
+    params_fixed = [ True if p in fixed else False for p in param_names  ]
+    
+    
+    if True in params_fixed and 'bounds' in kwargs.keys():
+        try:
+            b0 = [ bb for fi,bb in zip(params_fixed,kwargs['bounds'][0]) if fi==False ]
+        except:
+            b0 = kwargs['bounds'][0]
+        try:
+            b1 = [ bb for fi,bb in zip(params_fixed,kwargs['bounds'][1]) if fi==False ]
+        except:
+            b1 =kwargs['bounds'][0]
+        kwargs['bounds'] = (b0,b1)
+    
+    print("Parámetros:", param_names)
+    
+    
+    # print(locals())
+    
+    print('\n')
+    if plot:
+        plt.figure()
+        plt.plot(x_data, y_data,'.')
+        ylim=plt.gca().get_ylim()
+        l1, = plt.plot(x_data, model(x_data,*params_initial),'r-')
+        plt.ylim(ylim)
+    
+    # Función auxiliar para el ajuste
+    def aux_func(x_data,*args):
+        all_params =  np.ones(len(param_names))
+        
+        jj=0
+        for ii in  range(len(all_params)):
+            if params_fixed[ii]:
+                all_params[ii] = params_initial[ii]
+            else:
+                all_params[ii] = args[jj]
+                jj += 1
+        # print(params_fixed,all_params)
+        rta = model(x_data,*all_params)
+        if plot:
+            l1.set_ydata(rta)
+            plt.draw()
+            plt.pause(0.01)
+        return rta
+    
+    
+    # Hacemos el curve_fit
+    t0 = time.time()
+    print("Arancamos el fit")
+    
+    kwargs['p0'] = [ p for p,ff in zip(params_initial,params_fixed) if ff is False  ]
+    
+    params, pcov = curve_fit(aux_func, x_data, y_data, **kwargs )
+    
+    print(f"time: {round(time.time()-t0,1)} seg")
+    
+    
+    # Rearmamos los parámetros para incluir los fijos
+    params2 =  np.ones(len(param_names))
+    jj=0
+    for ii in range(len(params2)):
+        if params_fixed[ii]:
+            params2[ii] = params_initial[ii]
+        else:
+            params2[ii] = params[jj]
+            jj += 1
+    
+    # Rearmo la pcov
+    ii, a = 0, []
+    for fixed in params_fixed:
+        if fixed:
+            a.append( [0]*len(pcov[0])  )
+        else:
+            a.append( pcov[ii].tolist() )
+            ii+=1
+    a = np.array(a)
+    ii, b = 0, []
+    for fixed in params_fixed:
+        if fixed:
+            b.append( [0]*len(a.T[0])  )
+        else:
+            b.append( a.T[ii].tolist() )
+            ii+=1
+    pcov2 = np.array(b)
+    
+    # Caluclo información estadística
+    info = estadistica(x_data,y_data,model,pcov2,params2,nombres=None,alpha=0.05)    
+    print_estadistica(info)
+    return params2, pcov2 , info
+
+# fit(modelo, FreqsDR, CountsDR/CountsDR.sum(), p0=(1,1,1),bounds=(-1e6,1e6) )
+
+# fit(modelo, FreqsDR, CountsDR/CountsDR.sum(), fixed="", plot=True, p0=(1,2,3),bounds=(-1e6,1e6) )
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Levantamos los datos %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+"""
+Primero tengo mediciones de espectros cpt de un ion variando la tension dc_A
+"""
+
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20220106_CPT_DosLaseres_v08_TISA_DR\Data
+# os.chdir('../20231123_CPTconmicromocion3/Data/')
+
+folder = '../20231123_CPTconmicromocion3/Data/'
+CPT_FILES = f"""
+{folder}/000016262-IR_Scan_withcal_optimized
+{folder}/000016239-IR_Scan_withcal_optimized
+{folder}/000016240-IR_Scan_withcal_optimized
+{folder}/000016241-IR_Scan_withcal_optimized
+{folder}/000016244-IR_Scan_withcal_optimized
+{folder}/000016255-IR_Scan_withcal_optimized
+{folder}/000016256-IR_Scan_withcal_optimized
+{folder}/000016257-IR_Scan_withcal_optimized
+"""
+
+
+def SeeKeys(files):
+    for i, fname in enumerate(files.split()):
+        data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+        print(fname)
+        print(list(data['datasets'].keys()))
+
+print(SeeKeys(CPT_FILES))
+
+#carpeta pc nico labo escritorio:
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20211101_CPT_DosLaseres_v03\Data
+
+Counts = []
+Freqs = []
+
+AmpTisa = []
+UVCPTAmp = []
+No_measures = []
+Voltages = []
+
+for i, fname in enumerate(CPT_FILES.split()):
+    print(str(i) + ' - ' + fname)
+    #print(fname)
+    data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+
+    # Aca hago algo repugnante para poder levantar los strings que dejamos
+    # que además tenian un error de tipeo al final. Esto no deberá ser necesario
+    # cuando se solucione el error este del guardado.
+    Freqs.append(np.array(data['datasets']['IR1_Frequencies']))
+    Counts.append(np.array(data['datasets']['data_array']))
+    #AmpTisa.append(np.array(data['datasets']['TISA_CPT_amp']))
+    UVCPTAmp.append(np.array(data['datasets']['UV_CPT_amp']))
+    No_measures.append(np.array(data['datasets']['no_measures']))
+    Voltages.append(np.array(data['datasets']['scanning_voltages']))
+
+def Split(array,n):
+    length=len(array)/n
+    splitlist = []
+    jj = 0
+    while jj<length:
+        partial = []
+        ii = 0
+        while ii < n:
+            partial.append(array[jj*n+ii])
+            ii = ii + 1
+        splitlist.append(partial)
+        jj = jj + 1
+    return splitlist
+
+
+CountsSplit = []
+CountsSplit.append(Split(Counts[0],len(Freqs[0])))
+
+
+CountsSplit_2ions = []
+CountsSplit_2ions.append(Split(Counts[4],len(Freqs[4])))
+
+
+###############################################################################
+
+"""
+AHORA VAMOS A MEDICIONES CON MAS DE UN ION!!!
+
+Las mediciones estan buenas, habria que ver de ajustarlas bien, yo no lo logre.
+
+"""
+
+"""
+Ploteo la cpt de referencia / plotting the reference CPT
+
+1: 2 iones, -100 mV dcA
+2: 2 iones, -150 mV dcA
+3: 2 iones, -50 mV dcA
+4: 2 iones, 5 voltajes (el ion se va en la 4ta medicion y en la 5ta ni esta)
+5, 6 y 7: 3 iones en donde el scaneo esta centrado en distintos puntos
+
+"""
+
+
+"""
+Mergeo la 5, 6 y 7
+"""
+
+Freqs5 = [2*f*1e-6 for f in Freqs[5]]
+Freqs6 = [2*f*1e-6 for f in Freqs[6]]
+Freqs7 = [2*f*1e-6 for f in Freqs[7]]
+
+Counts5 = Counts[5]
+Counts6 = Counts[6]
+Counts7 = Counts[7]
+
+i_1_ini = 0
+i_1 = 36
+i_2_ini = 0
+i_2 = 24
+
+f_1 = 18
+f_2 = 30
+
+
+scale_1 = 0.92
+scale_2 = 0.98
+
+#Merged_freqs_test = [f-f_2 for f in Freqs6[i_2_ini:i_2]]+[f-f_1 for f in Freqs5[i_1_ini:i_1]]+Freqs7
+
+#plt.plot(Merged_freqs_test,'o')
+
+
+
+Merged_freqs = [f-f_2 for f in Freqs6[0:i_2]]+[f-f_1 for f in Freqs5[0:i_1]]+Freqs7
+Merged_counts = [scale_2*c for c in Counts6[0:i_2]]+[scale_1*c for c in Counts5[0:i_1]]+list(Counts7)
+
+Merged_freqs_rescaled = np.linspace(np.min(Merged_freqs),np.max(Merged_freqs),len(Merged_freqs))
+
+#drs = [391.5, 399.5, 405.5, 414]
+drs = [370,379,385,391.5]
+
+if False:
+    plt.figure()
+    jvec = [2]
+    i = 0
+    drive=22.1
+
+    for j in jvec:
+        plt.plot([f-f_1 for f in Freqs5[0:i_1]], [scale_1*c for c in Counts5[0:i_1]],'o')
+        plt.plot([f-f_2 for f in Freqs6[0:i_2]], [scale_2*c for c in Counts6[0:i_2]],'o')
+        plt.plot(Freqs7, Counts7,'o')
+        plt.errorbar(Merged_freqs, Merged_counts, yerr=np.sqrt(Merged_counts), fmt='o', capsize=2, markersize=2)
+    
+    
+        i = i + 1
+    plt.xlabel('Frecuencia (MHz)')
+    plt.ylabel('counts')
+    plt.grid()
+    for dr in drs:
+        plt.axvline(dr)
+        plt.axvline(dr+drive, color='red', linestyle='dashed', alpha=0.3)
+        plt.axvline(dr-drive, color='red', linestyle='dashed', alpha=0.3)
+    
+    plt.legend()
+
+#%%  Funciones para hacer ajustes
+"""
+ajusto la mergeada de 3 iones
+"""
+
+import numba
+
+
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = -20
+
+offsetxpi = 438+correccion
+DetDoppler = -35-correccion-22
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+drivefreq = 2*np.pi*22.135*1e6
+
+FreqsDR = [f-offsetxpi for f in Merged_freqs]
+CountsDR = Merged_counts
+
+freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+CircPr = 1
+alpha = 0
+
+
+
+# @numba.jit
+def FitEIT_MM1(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+
+    #BETA1, BETA2, BETA3 = 0, 0, 2
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 for f in Fluorescence1])
+
+    return ScaledFluo1+OFFSET
+    #return ScaledFluo1
+
+
+# @numba.jit
+def FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3):
+#def FitEIT_MM(freqs, SG, SP, SCALE1, OFFSET, BETA1):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    TEMP = 0.1e-3
+    freqs = np.array(freqs)
+
+    #BETA1, BETA2, BETA3 = 0, 0, 2
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA1, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence2 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA2, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+    Detunings, Fluorescence3 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, DopplerLaserLinewidth, ProbeLaserLinewidth, TEMP, alpha, phidoppler, titadoppler, phiprobe, titaprobe,  BETA3, drivefreq, min(freqs), max(freqs)+(freqs[1]-freqs[0]), freqs[1]-freqs[0], circularityprobe=CircPr, plot=False, solvemode=1, detpvec=None)
+
+
+    # ScaledFluo1 = np.array([f*SCALE1 for f in Fluorescence1])
+    # ScaledFluo2 = np.array([f*SCALE2 for f in Fluorescence2])
+    # ScaledFluo3 = np.array([f*SCALE3 for f in Fluorescence3])
+    # return ScaledFluo1+ScaledFluo2+ScaledFluo3+OFFSET
+    Fluorescence1 = np.array(Fluorescence1)
+    Fluorescence2 = np.array(Fluorescence2)
+    Fluorescence3 = np.array(Fluorescence3)
+    return SCALE1*Fluorescence1+SCALE2*Fluorescence2+SCALE3*Fluorescence3+OFFSET
+
+
+
+#%% Acá hay un ajuste del de 3 iones que da razonable
+
+# FreqsDR, CountsDR = np.array(FreqsDR) , np.array(CountsDR)
+# freqs = np.array(FreqsDR)
+
+
+# t0 = time.time()
+# print("Arranamos FIT 1")
+
+# par_ini = [0.65, 7.06, 86070, 3917,  1.64]
+# popt_1ions, pcov_1ions = curve_fit(FitEIT_MM1, FreqsDR, CountsDR, p0=par_ini, bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 7e3, 10)))
+# print(f"time: {round(time.time()-t0,1)} seg")
+
+
+
+
+# par_ini = popt_1ions.tolist()[:2]+[1/3]*2 + [0.1] +popt_1ions.tolist()[-1:]*3
+# bounds  = ((0, 0,  0, 0, 0, 0, 0, 0), 
+#            (2, 20, 1, 1, 1, 10, 10, 10))
+
+# # bounds = (-np.inf, np.inf)
+
+
+
+# print("Arranamos FIT 3")
+# def fun(freqs, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3):
+#     SCALE3 = max(1-SCALE2-SCALE1-OFFSET,0)
+#     Fluorescence3 = FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3)
+#     try:
+#         l1.set_ydata(Fluorescence3/sum(Fluorescence3)*sum(CountsDR))
+#     except:
+#         print("Primer corrida")
+#     finally:
+#         print(SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3)
+#         plt.pause(0.1)
+#     return Fluorescence3/sum(Fluorescence3)
+
+# plt.figure()
+# plt.errorbar(freqs, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+# l1, =plt.plot(freqs, fun(freqs, *par_ini )*sum(CountsDR))
+# plt.draw()
+
+
+# popt_3ions, pcov_3ions = curve_fit(fun, FreqsDR, CountsDR/CountsDR.sum(), p0=par_ini,bounds=bounds )
+   
+
+# print(f"time: {round(time.time()-t0,1)} seg")
+
+# SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3 = popt_3ions
+# SCALE3 = max(1-SCALE2-SCALE1-OFFSET,0)
+# # Fluorescence= FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3)
+# Fluorescence= fun(freqs, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3)
+
+# plt.plot(freqs, Fluorescence*sum(CountsDR))
+
+# if False:
+#     popt_3ions = np.array([0.70790618, 7.41165226, 0.1707309 , 0.13974759, 0.02322333,
+#                            3.69298275, 3.68847693, 1.36216489])
+    
+
+#%% Armo algo para meter parametros fijos
+
+FreqsDR, CountsDR = np.array(FreqsDR) , np.array(CountsDR)
+
+
+
+t0 = time.time()
+print("Arranamos FIT 1")
+
+par_ini = [0.65, 7.06, 86070, 3917,  1.64]
+popt_1ions, pcov_1ions, info1 = fit(FitEIT_MM1, FreqsDR, CountsDR, p0=par_ini, bounds=((0, 0, 0, 0, 0), (2, 20, 5e8, 7e3, 10)))
+print(f"time: {round(time.time()-t0,1)} seg")
+
+
+
+
+par_ini = popt_1ions.tolist()[:2]+[1/3]*2 + [0.1] +popt_1ions.tolist()[-1:]*3
+bounds  = ((0, 0,  0, 0, 0, 0, 0, 0), 
+           (2, 20, 1, 1, 1, 10, 10, 10))
+
+
+def fun(freqs, SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3):
+    SCALE3 = max(1-SCALE2-SCALE1-OFFSET,0)
+    Fluorescence3 = FitEIT_MM(freqs, SG, SP, SCALE1, SCALE2, SCALE3, OFFSET, BETA1, BETA2, BETA3)
+    return Fluorescence3/sum(Fluorescence3)
+
+
+
+
+par_ini = np.array([0.64872536, 7.06495239, 0.9985873 , 0.9985873 , 0.09090475,
+                 1.63941009, 1.63941006, 1.80228481])
+
+SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3 = par_ini
+SCALE1, SCALE2 = 0.3, 0.3
+
+par_ini = SG, SP, SCALE1, SCALE2, OFFSET, BETA1, BETA2, BETA3
+
+
+t0 = time.time()
+print("Arranamos FIT 1")
+popt_3ions, pcov_3ions, info2 = fit(fun, FreqsDR, CountsDR/sum(CountsDR), fixed="SG SP", plot=True, p0=par_ini, bounds=bounds)
+print(f"time: {round(time.time()-t0,1)} seg")
+
+
+
+par_ini = popt_3ions
+t0 = time.time()
+print("Arranamos FIT 1")
+popt_3ions, pcov_3ions, info2 = fit(fun, FreqsDR, CountsDR/sum(CountsDR), fixed="", plot=True, p0=par_ini, bounds=bounds)
+print(f"time: {round(time.time()-t0,1)} seg")
+
+

analisis/plots/20250516_CPT_bladetrap/lolo_analisis_superajuste.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Ploteo de datos y ajustes del barrido en voltaje del Endcap
+equivalente a pasear el ion en algun entorno del punto de compensación ideal
+y ver los efectos de micromoción (y tal vez temperatura)
+
+
+
+@author: lolo
+"""
+
+
+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
+# from scipy import interpolate
+
+from numba import jit,njit
+
+from time import time
+
+#%% Importaciones extra
+
+# /home/lolo/Dropbox/marce/LIAF/Trampa_anular/artiq_experiments/analisis/plots/20231123_CPTconmicromocion3/Data/EITfit/MM_eightLevel_2repumps_AnalysisFunctions.py
+
+
+from Data.EITfit.lolo_modelo_full_8niveles import PerformExperiment_8levels_MM
+
+
+# PARAMETROS = np.load('PARAMETROS.npz',allow_pickle=True)
+# for var_name in PARAMETROS.keys():
+#     globals()[var_name] = PARAMETROS[var_name]
+#     print(f'loaded: {var_name}')
+
+
+# Funciones auxiliares
+
+from scipy.stats.distributions import  t,chi2
+
+def estadistica(datos_x,datos_y,modelo,pcov,parametros,nombres=None,alpha=0.05):
+    
+    if nombres is None:
+        nombres = [ f'{j}' for j in range(len(parametros)) ]
+    
+    # Cantidad de parámetros
+    P = len(parametros)
+    
+    # Número de datos
+    N = len(datos_x)
+    
+    # Grados de libertas (Degrees Of Freedom)
+    dof = N-P-1
+
+    # Cauculamos coordenadas del modelo
+    # modelo_x    = datos_x if modelo_x_arr is None else modelo_x_arr
+    # modelo_y    = modelo( modelo_x, *parametros )
+    
+    # Predicción del modelo para los datos_x medidos
+    prediccion_modelo = modelo( datos_x, *parametros )
+    
+    # Calculos de cantidades estadísticas relevantes
+    COV       = pcov                                      # Matriz de Covarianza
+    SE        = np.sqrt(np.diag( COV  ))                        # Standar Error / Error estandar de los parámetros
+    residuos  = datos_y - prediccion_modelo               # diferencia enrte el modelo y los datos
+    
+    SSE       = sum(( residuos )**2 )                     # Resitual Sum of Squares
+    SST       = sum(( datos_y - np.mean(datos_y))**2)        # Total Sum of Squares
+    
+    # http://en.wikipedia.org/wiki/Coefficient_of_determination
+    # Expresa el porcentaje de la varianza que logra explicar el modelos propuesto
+    Rsq       =  1 - SSE/SST                               # Coeficiente de determinación
+    Rsq_adj   = 1-(1-Rsq) * (N-1)/(N-P-1)                  # Coeficiente de determinación Ajustado   
+    
+    # https://en.wikipedia.org/wiki/Pearson_correlation_coefficient#In_least_squares_regression_analysis
+    # Expresa la correlación que hay entre los datos y la predicción del modelo
+    r_pearson = np.corrcoef( datos_y ,  prediccion_modelo )[0,1]
+    
+    # Reduced chi squared
+    # https://en.wikipedia.org/wiki/Reduced_chi-squared_statistic
+    chi2_     = sum( residuos**2 )/N
+    chi2_red  = sum( residuos**2 )/(N-P)
+    
+    # Chi squared test
+    chi2_test = sum( residuos**2 / abs(prediccion_modelo) )
+    # p-value del ajuste
+    p_val  = chi2(dof).cdf( chi2_test )
+    
+    
+    sT = t.ppf(1.0 - alpha/2.0, N - P ) # student T multiplier
+    CI = sT * SE                        # Confidence Interval
+    
+    print('R-squared    ',Rsq)
+    print('R-sq_adjusted',Rsq_adj)
+    print('chi2         ',chi2_)
+    print('chi2_reduced ',chi2_red)
+    print('chi2_test    ',chi2_test)
+    print('r-pearson    ',r_pearson)
+    print('p-value      ',p_val)
+    print('')
+    print('Error Estandard (SE):')
+    for i in range(P):
+        print(f'parametro[{nombres[i]:>5s}]: ' , parametros[i], ' ± ' , SE[i])
+    print('')
+    print('Intervalo de confianza al '+str((1-alpha)*100)+'%:')
+    for i in range(P):
+        print(f'parametro[{nombres[i]:>5s}]: ' , parametros[i], ' ± ' , CI[i])
+    
+    return dict(R2=Rsq,R2_adj=Rsq_adj,chi2=chi2_,chi2_red=chi2_red,
+                chi2_test=chi2_test,r=r_pearson,pvalue=p_val,
+                SE=SE,CI=CI)
+
+
+
+
+
+
+#%%
+
+"""
+Primero tengo mediciones de espectros cpt de un ion variando la tension dc_A
+"""
+
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20220106_CPT_DosLaseres_v08_TISA_DR\Data
+# os.chdir('../20231123_CPTconmicromocion3/Data/')
+
+folder = '../20231123_CPTconmicromocion3/Data/'
+CPT_FILES = f"""
+{folder}/000016262-IR_Scan_withcal_optimized
+{folder}/000016239-IR_Scan_withcal_optimized
+{folder}/000016240-IR_Scan_withcal_optimized
+{folder}/000016241-IR_Scan_withcal_optimized
+{folder}/000016244-IR_Scan_withcal_optimized
+{folder}/000016255-IR_Scan_withcal_optimized
+{folder}/000016256-IR_Scan_withcal_optimized
+{folder}/000016257-IR_Scan_withcal_optimized
+"""
+
+
+def SeeKeys(files):
+    for i, fname in enumerate(files.split()):
+        data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+        print(fname)
+        print(list(data['datasets'].keys()))
+
+print(SeeKeys(CPT_FILES))
+
+#carpeta pc nico labo escritorio:
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20211101_CPT_DosLaseres_v03\Data
+
+Counts = []
+Freqs = []
+
+AmpTisa = []
+UVCPTAmp = []
+No_measures = []
+Voltages = []
+
+for i, fname in enumerate(CPT_FILES.split()):
+    print(str(i) + ' - ' + fname)
+    #print(fname)
+    data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+
+    # Aca hago algo repugnante para poder levantar los strings que dejamos
+    # que además tenian un error de tipeo al final. Esto no deberá ser necesario
+    # cuando se solucione el error este del guardado.
+    Freqs.append(np.array(data['datasets']['IR1_Frequencies']))
+    Counts.append(np.array(data['datasets']['data_array']))
+    #AmpTisa.append(np.array(data['datasets']['TISA_CPT_amp']))
+    UVCPTAmp.append(np.array(data['datasets']['UV_CPT_amp']))
+    No_measures.append(np.array(data['datasets']['no_measures']))
+    Voltages.append(np.array(data['datasets']['scanning_voltages']))
+
+def Split(array,n):
+    length=len(array)/n
+    splitlist = []
+    jj = 0
+    while jj<length:
+        partial = []
+        ii = 0
+        while ii < n:
+            partial.append(array[jj*n+ii])
+            ii = ii + 1
+        splitlist.append(partial)
+        jj = jj + 1
+    return splitlist
+
+
+CountsSplit = []
+CountsSplit.append(Split(Counts[0],len(Freqs[0])))
+
+
+CountsSplit_2ions = []
+CountsSplit_2ions.append(Split(Counts[4],len(Freqs[4])))
+
+
+#%% Cargo parámetros fiteados de antes
+
+
+PARAMETROS = np.load('analisis_superajuste_PARAMETROS.npz',allow_pickle=True)
+for var_name in PARAMETROS.keys():
+    globals()[var_name] = PARAMETROS[var_name]
+    print(f'loaded: {var_name}')
+
+
+if False:
+    # Esto es para correr en caso de necesidad de limpiar todos los vectores de parametros
+    print('Limpio los vectores de parámetros')
+    for var in [ kk for kk in globals().keys() if kk.endswith('_vec') ]:
+        print(f'del {var}')
+        del(globals()[var])
+
+
+#%% Definiciones de Numba
+
+@jit
+def FitEIT_MM_single_plot(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+
+    freqs = [2*f*1e-6-offset for f in Freqs]
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, 
+                                                            DopplerLaserLinewidth, ProbeLaserLinewidth, 
+                                                            TEMP, alpha, phidoppler, titadoppler, 
+                                                            phiprobe, titaprobe,  BETA1, drivefreq, 
+                                                            min(freqs), max(freqs)+(freqs[1]-freqs[0]), 
+                                                            freqs[1]-freqs[0], circularityprobe=CircPr, 
+                                                            plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1, Detunings
+
+
+
+@jit
+def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+    "Esta verison de la función devuelve sólo el eje y, para usar de modelo en un ajuste"
+    return FitEIT_MM_single_plot(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP)[0]
+
+
+
+param_names = 'offset DetDoppler SG SP SCALE1 OFFSET BETA1 TEMP'.split()
+
+#%%
+"""
+AHORA INTENTO SUPER AJUSTES O SEA CON OFFSETXPI Y DETDOPPLER INCLUIDOS
+
+La 0 no ajusta bien incluso con todos los parametros libres
+De la 1 a la 11 ajustan bien
+"""
+
+
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+
+"""
+SUPER AJUSTE (SA)
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+#DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+SelectedCurveVec = [1,2,3,4,5,6,7,8,9,10,11]
+#SelectedCurveVec = [10]
+
+CircPr = 1
+alpha = 0
+
+t0 = time()
+
+if not 'popt_SA_vec' in globals().keys() or len(popt_SA_vec)==0:
+
+    popt_SA_vec = []
+    pcov_SA_vec = []
+    Detuningsshort_vec = []
+    Counts_vec = []
+    Detuningslong_vec = []
+    FittedCounts_vec = []
+
+    Betas_vec = []
+    ErrorBetas_vec = []
+    Temp_vec = []
+    ErrorTemp_vec = []
+
+    DetuningsUV_vec = []
+    ErrorDetuningsUV_vec = []
+    
+    Estadistica_vec = []
+
+    for selectedcurve in SelectedCurveVec:
+        print(f"{round(time()-t0,1):6.1f}: Procesando la curva {selectedcurve}")
+        #selectedcurve = 2 #IMPORTANTE: SELECCIONA LA MEDICION
+
+        FreqsDR = Freqs[0]
+        CountsDR = CountsSplit[0][selectedcurve]
+
+
+        if selectedcurve==1:
+            CountsDR[100]=0.5*(CountsDR[99]+CountsDR[101])
+            CountsDR[105]=0.5*(CountsDR[104]+CountsDR[106])
+        if selectedcurve==2:
+            CountsDR[67]=0.5*(CountsDR[66]+CountsDR[68])
+            CountsDR[71]=0.5*(CountsDR[70]+CountsDR[72])
+        if selectedcurve==6:
+            CountsDR[1]=0.5*(CountsDR[0]+CountsDR[2])
+            CountsDR[76]=0.5*(CountsDR[75]+CountsDR[77])
+        if selectedcurve==7:
+            CountsDR[117]=0.5*(CountsDR[116]+CountsDR[118])
+
+        freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+
+
+        if True:
+            popt_3_SA, pcov_3_SA = curve_fit(FitEIT_MM_single, FreqsDR, CountsDR, p0=[430, -25, 0.9, 6.2, 3e4, 1.34e3, 2, (np.pi**2)*1e-3], bounds=((0, -50, 0, 0, 0, 0, 0, 0), (1000, 0, 2, 20, 5e4, 5e4, 10, (np.pi**2)*10e-3)))
+
+            popt_SA_vec.append(popt_3_SA)
+            pcov_SA_vec.append(pcov_3_SA)
+
+            FittedEITpi_3_SA_short, Detunings_3_SA_short = FitEIT_MM_single_plot(FreqsDR, *popt_3_SA)
+            freqslong = np.arange(min(FreqsDR), max(FreqsDR)+FreqsDR[1]-FreqsDR[0], 0.1*(FreqsDR[1]-FreqsDR[0]))
+            FittedEITpi_3_SA_long, Detunings_3_SA_long = FitEIT_MM_single_plot(freqslong, *popt_3_SA)
+            
+            
+            # estadistica(datos_x,datos_y,modelo,pcov,parametros,nombres=None,alpha=0.05)
+            est_tmp = estadistica(FreqsDR,CountsDR,FitEIT_MM_single,pcov_3_SA,popt_3_SA,
+                                  nombres=param_names,alpha=0.05)
+            Estadistica_vec.append(est_tmp)
+
+        DetuningsUV_vec.append(popt_3_SA[1])
+        ErrorDetuningsUV_vec.append(np.sqrt(pcov_3_SA[1,1]))
+
+        Betas_vec.append(popt_3_SA[6])
+        ErrorBetas_vec.append(np.sqrt(pcov_3_SA[6,6]))
+        Temp_vec.append(popt_3_SA[7])
+        ErrorTemp_vec.append(np.sqrt(pcov_3_SA[7,7]))
+
+        Detuningsshort_vec.append(Detunings_3_SA_short)
+        Counts_vec.append(CountsDR)
+        Detuningslong_vec.append(Detunings_3_SA_long)
+        FittedCounts_vec.append(FittedEITpi_3_SA_long)
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Graficamos todos los fiteos
+
+# tmp_datos=(Detuningsshort_vec,Counts_vec,Detuningslong_vec,FittedCounts_vec,SelectedCurveVec)
+
+# for Detunings_3_SA_short,CountsDR,Detunings_3_SA_long,FittedEITpi_3_SA_long,selectedcurve in zip(*tmp_datos):
+#     plt.figure()
+#     plt.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.5, capsize=2, markersize=2)
+#     plt.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, color='darkolivegreen', linewidth=3, label=f'med {selectedcurve}')
+#     #plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+#     plt.xlabel('Detuning (MHz)')
+#     plt.ylabel('Counts')
+#     plt.legend(loc='upper left', fontsize=20)
+#     plt.grid()
+
+#     print(f'listo med {selectedcurve}')
+#     print(popt_3_SA)
+
+
+fig, axx = plt.subplots( 3,4, figsize=(13,8) ,  constrained_layout=True, sharex=True , sharey=True )
+fig.set_constrained_layout_pads(w_pad=2/72, h_pad=2/72, hspace=0, wspace=0)
+
+tmp_datos=(Detuningsshort_vec,Counts_vec,Detuningslong_vec,FittedCounts_vec,SelectedCurveVec,axx.flatten())
+
+for Detunings_3_SA_short,CountsDR,Detunings_3_SA_long,FittedEITpi_3_SA_long,selectedcurve,ax in zip(*tmp_datos):
+    ax.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.3, capsize=2, markersize=2)
+    ax.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, color='black', linewidth=2, label=f'med {selectedcurve}', alpha=0.7)
+    #plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+    # ax.set_xlabel('Detuning (MHz)')
+    # ax.set_ylabel('Counts')
+    ax.legend(loc='upper left', fontsize=12)
+    ax.grid(True, ls=":")
+
+    print(f'listo med {selectedcurve}')
+    # print(popt_3_SA)
+
+
+for ax in axx[:,0]:
+    ax.set_ylabel('Counts')
+
+for ax in axx[-1,:]:
+    ax.set_xlabel('Detuning (MHz)')
+
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Inspección de parámetros
+
+param_names = 'offset DetDoppler SG SP SCALE1 OFFSET BETA1 TEMP'.split()
+
+err_vecs = np.array([ np.sqrt(np.diag(el)) for el in pcov_SA_vec ])
+num_med  = np.arange(len(pcov_SA_vec)) +1
+
+r2_values = np.array([ el['R2_adj'] for el in Estadistica_vec ])
+
+
+fig, axx = plt.subplots( len(popt_SA_vec[0])+1,1, figsize=(13,8) ,  constrained_layout=True, sharex=True , sharey=False )
+fig.set_constrained_layout_pads(w_pad=2/72, h_pad=2/72, hspace=0, wspace=0)
+
+for ax,param_vec,err_vec,par_name in zip(axx,popt_SA_vec.T,err_vecs.T,param_names) :
+    ax.plot(num_med, param_vec, '.-')
+    ax.errorbar( num_med, param_vec, yerr=err_vec, 
+                 fmt='s', mfc='none', elinewidth = 1, capsize=3, ms=1)
+
+    ax.grid(True, ls=":", color='lightgray')
+    ax.set_ylabel(par_name)
+
+
+ax=axx[-1]
+ax.plot( num_med , r2_values, '.-')
+ax.set_ylabel(r'$R^2$')
+ax.grid(True, ls=":", color='lightgray')
+
+
+
+fig.align_ylabels()
+ax.set_xticks(num_med)
+ax.set_xlabel('Num. de medición')
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Endcap hiperbola (con residuos)
+"""
+Veamos cómo varía el Beta con el voltaje del endcap
+"""
+
+import seaborn as sns
+paleta = sns.color_palette("rocket")
+
+
+I = slice(None,9)
+
+voltages_dcA  = Voltages[0][SelectedCurveVec]
+
+
+
+def lineal(x,a,b):
+    return a*x+b
+
+def hiperbola(x,a,y0,b,x0):
+    """
+    Hiperbola de ecuación:
+        1 =(y-y0)²/a² - (x-x0)²/b² 
+    """
+    return a*np.sqrt(((x-x0)**2+b**2))+y0
+
+es_hiperbola = False
+
+    
+# par_inicial = (100,0.1,1,-0.15)
+#               a   y0   b  x0
+par_inicial = (12,0.1,1,-0.13)
+
+
+popthip,pcovhip = curve_fit(hiperbola,voltages_dcA[I],Betas_vec[I],p0=par_inicial)
+
+xhip = np.linspace(-0.23,0.005,200)
+
+# plt.figure()
+# plt.errorbar(voltages_dcA[I],Betas_vec[I],yerr=ErrorBetas_vec[I],fmt='o',capsize=5,markersize=5,color=paleta[1])
+# plt.plot(xhip,hiperbola(xhip,*popthip))
+# # plt.plot(xhip,hiperbola(xhip,*par_inicial),'--',color='red')
+# plt.xlabel('Endcap voltage (V)')
+# plt.ylabel('Modulation factor')
+# plt.grid()
+
+
+
+
+fig, axx = plt.subplots( 2, figsize=(10,7) ,  
+                        constrained_layout=True, sharex=True,
+                        gridspec_kw=dict(height_ratios=[10,2]))
+fig.set_constrained_layout_pads(w_pad=2/72, h_pad=2/72, hspace=0, wspace=0)
+
+ax = axx[0]
+
+ax.errorbar(voltages_dcA[I],Betas_vec[I],yerr=ErrorBetas_vec[I],fmt='o',capsize=5,markersize=5,color=paleta[1])
+ax.plot(xhip,hiperbola(xhip,*popthip))
+# plt.plot(xhip,hiperbola(xhip,*par_inicial),'--',color='red')
+
+ax.set_ylabel('Modulation factor')
+
+ax = axx[1]
+
+ax.errorbar(voltages_dcA[I],Betas_vec[I]-hiperbola(voltages_dcA[I],*popthip),
+            yerr=ErrorBetas_vec[I],fmt='o',capsize=5,markersize=5,color=paleta[1])
+
+ax.set_ylabel('Res.')
+ax.set_xlabel('Endcap voltage (V)')
+
+for ax in axx:
+    ax.grid(True, ls=":", color='lightgray')
+
+
+print([t*1e3 for t in Temp_vec])
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Este hay que armarlo aún
+
+plt.figure()
+plt.errorbar(voltages_dcA,[t*1e3 for t in Temp_vec],yerr=[t*1e3 for t in ErrorTemp_vec],fmt='o',capsize=5,markersize=5,color=paleta[3])
+# plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+print(f'\n\nTE FALTA DEFINIR LA VARIABLE minimum_voltage\n\n')
+plt.axhline(0.538)
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+#plt.ylim(0,2)
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Ajuste de los betas y la temperatura
+
+from scipy.special import jv
+
+
+def expo(x,tau,A,B):
+    return A*np.exp(x/tau)+B
+
+def cuadratica(x,a,c):
+    return a*(x**2)+c
+
+def InverseMicromotionSpectra(beta, A, det, x0, gamma, B):
+    ftrap=22.1
+    #gamma=30
+    P = ((jv(0, beta)**2)/((((det-x0)**2)+(0.5*gamma)**2)**2))*(-2*(det-x0))
+    i = 1
+    #print(P)
+    while i <= 5:
+        P = P + (-2*(det-x0))*((jv(i, beta))**2)/(((((det-x0)+i*ftrap)**2)+(0.5*gamma)**2)**2) + (-2*(det-x0))*(((jv(-i, beta))**2)/((((det-x0)-i*ftrap)**2)+(0.5*gamma)**2)**2)
+        i = i + 1
+        #print(P)
+    #return 1/(A*P+B)
+    return 1/(A*P+B)
+
+
+def InverseMicromotionSpectra_raw(beta, A, det, B):
+    ftrap=22.1
+    gamma=21
+    P = ((jv(0, beta)**2)/((((det)**2)+(0.5*gamma)**2)**2))*(-2*(det))
+    i = 1
+    #print(P)
+    while i <= 3:
+        P = P + (-2*(det))*((jv(i, beta))**2)/(((((det)+i*ftrap)**2)+(0.5*gamma)**2)**2) + (-2*(det))*(((jv(-i, beta))**2)/((((det)-i*ftrap)**2)+(0.5*gamma)**2)**2)
+        i = i + 1
+        #print(P)
+    return A/P+B
+
+
+"""
+Temperatura vs beta con un ajuste exponencial 
+"""
+
+popt_exp, pcov_exp = curve_fit(expo,Betas_vec[:10],[t*1e3 for t in Temp_vec[:10]])
+popt_quad, pcov_quad = curve_fit(cuadratica,Betas_vec[:10],[t*1e3 for t in Temp_vec[:10]],p0=(1,10))
+#popt_rho22, pcov_rho22 = curve_fit(InverseMicromotionSpectra,Betas_vec,[t*1e3 for t in Temp_vec],p0=(10,10,-10,1,20)) #esto ajusta muy bien
+#popt_rho22, pcov_rho22 = curve_fit(InverseMicromotionSpectra,Betas_vec, [t*1e3 for t in Temp_vec],p0=(-10,-10,10,1,20)) #esto ajusta muy bien
+popt_rho22_raw, pcov_rho22_raw = curve_fit(InverseMicromotionSpectra_raw,Betas_vec[:10], [t*1e3 for t in Temp_vec[:10]],p0=(-10, -10, 1)) #esto ajusta muy bien
+
+
+print(popt_rho22_raw)
+
+betaslong = np.arange(0,2*2.7,0.01)
+
+print(f'Min temp predicted: {InverseMicromotionSpectra_raw(betaslong,*popt_rho22_raw)[100]}')
+
+plt.figure()
+plt.errorbar(Betas_vec[:10],[t*1e3 for t in Temp_vec[:10]],xerr=ErrorBetas_vec[:10], yerr=[t*1e3 for t in ErrorTemp_vec[:10]],fmt='o',capsize=5,markersize=5,color=paleta[3])
+#plt.plot(betaslong,expo(betaslong,*popt_exp),label='Ajuste exponencial')
+#plt.plot(betaslong,cuadratica(betaslong,*popt_quad),label='Ajuste cuadratico')
+#plt.plot(betaslong,InverseMicromotionSpectra(betaslong,*popt_rho22),label='Ajuste cuadratico')
+plt.plot(betaslong,InverseMicromotionSpectra_raw(betaslong,*popt_rho22_raw),label='Ajuste cuadratico')
+
+#plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+#plt.axhline(0.538)
+plt.xlabel('Modulation factor')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+
+
+#%%
+"""
+Esto no es del super ajuste sino de los ajustes anteriores en donde DetDoppler y offset son puestos a mano
+Aca grafico los betas con su error en funcion de la tension variada.
+Ademas, hago ajuste lineal para primeros y ultimos puntos, ya que espero que
+si la tension hace que la posicion del ion varie linealmente, el beta varia proporcional a dicha posicion.
+"""
+
+import seaborn as sns
+
+def lineal(x,a,b):
+    return a*x+b
+
+paleta = sns.color_palette("rocket")
+
+betavector = [beta1,beta2,beta3,beta4,beta5,beta6,beta7,beta8,beta9]
+errorbetavector = [errorbeta1,errorbeta2,errorbeta3,errorbeta4,errorbeta5,errorbeta6,errorbeta7,errorbeta8,errorbeta9]
+voltages_dcA = Voltages[0][1:10]
+
+poptini,pcovini = curve_fit(lineal,voltages_dcA[0:3],betavector[0:3])
+poptfin,pcovfin = curve_fit(lineal,voltages_dcA[4:],betavector[4:])
+
+minimum_voltage = -(poptini[1]-poptfin[1])/(poptini[0]-poptfin[0]) #voltaje donde se intersectan las rectas, es decir, donde deberia estar el minimo de micromocion
+minimum_modulationfactor = lineal(minimum_voltage,*poptini) #es lo mismo si pongo *poptfin
+
+xini = np.linspace(-0.23,-0.13,100)
+xfin = np.linspace(-0.15,0.005,100)
+
+plt.figure()
+plt.errorbar(voltages_dcA,betavector,yerr=errorbetavector,fmt='o',capsize=5,markersize=5,color=paleta[1])
+plt.plot(xini,lineal(xini,*poptini))
+plt.plot(xfin,lineal(xfin,*poptfin))
+plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Modulation factor')
+plt.grid()
+
+
+#%%
+"""
+Aca veo la temperatura del ion en funcion del voltaje del endcap, ya que
+al cambiar la cantidad de micromocion, cambia la calidad del enfriado
+"""
+tempvector = np.array([temp1,temp2,temp3,temp4,temp5,temp6,temp7,temp8,temp9])*1e3
+errortempvector = np.array([errortemp1,errortemp2,errortemp3,errortemp4,errortemp5,errortemp6,errortemp7,errortemp8,errortemp9])*1e3
+
+voltages_dcA = Voltages[0][1:10]
+
+plt.figure()
+plt.errorbar(voltages_dcA,tempvector,yerr=errortempvector,fmt='o',capsize=5,markersize=5,color=paleta[3])
+plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+plt.xlabel('Endcap voltage (V)')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+plt.ylim(0,2)
+
+
+#%%
+"""
+Por las dudas, temperatura en funcion de beta
+"""
+plt.figure()
+plt.errorbar(betavector,tempvector,yerr=errortempvector,xerr=errorbetavector,fmt='o',capsize=5,markersize=5)
+plt.xlabel('Modulation factor')
+plt.ylabel('Temperature (mK)')
+plt.grid()
+
+
+
+#%%
+"""
+Si quiero ver algun parametro del ajuste puntual. el orden es: 0:SG, 1:SP, 2:SCALE1, 3:OFFSET
+"""
+ki=2
+plt.errorbar(np.arange(0,9,1),[popt_1[ki],popt_2[ki],popt_3[ki],popt_4[ki],popt_5[ki],popt_6[ki],popt_7[ki],popt_8[ki],popt_9[ki]],yerr=[np.sqrt(pcov_1[ki,ki]),np.sqrt(pcov_2[ki,ki]),np.sqrt(pcov_3[ki,ki]),np.sqrt(pcov_4[ki,ki]),np.sqrt(pcov_5[ki,ki]),np.sqrt(pcov_6[ki,ki]),np.sqrt(pcov_7[ki,ki]),np.sqrt(pcov_8[ki,ki]),np.sqrt(pcov_9[ki,ki])], fmt='o',capsize=3,markersize=3)
+
+
+#%%
+
+if False:
+    GUARDAR = {}
+    # for var in [ kk for kk in globals().keys() if kk.startswith('pop') ]:
+    #     print(var)
+    #     GUARDAR[var] = globals()[var]
+    # print('')
+    # for var in [ kk for kk in globals().keys() if kk.startswith('pcov') ]:
+    #     print(var)
+    #     GUARDAR[var] = globals()[var]
+
+    # print('')
+    # for var in [ kk for kk in globals().keys() if kk.startswith('Fitted') ]:
+    #     print(var)
+    #     GUARDAR[var] = globals()[var]
+    # print('')
+    for var in [ kk for kk in globals().keys() if kk.endswith('_vec') ]:
+        print(var)
+        GUARDAR[var] = globals()[var]
+
+
+    np.savez('analisis_superajuste_PARAMETROS.npz', **GUARDAR )

analisis/plots/20250516_CPT_bladetrap/lolo_graficos_pub.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Ploteo de datos y ajustes del barrido en voltaje del Endcap
+equivalente a pasear el ion en algun entorno del punto de compensación ideal
+y ver los efectos de micromoción (y tal vez temperatura)
+
+
+
+@author: lolo
+"""
+
+
+import h5py
+import matplotlib.pyplot as plt
+import numpy as np
+
+from scipy.optimize import curve_fit
+from time import time
+from numba import jit,njit
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Carga de datos y librerías auxiliares
+
+
+## Librerias ##################################################################
+from Data.EITfit.lolo_modelo_full_8niveles import PerformExperiment_8levels_MM
+
+
+# PARAMETROS = np.load('PARAMETROS.npz',allow_pickle=True)
+# for var_name in PARAMETROS.keys():
+#     globals()[var_name] = PARAMETROS[var_name]
+#     print(f'loaded: {var_name}')
+
+
+# Funciones auxiliares
+
+
+from scipy.stats.distributions import  t,chi2
+import inspect
+
+def estadistica(datos_x,datos_y,modelo,pcov,parametros,nombres=None,alpha=0.05):
+    
+    if nombres is None:
+        nombres = inspect.getfullargspec(modelo).args[1:]
+    
+    # Cantidad de parámetros
+    P = len(parametros)
+    
+    # Número de datos
+    N = len(datos_x)
+    
+    # Grados de libertas (Degrees Of Freedom)
+    dof = N-P-1
+
+    # Cauculamos coordenadas del modelo
+    # modelo_x    = datos_x if modelo_x_arr is None else modelo_x_arr
+    # modelo_y    = modelo( modelo_x, *parametros )
+    
+    # Predicción del modelo para los datos_x medidos
+    prediccion_modelo = modelo( datos_x, *parametros )
+    
+    # Calculos de cantidades estadísticas relevantes
+    COV       = pcov                                      # Matriz de Covarianza
+    SE        = np.sqrt(np.diag( COV  ))                        # Standar Error / Error estandar de los parámetros
+    residuos  = datos_y - prediccion_modelo               # diferencia enrte el modelo y los datos
+    
+    SSE       = sum(( residuos )**2 )                     # Resitual Sum of Squares
+    SST       = sum(( datos_y - np.mean(datos_y))**2)        # Total Sum of Squares
+    
+    # http://en.wikipedia.org/wiki/Coefficient_of_determination
+    # Expresa el porcentaje de la varianza que logra explicar el modelos propuesto
+    Rsq       =  1 - SSE/SST                               # Coeficiente de determinación
+    Rsq_adj   = 1-(1-Rsq) * (N-1)/(N-P-1)                  # Coeficiente de determinación Ajustado   
+    
+    # https://en.wikipedia.org/wiki/Pearson_correlation_coefficient#In_least_squares_regression_analysis
+    # Expresa la correlación que hay entre los datos y la predicción del modelo
+    r_pearson = np.corrcoef( datos_y ,  prediccion_modelo )[0,1]
+    
+    # Reduced chi squared
+    # https://en.wikipedia.org/wiki/Reduced_chi-squared_statistic
+    chi2_     = sum( residuos**2 )/N
+    chi2_red  = sum( residuos**2 )/(N-P)
+    
+    # Chi squared test
+    chi2_test = sum( residuos**2 / abs(prediccion_modelo) )
+    # p-value del ajuste
+    p_val  = chi2(dof).cdf( chi2_test )
+    
+    
+    sT = t.ppf(1.0 - alpha/2.0, N - P ) # student T multiplier
+    CI = sT * SE                        # Confidence Interval
+    
+
+    return dict(R2=Rsq,R2_adj=Rsq_adj,chi2=chi2_,chi2_red=chi2_red,
+                chi2_test=chi2_test,r=r_pearson,pvalue=p_val,
+                SE=SE,CI=CI,parametros=parametros,nombres=nombres,alpha=alpha,N=N)
+
+
+def print_estadistica(dic):
+    
+    pars = 'N,pvalue,R2,R2_adj,chi2,chi2_red,chi2_test,r,SE,CI,parametros,nombres,alpha'.split(',') 
+    
+    N,pvalue,R2,R2_adj,chi2,chi2_red,chi2_test,r,SE,CI,parametros,nombres,alpha = [ dic[k] for k in pars  ]
+    P = len(parametros)
+    
+    
+    print('R-squared    ',R2)
+    print('R-sq_adjusted',R2_adj)
+    print('chi2         ',chi2)
+    print('chi2_reduced ',chi2_red)
+    print('chi2_test    ',chi2_test)
+    print('r-pearson    ',r)
+    print('p-value      ',pvalue)
+    print('')
+    print('Error Estandard (SE):')
+    for i in range(P):
+        print(f'parametro[{nombres[i]:>5s}]: ' , parametros[i], ' ± ' , SE[i])
+    print('')
+    print('Intervalo de confianza al '+str((1-alpha)*100)+'%:')
+    for i in range(P):
+        print(f'parametro[{nombres[i]:>5s}]: ' , parametros[i], ' ± ' , CI[i])
+
+
+
+
+
+
+## Datos ######################################################################
+
+"""
+Primero tengo mediciones de espectros cpt de un ion variando la tension dc_A
+"""
+
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20220106_CPT_DosLaseres_v08_TISA_DR\Data
+# os.chdir('../20231123_CPTconmicromocion3/Data/')
+
+folder = '../20231123_CPTconmicromocion3/Data/'
+CPT_FILES = f"""
+{folder}/000016262-IR_Scan_withcal_optimized
+{folder}/000016239-IR_Scan_withcal_optimized
+{folder}/000016240-IR_Scan_withcal_optimized
+{folder}/000016241-IR_Scan_withcal_optimized
+{folder}/000016244-IR_Scan_withcal_optimized
+{folder}/000016255-IR_Scan_withcal_optimized
+{folder}/000016256-IR_Scan_withcal_optimized
+{folder}/000016257-IR_Scan_withcal_optimized
+"""
+
+
+def SeeKeys(files):
+    for i, fname in enumerate(files.split()):
+        data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+        print(fname)
+        print(list(data['datasets'].keys()))
+
+print(SeeKeys(CPT_FILES))
+
+#carpeta pc nico labo escritorio:
+#C:\Users\Usuario\Documents\artiq\artiq_experiments\analisis\plots\20211101_CPT_DosLaseres_v03\Data
+
+Counts = []
+Freqs = []
+
+AmpTisa = []
+UVCPTAmp = []
+No_measures = []
+Voltages = []
+
+for i, fname in enumerate(CPT_FILES.split()):
+    print(str(i) + ' - ' + fname)
+    #print(fname)
+    data = h5py.File(fname+'.h5', 'r') # Leo el h5: Recordar que nuestros datos estan en 'datasets'
+
+    # Aca hago algo repugnante para poder levantar los strings que dejamos
+    # que además tenian un error de tipeo al final. Esto no deberá ser necesario
+    # cuando se solucione el error este del guardado.
+    Freqs.append(np.array(data['datasets']['IR1_Frequencies']))
+    Counts.append(np.array(data['datasets']['data_array']))
+    #AmpTisa.append(np.array(data['datasets']['TISA_CPT_amp']))
+    UVCPTAmp.append(np.array(data['datasets']['UV_CPT_amp']))
+    No_measures.append(np.array(data['datasets']['no_measures']))
+    Voltages.append(np.array(data['datasets']['scanning_voltages']))
+
+def Split(array,n):
+    length=len(array)/n
+    splitlist = []
+    jj = 0
+    while jj<length:
+        partial = []
+        ii = 0
+        while ii < n:
+            partial.append(array[jj*n+ii])
+            ii = ii + 1
+        splitlist.append(partial)
+        jj = jj + 1
+    return splitlist
+
+
+CountsSplit = []
+CountsSplit.append(Split(Counts[0],len(Freqs[0])))
+
+
+CountsSplit_2ions = []
+CountsSplit_2ions.append(Split(Counts[4],len(Freqs[4])))
+
+
+## Cargo parámetros fiteados de antes #########################################
+
+
+PARAMETROS = np.load('analisis_superajuste_PARAMETROS.npz',allow_pickle=True)
+for var_name in PARAMETROS.keys():
+    globals()[var_name] = PARAMETROS[var_name]
+    print(f'loaded: {var_name}')
+
+
+if False:
+    # Esto es para correr en caso de necesidad de limpiar todos los vectores de parametros
+    print('Limpio los vectores de parámetros')
+    for var in [ kk for kk in globals().keys() if kk.endswith('_vec') ]:
+        print(f'del {var}')
+        del(globals()[var])
+
+
+## Definiciones de Numba ######################################################
+
+@jit
+def FitEIT_MM_single_plot(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+    #BETA = 1.8
+    # SG = 0.6
+    # SP = 8.1
+    # TEMP = 0.2e-3
+
+    freqs = [2*f*1e-6-offset for f in Freqs]
+
+    Detunings, Fluorescence1 = PerformExperiment_8levels_MM(SG, SP, gPS, gPD, DetDoppler, u, 
+                                                            DopplerLaserLinewidth, ProbeLaserLinewidth, 
+                                                            TEMP, alpha, phidoppler, titadoppler, 
+                                                            phiprobe, titaprobe,  BETA1, drivefreq, 
+                                                            min(freqs), max(freqs)+(freqs[1]-freqs[0]), 
+                                                            freqs[1]-freqs[0], circularityprobe=CircPr, 
+                                                            plot=False, solvemode=1, detpvec=None)
+
+    ScaledFluo1 = np.array([f*SCALE1 + OFFSET for f in Fluorescence1])
+    return ScaledFluo1, Detunings
+
+
+
+@jit
+def FitEIT_MM_single(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP):
+    "Esta verison de la función devuelve sólo el eje y, para usar de modelo en un ajuste"
+    return FitEIT_MM_single_plot(Freqs, offset, DetDoppler, SG, SP, SCALE1, OFFSET, BETA1, TEMP)[0]
+
+
+
+param_names = 'offset DetDoppler SG SP SCALE1 OFFSET BETA1 TEMP'.split()
+
+#%%
+"""
+AHORA INTENTO SUPER AJUSTES O SEA CON OFFSETXPI Y DETDOPPLER INCLUIDOS
+
+La 0 no ajusta bien incluso con todos los parametros libres
+De la 1 a la 11 ajustan bien
+"""
+
+
+#from EITfit.MM_eightLevel_2repumps_AnalysisFunctions import PerformExperiment_8levels
+from scipy.optimize import curve_fit
+
+"""
+SUPER AJUSTE (SA)
+"""
+
+phidoppler, titadoppler = 0, 90
+phirepump, titarepump = 0,  0
+phiprobe = 0
+titaprobe = 90
+
+Temp = 0.5e-3
+
+sg = 0.544
+sp = 4.5
+sr = 0
+DetRepump = 0
+
+
+lw = 0.1
+DopplerLaserLinewidth, RepumpLaserLinewidth, ProbeLaserLinewidth = lw, lw, lw #ancho de linea de los laseres
+
+
+u = 32.5e6
+
+#B = (u/(2*np.pi))/c
+
+correccion = 13
+
+#DetDoppler = -11.5-correccion
+
+gPS, gPD, = 2*np.pi*21.58e6, 2*np.pi*1.35e6
+alpha = 0
+
+
+drivefreq = 2*np.pi*22.135*1e6
+
+
+SelectedCurveVec = [1,2,3,4,5,6,7,8,9,10,11]
+#SelectedCurveVec = [10]
+
+CircPr = 1
+alpha = 0
+
+
+
+voltages_dcA  = Voltages[0][SelectedCurveVec]
+
+
+
+
+def hiperbola(x,a,y0,b,x0):
+    """
+    Hiperbola de ecuación:
+        1 =(y-y0)²/a² - (x-x0)²/b² 
+    """
+    return a*np.sqrt(((x-x0)**2+b**2))+y0
+
+
+def hiperbola2(x,a,b,x0):
+    """
+    Hiperbola de ecuación:
+        1 =(y)²/a² - (x-x0)²/b² 
+    """
+    return a*np.sqrt(((x-x0)**2+b**2))
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Graficamos todos los fiteos
+
+
+
+# fig, axx = plt.subplots( 3,4, figsize=(13,8) ,  constrained_layout=True, sharex=True , sharey=True )
+# fig.set_constrained_layout_pads(w_pad=2/72, h_pad=2/72, hspace=0, wspace=0)
+
+# tmp_datos=(Detuningsshort_vec,Counts_vec,Detuningslong_vec,FittedCounts_vec,SelectedCurveVec,axx.flatten())
+
+# for Detunings_3_SA_short,CountsDR,Detunings_3_SA_long,FittedEITpi_3_SA_long,selectedcurve,ax in zip(*tmp_datos):
+#     ax.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), fmt='o', color='darkgreen', alpha=0.3, capsize=2, markersize=2)
+#     ax.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, color='black', linewidth=2, label=f'med {selectedcurve}', alpha=0.7)
+#     #plt.title(f'Sdop: {round(popt[0], 2)}, Spr: {round(popt[1], 2)}, T: {round(popt[2]*1e3, 2)} mK, detDop: {DetDoppler} MHz')
+#     # ax.set_xlabel('Detuning (MHz)')
+#     # ax.set_ylabel('Counts')
+#     ax.legend(loc='upper left', fontsize=12)
+#     ax.grid(True, ls=":")
+
+#     print(f'listo med {selectedcurve}')
+#     # print(popt_3_SA)
+
+
+# for ax in axx[:,0]:
+#     ax.set_ylabel('Counts')
+
+# for ax in axx[-1,:]:
+#     ax.set_xlabel('Detuning (MHz)')
+
+
+
+
+
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Gráfico central OPCION A
+
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.size': 8})
+
+# Para esto hace falta:
+# sudo apt install dvipng
+
+plt.rcParams['text.usetex']=True
+# plt.rcParams['text.latex.unicode']=True
+# params= {'text.latex.preamble' : [r'\usepackage{amsmath}']}
+# plt.rcParams.update(params)
+
+
+# fig, axx = plt.subplots( 3,4, figsize=(8.6/2.54*2,4) ,  constrained_layout=True, sharex=True , sharey=True )
+# fig.set_constrained_layout_pads(w_pad=2/72, h_pad=2/72, hspace=0, wspace=0)
+
+
+## Layout ###########################
+from matplotlib import gridspec
+figsize=(8.6/2.54*2,4)
+width_ratios=[1,2,1]
+
+fig, axx = plt.subplots(ncols=3, nrows=3, sharex=True, sharey=False,   constrained_layout=True,
+                        figsize=figsize, gridspec_kw=dict(width_ratios=width_ratios))
+fig.set_constrained_layout_pads(w_pad=1/72, h_pad=1/72, hspace=0, wspace=0)
+fig.set_constrained_layout_pads(w_pad=0, h_pad=0, hspace=0, wspace=0)
+
+gs = axx[0, 0].get_gridspec()
+# remove the underlying axes
+for ax in axx[:,1]:
+    ax.remove()
+    
+
+gs2 = gridspec.GridSpec(4,3, width_ratios=width_ratios,left=0.16,right=0.9,bottom=0.12)
+
+ax_central = fig.add_subplot(gs2[:-1, 1])
+
+ax_res = fig.add_subplot(gs2[-1, 1], sharex=ax_central,zorder=-5)
+plt.setp(ax_central.get_xticklabels(), visible=False)
+
+for ax in axx[:,2]:
+    ax.yaxis.tick_right()
+    ax.yaxis.set_label_position("right")
+
+
+
+## CPTs ########################################
+selection= (0,1,3,4,7,8)
+axes_vec = (axx[0,0],axx[1,0],axx[2,0],axx[2,2],axx[1,2],axx[0,2])
+
+tmp_datos=(Detuningsshort_vec[selection,:],
+           Counts_vec[selection,:],
+           Detuningslong_vec[selection,:],
+           FittedCounts_vec[selection,:],
+           np.array(selection)+1,
+           axes_vec,'abcfed')
+
+for Detunings_3_SA_short,CountsDR,Detunings_3_SA_long,FittedEITpi_3_SA_long,selectedcurve,ax,le in zip(*tmp_datos):
+    ax.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), 
+                fmt='o', color='darkgreen', alpha=0.2, capsize=2, 
+                markersize=2, label='measured data')
+    ax.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, 
+            color='black', linewidth=2, label=f'micromotion model', alpha=0.7)
+    
+    ax.grid(True, ls=":", color='lightgray')
+    
+    ax.set_yticklabels([ f"{int(y/1000)}k" for y in ax.get_yticks() ])
+    
+    ax.set_title(f'({le})', x=0.1, y=0.78, color='gray')
+    # ax.legend()
+    # ax.legend(ax.get_legend_handles_labels()[0], f'{selectedcurve}')
+    print(f'listo med {selectedcurve}')
+
+
+axx[2,0].set_xlabel('Detuning [MHz]')
+axx[2,2].set_xlabel('Detuning [MHz]')
+
+axx[1,0].set_ylabel('Counts')
+axx[1,2].set_ylabel('Counts')
+
+
+
+
+
+## Grafico central ###############################
+I = slice(None,9)
+par_inicial = (12,0.1,1,-0.13)
+param,pcov = curve_fit(hiperbola,voltages_dcA[I],Betas_vec[I],p0=par_inicial)
+x_hip = np.linspace(-0.23,0.005,200)
+
+EST=estadistica(voltages_dcA[I],Betas_vec[I],hiperbola,pcov,param,nombres=None,alpha=0.05)
+print_estadistica(EST)
+
+
+I = slice(None,9)
+par_inicial = (12,1,-0.13)
+param2,pcov2 = curve_fit(hiperbola2,voltages_dcA[I],Betas_vec[I],p0=par_inicial)
+x_hip = np.linspace(-0.23,0.005,200)
+
+EST2=estadistica(voltages_dcA[I],Betas_vec[I],hiperbola2,pcov2,param2,nombres=None,alpha=0.05)
+print_estadistica(EST2)
+
+
+
+
+
+
+
+
+ax = ax_central
+ax.errorbar(voltages_dcA[I],Betas_vec[I],yerr=ErrorBetas_vec[I],fmt='o',
+            capsize=4,markersize=3,color='C3', label=r'fitted $\beta$')
+ax.plot(x_hip,hiperbola(x_hip,*param),color='C0', label=r'hyperbola model')
+ax.plot(x_hip,hiperbola2(x_hip,*param2),'--',color='C4', label=r'hyperbola model')
+
+ax.set_ylabel(r'Modulation factor $\beta$', labelpad=-5)
+ax.set_ylim(-0.05,3)
+ax.set_xlim(-0.22,0)
+ax.set_title(f'(g)', x=0.95, y=0.006, color='gray')
+
+ax = ax_res
+ax.errorbar(voltages_dcA[I],Betas_vec[I]-hiperbola(voltages_dcA[I],*param),
+            yerr=ErrorBetas_vec[I],fmt='o',capsize=4,markersize=3,color='C3')
+ax.errorbar(voltages_dcA[I]+0.005,Betas_vec[I]-hiperbola2(voltages_dcA[I],*param2),
+            yerr=ErrorBetas_vec[I],fmt='o',capsize=4,markersize=3,color='C4')
+ax.axhline( 0 , color='C0')
+ax.set_ylabel('Res.', labelpad=-5)
+ax.set_xlabel('Endcap voltage [V]')
+ax.set_title(f'(h)', x=0.95, y=0.72, color='gray')
+
+
+ax_res.get_xticklabels()[-1].set_visible(False)
+
+for ax in [ax_central,ax_res]:
+    ax.grid(True, ls=":", color='lightgray')
+
+
+# print([t*1e3 for t in Temp_vec])
+
+
+# Anotaciones ##########################3
+for jj,ax in zip(selection,axes_vec):
+    
+    Axes_x = 1 if axx.flatten().tolist().index(ax)%3==0 else 0
+    ax_central.annotate("",
+                         xy=(ax_central.get_lines()[0].get_xdata()[jj], ax_central.get_lines()[0].get_ydata()[jj]), 
+                         xycoords=ax_central.transData,
+                         xytext=(Axes_x, 0.5), textcoords=ax.transAxes,
+                         arrowprops=dict(arrowstyle="<-",connectionstyle="arc3,rad=-0.2", color='gray', alpha=0.5),
+                         zorder=-2)
+    
+
+
+# Leyenda ##############################
+# h1, l1 = ax_central.get_legend_handles_labels()
+# h2, l2 = axx[0,0].get_legend_handles_labels()
+# ax_central.legend(h1+h2, l1+l2, loc='upper left')
+
+
+
+fig.align_ylabels([ax_central,ax_res])
+fig.tight_layout()
+
+
+# fig.savefig('grafico_central_opcion_A.png', dpi=300)
+# fig.savefig('grafico_central_opcion_A.pdf')
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Gráfico central OPCION B
+
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.size': 8})
+
+# Para esto hace falta:
+# sudo apt install dvipng
+
+plt.rcParams['text.usetex']=True
+# plt.rcParams['text.latex.unicode']=True
+# params= {'text.latex.preamble' : [r'\usepackage{amsmath}']}
+# plt.rcParams.update(params)
+
+
+# fig, axx = plt.subplots( 3,4, figsize=(8.6/2.54*2,4) ,  constrained_layout=True, sharex=True , sharey=True )
+# fig.set_constrained_layout_pads(w_pad=2/72, h_pad=2/72, hspace=0, wspace=0)
+
+
+
+voltages_dcA  = Voltages[0][SelectedCurveVec]*4
+
+
+
+
+## Layout ###########################
+from matplotlib import gridspec
+figsize=(8.6/2.54*2,4)
+width_ratios=[1,2,1]
+
+fig, axx = plt.subplots(ncols=3, nrows=3, sharex=True, sharey=False,   constrained_layout=True,
+                        figsize=figsize, gridspec_kw=dict(width_ratios=width_ratios))
+fig.set_constrained_layout_pads(w_pad=1/72, h_pad=1/72, hspace=0, wspace=0)
+fig.set_constrained_layout_pads(w_pad=0, h_pad=0, hspace=0, wspace=0)
+
+gs = axx[0, 0].get_gridspec()
+# remove the underlying axes
+for ax in axx[:,1]:
+    ax.remove()
+    
+
+gs2 = gridspec.GridSpec(4,3, width_ratios=width_ratios,left=0.16,right=0.9,bottom=0.12)
+
+ax_central = fig.add_subplot(gs2[1:-1, 1])
+
+ax_dib = fig.add_subplot(gs2[0, 1], sharex=ax_res, zorder=-20)
+ax_dib.spines[:].set_visible(False)
+ax_dib.xaxis.set_tick_params(labelbottom=False)
+ax_dib.yaxis.set_tick_params(labelleft=False)
+ax_dib.set_xticks([])
+ax_dib.set_yticks([])
+
+ax_res = fig.add_subplot(gs2[-1, 1], sharex=ax_central,zorder=-5)
+plt.setp(ax_central.get_xticklabels(), visible=False)
+
+for ax in axx[:,2]:
+    ax.yaxis.tick_right()
+    ax.yaxis.set_label_position("right")
+
+
+
+## CPTs ########################################
+selection= (0,1,3,4,7,8)
+axes_vec = (axx[0,0],axx[1,0],axx[2,0],axx[2,2],axx[1,2],axx[0,2])
+
+tmp_datos=(Detuningsshort_vec[selection,:],
+           Counts_vec[selection,:],
+           Detuningslong_vec[selection,:],
+           FittedCounts_vec[selection,:],
+           np.array(selection)+1,
+           axes_vec,'abcfed')
+
+
+from scipy.signal import savgol_filter as savgol
+
+
+for Detunings_3_SA_short,CountsDR,Detunings_3_SA_long,FittedEITpi_3_SA_long,selectedcurve,ax,le in zip(*tmp_datos):
+    # ax.errorbar(Detunings_3_SA_short, CountsDR, yerr=2*np.sqrt(CountsDR), 
+    #             fmt='o', color='darkgreen', alpha=0.2, capsize=2, 
+    #             markersize=2, label='measured data')
+    
+    yerr_max = CountsDR+2*np.sqrt(CountsDR)
+    yerr_min = CountsDR-2*np.sqrt(CountsDR)
+    
+    yerr_max = savgol(yerr_max,3,2)
+    yerr_min = savgol(yerr_min,3,2)
+    
+    ax.fill_between(Detunings_3_SA_short, yerr_max, yerr_min,
+                    color='darkgreen', alpha=0.2)
+    
+    ax.plot(Detunings_3_SA_short, CountsDR, '.', ms=2,
+                    color='darkgreen', alpha=0.9)
+    
+    ax.plot(Detunings_3_SA_long, FittedEITpi_3_SA_long, 
+            color='black', linewidth=1, label=f'micromotion model', alpha=0.7)
+    
+    ax.grid(True, ls=":", color='lightgray')
+    
+    ax.set_yticklabels([ f"{int(y/1000)}k" for y in ax.get_yticks() ])
+    
+    ax.set_title(f'({le})', x=0.1, y=0.78, color='gray')
+    # ax.legend()
+    # ax.legend(ax.get_legend_handles_labels()[0], f'{selectedcurve}')
+    print(f'listo med {selectedcurve}')
+
+
+axx[2,0].set_xlabel('Detuning [MHz]')
+axx[2,2].set_xlabel('Detuning [MHz]')
+
+axx[1,0].set_ylabel('Counts')
+axx[1,2].set_ylabel('Counts')
+
+
+
+
+
+## Grafico central ###############################
+I = slice(None,9)
+par_inicial = (12,1,-0.13)
+param,pcov = curve_fit(hiperbola2,voltages_dcA[I],Betas_vec[I],p0=par_inicial)
+x_hip = np.linspace(-0.23*4,0.005,200)
+
+EST=estadistica(voltages_dcA[I],Betas_vec[I],hiperbola2,pcov,param,nombres=None,alpha=0.05)
+print_estadistica(EST)
+
+
+ax = ax_central
+ax.errorbar(voltages_dcA[I],Betas_vec[I],yerr=ErrorBetas_vec[I],fmt='o',
+            capsize=4,markersize=3,color='C3', label=r'fitted $\beta$')
+ax.plot(x_hip,hiperbola2(x_hip,*param),color='C0', label=r'hyperbola model')
+ax.set_ylabel(r'Modulation factor $\beta$', labelpad=-5)
+ax.set_ylim(-0.05,3)
+ax.set_xlim(-0.22*4,0)
+ax.set_title(f'(h)', x=0.95, y=0.006, color='gray')
+
+ax = ax_res
+ax.errorbar(voltages_dcA[I],Betas_vec[I]-hiperbola2(voltages_dcA[I],*param),
+            yerr=ErrorBetas_vec[I],fmt='o',capsize=4,markersize=3,color='C3')
+ax.axhline( 0 , color='C0')
+ax.set_ylabel('Res.', labelpad=-5)
+ax.set_xlabel('Endcap voltage [V]')
+ax.set_title(f'(i)', x=0.95, y=0.72, color='gray')
+
+
+ax_res.get_xticklabels()[-1].set_visible(False)
+
+for ax in [ax_central,ax_res]:
+    ax.grid(True, ls=":", color='lightgray')
+
+
+# print([t*1e3 for t in Temp_vec])
+
+
+# Anotaciones ##########################
+for jj,ax in zip(selection,axes_vec):
+    
+    rad = 0.2 if jj==8 or jj==3 else -0.2
+    Axes_x = 1 if axx.flatten().tolist().index(ax)%3==0 else 0
+    ax_central.annotate("",
+                         xy=(ax_central.get_lines()[0].get_xdata()[jj], ax_central.get_lines()[0].get_ydata()[jj]), 
+                         xycoords=ax_central.transData,
+                         xytext=(Axes_x, 0.5), textcoords=ax.transAxes,
+                         arrowprops=dict(arrowstyle="<-",connectionstyle=f"arc3,rad={rad}", color='gray', alpha=0.5),
+                         zorder=-2)
+    
+
+
+# dibujos ##########################
+
+# a, y0, b, x0 = param
+a, b, x0 = param
+
+
+y0 = -0.212663964284234
+
+
+ax_dib.plot( x_hip , x_hip*0+y0 , color='gray')
+ax_dib.set_ylim(-y0*0.1,y0*1.2)
+
+ax_dib.plot( [x0], [0], 'x' )
+ax_dib.text(x0+0.01, 0, 'trap center', fontsize = 8, ha='left',va='center', color='C0') 
+
+
+ax_dib.plot( voltages_dcA[I], voltages_dcA[I]*0+y0, '.' )
+
+for Vx in voltages_dcA[I]:
+    ax_dib.plot( [Vx,x0], [y0,0], ':', color='lightgray', lw=1)
+
+
+
+import matplotlib.patches as mpatches
+
+arr = mpatches.FancyArrowPatch((x0, y0*1.1), (x0/2, y0*1.1),
+                               arrowstyle='->,head_width=.15', mutation_scale=10, color='C1')
+ax_dib.add_patch(arr)
+ax_dib.annotate("ion position", (.5, .5), xycoords=arr, ha='center', va='bottom', color='C1')
+
+
+# r
+arr = mpatches.FancyArrowPatch((x0,0), ( voltages_dcA[5], y0),
+                               arrowstyle='->,head_width=.25', mutation_scale=10, color='black')
+ax_dib.add_patch(arr)
+ax_dib.annotate(r"$\vec r$", (.5, .5), xycoords=arr, ha='center', va='bottom', color='black')
+
+
+
+
+bbox = ax_dib.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
+aspect_ratio = bbox.width / bbox.height
+
+ax_dib.plot(0.1, 0, ">k", transform=ax_dib.transAxes, clip_on=False, ms=3, lw=1)
+ax_dib.plot([0,0.1], [0,0], "-k", transform=ax_dib.transAxes, clip_on=False, lw=1)
+
+ax_dib.plot(0, 0.1*aspect_ratio, "^k", transform=ax_dib.transAxes, clip_on=False, ms=3, lw=1)
+ax_dib.plot([0,0], [0,0.1*aspect_ratio], "-k", transform=ax_dib.transAxes, clip_on=False, lw=1)
+
+
+ax_dib.text(0.1, 0.13, "x", transform=ax_dib.transAxes,
+            fontsize=8,  va='top')
+ax_dib.text(0.03, 0.13*aspect_ratio, "y", transform=ax_dib.transAxes,
+            fontsize=8,  va='top')
+
+
+ax_dib.set_title(f'(g)', x=0.95, y=0.5, color='gray')
+
+
+# Leyenda ##############################
+# h1, l1 = ax_central.get_legend_handles_labels()
+# h2, l2 = axx[0,0].get_legend_handles_labels()
+# ax_central.legend(h1+h2, l1+l2, loc='upper left')
+
+
+
+fig.align_ylabels([ax_central,ax_res])
+fig.tight_layout()
+
+
+fig.savefig('grafico_central_opcion_B.png', dpi=300)
+fig.savefig('grafico_central_opcion_B.pdf')
+
+
+
+
+#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#%% Grafico de RF Heating y temp
+
+
+from scipy.special import jv
+import seaborn as sns
+paleta = sns.color_palette("rocket")
+
+
+"""
+Por si no quiero correr todo de nuevo, 
+los vectores del grafico son estos
+    
+Betas_vec = [1.5063238290734708, 0.901629236713104, 0.5280696724084589, 0.32347492275852474, 0.581352716043054, 0.9655636982224044, 1.6186284658310388, 2.1055294502704047, 2.548008896618126, 3.130666254406969, 3.1665902866111795]
+ErrorBetas_vec = [0.034184989382424424, 0.04827624922956116, 0.054704762232730145, 0.06708926613955447, 0.047526038227881616, 0.05210296764897591, 0.03630379898730492, 0.034064021790261405, 0.050405155463964166, 0.10838273932613045, 0.2828605486723366]
+
+Temp_vec = [0.0017384071359855713, 0.0006380145223733723, 0.0007457923288975645, 0.0006442238745101592, 0.0006270680749881928, 0.0008995355804703286, 0.0017799223158665226, 0.002941224610139307, 0.008378628768005558, 0.026250695067608725, 0.09869604401089357]
+ErrorTemp_vec = [0.0004229476096548473, 0.00014439375508413987, 0.00013204015146487435, 9.307939678673377e-05, 0.000100129717662808, 0.0001841318633900307, 0.0003595040837509976, 0.0005950353892849986, 0.001866844309182069, 0.012656306714647434, 0.13143081065882864]
+"""
+
+
+   
+Betas_vec = [1.5063238290734708, 0.901629236713104, 0.5280696724084589, 0.32347492275852474, 0.581352716043054, 0.9655636982224044, 1.6186284658310388, 2.1055294502704047, 2.548008896618126, 3.130666254406969, 3.1665902866111795]
+ErrorBetas_vec = [0.034184989382424424, 0.04827624922956116, 0.054704762232730145, 0.06708926613955447, 0.047526038227881616, 0.05210296764897591, 0.03630379898730492, 0.034064021790261405, 0.050405155463964166, 0.10838273932613045, 0.2828605486723366]
+
+Temp_vec = [0.0017384071359855713, 0.0006380145223733723, 0.0007457923288975645, 0.0006442238745101592, 0.0006270680749881928, 0.0008995355804703286, 0.0017799223158665226, 0.002941224610139307, 0.008378628768005558, 0.026250695067608725, 0.09869604401089357]
+ErrorTemp_vec = [0.0004229476096548473, 0.00014439375508413987, 0.00013204015146487435, 9.307939678673377e-05, 0.000100129717662808, 0.0001841318633900307, 0.0003595040837509976, 0.0005950353892849986, 0.001866844309182069, 0.012656306714647434, 0.13143081065882864]
+
+
+
+
+def MicromotionSpectra(beta,det, gamma):
+    """
+    Espectro de transicion doppler considerando micromocion
+    """
+    ftrap=2*np.pi*22.1e6
+    #gamma=23
+    P = (jv(0, beta)**2)/(((det)**2)+(0.5*gamma)**2)
+    i = 1
+    #print(P)
+    while i <= 2: #numero de bandas de micromocion a considerar
+        P = P + ((jv(i, beta))**2)/((((det)+i*ftrap)**2)+(0.5*gamma)**2) + ((jv(-i, beta))**2)/((((det)-i*ftrap)**2)+(0.5*gamma)**2) 
+        i = i + 1
+        #print(P)
+    return (gamma/2*np.pi)*P
+    #return P
+
+
+def InverseDerivMicromotionSpectra(beta, det, gamma):
+    """
+    La inversa de la derivada del espectro de micromocion
+    """
+    
+    ftrap=2*np.pi*22.1e6
+    #gamma=23
+    #det = -gamma/2
+    P = ((jv(0, beta)**2)/((((det)**2)+(0.5*gamma)**2)**2))*(-2*(det))
+    i = 1
+    #print(P)
+    while i <= 2:
+        P = P + (-2*(det))*((jv(i, beta))**2)/(((((det)+i*ftrap)**2)+(0.5*gamma)**2)**2) + (-2*(det))*(((jv(-i, beta))**2)/((((det)-i*ftrap)**2)+(0.5*gamma)**2)**2)
+        i = i + 1
+        #print(P)
+    return 1/((gamma/2*np.pi)*P)
+    #return 1/P
+
+
+def FinalTemp(beta,det, C,D):
+    """
+    Funcion para ajustar la tmeperatura final en funcion de beta.
+    Esta funcion tiene un parametro de ajuste C para estudiar posibles desviacioens de la temperatura
+    doppler teorica para un sistema de dos niveles.
+    """
+    gamma = 23e6
+    hbar = 1.05e-34
+    kb = 1.38e-23
+    return ((hbar/(kb))*C*MicromotionSpectra(beta,2*np.pi*det,2*np.pi*gamma)+D*(beta**2))*InverseDerivMicromotionSpectra(beta, 2*np.pi*det, 2*np.pi*gamma)
+
+
+def FinalTemp_withoutC(beta,det, D, forgetmicromotion=False):
+    """
+    Funcion para ajustar la temperatura final en funcion de beta.
+    Esta funcion no tiene ese parametro de ajuste ya que vi que era muy cercano a 1.
+    """
+    gamma = 23e6
+    hbar = 1.05e-34
+    kb = 1.38e-23
+    C = 1 #justamente aca dejo fijo ese parametro
+    
+    if forgetmicromotion:
+        D=0
+    
+    return ((hbar/(kb))*C*MicromotionSpectra(beta,2*np.pi*det,2*np.pi*gamma)+D*(beta**2))*InverseDerivMicromotionSpectra(beta, 2*np.pi*det, 2*np.pi*gamma)
+    #return (C*MicromotionSpectra(beta,det,gamma))*InverseDerivMicromotionSpectra(beta, det, gamma)
+
+
+def FinalTemp_withoutmicromotion(beta,det):
+    """
+    Funcion para ajustar la temperatura final en funcion de beta.
+    Esta funcion no tiene ese parametro de ajuste ya que vi que era muy cercano a 1.
+    """
+    gamma = 23e6
+    hbar = 1.05e-34
+    kb = 1.38e-23
+    C = 1 #justamente aca dejo fijo ese parametro
+    
+    D=0
+    
+    return ((hbar/(kb))*C*MicromotionSpectra(beta,2*np.pi*det,2*np.pi*gamma)+D*(beta**2))*InverseDerivMicromotionSpectra(beta, 2*np.pi*det, 2*np.pi*gamma)
+    #return (C*MicromotionSpectra(beta,det,gamma))*InverseDerivMicromotionSpectra(beta, det, gamma)
+
+
+
+
+
+
+def CoolingLimit_noMM(det):
+    gamma = 2*np.pi*23e6
+    hbar = 1.05e-34
+    kb = 1.38e-23
+    beta = 0
+    
+    rta  = ((2*hbar/(2*kb))*MicromotionSpectra(beta,det,gamma))
+    rta *= InverseDerivMicromotionSpectra(beta, det, gamma)
+    return rta
+
+DetVec = np.arange(-2*np.pi*30e6,-2*np.pi*1e6,2*np.pi*0.1e6)
+Temps_limit = []
+for detuning in DetVec:
+    Temps_limit.append(CoolingLimit_noMM(detuning))
+
+
+print(f'best: {1e3*np.min(Temps_limit)}')    
+
+if False:
+    plt.figure()
+    plt.plot(DetVec*1e-6/(2*np.pi), np.array(Temps_limit)*1e3)
+    plt.grid()
+    plt.xlabel('detuning (MHz)')
+    plt.ylabel('final temperature')
+
+
+#Dos pruebas... ignorar
+#popt_rho22_balance, pcov_rho22_balance = curve_fit(FinalTemp,list(Betas_vec[:9]), [t for t in Temp_vec[:9]],p0=(-11e6,0.8,4e-28)) #esto ajusta muy bien
+#popt_rho22_balance, pcov_rho22_balance = curve_fit(FinalTemp,list(Betas_vec[:10]), [t for t in Temp_vec[:10]],sigma=ErrorTemp_vec[:10],absolute_sigma=False,p0=(-10e6,0.8,5e-20)) #esto ajusta muy bien
+
+#Buen ajuste final:
+popt_rho22_balance, pcov_rho22_balance = curve_fit(FinalTemp_withoutC,list(Betas_vec[:10]), [t for t in Temp_vec[:10]],sigma=ErrorTemp_vec[:10],absolute_sigma=False,p0=(-10e6,5e-20)) #esto ajusta muy bien
+popt_rho22_balance_noMM, pcov_rho22_balance_noMM = curve_fit(FinalTemp_withoutmicromotion,list(Betas_vec[:10]), [t for t in Temp_vec[:10]],sigma=ErrorTemp_vec[:10],absolute_sigma=False,p0=(-10e6)) #esto ajusta muy bien
+
+
+
+betaslong = np.arange(0,2.8,0.01)
+
+print(f'Min temp predicted: {FinalTemp_withoutC(betaslong,*popt_rho22_balance)[0]}')
+#print(f'Min temp predicted: {1e3*FinalTemp(betaslong,*popt_rho22_balance)[0]} mK')
+
+print(f'Detuning: {1e-6*popt_rho22_balance[0]} MHz')
+
+
+print(f'params: {popt_rho22_balance}')
+print(f'errores: {np.sqrt(np.diag(pcov_rho22_balance))}')
+
+k_plot = 9
+
+
+
+
+
+# #plt.plot(betaslong,FinalTemp_fixedall(betaslong,*popt_rho22_balance),label='Ajuste con espectro modulado')
+# # plt.xlim(-0.1,1.1)
+# #plt.ylim(0,1)
+# #plt.axvline(minimum_voltage,linestyle='dashed',color='grey')
+# #plt.axhline(0.538)
+# plt.xlabel('Modulation factor')
+# plt.ylabel('Temperature (mK)')
+# plt.legend()
+# plt.grid()
+
+
+
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.size': 8})
+
+# Para esto hace falta:
+# sudo apt install dvipng
+
+plt.rcParams['text.usetex']=True
+
+
+# Acá estimo un detuning de (10 +- 4) MHz
+Detuning_range = ( 10 + 4*np.array([-1,1]) )*1e6
+Doppler_limit_area = CoolingLimit_noMM(-2*np.pi*Detuning_range)*1e3
+
+
+
+figsize=(8.6/2.54,3.5)
+
+
+fig, ax = plt.subplots(1,1,  constrained_layout=True,
+                        figsize=figsize)
+# fig.set_constrained_layout_pads(w_pad=1/72, h_pad=1/72, hspace=0, wspace=0)
+# fig.set_constrained_layout_pads(w_pad=0, h_pad=0, hspace=0, wspace=0)
+
+ax.errorbar(Betas_vec[:k_plot],[t*1e3 for t in Temp_vec[:k_plot]],xerr=ErrorBetas_vec[:k_plot], 
+            yerr=[t*1e3 for t in ErrorTemp_vec[:k_plot]],fmt='o',
+            capsize=3,markersize=3,color='C3',zorder=10,alpha=0.9, label='inferred data')
+#plt.plot(betaslong,[t*1e3 for t in FinalTemp(betaslong,*popt_rho22_balance)],label='Ajuste con espectro modulado')
+ax.plot(betaslong,[t*1e3 for t in FinalTemp_withoutC(betaslong,*popt_rho22_balance)],
+        '-', color='C0',  label='model w/ RF heating')
+
+ax.plot(betaslong,[t*1e3 for t in FinalTemp_withoutmicromotion(betaslong,*popt_rho22_balance_noMM)],
+        '--', color='C1',label='model w/o RF heating')
+
+
+ax.fill_between( [0, 2.8] , np.ones(2)*Doppler_limit_area[0],   np.ones(2)*Doppler_limit_area[1],
+                color='gray', alpha=0.5, label='Doppler limit w/o micromotion')
+
+    
+ax.grid(True, ls=":", color='lightgray')
+# ax.set_yticklabels([ f"{int(y/1000)}k" for y in ax.get_yticks() ])
+# ax.set_title(f'({le})', x=0.1, y=0.78, color='gray')
+
+ax.set_xlabel(r'Modulation factor $\beta$')
+ax.set_ylabel('Temperature [mK]')
+ax.set_xlim(0,2.8)
+# ax.legend(fontsize=8)
+
+# Leyenda ##############################
+h1, l1 = ax.get_legend_handles_labels()
+
+
+ax.legend(h1[-1:]+h1[:-1], l1[-1:]+l1[:-1], loc='upper left', fontsize=8)
+
+
+fig.savefig('grafico_temp_A.png', dpi=300)
+fig.savefig('grafico_temp_A.pdf')
+
+
+
+
+
+#%% Versión B
+
+
+
+#Buen ajuste final:
+popt_rho22_balance, pcov_rho22_balance = curve_fit(FinalTemp_withoutC,list(Betas_vec[:10]), [t for t in Temp_vec[:10]],sigma=ErrorTemp_vec[:10],absolute_sigma=False,p0=(-10e6,5e-20)) #esto ajusta muy bien
+popt_rho22_balance_noMM, pcov_rho22_balance_noMM = curve_fit(FinalTemp_withoutmicromotion,list(Betas_vec[:10]), [t for t in Temp_vec[:10]],sigma=ErrorTemp_vec[:10],absolute_sigma=False,p0=(-10e6)) #esto ajusta muy bien
+
+betaslong = np.arange(0,2.8,0.01)
+
+print(f'Min temp predicted: {FinalTemp_withoutC(betaslong,*popt_rho22_balance)[0]}')
+#print(f'Min temp predicted: {1e3*FinalTemp(betaslong,*popt_rho22_balance)[0]} mK')
+
+print(f'Detuning: {1e-6*popt_rho22_balance[0]} MHz')
+
+
+print(f'params: {popt_rho22_balance}')
+print(f'errores: {np.sqrt(np.diag(pcov_rho22_balance))}')
+
+k_plot = 9
+
+
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.size': 8})
+plt.rcParams['text.usetex']=True
+
+
+# Acá estimo un detuning de (10 +- 4) MHz
+Detuning_range = ( 10 + 4*np.array([-1,1]) )*1e6
+Doppler_limit_area = CoolingLimit_noMM(-2*np.pi*Detuning_range)*1e3
+
+
+
+figsize=(8.6/2.54,4)
+
+
+height_ratios=[10,3]
+
+fig, axx = plt.subplots(2,1, sharex=True,  constrained_layout=True,
+                        figsize=figsize, gridspec_kw=dict(height_ratios=height_ratios))
+fig.set_constrained_layout_pads(w_pad=1/72, h_pad=0, hspace=0, wspace=0)
+
+
+ax=axx[0]
+ax.errorbar(Betas_vec[:k_plot],[t*1e3 for t in Temp_vec[:k_plot]],xerr=ErrorBetas_vec[:k_plot], 
+            yerr=[t*1e3 for t in ErrorTemp_vec[:k_plot]],fmt='o',
+            capsize=3,markersize=3,color='C3',zorder=10,alpha=0.9, label='inferred data')
+#plt.plot(betaslong,[t*1e3 for t in FinalTemp(betaslong,*popt_rho22_balance)],label='Ajuste con espectro modulado')
+ax.plot(betaslong,[t*1e3 for t in FinalTemp_withoutC(betaslong,*popt_rho22_balance)],
+        '-', color='C0',  label='model w/ RF heating')
+
+ax.plot(betaslong,[t*1e3 for t in FinalTemp_withoutmicromotion(betaslong,*popt_rho22_balance_noMM)],
+        '--', color='C1',label='model w/ RF heating')
+
+
+ax.fill_between( [0, 2.8] , np.ones(2)*Doppler_limit_area[0],   np.ones(2)*Doppler_limit_area[1],
+                color='gray', alpha=0.5, label='Doppler limit w/o micromotion')
+
+    
+ax.grid(True, ls=":", color='lightgray')
+# ax.set_yticklabels([ f"{int(y/1000)}k" for y in ax.get_yticks() ])
+# ax.set_title(f'({le})', x=0.1, y=0.78, color='gray')
+
+ax.set_ylabel('Temperature [mK]')
+
+
+# Leyenda ##############################
+h1, l1 = ax.get_legend_handles_labels()
+ax.legend(h1[-1:]+h1[:-1], l1[-1:]+l1[:-1], loc='upper left', fontsize=8)
+
+
+ax=axx[1]
+
+residuos = np.array([t*1e3 for t in Temp_vec[:k_plot]]) - np.array([t*1e3 for t in FinalTemp_withoutC(np.array(Betas_vec[:k_plot]),*popt_rho22_balance)])
+ax.errorbar(Betas_vec[:k_plot],residuos,xerr=ErrorBetas_vec[:k_plot], 
+            yerr=[t*1e3 for t in ErrorTemp_vec[:k_plot]],fmt='o',
+            capsize=3,markersize=3,color='C3',zorder=10,alpha=0.9, label='inferred data')
+
+
+
+
+modelA = np.array([t*1e3 for t in FinalTemp_withoutC(betaslong,*popt_rho22_balance)])
+modelB = np.array([t*1e3 for t in FinalTemp_withoutmicromotion(betaslong,*popt_rho22_balance_noMM)])
+ax.plot(betaslong,modelB-modelA,
+        '--', color='C1',label='model w/ RF heating')
+
+
+ax.axhline( 0 , color='C0')
+ax.set_xlim(0,2.8)
+ax.set_xlabel(r'Modulation factor $\beta$')
+ax.set_ylabel('Res. [mK]')
+ax.grid(True, ls=":", color='lightgray')
+
+ax.set_ylim(-5,5)
+# ax.legend(fontsize=8)
+
+
+fig.align_ylabels(axx)
+
+
+fig.savefig('grafico_temp_B.png', dpi=300)
+fig.savefig('grafico_temp_B.pdf')
+