Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
from artiq.experiment import *
from pyLIAF.artiq.controllers import UrukulCh
#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
import time
import numpy as np
class UV_Saturation(EnvExperiment):
"""Saturation measurement of the SP transition"""
def build(self):
# Agrego kernel invariants a ver si mejoro algo de la performance
kernel_invariants = getattr(self, 'kernel_invariants', set())
self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "IR_Freqs", "t_trans", "t_readout"}
self.setattr_device("core")
self.setattr_device("ccb")
self.pmt = self.get_device("ttl0")
self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR") #corresponde a 0.8 Vpp
self.setattr_argument(f"IR_freq",
NumberValue(208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
"Experiment params")
self.setattr_argument(f"UV_freq",
NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
"Experiment params")
self.setattr_argument(f"t_readout",
NumberValue(200*ms, unit='ms', scale=ms, min=1*ms),
"Experiment params")
self.setattr_argument(f"t_wait",
NumberValue(50*us, unit='us', scale=us, min=1*us),
"Experiment params")
self.setattr_argument("Comments", StringValue(" "), "General comments")
self.setattr_argument("UV_amps", Scannable(
default=CenterScan(0., 0.3, 0.01),
global_min = 0.,
global_max = 0.3
)
)
@rpc
def create_datasets(self):
self.set_dataset("measurements_UV_sat", np.zeros(len(self.UV_amps.sequence), dtype=int), broadcast=True, archive=True)
self.set_dataset("UV_amps", self.UV_amps.sequence, broadcast=True, archive=True)
self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
#self.set_dataset("calibration", self.get_dataset())
self.laserIR.generate_dataset()
self.laserUV.generate_dataset()
@rpc(flags={"async"})
def create_applets(self):
self.ccb.issue("create_applet", "SaturationUV",
"${python} -m pyLIAF.artiq.applets.plot_xy "
"measurements_UV_sat "
"--x UV_amps")
@kernel
def run(self):
t_cool_mu = self.core.seconds_to_mu(self.t_wait) # Precomputo esto para despues
cuentas = 0
self.create_datasets()
self.create_applets()
self.init_kernel()
delay(1*ms)
self.laserIR.on()
self.laserUV.on()
self.laserIR.set_frequency(self.IR_freq, 0.35)
self.laserUV.set_frequency(self.UV_freq, 0.30)
save_index = 0
for amp in self.UV_amps.sequence:
at_mu(self.core.get_rtio_counter_mu()) # espero lo que haya que esperar por el mutate
delay(1*ms) # Agrego unos forros 200us porque si no no anda
self.laserUV.set_amp(amp, self.UV_freq) # Cambio la frec del perfil 1 (estoy en el 0)
delay(100*us)
cuentas_ON = self.readout() # Hago la medicion y vuelvo con las cuentas
delay(100*us)
self.laserIR.off()
delay(100*us)
cuentas_OFF = self.readout() # Hago la medicion y vuelvo con las cuentas
counts = cuentas_ON-cuentas_OFF
#print(counts)
self.mutate_dataset("measurements_UV_sat", save_index, counts)
delay(150*us)
self.laserIR.on()
save_index = save_index + 1
print("jose maria listorti")
@kernel
def init_kernel(self):
self.core.reset()
self.pmt.input()
#self.laserUV.initialize_channel()
#self.laserIR.initialize_channel()
# Seteo los perfiles 0 y 1 con los mismos valores
# el 0 va a ser la referencia, el 1 va a ser el que se mueve
delay(1000*us)
self.laserIR.set_channel()
self.laserUV.set_channel()
# Me aseguro que todo termine antes de seguir
self.core.break_realtime()
self.core.wait_until_mu(now_mu())
@kernel
def readout(self) -> TInt64:
"""Registro de cuentas emitidas"""
#delay(self.t_trans)
here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
return self.pmt.count(here) # recupero las cuentas medidas