def acquireImage(self, npe=16, TR=4000, ts=4):
# Implement new concept:
# com.start_image(npe)
socket.write(struct.pack('<I', 6 << 28 | npe << 16 | TR))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
t0 = time.time()
for n in range(npe):
while True: # Read data
socket.waitForReadyRead()
datasize = socket.bytesAvailable()
time.sleep(0.0001)
if datasize == 8 * self.size:
print("Readout finished : ", datasize)
self.buffer[0:8 * self.size] = socket.read(8 * self.size)
break
else:
continue
self.process_readout(ts)
self.readout_finished.emit()
t1 = time.time()
print('Finished image acquisition in {:.4f} min'.format(
(t1 - t0) / 60))
def acquireProjection(self, idx, ts=20):
print("Acquire projection along axis: ", idx, "\n")
socket.write(struct.pack('<I', 7 << 28 | idx))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
while True: # Read data
socket.waitForReadyRead()
datasize = socket.bytesAvailable()
# print(datasize)
time.sleep(0.0001)
if datasize == 8 * self.size:
print("Readout finished : ", datasize)
self.buffer[0:8 * self.size] = socket.read(8 * self.size)
t1 = time.time() # calculate time for acquisition
break
else:
continue
print("Start processing readout.")
self.process_readout(ts)
self.readout_finished.emit()
def acquire(self, ts=20):
t0 = time.time() # calculate time for acquisition
socket.write(struct.pack('<I', 1 << 28))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
while True: # Read data
socket.waitForReadyRead()
datasize = socket.bytesAvailable()
# print(datasize)
time.sleep(0.0001)
if datasize == 8 * self.size:
print("Readout finished : ", datasize)
self.buffer[0:8 * self.size] = socket.read(8 * self.size)
t1 = time.time() # calculate time for acquisition
break
else:
continue
print("Start processing readout.")
self.process_readout(ts)
print("Start analyzing data.")
self.analytics()
print('Finished acquisition in {:.3f} ms'.format((t1 - t0) * 1000.0))
# Emit signal, when data was read
self.readout_finished.emit()
def set_IR(
self,
TI=15
): #, REC=1000): # Function to modify SE -- call whenever acquiring a SE
params.ti = TI
self.change_IR(params.ti, self.seq_ir) #, REC)
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_ir)
# Implement new concept:
# com.set_sequence(byte_array)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
socket.setReadBufferSize(8 * self.size)
self.ir_flag = True
self.se_flag = False
self.fid_flag = False
print("\nIR sequence uploaded with TI = ", TI,
" ms.") #" and REC = ", REC, " ms.")
def set_SIR(self, TI=15):
params.ti = TI
#self.change_SIR(params.ti, self.seq_sir)
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_sir)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
socket.setReadBufferSize(8 * self.size)
print("\nSIR sequence uploaded with TI = ", TI,
" ms.") #" and REC = ", REC, " ms.")
def set_2dSE(
self
): # Function to init and set FID -- only acquire call is necessary afterwards
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_2dSE)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
socket.setReadBufferSize(8 * self.size)
print("\n2D SE sequence uploaded.")
def set_uploaded_seq(self, seq):
print("Set uploaded Sequence.")
self.assembler = Assembler()
byte_array = self.assembler.assemble(seq)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
# Multiple function calls
socket.setReadBufferSize(8 * self.size)
print(byte_array)
print("Sequence uploaded to server.")
self.uploaded.emit(True)
def set_SE(self,
TE=10): # Function to modify SE -- call whenever acquiring a SE
# Change TE in sequence and push to server
params.te = TE
self.change_TE(params.te) #, REC)
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_se)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
socket.setReadBufferSize(8 * self.size)
self.ir_flag = False
self.se_flag = True
self.fid_flag = False
print("\nSE sequence uploaded with TE = ", TE, " ms.")
def acquireImage(self, npe=16, ts=20):
socket.write(struct.pack('<I', 6 << 28 | npe))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
for n in range(npe):
while True: # Read data
socket.waitForReadyRead()
datasize = socket.bytesAvailable()
time.sleep(0.0001)
if datasize == 8 * self.size:
print("Readout finished : ", datasize)
self.buffer[0:8 * self.size] = socket.read(8 * self.size)
break
else:
continue
self.process_readout(ts)
self.readout_finished.emit()
def set_gradients(self, gx=None, gy=None, gz=None, gz2=None):
if not gx == None:
if np.sign(gx) < 0: sign = 1
else: sign = 0
socket.write(
struct.pack('<I',
5 << 28 | self.GR_x << 24 | sign << 20 | abs(gx)))
if not gy == None:
if np.sign(gy) < 0: sign = 1
else: sign = 0
socket.write(
struct.pack('<I',
5 << 28 | self.GR_y << 24 | sign << 20 | abs(gy)))
if not gz == None:
if np.sign(gz) < 0: sign = 1
else: sign = 0
socket.write(
struct.pack('<I',
5 << 28 | self.GR_z << 24 | sign << 20 | abs(gz)))
if not gz2 == None:
if np.sign(gz2) < 0: sign = 1
else: sign = 0
#socket.write(struct.pack('<I', 5 << 28 | self.GR_z2 << 24 | sign << 20 | abs(gz2)))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
def set_FID(
self
): # Function to init and set FID -- only acquire call is necessary afterwards
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_fid)
# Implement new concept:
# com.set_sequence(byte_array)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
socket.setReadBufferSize(8 * self.size)
self.ir_flag = False
self.se_flag = False
self.fid_flag = True
print("\nFID sequence uploaded.")
def set_at(self, at):
params.at = at
socket.write(struct.pack('<I', 3 << 28 | int(abs(at) / 0.25)))
print("Set attenuation!")
def set_freq(self, freq):
params.freq = freq
socket.write(struct.pack('<I', 2 << 28 | int(1.0e6 * freq)))
print("Set frequency!")
# Prepare plot
ax = plt.gca()
ax.grid(True)
plt.show()
if np.sign(grad_offset) < 0: sign = 1
else: sign = 0
# Check send values
print("Sending offset {} with sign {} to gradient {}.".format(
abs(grad_offset), sign, x_grad))
# Send test command to set X gradient to grad_offset
#socket.write(struct.pack('<I', 5 << 28 | x_grad << 24 | sign << 20 | abs(grad_offset)))
#while(True): # Wait until bytes written
# if not socket.waitForBytesWritten(): break
# Send frequency to server
socket.write(struct.pack('<I', 2 << 28 | int(1.0e6 * freq)))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
# Semd attemiaton to server
socket.write(struct.pack('<I', 3 << 28 | int(abs(at) / 0.25)))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
# Send Sequence
socket.write(struct.pack('<I', 4 << 28))
byte_array = assembler.assemble(seq)
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
# Test 2D SE acquisition
def T1_measurement(self, values, freq, recovery, **kwargs):
print('T1 Measurement')
avgPoint = kwargs.get('avgP', 1)
avgMeas = kwargs.get('avgM', 1)
seq_type = kwargs.get('seqType', 1)
ts = 2
self.idxM = 0
self.idxP = 0
self.T1 = []
self.R2 = []
self.set_freq(freq)
#while self.idxM < avgMeas:
#print("Measurement : ", self.idxM+1, "/", avgMeas)
self.measurement = []
for self.ti in values:
self.peaks = []
if seq_type == 'sir':
self.set_SIR(self.ti)
else:
self.set_IR(self.ti)
while self.idxP < avgPoint:
print("Datapoint : ", self.idxP + 1, "/", avgPoint)
time.sleep(recovery / 1000)
socket.write(struct.pack('<I', 1 << 28))
while True: # Readout data
socket.waitForReadyRead()
datasize = socket.bytesAvailable()
print(datasize)
time.sleep(0.1)
if datasize == 8 * self.size:
print("IR readout finished : ", datasize)
self.buffer[0:8 * self.size] = socket.read(8 *
self.size)
break
else:
continue
print("Start processing IR readout.")
self.process_readout(ts)
print("Start analyzing IR data.")
self.analytics()
self.peaks.append(
np.max(self.mag_con) *
np.sign(self.real_con[np.argmin(self.real_con[0:50])]))
#self.peaks.append(self.peak_value*np.sign(self.real_con[np.argmin(self.real_con[0:50])]))
self.readout_finished.emit()
self.idxP += 1
self.measurement.append(np.mean(self.peaks))
self.idxP = 0
#self.calculateT1fit(values)
#bounds=([0, self.measurement[0], 0], [100, 50000, 1])
self.calculateT1fit(values) #, bounds)
self.t1_finished.emit()
#self.idxM += 1
return np.nanmean(self.T1), np.nanmean(self.R2)
def T1_measurement(self, values, freq, recovery, **kwargs):
print('T1 Measurement')
avgPoint = kwargs.get('avgP', 1)
avgMeas = kwargs.get('avgM', 1)
seq_type = kwargs.get('seqType', 1)
self.idxM = 0
self.idxP = 0
self.T1 = []
self.R2 = []
self.set_freq(freq)
while self.idxM < avgMeas:
print("Measurement : ", self.idxM + 1, "/", avgMeas)
self.measurement = []
for self.ti in values:
self.peaks = []
if seq_type == 'sir':
self.set_SIR(self.ti)
else:
self.set_IR(self.ti)
while self.idxP < avgPoint:
print("Datapoint : ", self.idxP + 1, "/", avgPoint)
time.sleep(recovery / 1000)
socket.write(struct.pack('<I', 1 << 28))
while True: # Readout data
socket.waitForReadyRead()
datasize = socket.bytesAvailable()
print(datasize)
time.sleep(0.1)
if datasize == 8 * self.size:
print("IR readout finished : ", datasize)
self.buffer[0:8 * self.size] = socket.read(
8 * self.size)
break
else:
continue
print("Start processing IR readout.")
self.process_readout()
print("Start analyzing IR data.")
self.analytics()
self.peaks.append(
np.max(self.mag_con) *
np.sign(self.real_con[np.argmin(self.real_con[0:50])]))
#self.peaks.append(self.peak_value*np.sign(self.real_con[np.argmin(self.real_con[0:50])]))
self.readout_finished.emit()
self.idxP += 1
self.measurement.append(np.mean(self.peaks))
self.idxP = 0
def func(x):
return p[0] - p[1] * np.exp(-p[2] * x)
try:
p, cov = curve_fit(self.T1_fit, values, self.measurement)
# Calculate T1 value and error
self.T1.append(
round(1.44 * brentq(func, values[0], values[-1]), 2))
self.R2.append(
round(
1 - (np.sum(
(self.measurement - self.T1_fit(values, *p))**2) /
(np.sum(
(self.measurement - np.mean(self.measurement))
**2))), 5))
self.x_fit = np.linspace(0, int(1.2 * values[-1]), 1000)
self.y_fit = self.T1_fit(self.x_fit, *p)
self.fit_params = p
except: # in case no fit found
self.T1.append(float('nan'))
self.R2.append(float('nan'))
self.x_fit = float('nan')
self.y_fit = float('nan')
self.fit_params = float('nan')
self.t1_finished.emit()
self.idxM += 1
return np.nanmean(self.T1), np.nanmean(self.R2)
def T2_measurement(self, values, freq, recovery, **kwargs):
print('T1 Measurement')
avgPoint = kwargs.get('avgP', 1)
avgMeas = kwargs.get('avgM', 1)
self.idxM = 0
self.idxP = 0
self.T2 = []
self.R2 = []
self.measurement = []
self.set_freq(freq)
while self.idxM < avgMeas:
print("Measurement : ", self.idxM + 1, "/", avgMeas)
self.measurement = []
for self.te in values:
self.peaks = []
self.set_SE(self.te)
while self.idxP < avgPoint:
print("Datapoint : ", self.idxP + 1, "/", avgPoint)
time.sleep(recovery / 1000)
socket.write(struct.pack('<I', 1 << 28))
while True:
socket.waitForReadyRead()
datasize = socket.bytesAvailable()
print(datasize)
time.sleep(0.1)
if datasize == 8 * self.size:
print("IR readout finished : ", datasize)
self.buffer[0:8 * self.size] = socket.read(
8 * self.size)
break
else:
continue
print("Start processing SE readout.")
self.process_readout()
print("Start analyzing SE data.")
self.analytics()
self.peaks.append(np.max(self.mag_con))
self.readout_finished.emit()
self.idxP += 1
self.measurement.append(np.mean(self.peaks))
self.idxP = 0
# Calculate T2 value and error
try:
p, cov = curve_fit(self.T2_fit,
values,
self.measurement,
bounds=([0, self.measurement[0],
0], [10, 50000, 0.5]))
# Calculation of T2: M(T2) = 0.37*(func(0)) = 0.37(A+B), T2 = -1/C * ln((M(T2)-A)/B)
self.T2.append(
round(
-(1 / p[2]) * np.log(
((0.37 * (p[0] + p[1])) - p[0]) / p[1]), 5))
self.R2.append(
round(
1 - (np.sum(
(self.measurement - self.T2_fit(values, *p))**2) /
(np.sum(
(self.measurement - np.mean(self.measurement))
**2))), 5))
self.x_fit = np.linspace(0, int(1.2 * values[-1]), 1000)
self.y_fit = self.T2_fit(self.x_fit, *p)
self.fit_params = p
self.t2_finished.emit()
self.idxM += 1
except:
self.T2.append(float('nan'))
self.R2.append(float('nan'))
self.x_fit = float('nan')
self.y_fit = float('nan')
self.fit_params = float('nan')
self.t2_finished.emit()
self.idxM += 1
return np.nanmean(self.T2), np.nanmean(self.R2)
grad_offset = -100
x_grad = 3
y_grad = 1
z_grad = 2
z2_grad = 3
if np.sign(grad_offset) < 0: sign = 1
else: sign = 0
# Check send values
print("Sending offset {} with sign {} to gradient {}.".format(
abs(grad_offset), sign, x_grad))
# Send test command to set X gradient to grad_offset
socket.write(
struct.pack('<I', 5 << 28 | x_grad << 24 | sign << 20 | abs(grad_offset)))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
time.sleep(1)
# Test 2D SE acquisition
npe = 32
socket.write(struct.pack('<I', 6 << 28 | npe))
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
time.sleep(1)
