def plot_residuals(self, *args, **kwargs):
"""
Plotea los residuos del ajuste.
"""
if self._params[0] == None:
raise ValueError(
'Impossible to eval model: params has not yet ben estimated! (no data fitted)'
)
else:
if isinstance(self._xdata[0], unc.UFloat):
xdata = unp.nominal_values(self._xdata)
else:
xdata = self._xdata
nq.plot(xdata, self._ydata - self.eval(xdata), *args, **kwargs)
def plot_model_vs_data(self, nicebox=False, *args, **kwargs):
"""
Plotea en un gráfico los datos (x,y) cargados en el modelo, superpuestos con el
modelo (previamente ajustado) evaluado en los valores de xdata cargados.
"""
if self._params[0] == None:
raise ValueError(
'Impossible to eval model: params has not yet ben estimated! (no data fitted)'
)
else:
if isinstance(self._xdata[0], unc.UFloat):
xdata = unp.nominal_values(self._xdata)
else:
xdata = self._xdata
fig = nq.plot(xdata, [self._ydata, self.eval(xdata)],
legend=['Data', 'Fit'],
linestyle=['-', '--'],
title=self.name,
*args,
**kwargs)
if nicebox is True:
self.print_nice_box(fig.axes[0])
return fig
import numpy as np
import nicenquickplotlib as nq
x = []
x.append(np.linspace(0,6))
x.append(np.linspace(0,5))
x.append(np.linspace(0,4))
nq.set_figstyle('default')
nq.plot(x, [np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])], legend=[r'$\sin(x)$', r'$\cos(x)$', r'$\sqrt{x}$'], xlabel='x label', ylabel='y label')
nq.set_figstyle('blacknwhite')
nq.plot(x, [np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])], legend=[r'$\sin(x)$', r'$\cos(x)$', r'$\sqrt{x}$'], xlabel='x label', ylabel='y label')
nq.set_figstyle('soft')
nq.plot(x, [np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])], legend=[r'$\sin(x)$', r'$\cos(x)$', r'$\sqrt{x}$'], xlabel='x label', ylabel='y label')
nq.set_figstyle('my_figstyle.yaml')
nq.plot(x, [np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])], legend=[r'$\sin(x)$', r'$\cos(x)$', r'$\sqrt{x}$'], xlabel='x label', ylabel='y label')
nq.save_all()
# The idea of this script is to have a call to all functions of the
# nicenquickplotlib module in order to test all.
import numpy as np
import nicenquickplotlib as nq
x = []
x.append(np.linspace(0, 6))
x.append(np.linspace(0, 5))
x.append(np.linspace(0, 4))
# Testing for data input combinations ----
nq.plot(x[0], title="data input x1")
nq.plot([x[0], x[1]], title="data input [x[0], x[1]]")
nq.plot(x[0], np.sin(x[0]), title="data input x[0], np.sin(x[0])")
nq.plot(x[0], [np.sin(x[0]), np.cos(x[0])],
title="data input x[0],[np.sin(x[0]), np.cos(x[0])]")
nq.plot([x[0], x[1]], [np.sin(x[0]), np.cos(x[1])],
title="data input [x[0], x[1]], [np.sin(x[0]), np.cos(x[1])]")
nq.plot(x,
[np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])],
title="data input x, [np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])]")
# Testingh the "togheter" option ----------
nq.plot(
x, [np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])],
together=False,
title=
"together x, [np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])], toghether=False")
# Testing axis labels ---------------------
nq.plot(x,
[np.sin(x[0]), np.cos(x[1]), np.sqrt(x[2])],
vin_s = [None] * len(V_in)
vout_n = [None] * len(V_in)
vout_s = [None] * len(V_in)
for k in range(len(V_in)):
vin_n[k] = V_in[k].mean()
vin_s[k] = V_in[k].std()
vout_n[k] = V_out[k].mean()
vout_s[k] = V_out[k].std()
input_value = unp.uarray(vin_n, vin_s)
output_value = unp.uarray(vout_n, vout_s)
nq.plot(x=GENERATOR_FREQUENCIES,
y=[input_value, output_value],
together=False,
legend=['$V_{in}$', '$V_{out}$'],
xlabel='Frequency (Hz)',
ylabel='Voltage (V)',
marker='.',
xscale='L',
title='Signals')
nq.plot(x=GENERATOR_FREQUENCIES,
y=[
output_value / input_value,
unp.std_devs(output_value / input_value) /
unp.nominal_values(output_value / input_value) * 1e6
],
together=False,
xlabel='Frequency (Hz)',
ylabel=['Ratio', 'Error (ppm)'],
marker='.',
xscale='L',
'../RVD_measurements/181226B', '../RVD_measurements/181226C', '../RVD_measurements/181226D', ] LABELS = [ '181220C', '181221A', '181221B', # ~ '181226A', '181226B', '181226C', '181226C', ] freqs = [] ratios = [] phases = [] for k in range(len(MEASUREMENTS_TO_COMPARE)): data = np.genfromtxt(MEASUREMENTS_TO_COMPARE[k] + '/' + DIRS.TRANSFERENCE_RESULTS_DIR + '/' + 'transference_dataset1.csv') data = data.transpose() freqs.append(data[0]) ratios.append(unc.unumpy.uarray(data[1], data[2])) data = np.genfromtxt(MEASUREMENTS_TO_COMPARE[k] + '/' + DIRS.TRANSFERENCE_RESULTS_DIR + '/' + 'transference_dataset2.csv') data = data.transpose() phases.append(unc.unumpy.uarray(data[1], data[2])) nq.plot(freqs, ratios, xscale='L', marker='.', legend=LABELS, xlabel='Frequency (Hz)', ylabel='Ratio') nq.plot(freqs, phases, xscale='L', marker='.', legend=LABELS, xlabel='Frequency (Hz)', ylabel='Phase (rad)') nq.save_all() nq.show()
import nicenquickplotlib as nq
import uncertainties as unc # https://pythonhosted.org/uncertainties/index.html
import numpy as np
x = np.linspace(0, 2, 10) # Create x data.
y_vals_1 = x**2 # Create y_1 data.
y_errs_1 = y_vals_1 * 0.1 + np.random.rand(len(x)) * 0.1 # Create y_1 errors.
y_vals_2 = np.sqrt(x) # Create y_2 data.
y_errs_2 = y_vals_2 * 0.1 + np.random.rand(len(x)) * 0.1 # Create y_2 errors.
y_1 = unc.unumpy.uarray(y_vals_1,
y_errs_1) # Create y_1 array of uncertainties.
y_2 = unc.unumpy.uarray(y_vals_2,
y_errs_2) # Create y_2 array of uncertainties.
nq.plot(x, [y_1, y_2],
title='y error bands',
legend=['Data 1', 'Data 2'],
marker=True)
nq.set_figstyle('blacknwhite')
nq.plot(x, [y_1, y_2],
title='y error bands with blacknwhite figstyle',
legend=['Data 1', 'Data 2'],
marker=True)
nq.save_all(csv=True)
time.sleep(1)
for i in range(len(frequencies)):
fungen.write(':frequency:fixed {}'.format(
frequencies[i])) #sets function generator frequency
data = np.array(
little_board.acquire(n_samples=1000,
sampling_frequency=FS,
ch0=True,
ch1=True))
signal_fft = [None] * len(data)
for k in range(len(data)):
data[k] -= data[k].mean()
signal_fft[k] = np.abs(np.fft.fft(data[k]))
signal_fft[k] = signal_fft[k][:int(len(signal_fft[k]) / 2)]
nq.plot(np.array(data[k]),
title=str(i) + ' CH ' + str(k) + ' at freq=' +
str(frequencies[i]))
nq.plot(np.linspace(0, FS / 2, len(signal_fft[k])),
signal_fft[k],
title=str(1 + i) + ' FFT CH' + str(k),
xlabel='Frecuencia (Hz)')
nq.plot(np.linspace(0, FS / 2, len(signal_fft[k])),
[signal_fft[0], signal_fft[1]],
legend=['CH0', 'CH1'],
title=str(1 + i) + ' los dos canales juntos',
xlabel='Frecuencia (Hz)')
fungen.write('OUTP1:STAT OFF')
fungen.close()
nq.save_all(timestamp=True)
frequencies_out = [None] * len(frequencies)
fungen.write('OUTP1:STAT ON')
time.sleep(1)
for i in range(len(frequencies)):
fungen.write(':frequency:fixed {}'.format(
frequencies[i])) #sets function generator frequency
data = np.array(
little_board.acquire(n_samples=1000,
sampling_frequency=FS,
ch0=False,
ch1=True))
data -= data.mean()
signal_fft = np.abs(np.fft.fft(data))
signal_fft = signal_fft[:int(len(signal_fft) / 2)]
frequencies_out[i] = np.argmax(signal_fft) * FS / len(signal_fft) / 2
nq.plot(np.array(data))
nq.plot(np.linspace(0, FS / 2, len(signal_fft)),
signal_fft,
title=str(1 + i) + '_fft',
xlabel='Frecuencia (Hz)')
fungen.write('OUTP1:STAT OFF')
fungen.close()
nq.plot(np.array(frequencies),
np.array(frequencies_out),
marker='.',
xlabel='Frecuencia del generador (Hz)',
ylabel='Frecuencia detectada (Hz)',
title='Aliassing')
#nq.save_all(timestamp=True)
T_abs_s[k] = sqrt(T_abs_s[k])
T_phi_s[k] = sqrt(T_phi_s[k])
# Definitive values calculation ---------
# In this step I keep the worst of the std's obtained either
# when calculating the mean value using the std's from measurements
# or the std obtained by the disperssion of the points.
T_abs_definitive[k] = unc.ufloat(
T_abs_n[k].n, T_abs_n[k].s + T_abs_s[k].n + T_abs_s[k].s)
T_phi_definitive[k] = unc.ufloat(
T_phi_n[k].n, T_phi_n[k].s + T_phi_s[k].n + T_phi_s[k].s)
freq = np.array(freq)
# PLOT ----------------------------
nq.plot(x=freq,
y=[T_abs_definitive, T_phi_definitive],
together=False,
xlabel='Frequency (Hz)',
ylabel=['Ratio', 'Phase (rad)'],
xscale='L',
title='Transference',
marker='.')
nq.plot(
x=freq,
y=[
unp.std_devs(T_abs_definitive) / unp.nominal_values(T_abs_definitive),
np.abs(
unp.std_devs(T_phi_definitive) /
unp.nominal_values(T_phi_definitive))
],
together=False,
xlabel='Frequency (Hz)',
ylabel=[
r'Ratio err $\frac{\sigma}{\mu}$', r'Phase err $\frac{\sigma}{\mu}$'
fungen.write('OUTP1:IMP INF'
) # Set the output impedance to zero (infinite load impedance).
fungen.write('voltage {}'.format(GENERATOR_AMPLITUDE))
fungen.write('voltage:offset {}'.format(GENERATOR_AMPLITUDE / 2))
fungen.write(':frequency:fixed {}'.format(
GENERATOR_FREQUENCY)) #sets function generator frequency
fungen.write('source1:function:shape squ')
little_board = cf.Little_Board('Dev11')
fungen.write('OUTP1:STAT ON')
time.sleep(1)
data = np.array(
little_board.acquire(n_samples=N_SAMPLES,
sampling_frequency=GENERATOR_FREQUENCY * N_SAMPLES /
N_CYCLES,
ch0=True,
ch1=True))
time_axis = np.linspace(0, N_CYCLES / GENERATOR_FREQUENCY, N_SAMPLES)
nq.plot(x=time_axis,
y=[np.array(data[0]), np.array(data[1])],
together=False,
xlabel='Tiempo (s)')
fungen.write('OUTP1:STAT OFF')
fungen.close()
nq.save_all(timestamp=True, image_format='pdf', csv=True)
nq.show()
# ----------------------------------------------------------------------
samples = np.sin(2 * np.pi * np.arange(SAMPLING_FREQUENCY / SIGNAL_FREQUENCY) *
SIGNAL_FREQUENCY / SAMPLING_FREQUENCY)
# Create the output samples ---------------------
output_samples = samples
for k in range(N_CYCLES - 1):
output_samples = np.append(output_samples, samples)
# Play and record samples -----------------------
recorded_samples = sd.playrec(output_samples, SAMPLING_FREQUENCY, channels=2)
sd.wait()
recorded_samples = np.transpose(recorded_samples)
time = np.linspace(0, N_CYCLES / SIGNAL_FREQUENCY, len(output_samples))
# Calculate FFT --------------------------------------------------------
samples_FFT = np.fft.rfft(output_samples)
recorded_FFT = np.fft.rfft(recorded_samples[0])
samples_FFT = np.absolute(samples_FFT)
recorded_FFT = np.absolute(recorded_FFT)
# Plot recorded signals ------------------------------------------------
# ~ nq.plot(time, [output_samples, recorded_samples[0]], together=False)
nq.plot([np.log(samples_FFT) * 20,
np.log(recorded_FFT) * 20],
together=False,
marker='.',
xlabel='Frecuency (Hz)',
title='FFT')
# Calculate SNR --------------------------------------------------------
print('20*log(SNR) = ' + str(np.log(calculate_SNR(recorded_samples[0])) * 20))
print('SNR = ' + str(calculate_SNR(recorded_samples[0])))
nq.show()
'../RVD_measurements/AC_mode/20190103114910874635',
'../RVD_measurements/AC_mode/20190103130458050521',
]
LABELS = [
# ~ '190103A',
'190103B',
'190103C',
]
freqs = []
ratios = []
for k in range(len(MEASUREMENTS_TO_COMPARE)):
current_timestamp = MEASUREMENTS_TO_COMPARE[k]
current_timestamp = current_timestamp[current_timestamp.rfind('/') + 1:]
data = np.genfromtxt(MEASUREMENTS_TO_COMPARE[k] + '/' + current_timestamp +
'_' + 'transference_dataset1.csv')
data = data.transpose()
freqs.append(data[0])
ratios.append(unc.unumpy.uarray(data[1], data[2]))
nq.plot(freqs,
ratios,
xscale='L',
marker='.',
legend=LABELS,
xlabel='Frequency (Hz)',
ylabel='Ratio',
title='AC mode trensferences comparison')
nq.save_all()
nq.show()
import nicenquickplotlib as nq # https://github.com/SengerM/nicenquickplotlib
GENERATOR_FREQUENCY = 20 # Hz
SAMPLING_FREQUENCIES = [100, 1000, 10e3, 48e3/2] # Maximum sampling rate = 48 kSPS
GENERATOR_AMPLITUDE = 2.5 # volt
N_SAMPLES = 1000 # Max 1024
rm = visa.ResourceManager()
rm.list_resources()
fungen = rm.open_resource('USB0::0x0699::0x0346::C036492::INSTR')
fungen.write('OUTP1:IMP INF') # Set the output impedance to zero (infinite load impedance).
fungen.write('voltage {}'.format(GENERATOR_AMPLITUDE))
fungen.write('voltage:offset {}'.format(GENERATOR_AMPLITUDE/2))
fungen.write(':frequency:fixed {}'.format(GENERATOR_FREQUENCY)) #sets function generator frequency
fungen.write('source1:function:shape squ')
little_board = cf.Little_Board('Dev11')
fungen.write('OUTP1:STAT ON')
time.sleep(1)
for k in range(len(SAMPLING_FREQUENCIES)):
data = np.array(little_board.acquire(n_samples=N_SAMPLES, sampling_frequency=SAMPLING_FREQUENCIES[k],ch0=True,ch1=True))
time_axis = np.linspace(0,N_SAMPLES/SAMPLING_FREQUENCIES[k],N_SAMPLES)
nq.plot(x=time_axis, y=[np.array(data[0]), np.array(data[1]), np.array(data[0])-np.array(data[1])], marker='.', together=False, xlabel='Tiempo (s)', title='fs = ' + str(SAMPLING_FREQUENCIES[k]))
fungen.write('OUTP1:STAT OFF')
fungen.close()
nq.save_all(timestamp='now', image_format='pdf', csv=True)
nq.show()
@author: Publico
"""
import numpy as np
import visa
import time
import cool_functions as cf
import nicenquickplotlib as nq # https://github.com/SengerM/nicenquickplotlib
N_SAMPLES = 1000 # Max 1024
SAMPLING_FREQUENCY = 8000
rm = visa.ResourceManager()
rm.list_resources()
little_board = cf.Little_Board('Dev11')
time.sleep(1)
data = np.array(
little_board.acquire(n_samples=N_SAMPLES,
sampling_frequency=SAMPLING_FREQUENCY,
ch0=True,
ch1=False))
time_axis = np.linspace(0, N_SAMPLES / SAMPLING_FREQUENCY, N_SAMPLES)
nq.plot(x=time_axis, y=np.array(data), xlabel='Tiempo (s)')
nq.save_all(timestamp=True, image_format='pdf', csv=True)
nq.show()
