Skip to content

A
artiq_experiments
Commit 38bcc0ba authored by Nicolas Nunez Barreto's avatar Nicolas Nunez Barreto
Browse files
Options

muchas cosas cambiaron mi joven padawan

parent d816ca59
Hide whitespace changes
Inline Side-by-side
Showing with 351 additions and 767 deletions
artiq_master/repository/Calibrations/IR_blinking.py deleted 100644 → 0
View file @ d816ca59
import numpy as np
from artiq.experiment import *
from pyLIAF.artiq.controllers import UrukulCh
class PMTCalibration(EnvExperiment):
"""Blinking script plotting for pmt calibration """
def build(self):
self.setattr_device("ccb")
self.setattr_device("scheduler")
self.setattr_device("core")
self.pmt = self.get_device("ttl0")
self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR") #corresponde a 0.8 Vpp
self.setattr_argument(f"t_readout",
NumberValue(100*ms, unit='ms', scale=ms, min=1*ms),
"PMT Calibration")
@rpc
def create_datasets(self):
self.set_dataset("pmt_counts_on", np.zeros(1, dtype=int), broadcast=True, archive=False)
self.set_dataset("pmt_counts_off", np.zeros(1, dtype=int), broadcast=True, archive=False)
@rpc
def create_applets(self):
self.ccb.issue("create_applet", "calibration_pmt_blinking",
"${python} -m pyLIAF.artiq.applets.realtime "
"200 "
"pmt_counts_on "
"--y2 pmt_counts_off")
@kernel
def init_kernel(self):
self.core.reset()
self.laserIR.initialize_channel()
self.laserUV.initialize_channel()
self.pmt.input()
delay(10*us)
self.laserIR.set_channel()
self.laserUV.set_channel()
self.core.wait_until_mu(now_mu())
delay(1*ms)
self.laserIR.on()
self.laserUV.on()
def run(self):
self.create_datasets()
self.create_applets()
self.init_kernel()
try:
while True:
self.measure_counts()
while self.scheduler.check_pause():
print("PAUSED BLINKING")
self.core.comm.close()
self.scheduler.pause()
# TODO: reset freqs/amps
print("RESUMED BLINKING")
except TerminationRequested:
self.cleanup()
print("STOPPED BLINKING")
@kernel
def readout(self):
"""Registro de cuentas emitidas"""
here = self.pmt.gate_rising(self.t_readout)
cuentas = self.pmt.count(here)
delay(1*us)
return cuentas
@kernel
def measure_counts(self):
self.core.break_realtime()
self.laserUV.on()
self.laserIR.off()
self.mutate_dataset("pmt_counts_off", 0, self.readout())
at_mu(self.core.get_rtio_counter_mu() + 10000)
self.laserIR.on()
self.mutate_dataset("pmt_counts_on", 0, self.readout())
@kernel
def cleanup(self):
self.core.break_realtime()
self.laserIR.off()
self.laserUV.off()
artiq_master/repository/Calibrations/Power Calibration AOM/Photodiode_in_time.py → artiq_master/repository/Calibrations/Photodiode_in_time.py
View file @ 38bcc0ba
...@@ -92,7 +92,7 @@ class PMTCalibration(EnvExperiment): ...@@ -92,7 +92,7 @@ class PMTCalibration(EnvExperiment):
@rpc(flags={"async"}) @rpc(flags={"async"})
def measure_PD(self, dump=False): def measure_PD(self, dump=False):
value = rpi.ReadPD_average_pi(0, 1) value = rpi.ReadPD_average_pi(2, 1)
#print(type(value)) #print(type(value))
if not dump: if not dump:
self.mutate_dataset("Current_PD", 0, np.abs(value)) self.mutate_dataset("Current_PD", 0, np.abs(value))
......
artiq_master/repository/Calibrations/Power Calibration AOM/IR/IR_Power_calibration_BS_rpi_multiple.py deleted 100644 → 0
View file @ d816ca59
import numpy as np
from time import sleep
from artiq.experiment import *
from pyLIAF.artiq.controllers import UrukulCh
#from pyLIAF.RedPitaya import Read_analog as rp
from pyLIAF.RaspberryPi.PD_reader import PDreader as rpi
from scipy import interpolate
class IR_LaserPowerCalibration_BS(EnvExperiment):
"""Multiple powers - Binary search - IR Laser power calibration with photodiode and a raspberry pi """
def build(self):
self.setattr_device("ccb")
self.setattr_device("scheduler")
self.setattr_device("core")
self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.3, name="IR") #corresponde a 0.7 Vpp
self.setattr_argument("Target_PD_Value", NumberValue(0.4, min=0.01, max=3), "Calibration_parameters")
self.setattr_argument("Max_amplitude", NumberValue(0.30, min=0.01, max=0.35), "Calibration_parameters")
self.setattr_argument("Min_amplitude", NumberValue(0.01, min=0.01, max=0.35), "Calibration_parameters")
#self.setattr_argument("tolerance", NumberValue(0.005, max=0.5), "Calibration_parameters")
self.setattr_argument("Calibration_freqs_IR", Scannable(
default=CenterScan(208*MHz, 10*MHz, 0.1*MHz),
unit="MHz",
scale=MHz,
global_min = 1*MHz,
global_max = 400*MHz
)
)
@rpc
def create_datasets(self):
#self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
self.set_dataset("Current_PD_IR", np.array([0.05]), broadcast=True, archive=False)
self.set_dataset("Calibration_freqs", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
self.set_dataset("Experiment_freqs_IR", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
self.set_dataset("Experiment_amps_IR", np.zeros(len(self.Calibration_freqs_IR.sequence), dtype=float), broadcast=True, archive=True)
@rpc(flags={"async"})
def create_applets(self):
self.ccb.issue("create_applet", "IR_powercalibration_BS",
"${python} -m pyLIAF.artiq.applets.plot_xy "
"Experiment_amps_IR "
"--x Calibration_freqs")
@rpc(flags={"async"})
def Binary_Search(self, pd_value, initial_amplitude, final_amplitude, current_freq):
mid_amplitude = round(0.5*(initial_amplitude+final_amplitude), 4)
#print(f'mid_amplitude: {mid_amplitude}')
if abs(initial_amplitude - mid_amplitude) < 0.00001 or abs(final_amplitude - mid_amplitude) < 0.00001:
#print('toco un borde jejox')
return mid_amplitude
#else:
if mid_amplitude > self.Max_amplitude or mid_amplitude < self.Min_amplitude:
print('Pusiste al reves los limites')
raise
self.change_frequency(current_freq, mid_amplitude)
#self.measure_PD(dump=True)
self.measure_PD()
measured_PD = self.get_dataset("Current_PD_IR")[0]
if np.abs(measured_PD - pd_value) > 0.00005:
if measured_PD > pd_value:
return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq)
elif measured_PD < pd_value:
return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)
else:
#print('no se, fijate, paso algo')
return 0
else:
return mid_amplitude
@rpc(flags={"async"})
def measure_PD(self, dump=False): #este dump esta al pedo, habra que sacarlo en el futuro
value = rpi.ReadPD_average_pi(0, 1)
print(value)
if not dump:
self.mutate_dataset(f"Current_PD_IR", 0, np.abs(value))
@kernel
def init_kernel(self):
self.core.reset()
delay(1*ms)
self.core.break_realtime()
#self.laserIR.initialize_channel()
delay(100*us)
self.laserIR.set_channel()
self.core.wait_until_mu(now_mu())
delay(1*ms)
self.laserIR.on()
@kernel
def change_frequency(self, freq, amp):
self.core.break_realtime()
delay(50*ms)
self.laserIR.set_frequency(freq, amp)
delay(50*ms)
def run(self):
self.create_datasets()
self.create_applets()
self.init_kernel()
i = 0
self.measure_PD(dump=True)
initial_amplitude = self.Min_amplitude
final_amplitude = self.Max_amplitude
initial_PD = self.Target_PD_Value
for freq in self.Calibration_freqs_IR.sequence:
self.change_frequency(freq, initial_amplitude)
#self.measure_PD(dump=True)
calibrated_amplitude = self.Binary_Search(initial_PD, initial_amplitude, final_amplitude, freq)
print(f'Done freq {freq}')
self.mutate_dataset("Experiment_amps_IR", i, calibrated_amplitude)
#initial_amplitude = calibrated_amplitude-0.1
#final_amplitude = calibrated_amplitude+0.1
i = i + 1
artiq_master/repository/Calibrations/Power Calibration AOM/IR_Calibration_Fitting.py deleted 100644 → 0
View file @ d816ca59
import numpy as np
from time import sleep
from artiq.experiment import *
from pyLIAF.artiq.controllers import UrukulCh
from pyLIAF.RedPitaya import Read_analog as rp
from scipy import interpolate
class IR_LaserPowerCalibration_BS(EnvExperiment):
"""Binary search - IR Laser power calibration with photodiode and a red pitaya """
def build(self):
self.setattr_device("ccb")
self.setattr_device("scheduler")
self.setattr_device("core")
self.setattr_argument("Calibration_freqs_IR", Scannable(
default=CenterScan(208*MHz, 10*MHz, 0.1*MHz),
unit="MHz",
scale=MHz,
global_min = 1*MHz,
global_max = 400*MHz
)
)
@rpc
def create_datasets(self):
#self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
self.set_dataset("Current_PD_IR", np.array([0.05]), broadcast=True, archive=False)
self.set_dataset("Calibration_freqs", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
self.set_dataset("Experiment_freqs_IR_final", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
self.set_dataset("Experiment_amps_IR_final", np.zeros(len(self.Calibration_freqs_IR.sequence), dtype=float), broadcast=True, archive=True)
@rpc(flags={"async"})
def run(self):
Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
Calibrated_Experiment_amps = list(self.get_dataset("Experiment_amps_IR"))
def run(self):
self.create_datasets()
self.init_kernel()
artiq_master/repository/Calibrations/Power Calibration AOM/Power_calibration_check.py deleted 100644 → 0
View file @ d816ca59
import numpy as np
from time import sleep
from artiq.experiment import *
from pyLIAF.artiq.controllers import UrukulCh
from pyLIAF.RedPitaya import Read_analog as rp
from scipy import interpolate
class LaserPowerCalibration(EnvExperiment):
"""Testing UV Laser power calibration with photodiode and a red pitaya """
def build(self):
self.setattr_device("ccb")
self.setattr_device("scheduler")
self.setattr_device("core")
self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
@rpc
def create_datasets(self):
self.Test_Experiment_freqs = self.get_dataset("Experiment_freqs")
self.Test_Experiment_amps = self.get_dataset("Experiment_amps")
self.set_dataset("Test_Experiment_freqs", self.Test_Experiment_freqs, broadcast=True, archive=True)
self.set_dataset("Test_Experiment_amps", self.Test_Experiment_amps, broadcast=True, archive=True)
self.set_dataset("Test_Measured_PD_UV_counts", list(np.zeros(len(self.Test_Experiment_freqs), dtype=int)), broadcast=True, archive=True)
@rpc(flags={"async"})
def create_applets(self):
self.ccb.issue("create_applet", "verification_powercalibration",
"${python} -m pyLIAF.artiq.applets.plot_xy "
"Test_Measured_PD_UV_counts "
"--x Test_Experiment_freqs")
"""
@rpc(flags={"async"})
def measure_PD(self, i):
#sleep(1)
value = rp.ReadVoltage()
print(np.abs(value))
self.mutate_dataset("Test_Measured_PD_UV_counts", i, np.abs(value))
"""
@rpc(flags={"async"})
def measure_PD(self, i, dump=False):
if not self.RPstatus:
self.rp_s = rp.Initiate_comm()
self.RPstatus = True
value = rp.ReadVoltage(self.rp_s)
print(value)
if not dump:
self.mutate_dataset(f"Test_Measured_PD_UV_counts", i, np.abs(value))
@kernel
def init_kernel(self):
self.core.reset()
self.laserUV.initialize_channel()
delay(10*us)
self.laserUV.set_channel()
self.core.wait_until_mu(now_mu())
delay(1*ms)
self.laserUV.on()
@kernel
def change_frequency(self, freq, amp):
self.core.break_realtime()
delay(50*ms)
self.laserUV.set_frequency(freq, amp)
delay(50*ms)
def run(self):
self.create_datasets()
self.create_applets()
self.init_kernel()
self.RPstatus = False
self.No_freqs = len(self.Test_Experiment_freqs)
i = 0
self.measure_PD(0, dump=True)
for amp, freq in zip(self.Test_Experiment_amps, self.Test_Experiment_freqs):
print(amp, freq)
#self.change_frequency(freq, 0.12)
self.change_frequency(freq, amp)
self.measure_PD(0, dump=True)
self.measure_PD(i)
i = i + 1
artiq_master/repository/Calibrations/Power Calibration AOM/Power_calibration_inversed.py deleted 100644 → 0
View file @ d816ca59
import numpy as np
from time import sleep
from artiq.experiment import *
from pyLIAF.artiq.controllers import UrukulCh
from pyLIAF.RedPitaya import Read_analog as rp
from scipy import interpolate
class InvLaserPowerCalibration(EnvExperiment):
"""INVERSED UV Laser power calibration with photodiode and a red pitaya """
def build(self):
self.setattr_device("ccb")
self.setattr_device("scheduler")
self.setattr_device("core")
self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
self.setattr_argument("Do_calibration", BooleanValue(False), "Calibration_parameters")
self.setattr_argument("Calibration_PD_Value", NumberValue(0.2, min=0.01, max=0.5, ndecimals=5), "Calibration_parameters")
self.setattr_argument("Calibration_freqs", Scannable(
default=CenterScan(110*MHz, 10*MHz, 0.1*MHz),
unit="MHz",
scale=MHz,
global_min = 1*MHz,
global_max = 400*MHz
)
)
self.setattr_argument("Calibration_amps", Scannable(
default=CenterScan(0.2, 0.1, 0.01),
global_min = 0,
global_max = 0.3
)
)
# self.setattr_argument("Experiment_frequencies", Scannable(
# default=CenterScan(110*MHz, 10*MHz, 0.1*MHz),
# unit="MHz",
# scale=MHz,
# global_min = 1*MHz,
# global_max = 400*MHz
# )
# )
@rpc
def create_datasets(self):
if self.Do_calibration:
self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
self.set_dataset("Calibration_freqs", len(self.Calibration_amps.sequence)*self.Calibration_freqs.sequence, broadcast=True, archive=True)
self.set_dataset("Calibration_amps", self.Calibration_amps.sequence, broadcast=True, archive=True)
self.set_dataset("Experiment_freqs", self.Calibration_freqs.sequence, broadcast=True, archive=True)
self.set_dataset("Experiment_amps", np.zeros(len(self.Calibration_freqs.sequence), dtype=float), broadcast=True, archive=True)
@rpc(flags={"async"})
def create_applets(self):
self.ccb.issue("create_applet", "powercalibration",
"${python} -m pyLIAF.artiq.applets.plot_xy "
"PD_UV_counts "
"--x Calibration_freqs")
@rpc(flags={"async"})
def RemoveZeros(calib, freqs):
i, j = 0, 1
new_calib = calib
while i < len(calib):
if new_calib[0] == 0:
new_calib = new_calib[1:]
i = i + 1
else:
init_len = len(new_calib)
final_calib = new_calib
while j < init_len:
if final_calib[-1] == 0:
final_calib = final_calib[:-1]
j = j + 1
else:
if j == 1:
return freqs[i:], final_calib
else:
return freqs[i:-j+1], final_calib
@rpc(flags={"async"})
def Calibrate_amplitudes(self):
Interpolation_functions = []
PD_UV_counts = self.get_dataset("PD_UV_counts")
n = len(self.Calibration_freqs.sequence)
PD_split = np.matrix([PD_UV_counts[i * n:(i + 1) * n] for i in range((len(PD_UV_counts) + n - 1) // n )])
PD_T = np.transpose(PD_split)
amps = self.Calibration_amps.sequence
for i in range(len(PD_T)):
#PD_values = np.array(PD_T[i][0])[0]
PD_values = np.array(PD_T[i])[0]
f = interpolate.interp1d(PD_values, amps, kind='linear')
Interpolation_functions.append(f)
Calibration_PD_Value = self.Calibration_PD_Value
Calibrated_Amplitudes = []
for fi in Interpolation_functions:
try:
Calibrated_Amplitudes.append(float(fi(Calibration_PD_Value)))
except:
Calibrated_Amplitudes.append(0)
print('no, rey')
#Freqs_withoutZeros, Calibs_withoutZeros = RemoveZeros(Calibs, freqs)
Function_Calibs_vs_freq = interpolate.interp1d(self.Calibration_freqs.sequence, Calibrated_Amplitudes, kind='linear')
i = 0
for freq in self.Calibration_freqs.sequence:
calibamp = Function_Calibs_vs_freq(freq)
print(calibamp)
self.mutate_dataset("Experiment_amps", i, calibamp)
i = i + 1
print('okarda con la calibreta')
@rpc(flags={"async"})
def Calibrate_amplitudes_v2(self):
Interpolation_functions = []
PD_UV_counts = self.get_dataset("PD_UV_counts")
n = len(self.Calibration_freqs.sequence)
PD_split = np.matrix([PD_UV_counts[i * n:(i + 1) * n] for i in range((len(PD_UV_counts) + n - 1) // n )])
PD_T = PD_split
#PD_T = PD_split
amps = self.Calibration_amps.sequence
Calibration_PD_Value = self.Calibration_PD_Value
Calibrated_Amplitudes = []
for i in range(len(PD_T)):
PD_values = np.array(PD_T[i])[0]
print(len(PD_values))
print(len(amps))
j = 0
while j < len(PD_values):
if PD_values[j] < Calibration_PD_Value:
j = j + 1
elif PD_values[j] > Calibration_PD_Value:
Calibrated_Amplitudes.append(amps[j])
break
else:
Calibrated_Amplitudes.append(0)
print('malardo')
break
i = 0
for i in range(len(Calibrated_Amplitudes)):
self.mutate_dataset("Experiment_amps", i, Calibrated_Amplitudes[i])
i = i + 1
print('okarda con la calibreta')
@rpc(flags={"async"})
def measure_PD(self, i):
value = rp.ReadVoltage()
print(value)
if i%self.No_freqs == 0:
sleep(0.3)
value = rp.ReadVoltage()
sleep(0.3)
print(f"Corrected value: {value}")
self.mutate_dataset(f"PD_UV_counts", i, np.abs(value))
@kernel
def init_kernel(self):
self.core.reset()
self.laserUV.initialize_channel()
delay(10*us)
self.laserUV.set_channel()
self.core.wait_until_mu(now_mu())
delay(1*ms)
self.laserUV.on()
@kernel
def change_frequency(self, freq, amp):
self.core.break_realtime()
delay(50*ms)
self.laserUV.set_frequency(freq, amp)
#def GetTargetAmplitude(self, amplitudes, PD_values, i):
#f = interpolate.interp1d(amplitudes, PD_values)
#amplitudes_interpoladas = np.arange()
def run(self):
self.create_datasets()
self.create_applets()
self.init_kernel()
self.No_freqs = len(self.Calibration_freqs.sequence)
i = 0
if self.Do_calibration:
print('Usaremos mediciones nuevas')
for freq in self.Calibration_freqs.sequence:
print(freq)
for amp in self.Calibration_amps.sequence:
self.change_frequency(freq, amp)
self.measure_PD(i)
i = i + 1
self.Calibrate_amplitudes()
else:
print('Usando mediciones ya hechas')
self.Calibrate_amplitudes_v2()
artiq_master/repository/Calibrations/Power Calibration AOM/Power_calibration_v2.py deleted 100644 → 0
View file @ d816ca59
import numpy as np
from time import sleep
from artiq.experiment import *
from pyLIAF.artiq.controllers import UrukulCh
from pyLIAF.RedPitaya import Read_analog as rp
from scipy import interpolate
class LaserPowerCalibration_v2(EnvExperiment):
"""V2 - Binary search - UV Laser power calibration with photodiode and a red pitaya """
def build(self):
self.setattr_device("ccb")
self.setattr_device("scheduler")
self.setattr_device("core")
self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
self.setattr_argument("Target_PD_Value", NumberValue(0.2, min=0.01, max=0.5), "Calibration_parameters")
self.setattr_argument("Max_amplitude", NumberValue(0.25, min=0.01, max=0.5), "Calibration_parameters")
self.setattr_argument("Min_amplitude", NumberValue(0.01, min=0.01, max=0.5), "Calibration_parameters")
self.setattr_argument("tolerance", NumberValue(0.005, max=0.5), "Calibration_parameters")
self.setattr_argument("Calibration_freqs", Scannable(
default=CenterScan(110*MHz, 10*MHz, 0.1*MHz),
unit="MHz",
scale=MHz,
global_min = 1*MHz,
global_max = 400*MHz
)
)
@rpc
def create_datasets(self):
#self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
self.set_dataset("Current_PD_UV", np.array([0.05]), broadcast=True, archive=False)
self.set_dataset("Calibration_freqs", self.Calibration_freqs.sequence, broadcast=True, archive=True)
self.set_dataset("Experiment_freqs", self.Calibration_freqs.sequence, broadcast=True, archive=True)
self.set_dataset("Experiment_amps", np.zeros(len(self.Calibration_freqs.sequence), dtype=float), broadcast=True, archive=True)
@rpc(flags={"async"})
def create_applets(self):
self.ccb.issue("create_applet", "v2_powercalibration",
"${python} -m pyLIAF.artiq.applets.plot_xy "
"Experiment_amps "
"--x Calibration_freqs")
@rpc(flags={"async"})
def Binary_Search(self, pd_value, initial_amplitude, final_amplitude, current_freq):
mid_amplitude = round(0.5*(initial_amplitude+final_amplitude), 4)
print(f'mid_amplitude: {mid_amplitude}')
if abs(initial_amplitude - mid_amplitude) < 0.00001 or abs(final_amplitude - mid_amplitude) < 0.00001:
print('toco un borde jejox')
return mid_amplitude
#else:
if mid_amplitude > self.Max_amplitude or mid_amplitude < self.Min_amplitude:
raise
self.change_frequency(current_freq, mid_amplitude)
self.measure_PD()
measured_PD = self.get_dataset("Current_PD_UV")[0]
if np.abs(measured_PD - pd_value) > 0.0005:
if measured_PD > pd_value:
return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq)
elif measured_PD < pd_value:
return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)
else:
print('no se, fijate, paso algo')
return 0
else:
return mid_amplitude
@rpc(flags={"async"})
def measure_PD(self):
value = rp.ReadVoltage()
print(np.abs(value))
self.mutate_dataset(f"Current_PD_UV", 0, np.abs(value))
@kernel
def init_kernel(self):
self.core.reset()
delay(1*ms)
self.core.break_realtime()
self.laserUV.initialize_channel()
delay(100*us)
self.laserUV.set_channel()
self.core.wait_until_mu(now_mu())
delay(1*ms)
self.laserUV.on()
@kernel
def change_frequency(self, freq, amp):
self.core.break_realtime()
delay(50*ms)
self.laserUV.set_frequency(freq, amp)
delay(10*ms)
def run(self):
self.create_datasets()
self.create_applets()
self.init_kernel()
i = 0
initial_amplitude = self.Min_amplitude
final_amplitude = self.Max_amplitude
initial_PD = self.Target_PD_Value
for freq in self.Calibration_freqs.sequence:
self.change_frequency(freq, initial_amplitude)
calibrated_amplitude = self.Binary_Search(initial_PD, initial_amplitude, final_amplitude, freq)
print(f'Done freq {freq}')
self.mutate_dataset("Experiment_amps", i, calibrated_amplitude)
#initial_amplitude = calibrated_amplitude-0.1
#final_amplitude = calibrated_amplitude+0.1
i = i + 1
artiq_master/repository/Experiments/Spectrum/With_calibration/IR/MICROMOTION_IR_spectrum_withcalib_delaysfixed_TwoIRLasers.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_ChangeDCvoltages.py
View file @ 38bcc0ba
...@@ -9,8 +9,8 @@ PORT = 60000 ...@@ -9,8 +9,8 @@ PORT = 60000
PASS = b'Secr3t Pa55W0rd' PASS = b'Secr3t Pa55W0rd'
from multiprocessing.connection import Client from multiprocessing.connection import Client
class IR_Scan_withcal_optimized(EnvExperiment): class IR_Scan_DCvoltages(EnvExperiment):
"""Can change dc voltages - Two IR lasers - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays""" """IR scan with DC voltages changes ability"""
def build(self): def build(self):
# Agrego kernel invariants a ver si mejoro algo de la performance # Agrego kernel invariants a ver si mejoro algo de la performance
kernel_invariants = getattr(self, 'kernel_invariants', set()) kernel_invariants = getattr(self, 'kernel_invariants', set())
......
artiq_master/repository/Experiments/Spectrum/With_calibration/IR/FULLHEATING_IR_spectrum_withcalib_delaysfixed_TwoIRLasers_LaserHeatingStage.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_HeatingStages.py
View file @ 38bcc0ba
...@@ -8,8 +8,8 @@ PORT = 60000 ...@@ -8,8 +8,8 @@ PORT = 60000
PASS = b'Secr3t Pa55W0rd' PASS = b'Secr3t Pa55W0rd'
from multiprocessing.connection import Client from multiprocessing.connection import Client
class IR_Scan_withcal_optimized(EnvExperiment): class IR_Scan_Heating(EnvExperiment):
"""Full heating - Two IR lasers - With heating stage - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays""" """IR scan with FULL heating stage (blue-detuned UV laser or turning off lasers)"""
def build(self): def build(self):
# Agrego kernel invariants a ver si mejoro algo de la performance # Agrego kernel invariants a ver si mejoro algo de la performance
kernel_invariants = getattr(self, 'kernel_invariants', set()) kernel_invariants = getattr(self, 'kernel_invariants', set())
......
artiq_master/repository/Experiments/Spectrum/With_calibration/IR/SLOW_IR_spectrum_andor.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_andor.py
View file @ 38bcc0ba
...@@ -9,8 +9,8 @@ PORT = 60000 ...@@ -9,8 +9,8 @@ PORT = 60000
PASS = b'Secr3t Pa55W0rd' PASS = b'Secr3t Pa55W0rd'
from multiprocessing.connection import Client from multiprocessing.connection import Client
class IR_Scan_withcal_optimized_andor(EnvExperiment): class IR_Scan_andor(EnvExperiment):
"""Andor measurement - Two IR lasers - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays""" """IR scan with detection by Andor camera"""
def build(self): def build(self):
# Agrego kernel invariants a ver si mejoro algo de la performance # Agrego kernel invariants a ver si mejoro algo de la performance
kernel_invariants = getattr(self, 'kernel_invariants', set()) kernel_invariants = getattr(self, 'kernel_invariants', set())
......
artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_withcalib_delaysfixed_TwoIRLasers.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_simple.py
View file @ 38bcc0ba
...@@ -6,8 +6,8 @@ import numpy as np ...@@ -6,8 +6,8 @@ import numpy as np
class IR_Scan_withcal_optimized(EnvExperiment): class IR_Scan_simple(EnvExperiment):
"""Two IR lasers - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays""" """Simple IR scan"""
def build(self): def build(self):
# Agrego kernel invariants a ver si mejoro algo de la performance # Agrego kernel invariants a ver si mejoro algo de la performance
kernel_invariants = getattr(self, 'kernel_invariants', set()) kernel_invariants = getattr(self, 'kernel_invariants', set())
......
artiq_master/repository/Experiments/Spectrum/With_calibration/IR/IR_spectrum_withcalib_delaysfixed_TwoIRLasers_LaserHeatingStage.py → artiq_master/repository/Experiments/Spectrum/With_calibration/IR/old/IR_spectrum_withcalib_delaysfixed_TwoIRLasers_LaserHeatingStage.py
View file @ 38bcc0ba
...@@ -9,7 +9,7 @@ PASS = b'Secr3t Pa55W0rd' ...@@ -9,7 +9,7 @@ PASS = b'Secr3t Pa55W0rd'
from multiprocessing.connection import Client from multiprocessing.connection import Client
class IR_Scan_withcal_optimized(EnvExperiment): class IR_Scan_withcal_optimized(EnvExperiment):
"""Two IR lasers - With heating stage - IR frequency sweep with calibration - First N freqs, then change freq - Optimized delays""" """IR scan with heating stage"""
def build(self): def build(self):
# Agrego kernel invariants a ver si mejoro algo de la performance # Agrego kernel invariants a ver si mejoro algo de la performance
kernel_invariants = getattr(self, 'kernel_invariants', set()) kernel_invariants = getattr(self, 'kernel_invariants', set())
......
artiq_master/repository/Experiments/Spectrum/With_calibration/UV/UV_spectrum_withcalib_AlternatingLasers.py → artiq_master/repository/Experiments/Spectrum/With_calibration/UV/UV_spectrum_alternatinglasers.py
View file @ 38bcc0ba
...@@ -7,7 +7,7 @@ import numpy as np ...@@ -7,7 +7,7 @@ import numpy as np
class UV_Scan_withcalib_Haeffner(EnvExperiment): class UV_Scan_withcalib_Haeffner(EnvExperiment):
"""Alternating lasers - With Calib - UV frequency sweep - First N freqs, then change freq - Haeffner algorithm: measures only with UV laser on, after preparing S state""" """ UV frequency sweep - Haeffner algorithm (measures only with UV laser on, after preparing S state)"""
def build(self): def build(self):
# Agrego kernel invariants a ver si mejoro algo de la performance # Agrego kernel invariants a ver si mejoro algo de la performance
kernel_invariants = getattr(self, 'kernel_invariants', set()) kernel_invariants = getattr(self, 'kernel_invariants', set())
......
artiq_master/repository/Experiments/Spectrum/With_calibration/UV/UV_spectrum_withcalib_bothlaserson.py
View file @ 38bcc0ba
...@@ -216,7 +216,6 @@ class UV_Scan_withcalib_bothlaserson(EnvExperiment): ...@@ -216,7 +216,6 @@ class UV_Scan_withcalib_bothlaserson(EnvExperiment):
delay(self.t_cool) delay(self.t_cool)
else: else:
delay(50*us) delay(50*us)
#self.prep_S()
cuentas = self.readout(runN) # Hago la medicion y vuelvo con las cuentas cuentas = self.readout(runN) # Hago la medicion y vuelvo con las cuentas
Accumulated_counts = Accumulated_counts + cuentas Accumulated_counts = Accumulated_counts + cuentas
self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts) self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
...@@ -256,10 +255,7 @@ class UV_Scan_withcalib_bothlaserson(EnvExperiment): ...@@ -256,10 +255,7 @@ class UV_Scan_withcalib_bothlaserson(EnvExperiment):
self.core.break_realtime() self.core.break_realtime()
self.core.wait_until_mu(now_mu()) self.core.wait_until_mu(now_mu())
@kernel
def prep_S(self):
pass
"""Preparo el estado S prendiendo solamente el laser IR"""
@kernel @kernel
def readout(self, runN) -> TInt64: def readout(self, runN) -> TInt64:
......
artiq_master/repository/Experiments/Transitory/longtrapping.py 0 → 100644
View file @ 38bcc0ba
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Jun 3 15:38:39 2024
@author: liaf-ankylosaurus-admin
"""
import numpy as np
from artiq.experiment import *
from time import sleep
#from pyLIAF.GenFunc.generador import Generador
PORT = 60000
PASS = b'Secr3t Pa55W0rd'
from multiprocessing.connection import Client
class InOut(EnvExperiment):
"""
Long trapping
"""
def build(self):
self.setattr_device("core")
self.setattr_device("ccb")
self.ttl0 = self.get_device("ttl0")
self.ttl4 = self.get_device("ttl4")
self.setattr_argument(f"t_med",
NumberValue(300*ms, unit='ms', scale=ms, min=0.1*ms, max=1000*ms),
"Experiment params")
self.setattr_argument("t_exp",
NumberValue(200*s, unit='s', scale=s, min=5*s, max=3000*s),
"Experiment params")
self.setattr_argument("N_ions_objective",
NumberValue(1, min=1, max=1000, ndecimals=0, step=1),
"Experiment params")
self.setattr_argument("Measurement_type",
EnumerationValue(["finite_time", "indefinite_time"]),
"Scan params")
@rpc
def initialize_tca_com(self):
address = ('localhost', PORT)
self.conn = Client(address, authkey=PASS)
sleep(0.1)
@rpc
def blinkRF(self,cmd='turnOnOffRF'):
self.conn.send(f'{cmd} blink')
rta = self.conn.recv()
@rpc(flags={"async"})
def create_datasets(self):
self.set_dataset('time', [], broadcast=True, archive=True)
self.set_dataset('counts', [], broadcast=True, archive=True)
self.set_dataset('counts_indefinite',np.array([0.0]), broadcast=True, archive=False)
self.set_dataset("N_ions", [], broadcast=False, archive=True)
@rpc(flags={"async"})
def create_applets(self):
self.ccb.issue("create_applet", "longtrapping",
"${python} -m pyLIAF.artiq.applets.plot_xy "
"counts "#Tiene que estar el espacio!!!
"--x time") #Aca habria que definir bien el vector que se use en el eje x
@rpc
def Varianza(self,sig) -> TList(TFloat):
ruido=np.std(sig)
print(ruido)
return [ruido]
@kernel
def run(self):
self.initialize_tca_com()
#Preparamos las variables y los graficos
self.create_datasets()
self.create_applets()
#Se prenden los "canales" a usar
self.core.reset()
self.ttl4.output()
self.ttl0.input()
self.ttl4.on()
delay(20*ms) # time for the artiq init.
if self.Measurement_type=="indefinite_time":
while True:
cuentas=self.ttl0.gate_rising(self.t_med)
cuentas=self.ttl0.count(cuentas)
self.mutate_dataset("counts_indefinite",0,cuentas)
print(cuentas)
self.core.break_realtime()
else:
sig=[]
for i in range(int(3/self.t_med)):
cuentas=self.ttl0.gate_rising(self.t_med)
sig=sig+[self.ttl0.count(cuentas)]
self.append_to_dataset("counts",sig[-1])
self.append_to_dataset("time",i/int(self.t_exp/self.t_med))
self.core.break_realtime()
ruido=self.Varianza(sig)[0]
delay(20*ms)
for i in range(int(3/self.t_med),int(self.t_exp/self.t_med)):
cuentas=self.ttl0.gate_rising(self.t_med)
cuentas=self.ttl0.count(cuentas)
self.append_to_dataset("counts",cuentas)
self.append_to_dataset("time",i/int(self.t_exp/self.t_med))
print(cuentas)
self.core.break_realtime()
start_time = now_mu() # Record the start timeself.core.break_realtime()
self.core.break_realtime()
artiq_master/repository/Calibrations/IR_blinking_both.py → artiq_master/repository/Experiments/Vibration/IonMotionDetection.py
View file @ 38bcc0ba
...@@ -3,21 +3,53 @@ from artiq.experiment import * ...@@ -3,21 +3,53 @@ from artiq.experiment import *
from pyLIAF.artiq.controllers import UrukulCh from pyLIAF.artiq.controllers import UrukulCh
class PMTCalibration(EnvExperiment): class IonVibration(EnvExperiment):
"""BOTH - Blinking script plotting for pmt calibration - Plots the abs Fluo, and the Signal to Background ratio""" """Spectroscopic measurement of possible ion vibration"""
def build(self): def build(self):
self.setattr_device("ccb") self.setattr_device("ccb")
self.setattr_device("scheduler") self.setattr_device("scheduler")
self.setattr_device("core") self.setattr_device("core")
self.pmt = self.get_device("ttl0") self.pmt = self.get_device("ttl0")
self.led = self.get_device("ttl6")
self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR") #corresponde a 0.8 Vpp self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR") #corresponde a 0.8 Vpp
self.setattr_argument(f"t_readout", self.setattr_argument(f"t_readout",
NumberValue(100*ms, unit='ms', scale=ms, min=1*ms), NumberValue(300*ms, unit='ms', scale=ms, min=1*ms),
"PMT Calibration") "Trapping")
self.setattr_argument(f"blinkfrequency",
NumberValue(50*Hz, unit='Hz', scale=Hz, min=1*Hz),
"Trapping")
self.setattr_argument(f"on_time",
NumberValue(0.1, min=0, max=1),
"Trapping")
self.setattr_argument("laserblinker",
EnumerationValue(["IR", "UV"]),
"Trapping")
self.setattr_argument("Blink", BooleanValue(1==0), "Trapping")
self.setattr_argument(f"UV_freq",
NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
"Lasers")
self.setattr_argument(f"UV_amp",
NumberValue(0.18, min=0.000, max=0.300, step=0.001),
"Lasers")
self.setattr_argument(f"IR_freq",
NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
"Lasers")
self.setattr_argument(f"IR_amp",
NumberValue(0.29, min=0.000, max=0.300, step=0.001),
"Lasers")
@rpc @rpc
def create_datasets(self): def create_datasets(self):
...@@ -27,15 +59,25 @@ class PMTCalibration(EnvExperiment): ...@@ -27,15 +59,25 @@ class PMTCalibration(EnvExperiment):
@rpc @rpc
def create_applets(self): def create_applets(self):
self.ccb.issue("create_applet", "ON_OFF_calibration_pmt_blinking",
"${python} -m pyLIAF.artiq.applets.realtime " if self.Blink:
"200 " self.ccb.issue("create_applet", "Trapping_on_off",
"pmt_counts_on " "${python} -m pyLIAF.artiq.applets.realtime "
"--y2 pmt_counts_off") "400 "
"pmt_counts_on "
"--y2 pmt_counts_off")
else:
self.ccb.issue("create_applet", "Monitoring_fluorescence",
"${python} -m pyLIAF.artiq.applets.realtime_lines "
"400 "
"pmt_counts_on "
"--y2 pmt_counts_off")
self.ccb.issue("create_applet", "DIFF_calibration_pmt_blinking", self.ccb.issue("create_applet", "DIFF_calibration_pmt_blinking",
"${python} -m pyLIAF.artiq.applets.realtime " "${python} -m pyLIAF.artiq.applets.realtime "
"200 " "40 "
"pmt_counts_diff") "pmt_counts_diff")
@kernel @kernel
...@@ -49,11 +91,14 @@ class PMTCalibration(EnvExperiment): ...@@ -49,11 +91,14 @@ class PMTCalibration(EnvExperiment):
#self.laserIR.channel.init() #self.laserIR.channel.init()
#self.laserUV.initialize_channel() #self.laserUV.initialize_channel()
self.led.output()
self.pmt.input() self.pmt.input()
delay(1000*us) delay(1000*us)
self.laserIR.set_channel() self.laserIR.set_channel()
self.laserUV.set_channel() self.laserUV.set_channel()
...@@ -63,8 +108,14 @@ class PMTCalibration(EnvExperiment): ...@@ -63,8 +108,14 @@ class PMTCalibration(EnvExperiment):
self.laserIR.on() self.laserIR.on()
self.laserUV.on() self.laserUV.on()
delay(1000*us)
def run(self): self.laserIR.set_frequency(self.IR_freq, self.IR_amp, profile=0)
self.laserUV.set_frequency(self.UV_freq, self.UV_amp, profile=0)
delay(1000*us)
def runt(self):
self.create_datasets() self.create_datasets()
self.create_applets() self.create_applets()
self.init_kernel() self.init_kernel()
...@@ -82,6 +133,41 @@ class PMTCalibration(EnvExperiment): ...@@ -82,6 +133,41 @@ class PMTCalibration(EnvExperiment):
self.cleanup() self.cleanup()
print("STOPPED BLINKING") print("STOPPED BLINKING")
def run(self):
self.create_datasets()
self.create_applets()
self.init_kernel()
print('este')
# print(period_off)
self.core.break_realtime()
self.blinkear()
@kernel
def blinkear(self):
period = 1/self.blinkfrequency
period_on = self.on_time*period
#print(period_on)
period_off = (1-self.on_time)*period
#print(period_off)
self.core.break_realtime()
while True:
if self.Blink:
if self.laserblinker == "IR":
self.laserIR.off()
delay(period_off)
self.laserIR.on()
delay(period_on)
else:
self.laserUV.off()
delay(period_off)
self.laserUV.on()
delay(period_on)
@kernel @kernel
def readout(self): def readout(self):
"""Registro de cuentas emitidas""" """Registro de cuentas emitidas"""
...@@ -94,20 +180,29 @@ class PMTCalibration(EnvExperiment): ...@@ -94,20 +180,29 @@ class PMTCalibration(EnvExperiment):
@kernel @kernel
def measure_counts(self): def measure_counts(self):
self.core.break_realtime()
self.laserUV.on()
self.laserIR.off()
delay(10*us)
counts_off = self.readout()
self.mutate_dataset("pmt_counts_off", 0, counts_off)
at_mu(self.core.get_rtio_counter_mu() + 10000)
self.laserIR.on()
delay(10*us) period = 1/self.blinkfrequency
counts_on = self.readout()
self.mutate_dataset("pmt_counts_on", 0, counts_on) period_on = self.on_time*period
at_mu(self.core.get_rtio_counter_mu() + 10000) print(period_on)
self.mutate_dataset("pmt_counts_diff", 0, counts_on/counts_off) period_off = (1-self.on_time)*period
print(period_off)
self.core.break_realtime()
#self.laserUV.on()
if self.Blink:
if self.laserblinker == "IR":
self.laserIR.off()
delay(period_off)
self.laserIR.on()
delay(period_on)
else:
self.laserUV.off()
delay(period_off)
self.laserUV.on()
delay(period_on)
@kernel @kernel
def cleanup(self): def cleanup(self):
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment