def MVA(year, month, day, doy, ti_MVA, tf_MVA, t, B, posicion):
fila, hoja_parametros, hoja_MVA, hoja_Bootstrap, hoja_fit = importar_fila(
year, month, day, doy, ti_MVA
)
t1 = float(hoja_parametros.cell(fila, 6).value)
t2 = float(hoja_parametros.cell(fila, 7).value)
t3 = float(hoja_parametros.cell(fila, 8).value)
t4 = float(hoja_parametros.cell(fila, 9).value)
inicio = donde(t, ti_MVA)
fin = donde(t, tf_MVA)
B_cut = B[inicio:fin, :]
# ahora empieza el MVA con los datos que elegí
posicion_cut = posicion[inicio : fin + 1, :]
altitud = np.mean(np.linalg.norm(posicion_cut, axis=1) - 3390)
M_ij = Mij(B_cut)
# ahora quiero los autovectores y autovalores
[lamb, x] = np.linalg.eigh(M_ij) # uso eigh porque es simetrica
# Los ordeno de mayor a menor
idx = lamb.argsort()[::-1]
lamb = lamb[idx]
x = x[:, idx]
# ojo que me da las columnas en vez de las filas como autovectores: el av x1 = x[:,0]
x1 = x[:, 0]
x2 = x[:, 1]
x3 = x[:, 2]
av = np.concatenate([x1, x2, x3])
if x3[0] < 0: # si la normal aputna para adentro me la da vuelta
x3 = -x3
if any(np.cross(x1, x2) - x3) > 0.01:
print("Cambio el signo de x1 para que los av formen terna derecha")
x1 = -x1
# las proyecciones
B1 = np.dot(B_cut, x1)
B2 = np.dot(B_cut, x2)
B3 = np.dot(B_cut, x3)
# el B medio
B_medio_vectorial = np.mean(B_cut, axis=0)
SZAngle = SZA(posicion_cut, 0)
if any(posicion_cut[:, 2]) < 0:
SZAngle = -SZAngle
B_norm_medio = np.linalg.norm(B_medio_vectorial)
hodograma(B1, B2, B3)
# el error
phi, delta_B3 = error(lamb, B_cut, x)
###############
# ###fit
orbita = posicion[donde(t, t1 - 1) : donde(t, t4 + 1)] / 3390 # radios marcianos
index = donde(t, (t2 + t3) / 2)
x0 = 0.78
e = 0.9
L0 = 0.96
normal_fit, X1, Y1, Z1, R, L0 = ajuste_conico(
posicion, index, orbita, x3, x0, e, L0
)
B3_fit = np.dot(B_cut, normal_fit)
###############
# #Bootstrap
N_boot = 1000
normal_boot, phi_boot, delta_B3_boot, out, out_phi = bootstrap(N_boot, B_cut)
muB, sigmaB, mu31, sigma31, mu32, sigma32 = plot_bootstrap(out, out_phi)
B3_boot = np.dot(B_cut, normal_boot)
#######
# Errores
if phi[2, 1] > phi[2, 0]:
error_normal = phi[2, 1] * 57.2958
else:
error_normal = phi[2, 0] * 57.2958
# quiero ver si el error más grande es phi31 o phi32
if sigma31 > sigma32:
error_boot = sigma31
else:
error_boot = sigma32
print("Fin del MVA")
#############
# ahora guardo todo en una spreadsheet
# ######updateo la hoja de los parámetros
# hoja_parametros.update_acell(f"D{fila}", f"{SZAngle:.3g}")
# hoja_parametros.update_acell(f"E{fila}", f"{int(altitud)}")
# hoja_parametros.update_acell(f"O{fila}", f"{round(B_norm_medio,2)}")
#
# cell_B = hoja_parametros.range(f"L{fila}:N{fila}")
# for i, cell in enumerate(cell_B):
# cell.value = round(B_medio_vectorial[i], 2)
# hoja_parametros.update_cells(cell_B)
#
# # if (
# # type(B_filtrado) != int
# # ): # si no es un int, en particular 0, agrega los datos a la lista
# # hoja_parametros.update_acell(f"J{fila}", f"{orden_filtro}")
# # hoja_parametros.update_acell(f"K{fila}", f"{frec_filtro}")
# # else:
# # hoja_parametros.update_acell(f"J{fila}", "Sin filtrar")
#
# # #######update la hoja de MVA
# hoja_MVA.update_acell(f"D{fila}", f"{ti_MVA}")
# hoja_MVA.update_acell(f"E{fila}", f"{tf_MVA}")
# hoja_MVA.update_acell(f"I{fila}", f"{lamb[1]/lamb[2]:.3g}")
#
# hoja_MVA.update_acell(f"S{fila}", f"{error_normal:.3g}")
# hoja_MVA.update_acell(f"T{fila}", f"{round(np.mean(B3),2)}")
# hoja_MVA.update_acell(f"U{fila}", f"{round(delta_B3,2)}")
# hoja_MVA.update_acell(f"V{fila}", f"{abs(round(np.mean(B3)/B_norm_medio,2))}")
#
# cell_lambda = hoja_MVA.range(f"F{fila}:H{fila}")
# for i, cell in enumerate(cell_lambda):
# cell.value = round(lamb[i], 2)
# hoja_MVA.update_cells(cell_lambda)
#
# cell_av = hoja_MVA.range(f"J{fila}:R{fila}")
# for i, cell in enumerate(cell_av):
# cell.value = round(av[i], 3)
# hoja_MVA.update_cells(cell_av)
#
# # #######update la hoja de bootstrap
# hoja_Bootstrap.update_acell(f"D{fila}", f"{len(B)}")
# hoja_Bootstrap.update_acell(f"E{fila}", f"{N_boot}")
#
# cell_normal = hoja_Bootstrap.range(f"F{fila}:H{fila}")
# for i, cell in enumerate(cell_normal):
# cell.value = round(normal_boot[i], 3)
# hoja_Bootstrap.update_cells(cell_normal)
#
# hoja_Bootstrap.update_acell(f"I{fila}", f"{error_boot:.3g}")
# hoja_Bootstrap.update_acell(f"J{fila}", f"{round(np.mean(B3_boot),2)}")
# hoja_Bootstrap.update_acell(f"K{fila}", f"{round(sigmaB,2)}")
# hoja_Bootstrap.update_acell(
# f"L{fila}", f"{abs(round(np.mean(B3_boot)/B_norm_medio,2))}"
# )
#
# # #######update la hoja del ajuste
# hoja_fit.update_acell(f"D{fila}", f"{L0}")
# hoja_fit.update_acell(f"E{fila}", f"{e}")
# hoja_fit.update_acell(f"F{fila}", f"{x0}")
#
# cell_normal = hoja_fit.range(f"G{fila}:I{fila}")
# for i, cell in enumerate(cell_normal):
# cell.value = round(normal_fit[i], 3)
# hoja_fit.update_cells(cell_normal)
#
# hoja_fit.update_acell(f"K{fila}", f"{round(np.mean(B3_fit),2)}")
# hoja_fit.update_acell(f"L{fila}", f"{abs(round(np.mean(B3_fit)/B_norm_medio,2))}")
#
# print("escribe la spreadsheet")
return (
x3,
normal_boot,
normal_fit,
inicio,
fin,
B_cut,
t1,
t2,
t3,
t4,
B_medio_vectorial,
fila,
hoja_parametros,
hoja_MVA,
hoja_Bootstrap,
hoja_fit,
)
x3 = -x3
if any(np.cross(x1, x2) - x3) > 0.01:
print('Cambio el signo de x1 para que los av formen terna derecha')
x1 = -x1
#lambda2/lambda3
print('lambda1 = {0:1.3g} \nlambda2 = {1:1.3g} \nlambda3 = {2:1.3g}'.format(
lamb[0], lamb[1], lamb[2]))
print('lambda2/lambda3 = {0:1.3g}'.format(lamb[1] / lamb[2]))
print('La normal es = {}'.format(x3))
#las proyecciones
B1 = np.dot(B_cut, x1)
B2 = np.dot(B_cut, x2)
B3 = np.dot(B_cut, x3)
hodograma(B1, B2, B3, 'nT', 'MAVEN MAG MVA ')
#el error
phi, delta_B3 = error(lamb, B_cut, M_cut, x)
print('Matriz de incerteza angular (grados): \n{}'.format(phi * 180 / np.pi))
print('<B3> = {0:1.3g} +- {1:1.3g} nT'.format(np.mean(B3), delta_B3))
if phi[2, 1] > phi[2, 0]:
print('El error phi32 = {0:1.3g}º es mayor a phi31 = {1:1.3g}º'.format(
phi[2, 1] * 57.2958, phi[2, 0] * 180 / np.pi))
else:
print('El error phi31 = {0:1.3g}º es mayor a phi32 = {1:1.3g}º'.format(
phi[2, 0] * 57.2958, phi[2, 1] * 180 / np.pi))
#quiero ver si el error más grande es phi31 o phi32
#el B medio
x3 = av[:, 2]
av = np.concatenate([x1, x2, x3])
if x3[0] < 0: # si la normal aputna para adentro me la da vuelta
x3 = -x3
if any(np.cross(x1, x2) - x3) > 0.01:
print("Cambio el signo de x1 para que los av formen terna derecha")
x1 = -x1
# las proyecciones
B1 = np.dot(B_MPB, x1)
B2 = np.dot(B_MPB, x2)
B3 = np.dot(B_MPB, x3)
hodograma(B1, B2, B3)
xi = 1.2
xf = 1.36
inicio_up = donde(x, xi - 126)
fin_up = donde(x, xi)
B_upstream = np.mean(B[inicio_up:fin_up, :], axis=0) # nT
inicio_down = donde(x, xf)
fin_down = donde(x, xf + 146)
B_downstream = np.mean(B[inicio_down:fin_down, :], axis=0) # nT
omega = (np.arccos(
np.dot(B_upstream, B_downstream) /
(np.linalg.norm(B_upstream) * np.linalg.norm(B_downstream))) * 180 / np.pi)
B_medio_vectorial) #la normalizo por cuestion de cuentas nomas
angulo_B_mva = np.arccos(
np.clip(np.dot(x3, B_intermedio), -1.0,
1.0)) #Es importante que los vectoers estén normalizados!
print('El ángulo entre el campo B y la normal del MVA es = {0:1.3g}º'.format(
angulo_B_mva * 180 / np.pi))
v_media_norm = np.array([-0.6541, 0.126,
0.7459]) #la normalizo por cuestion de cuentas nomas
angulo_v_mva = np.arccos(
np.clip(np.dot(x3, v_media_norm), -1.0,
1.0)) #Es importante que los vectoers estén normalizados!
print('El ángulo entre la velocidad y la normal del MVA es = {0:1.3g}º'.format(
angulo_v_mva * 180 / np.pi))
hodograma(B1, B2, B3, 'nT', 'MAVEN MAG MVA 18:13:33 - 18:14:06 UTC')
mu = 4 * np.pi * 1E-7 #Henry/m
J_s = np.cross(x3, (B_upstream - B_downstream)) / mu #nA/m
ancho_mpb = 90 #km, esta copiado de lo que da en el otro script
J_v = J_s / (1000 * ancho_mpb) #nA/m²
print(
'La corriente superficial con la normal del MVA es Js = {} mA/m, |Js| = {} mA/m'
.format(J_s * 1E-6,
np.linalg.norm(J_s) * 1E-6))
print(
'La corriente en volumen con la normal del MVA es Jv = {} nA/m², |Jv| = {} nA/m²'
.format(J_v, np.linalg.norm(J_v)))
M_ij = Mij(B_cut)
# np.savetxt('outs/matriz_%d'%dia[0], M_ij) #guarda la matriz de cada dia
#ahora quiero los autovectores y autovalores
[lamb, x] = np.linalg.eigh(M_ij) #uso eigh porque es simetrica
#Los ordeno de mayor a menor
idx = lamb.argsort()[::-1]
lamb = lamb[idx]
x = x[:, idx]
#ojo que me da las columnas en vez de las filas como autovectores: el av x1 = x[:,0]
x1 = x[:, 0]
x2 = x[:, 1]
x3 = x[:, 2]
if x3[0] < 0: #si la normal aputna para adentro me la da vuelta
x3 = -x3
#lambda2/lambda3
print(
'lambda1 = {0:1.3g} \nlambda2 = {1:1.3g} \nlambda3 = {2:1.3g}'.format(
lamb[0], lamb[1], lamb[2]))
print('lambda2/lambda3 = {0:1.3g}'.format(lamb[1] / lamb[2]))
#las proyecciones
B1 = np.dot(B_cut, x1)
B2 = np.dot(B_cut, x2)
B3 = np.dot(B_cut, x3)
hodograma(B1, B2, B3, 'nT', f'MAVEN MAG MVA fecha {doy}-{year}')
plt.show()
def MVA(year, month, day, ti_MVA, tf_MVA):
date_entry = f"{year}-{month}-{day}"
mag, t, B, posicion = importar_mag(year, month, day, ti_MVA, tf_MVA)
# ya los importa cortados a los datos, entonces no hace falta que haga el cut yo
M = len(t)
Bnorm = np.linalg.norm(B, axis=1)
# la matriz diaria:
MD = np.zeros((M, 9))
MD[:, 0] = t
for i in range(1, 4):
MD[:, i] = B[:, i - 1]
MD[:, 4] = Bnorm
for i in range(5, 8):
MD[:, i] = posicion[:, i - 5] / 3390 # en radios marcianos
MD[:, 8] = np.linalg.norm(posicion, axis=1) - 3390 # altitud en km
n_p = int(M / 2)
M_ij = Mij(B)
# ahora quiero los autovectores y autovalores
[lamb, x] = np.linalg.eigh(M_ij) # uso eigh porque es simetrica
# Los ordeno de mayor a menor
idx = lamb.argsort()[::-1]
lamb = lamb[idx]
x = x[:, idx]
# ojo que me da las columnas en vez de las filas como autovectores: el av x1 = x[:,0]
x1 = x[:, 0]
x2 = x[:, 1]
x3 = x[:, 2]
if x3[0] < 0: # si la normal aputna para adentro me la da vuelta
x3 = -x3
if any(np.cross(x1, x2) - x3) > 0.01:
print("Cambio el signo de x1 para que los av formen terna derecha")
x1 = -x1
print("la normal del MVA es ", x3)
# las proyecciones
B1 = np.dot(B, x1)
B2 = np.dot(B, x2)
B3 = np.dot(B, x3)
# el B medio
B_medio_vectorial = np.mean(B, axis=0)
altitud = np.mean(MD[:, 8])
SZA = angulo(posicion[n_p, :], [1, 0, 0]) * 180 / np.pi
print(f"altitud = {altitud}, SZA = {SZA}")
print("cociente de lambdas = ", lamb[1] / lamb[2])
B_norm_medio = np.linalg.norm(B_medio_vectorial)
print(f"El B medio es {B_norm_medio}")
hodograma(B1, B2, B3)
# el error
phi, delta_B3 = error(lamb, B, x)
print("MVA terminado")
return x3, B, t, posicion
def MVA(year, month, day, ti_MVA, tf_MVA):
date_entry = f"{year}-{month}-{day}"
mag, t, B, posicion = importar_mag(year, month, day, ti_MVA, tf_MVA)
M = len(t)
Bnorm = np.linalg.norm(B, axis=1)
# la matriz diaria:
MD = np.zeros((M, 9))
MD[:, 0] = t
for i in range(1, 4):
MD[:, i] = B[:, i - 1]
MD[:, 4] = Bnorm
for i in range(5, 8):
MD[:, i] = posicion[:, i - 5] / 3390 # en radios marcianos
MD[:, 8] = np.linalg.norm(posicion, axis=1) - 3390 # altitud en km
n_p = int(M / 2)
M_ij = Mij(B)
# ahora quiero los autovectores y autovalores
[lamb, x] = np.linalg.eigh(M_ij) # uso eigh porque es simetrica
# Los ordeno de mayor a menor
idx = lamb.argsort()[::-1]
lamb = lamb[idx]
x = x[:, idx]
# ojo que me da las columnas en vez de las filas como autovectores: el av x1 = x[:,0]
x1 = x[:, 0]
x2 = x[:, 1]
x3 = x[:, 2]
if x3[0] < 0: # si la normal apunta para adentro me la da vuelta
x3 = -x3
if any(np.cross(x1, x2) - x3) > 0.01:
print("Cambio el signo de x1 para que los av formen terna derecha")
x1 = -x1
av = np.concatenate([x1, x2, x3])
# las proyecciones
B1 = np.dot(B, x1)
B2 = np.dot(B, x2)
B3 = np.dot(B, x3)
# el B medio
B_medio_vectorial = np.mean(B, axis=0)
altitud = np.mean(MD[:, 8])
SZA = angulo(posicion[n_p, :], [1, 0, 0]) * 180 / np.pi
if posicion[n_p, 2] < 0:
SZA = -SZA
B_norm_medio = np.linalg.norm(B_medio_vectorial)
hodograma(B1, B2, B3, date_entry)
# el error
phi, delta_B3 = error(lamb, B, M, x)
if phi[2, 1] > phi[2, 0]:
error_normal = phi[2, 1] * 180 / np.pi
else:
error_normal = phi[2, 0] * 180 / np.pi
print("Fin del MVA.")
# ######update la hoja de los parámetros
(
hoja_parametros,
hoja_mva,
hoja_boot,
hoja_fit,
fecha_sheet,
hora_sheet,
) = acceso_spreadsheet()
nr = que_linea(date_entry, fecha_sheet, hora_sheet, hoja_mva, int(ti_MVA))
hojas = [hoja_parametros, hoja_mva, hoja_boot, hoja_fit]
for hoja in hojas: # pone la fecha en todas las hojas
poner_fecha(hoja, nr, date_entry, int(ti_MVA))
hoja_parametros.update_acell(f"D{nr}", f"{SZA:.3g}")
hoja_parametros.update_acell(f"E{nr}", f"{int(altitud)}")
hoja_parametros.update_acell(f"O{nr}", f"{round(B_norm_medio,2)}")
cell_B = hoja_parametros.range(f"L{nr}:N{nr}")
for i, cell in enumerate(cell_B):
cell.value = round(B_medio_vectorial[i], 2)
hoja_parametros.update_cells(cell_B)
# #######update la hoja de MVA
hoja_mva.update_acell(f"D{nr}", f"{ti_MVA}")
hoja_mva.update_acell(f"E{nr}", f"{tf_MVA}")
hoja_mva.update_acell(f"I{nr}", f"{lamb[1]/lamb[2]:.3g}")
hoja_mva.update_acell(f"S{nr}", f"{error_normal:.3g}")
hoja_mva.update_acell(f"T{nr}", f"{round(np.mean(B3),2)}")
hoja_mva.update_acell(f"U{nr}", f"{round(delta_B3,2)}")
hoja_mva.update_acell(f"V{nr}",
f"{abs(round(np.mean(B3)/B_norm_medio,2))}")
cell_lambda = hoja_mva.range(f"F{nr}:H{nr}")
for i, cell in enumerate(cell_lambda):
cell.value = round(lamb[i], 2)
hoja_mva.update_cells(cell_lambda)
cell_av = hoja_mva.range(f"J{nr}:R{nr}")
for i, cell in enumerate(cell_av):
cell.value = round(av[i], 3)
hoja_mva.update_cells(cell_av)
print("Escribió la spreadsheet del MVA.")
return x3, B, t, posicion, nr