def test_medida_array_1():
m = M([1, 2, 3, 4, 5], incerteza=0.5, unidade="ft")
assert len(m) == 5
for i in range(len(m)):
assert m[i].nominal == i + 1
assert m[i].incerteza == 0.5
assert m[i].si_nominal == 0.3048 * (i + 1)
assert m[i].si_incerteza == 0.1524
def test_medida_array_2():
m = Medida("100+-10", "libra")
l = M([1, 2, m, 4, 5], incerteza=0.5, unidade="ft")
print(l)
assert len(l) == 5
for i in range(len(l)):
if i == 2:
continue
assert l[i].nominal == i + 1
assert l[i].incerteza == 0.5
assert l[i].si_nominal == 0.3048 * (i + 1)
assert l[i].si_incerteza == 0.1524
assert l[2].nominal == 100
assert l[2].incerteza == 10
assert fabs(l[2].si_nominal - 45.359237) < 0.001
assert fabs(l[2].si_incerteza - 4.5359237) < 0.001
import numpy as np
from LabIFSC import M
from erros_mult import err_o200
mu_0 = 4e-7 * np.pi
N1 = M((760, 0))
a = M((15.20e-2, .05e-3))
N2 = M((2100, 0))
b = M((59.95e-3, .05e-3))
D = M((14.90e-3, .05e-3))
A = np.pi * D * D / 4 # área de seção reta do solenoide interno
Lteo = mu_0 * N1 * N2 * A / a # indutância mútua obtida teoricamente
R = M(
(98.6, err_o200(98.6))
) # (escala de 200 ohm) resistência do resistor ligado ao solenoide externo
dados7 = np.loadtxt('pratica4/dados/indutancia.dat').T
f = dados7[0] # +- 0.05, frequência (Hz) da corrente alternada
erro_f = f * 0 + 0.05
eps0 = dados7[1] # tensão de pico no solenoide interno
erro_eps0 = dados7[2]
V0 = dados7[3] # tensão de pico no resistor ligado ao solenoide externo
erro_V0 = dados7[4]
Lmed = []
for i in range(len(f)):
eps0i = M((eps0[i], erro_eps0[i]))
fi = M((f[i], 0.05))
from matplotlib import pyplot as plt
import numpy as np
from scipy import stats,optimize
from IPython.display import display, Math, Latex
from LabIFSC import M
#Resistividade (sigma) esperada: 2.92e−8
i = M((0.500,0.001)) # corrente em amperes
espessura = M((0.075e-3, 0.005e-3))
larguraA = M((29.75e-3, 0.05e-3))
larguraB = M((20.45e-3, 0.05e-3))
larguraC = M((10.20e-3, 0.05e-3))
areaA = larguraA*espessura # área de seção, região A
areaB = larguraB*espessura # área de seção, região B
areaC = larguraC*espessura # área de seção, região C
data1, data2, data3 = [np.loadtxt(f"data/aluminio_{i}.dat").T for i in range(1,4)]
r = stats.linregress(data1[0],data1[1])
EA = M((r[0],r[4]))
r = stats.linregress(data2[0],data2[1])
EB = M((r[0],r[4]))
r = stats.linregress(data3[0],data3[1])
EC = M((r[0],r[4]))
plt.figure(dpi=100)
plt.plot(data1[0],data1[1],'.',
data2[0],data2[1],'.',
data3[0],data3[1],'.')
plt.legend(['Região A', 'Região B', 'Região C'])
plt.title("Análise do alumínio")
plt.xlabel('Posição (m)')
import numpy as np
from LabIFSC import M
data = np.loadtxt("data/grafite.dat").T
r = M(
(np.average(data), np.std(data,
ddof=1))) # resistência média dos retangulinhos
################################
# Bastão de grafite
# Resistencia = 6.1 Ohms
# Diametros = 2.47 mm +-(0.01mm)
# Comprimento = 5.70 cm +-(0.01cm)
###############################
R = M((6.1, 0.1))
D = M((2.47e-3, 0.01e-3))
Lb = M((5.70e-2, 0.01e-2))
# resistividade
rho = np.pi * D**2 * R / (4 * Lb)
# paralelepípedos
Lp = M((0.8e-2, 0.05e-2)) # comprimento
a = M((0.2e-2, 0.05e-2)) # largura
#espessura
e = rho * Lp / (a * r)
# Comprimento máximo de um paralelepípedo feito com esse bastão,
# tendo essa espessura e essa largura
# PROCEDIMENTO:
# Colocar o voltímetro nos terminais de cada componente.
#
# Qual o erro propagado deste método? Pela altíssima resistencia interna
# voltimetro, ele não puxará muito da corrente, e como no caso anterior,
# a precisao dos instrumentos é maior que a alteração que as resistencias internas
# do multimetro pode causar.
N = 2
file = "pratica2/data/kvl_{}.dat".format(N) # pratica2/
data = []
data_np = np.loadtxt(file)
data.append(data_np)
data = np.asarray(data) if len(data_np.shape)==1 else data_np
Vfonte = [M((i[0], i[-1])) for i in data]
Va = [M((i[1], i[1]*0.05)) for i in data]
Vb = [M((i[2], i[2]*0.05)) for i in data]
Vc = [M((i[3], i[3]*0.05)) for i in data]
Vd = [M((i[4], i[4]*0.05)) for i in data] if len(data[0]) > 5 else 0
Ve = [M((i[5], i[5]*0.05)) for i in data] if len(data[0]) > 5 else 0
Vfonte2 = [M((i[6], i[-1])) for i in data] if len(data[0]) > 5 else 0
for i in range(4): # quantidade de dados
print("${:latex}$ & ${:latex}$ & ${:latex}$ & ${:latex}$ & Sim \\\\".format(Vc[i], Vb[i], Vfonte2[i], Vd[i]))
if (N==1):
print("V_fonte - V_A - V_B - V_C = 0")
for i in range(data.shape[0]):
from matplotlib import pyplot as plt
import numpy as np
from scipy import optimize
from IPython.display import display, Math, Latex
from LabIFSC import M
#47 nom == 47.4
#100 nom == 109.1
#100 nom == 98.0
GERAR_GRAFICOS = False
resistores = {'resistor_1':('Resistor de 10 kΩ', M((10.09e3,0.01e3))),
'resistor_2':('Resistor de 1 kΩ', M((1.002e3,0.001e3))),
'resistor_3':('Resistor de 100 Ω', M((105.2,0.1))),
'associacao_1':('Associação em série', M((221.0,0.1))),
'associacao_2':('Associação em paralelo', M((32.0,0.1))),
'associacao_3':('Associação mista', M((100.4,0.1)))}
def i_ohm(x,a,b,k):return a*x**k+b # i = u/r
erros = lambda pcov: np.sqrt(np.diag(pcov))
display(Math(r'I = aU^k+b'))
for resistor in resistores:
if GERAR_GRAFICOS: plt.figure(figsize=(3.5,2.5),dpi=200)
else: plt.figure(figsize=(3.5,2.5),dpi=100)
nome, R = resistores[resistor]
data = np.loadtxt(f'data/{resistor}.dat').T
import matplotlib.pyplot as plt
import numpy as np
from scipy import optimize
from LabIFSC import M
dados = np.loadtxt('pratica2/data/fonte.dat')
V_i, V_c = dados.T
erro_voltm = lambda x: 0.003 + 0.005 * abs(x) #veja wheatstone.dat
erro_V_i = np.array(list(map(erro_voltm, V_i)))
erro_V_c = np.array(list(map(erro_voltm, V_c)))
r_e = M(4.6, 0.5 + 0.008 * 4.6) # medida feita no lab
i, Pu, R = [], [], []
for k in range(len(V_i)):
vi = M(V_i[k], erro_V_i[k])
vc = M(V_c[k], erro_V_c[k])
i_ = vi / r_e
i.append(i_)
Pu.append((vi + vc) * i_)
R.append(vc / i_)
erro_R = np.array([r.incerteza for r in R])
R = np.array([r.nominal for r in R])
erro_Pu = np.array([pu.incerteza for pu in Pu])
Pu = np.array([pu.nominal for pu in Pu])
erro_i = np.array([i_.incerteza for i_ in i])
i = np.array([i_.nominal for i_ in i])
# ajuste
def pot_util(R, r_i, fem):
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
from LabIFSC import M
from erros_mult import *
mu_0 = np.pi*4e-7 # valor exato
N = M((760,0))
L = M((15.2e-2,.05e-3))
n = N/L
dados1 = np.loadtxt('pratica4/dados/calibração.dat').T
Vfundo = M((4.7e-3,err_v200m(4.7e-3)))
Vh, I = dados1
erroVh = erro_array(Vh,err_v2)
Vh = Vh-Vfundo.nominal
erroVh = np.array(erroVh)+Vfundo.incerteza
erroI = erro_array(I,err_a200m)
B = mu_0*n.nominal*I
erroB=[]
for i in I:
i = M((i,err_a200m(i)))
erroB.append((mu_0*n*i).incerteza)
ajuste1 = stats.linregress(B,Vh)
slope1,intercept1 = ajuste1[:2]
see = ajuste1[-1]
mv = Vh.mean()
sv2 = ((Vh-mv)**2).sum()
sd_intercept = see * np.sqrt(1./len(Vh) + mv*mv/sv2)
sd_slope = see * np.sqrt(1./sv2)
from matplotlib import pyplot as plt
import numpy as np
from scipy import optimize
from IPython.display import display, Math, Latex
from LabIFSC import M
e = M((1.6021762e-19, 0.0000001e-19)) # Carga fundamental
kb = M((1.3806485e-23, 0.0000001e-23)) # Constante de boltzmann
k = e / kb # 'k' da equação de Shockley
h = M((6.62607004e-34, 0.00000001e-34)) # Constante de Planck
#la = np.linspace(450e-9, 495e-9,50) # Comprimento de onda luz azul (466)
la = M((466e-9, 1e-9))
#lv = np.linspace(495e-9, 570e-9,50) # Comprimento de onda luz verde (575)
lv = M((575e-9, 1e-9))
c = M((299792458, 0)) # Velocidade da luz
T = M((295, 1)) # Temperatura ambiente
R = M((47.4, 0.1)) # Resistência
# Chutes default pros valores
I0 = M((1e-9, 0))
k = e / (kb * 2)
i_shockley = lambda x, i0, k: x * i0 * (np.exp(k * x / T) - 1) / (
x + R * i0 * (np.exp(k * x / T) - 1))
#####################################################################
######## MODELAGEM EXATA DO CIRCUITO - NÃO VAMOS USAR ##############
#####################################################################
from LabIFSC import M # esse módulo tá bugado :/
from scipy import optimize
print('TODOS OS TESTES DE EQUIVALÊNCIA ESTÃO BUGADOS, TESTE NA MÃO')
dados = np.loadtxt('pratica2/data/wheatstone.dat')
Vp, i = dados.T
Vp = -Vp
erro_voltm = lambda x: 0.003 + 0.005 * abs(x)
erro_Vp = np.array(list(map(erro_voltm, Vp)))
erro_ampm = lambda x: 0.1e-3 + 0.008 * abs(x)
erro_i = np.array(list(map(erro_ampm, i)))
# valores constam em wheatstone.dat
Vf = M(5.01, 0.06)
R1, R2, R3 = M(671, 5), M(666, 5), M(470, 4)
Rx_eq_prev = R2 * R3 / R1
print('R1, R2, R3:', R1, R2, R3)
# análise
#mu = []
#for x,xerr in zip(Vp,erro_Vp):
# mu.append(M(x,xerr)/Vf)
l = R2 / (R1 + R2)
Rx = []
for corrente, err_corrente in zip(i, erro_i):
Req = Vf / M(corrente, err_corrente)
Rx.append(((R1 + R2) * (R3 - Req) - R3 * Req) / (Req - R1 - R2))
import numpy as np
from scipy import optimize
import matplotlib.pyplot as plt
from LabIFSC import M
from erros_mult import *
mu_0 = 4e-7 * np.pi # valor exato
# esse valor vem de analise_calibracao.py
K = M((265.653591676, 0.641925750322))
N = 130 # número de espiras por bobina
# Modelos para ajuste
def bobina(z, I, a, z0):
return mu_0 * N * I * a**2 / (2 * ((z - z0)**2 + a**2)**(3 / 2))
def antihelmholtz(z, I, a, b, z0):
return bobina(z - b / 2, I, a, z0) - bobina(z + b / 2, I, a, z0)
# Bobina
dados31 = np.loadtxt('pratica4/dados/bobina.dat').T
z, Vh = dados31
erroVh = erro_array(Vh, err_v200m)
Vfundo = M((-.002, err_v200m(-.002)))
Vh = Vh - Vfundo.nominal
erroVh = np.array(erroVh) + Vfundo.incerteza
B, erroB = [], []
# amperímetro causará uma pequena queda de potencial, mas essa queda é muito menor
# que a precisao dos instrumentos usados para fazer qualquer medida no circuito.
N = 2
file = "pratica2/data/kcl_{}.dat".format(N) # pratica2/
data = []
data_np = np.loadtxt(file)
data.append(data_np)
data = np.asarray(data) if len(data_np.shape) == 1 else data_np
def I_erro(x):
return 0.01 * x if x <= 20e-3 else 0.012 * x
Ie = [M((i[0], I_erro(i[0]))) for i in data]
I0 = [M((i[1], I_erro(i[1]))) for i in data]
I1 = [M((i[2], I_erro(i[2]))) for i in data]
I2 = [M((i[3], I_erro(i[3]))) for i in data] if len(data[0]) > 4 else 0
I3 = [M((i[4], I_erro(i[4]))) for i in data] if len(data[0]) > 4 else 0
for i in range(3): # quantidade de dados
print("${:latex}$ & ${:latex}$ & ${:latex}$ & Sim \\\\".format(
I2[i] * 1e3, I0[i] * 1e3, I1[i] * 1e3))
if (N == 1):
print("Para o primeiro circuito temos que: ")
print("I_0 + I_1 = I_e\n------")
for i in range(data.shape[0]):
i_soma = I0[i] + I1[i]
i_entra = Ie[i]