629 lines
19 KiB
Python
629 lines
19 KiB
Python
import marimo
|
|
|
|
__generated_with = "0.25.2"
|
|
app = marimo.App(width="medium", auto_download=["html"])
|
|
|
|
|
|
@app.cell
|
|
def _():
|
|
import marimo as mo
|
|
import numpy as np
|
|
import pandas as pd
|
|
import sympy as sp
|
|
from scipy import stats
|
|
|
|
from pathlib import Path
|
|
|
|
import statistica
|
|
|
|
_outputs, defs = statistica.app.run()
|
|
Data = defs["Data"]
|
|
compat = defs["compat"]
|
|
media_pesata = defs["media_pesata"]
|
|
rimuovi_outlier = defs["rimuovi_outlier"]
|
|
plot_gauss = defs["plot_gauss"]
|
|
cartella_csv = Path(__file__).resolve().parent / "csv" / "focaleLente"
|
|
cartella_immagini = Path(__file__).resolve().parent / "LaTeX" / "immagini"
|
|
return (
|
|
Data,
|
|
cartella_csv,
|
|
cartella_immagini,
|
|
compat,
|
|
media_pesata,
|
|
mo,
|
|
np,
|
|
pd,
|
|
plot_gauss,
|
|
rimuovi_outlier,
|
|
sp,
|
|
)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(mo):
|
|
mo.md(r"""
|
|
# Misura della distanza focale
|
|
|
|
Sono usati solo i CSV presenti in `csv/focaleLente`.
|
|
|
|
- **m1, punti coniugati:** $f = pq/(p+q)$
|
|
- **m2, $q$ e ingrandimento:** $f = q/(1+h/L)$
|
|
- **m3, Bessel:** $f = d_1d_2/a$
|
|
|
|
Il metodo con $p$ e ingrandimento non viene usato perché non è stata
|
|
misurata la grandezza necessaria.
|
|
|
|
Le distanze da metro sono in cm con errore strumentale `0.1 cm`.
|
|
Le misure da calibro ventesimale sono in mm con errore strumentale
|
|
`0.05 mm`.
|
|
""")
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(cartella_csv, pd):
|
|
def leggi_csv(nome):
|
|
dati = pd.read_csv(cartella_csv / nome, sep=";", decimal=",")
|
|
dati.columns = dati.columns.astype(str).str.strip()
|
|
dati = dati.dropna(axis=1, how="all")
|
|
return dati.apply(pd.to_numeric, errors="coerce")
|
|
|
|
m1_48B = leggi_csv("lenti per csv 2(48B_m1).csv")
|
|
m1_252B = leggi_csv("lenti per csv 2(252B_m1).csv")
|
|
m2_48B = leggi_csv("lenti per csv 2(48B_m2).csv")
|
|
m2_252B = leggi_csv("lenti per csv 2(252B_m2).csv")
|
|
m3_48B = leggi_csv("lenti per csv 2(48B_m3).csv")
|
|
m3_252B = leggi_csv("lenti per csv 2(252B_m3).csv")
|
|
spessore_48B_df = leggi_csv("lenti per csv 2(spessore 48B).csv")
|
|
spessore_252B_df = leggi_csv("lenti per csv 2(spessore 252B).csv")
|
|
dimensione_freccia_df = leggi_csv("lenti per csv 2(dimensione freccia).csv")
|
|
return (
|
|
dimensione_freccia_df,
|
|
m1_252B,
|
|
m1_48B,
|
|
m2_252B,
|
|
m2_48B,
|
|
m3_252B,
|
|
m3_48B,
|
|
spessore_252B_df,
|
|
spessore_48B_df,
|
|
)
|
|
|
|
|
|
@app.cell
|
|
def _(Data, dimensione_freccia_df, spessore_252B_df, spessore_48B_df):
|
|
_df_spessore_48B = Data(spessore_48B_df)
|
|
_df_spessore_48B.stat_chauv("s48B", 0.05, False)
|
|
spessore_48B = _df_spessore_48B.analisi_stat.s48B[0] /10
|
|
uspessore_48B = _df_spessore_48B.analisi_stat.us48B[0]/10
|
|
|
|
_df_spessore_252B = Data(spessore_252B_df)
|
|
_df_spessore_252B.stat_chauv("s252B", 0.05, False)
|
|
spessore_252B = _df_spessore_252B.analisi_stat.s252B[0] /10
|
|
uspessore_252B = _df_spessore_252B.analisi_stat.us252B[0]/10
|
|
|
|
_df_freccia = Data(dimensione_freccia_df)
|
|
_df_freccia.stat_chauv("freccia", 0.05, False)
|
|
freccia = _df_freccia.analisi_stat.freccia[0] /10
|
|
ufreccia = _df_freccia.analisi_stat.ufreccia[0]/10
|
|
return (
|
|
freccia,
|
|
spessore_252B,
|
|
spessore_48B,
|
|
ufreccia,
|
|
uspessore_252B,
|
|
uspessore_48B,
|
|
)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(
|
|
freccia,
|
|
mo,
|
|
spessore_252B,
|
|
spessore_48B,
|
|
ufreccia,
|
|
uspessore_252B,
|
|
uspessore_48B,
|
|
):
|
|
mo.md("## Misure accessorie")
|
|
(spessore_48B, uspessore_48B), (spessore_252B, uspessore_252B), (freccia, ufreccia)
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(
|
|
Data,
|
|
m1_252B,
|
|
m1_48B,
|
|
spessore_252B,
|
|
spessore_48B,
|
|
uspessore_252B,
|
|
uspessore_48B,
|
|
):
|
|
data48Bm1 = Data(m1_48B.copy())
|
|
data48Bm1.analisi_stat = m1_48B.copy()
|
|
data48Bm1.analisi_stat["up"] = 0.1
|
|
data48Bm1.analisi_stat["uq"] = 1 #Potevamo muovere lo schermo di ... e non notavamo differenze
|
|
data48Bm1.analisi_stat["s"] = spessore_48B
|
|
data48Bm1.analisi_stat["us"] = uspessore_48B
|
|
|
|
data252Bm1 = Data(m1_252B.copy())
|
|
data252Bm1.analisi_stat = m1_252B.copy()
|
|
data252Bm1.analisi_stat["up"] = 1 #Potevamo muovere lo schermo di ... e non notavamo differenze
|
|
data252Bm1.analisi_stat["uq"] = 1 #Potevamo muovere lo schermo di ... e non notavamo differenze
|
|
data252Bm1.analisi_stat["s"] = spessore_252B
|
|
data252Bm1.analisi_stat["us"] = uspessore_252B
|
|
|
|
data48Bm1.analisi_stat, data252Bm1.analisi_stat
|
|
return data252Bm1, data48Bm1
|
|
|
|
|
|
@app.cell
|
|
def _(sp):
|
|
p, q, s = sp.symbols("p q s", positive=True)
|
|
peff, qeff = sp.symbols("peff qeff", positive=True)
|
|
|
|
peff = p - (s/2)
|
|
qeff = q + (s/2)
|
|
return peff, qeff
|
|
|
|
|
|
@app.cell
|
|
def _(data252Bm1, data48Bm1, peff, qeff):
|
|
f1 = peff * qeff / (peff + qeff)
|
|
|
|
data48Bm1.calc_var(peff, "peff")
|
|
data252Bm1.calc_var(peff, "peff")
|
|
data48Bm1.calc_var(qeff, "qeff")
|
|
data252Bm1.calc_var(qeff, "qeff")
|
|
data48Bm1.calc_var(f1, "f1")
|
|
data252Bm1.calc_var(f1, "f1")
|
|
|
|
risultato48Bm1 = data48Bm1.analisi_stat[["peff", "upeff", "qeff", "uqeff", "f1", "uf1"]]
|
|
risultato252Bm1 = data252Bm1.analisi_stat[["peff", "upeff", "qeff", "uqeff", "f1", "uf1"]]
|
|
return risultato252Bm1, risultato48Bm1
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(mo):
|
|
mo.md(r"""
|
|
## Metodo 1: punti coniugati
|
|
|
|
`p` e `q` sono in cm, quindi anche `f1` è in cm.
|
|
""")
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(risultato252Bm1, risultato48Bm1):
|
|
risultato48Bm1, risultato252Bm1
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(
|
|
Data,
|
|
freccia,
|
|
m2_252B,
|
|
m2_48B,
|
|
spessore_252B,
|
|
spessore_48B,
|
|
ufreccia,
|
|
uspessore_252B,
|
|
uspessore_48B,
|
|
):
|
|
data48Bm2 = Data(m2_48B.copy())
|
|
data48Bm2.analisi_stat = m2_48B.copy()
|
|
data48Bm2.analisi_stat["uq"] = 1 #La freccia era sempre a fuoco per ogni q
|
|
data48Bm2.analisi_stat["h"] /= 10
|
|
data48Bm2.analisi_stat["uh"] = 0.1 #No guide fisse e calibro nell'vuoto siderale
|
|
data48Bm2.analisi_stat["L"] = freccia
|
|
data48Bm2.analisi_stat["uL"] = ufreccia
|
|
data48Bm2.analisi_stat["s"] = spessore_48B
|
|
data48Bm2.analisi_stat["us"] = uspessore_48B
|
|
|
|
data252Bm2 = Data(m2_252B.copy())
|
|
data252Bm2.analisi_stat = m2_252B.copy()
|
|
data252Bm2.analisi_stat["uq"] = 0.1
|
|
data252Bm2.analisi_stat["h"] /= 10
|
|
data252Bm2.analisi_stat["uh"] = 0.02
|
|
data252Bm2.analisi_stat["L"] = freccia
|
|
data252Bm2.analisi_stat["uL"] = ufreccia
|
|
data252Bm2.analisi_stat["s"] = spessore_252B
|
|
data252Bm2.analisi_stat["us"] = uspessore_252B
|
|
return data252Bm2, data48Bm2
|
|
|
|
|
|
@app.cell
|
|
def _(data252Bm2, data48Bm2, np, qeff, sp):
|
|
h, L, theta= sp.symbols("h L theta", positive=True)
|
|
|
|
data48Bm2.calc_var(qeff, "qeff")
|
|
data252Bm2.calc_var(qeff, "qeff")
|
|
|
|
data48Bm2.analisi_stat["theta"] = np.radians(15)
|
|
data48Bm2.analisi_stat["utheta"] = (np.radians(15) - np.radians(5)) / 2 # data48Bm2.analisi_stat["theta"] / (2* np.sqrt(3))
|
|
|
|
data252Bm2.analisi_stat["theta"] = np.radians(15)
|
|
data252Bm2.analisi_stat["utheta"] = (np.radians(15) - np.radians(5)) / 2
|
|
|
|
|
|
f2bCorretto = qeff / (1 + h * sp.cos(theta) / L) # / 1.0353 # [1; 1.0353]
|
|
f2b = qeff / (1 + h / L) #Senza correzione si theta per vedere come è
|
|
|
|
data48Bm2.calc_var(f2b, "f2b_senza")
|
|
data252Bm2.calc_var(f2b, "f2b_senza")
|
|
data48Bm2.calc_var(f2bCorretto, "f2b")
|
|
data252Bm2.calc_var(f2bCorretto, "f2b")
|
|
|
|
risultato48Bm2 = data48Bm2.analisi_stat[["qeff", "uqeff", "h", "uh", "f2b", "uf2b"]]
|
|
risultato252Bm2 = data252Bm2.analisi_stat[["qeff", "uqeff", "h", "uh", "f2b", "uf2b"]]
|
|
risultato48Bm2_senza = data48Bm2.analisi_stat[["qeff", "uqeff", "h", "uh", "f2b_senza", "uf2b_senza"]]
|
|
risultato252Bm2_senza = data252Bm2.analisi_stat[["qeff", "uqeff", "h", "uh", "f2b_senza", "uf2b_senza"]]
|
|
|
|
data48Bm2.analisi_stat, data252Bm2.analisi_stat,
|
|
return (
|
|
risultato252Bm2,
|
|
risultato252Bm2_senza,
|
|
risultato48Bm2,
|
|
risultato48Bm2_senza,
|
|
)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(mo):
|
|
mo.md(r"""
|
|
## Metodo 2: $q$ e ingrandimento
|
|
|
|
`q` e `L` sono in cm e `h` è in mm. Il rapporto `h/L` è adimensionale,
|
|
perché confronta la dimensione dell'immagine con quella dell'oggetto.
|
|
Il risultato `f2b` è in cm.
|
|
""")
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(risultato252Bm2, risultato48Bm2):
|
|
risultato48Bm2, risultato252Bm2
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(Data, m3_252B, m3_48B):
|
|
data48Bm3 = Data(m3_48B.copy())
|
|
data48Bm3.analisi_stat = m3_48B.copy()
|
|
data48Bm3.analisi_stat["ua"] = 0.3
|
|
data48Bm3.analisi_stat["ud1"] = 0.1 # Non notavamo differenze in 0.3 cm
|
|
data48Bm3.analisi_stat["ud2"] = 0.1
|
|
|
|
data252Bm3 = Data(m3_252B.copy())
|
|
data252Bm3.analisi_stat = m3_252B.copy()
|
|
data252Bm3.analisi_stat["ua"] = 0.3
|
|
data252Bm3.analisi_stat["ud1"] = 1 # No differenze notate in 1 cm
|
|
data252Bm3.analisi_stat["ud2"] = 1
|
|
return data252Bm3, data48Bm3
|
|
|
|
|
|
@app.cell
|
|
def _(data252Bm3, data48Bm3, sp):
|
|
a, d1, d2 = sp.symbols("a d1 d2", positive=True, real=True)
|
|
delta = d1 - d2
|
|
|
|
data48Bm3.calc_var(delta, "delta")
|
|
data252Bm3.calc_var(delta, "delta")
|
|
|
|
f3 = (a**2 - delta**2) / (4*a)
|
|
|
|
data48Bm3.calc_var(f3, "f3")
|
|
data252Bm3.calc_var(f3, "f3")
|
|
|
|
risultato48Bm3 = data48Bm3.analisi_stat[["a", "ua", "d1", "ud1", "d2", "ud2", "f3", "uf3"]]
|
|
risultato252Bm3 = data252Bm3.analisi_stat[["a", "ua", "d1", "ud1", "d2", "ud2", "f3", "uf3"]]
|
|
|
|
data48Bm3.analisi_stat
|
|
return risultato252Bm3, risultato48Bm3
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(mo):
|
|
mo.md(r"""
|
|
## Metodo 3: Bessel
|
|
|
|
`a`, `d1` e `d2` sono in cm. Si usa direttamente
|
|
""")
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(risultato252Bm3, risultato48Bm3):
|
|
risultato48Bm3, risultato252Bm3
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(
|
|
rimuovi_outlier,
|
|
risultato252Bm1,
|
|
risultato252Bm2,
|
|
risultato252Bm3,
|
|
risultato48Bm1,
|
|
risultato48Bm2,
|
|
risultato48Bm3,
|
|
):
|
|
f48B_m1_puliti, out48B_m1 = rimuovi_outlier(
|
|
risultato48Bm1["f1"].to_numpy(), risultato48Bm1["uf1"].mean()
|
|
)
|
|
f48B_m2_puliti, out48B_m2 = rimuovi_outlier(
|
|
risultato48Bm2["f2b"].to_numpy(), risultato48Bm2["uf2b"].mean()
|
|
)
|
|
f48B_m3_puliti, out48B_m3 = rimuovi_outlier(
|
|
risultato48Bm3["f3"].to_numpy(), risultato48Bm3["uf3"].mean()
|
|
)
|
|
|
|
f252B_m1_puliti, out252B_m1 = rimuovi_outlier(
|
|
risultato252Bm1["f1"].to_numpy(), risultato252Bm1["uf1"].mean()
|
|
)
|
|
f252B_m2_puliti, out252B_m2 = rimuovi_outlier(
|
|
risultato252Bm2["f2b"].to_numpy(), risultato252Bm2["uf2b"].mean()
|
|
)
|
|
f252B_m3_puliti, out252B_m3 = rimuovi_outlier(
|
|
risultato252Bm3["f3"].to_numpy(), risultato252Bm3["uf3"].mean()
|
|
)
|
|
|
|
outlier_fuochi = {
|
|
"48B m1": out48B_m1,
|
|
"48B m2": out48B_m2,
|
|
"48B m3": out48B_m3,
|
|
"252B m1": out252B_m1,
|
|
"252B m2": out252B_m2,
|
|
"252B m3": out252B_m3,
|
|
}
|
|
return (
|
|
f252B_m1_puliti,
|
|
f252B_m2_puliti,
|
|
f252B_m3_puliti,
|
|
f48B_m1_puliti,
|
|
f48B_m2_puliti,
|
|
f48B_m3_puliti,
|
|
outlier_fuochi,
|
|
)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(mo, outlier_fuochi):
|
|
mo.md("## Outlier dei fuochi")
|
|
outlier_fuochi
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(
|
|
f252B_m1_puliti,
|
|
f252B_m2_puliti,
|
|
f252B_m3_puliti,
|
|
f48B_m1_puliti,
|
|
f48B_m2_puliti,
|
|
f48B_m3_puliti,
|
|
media_pesata,
|
|
np,
|
|
pd,
|
|
risultato252Bm1,
|
|
risultato252Bm2,
|
|
risultato252Bm3,
|
|
risultato48Bm1,
|
|
risultato48Bm2,
|
|
risultato48Bm3,
|
|
):
|
|
f48B_m1, u48B_m1, chi2_48B_m1, dof_48B_m1, P_48B_m1 = media_pesata(
|
|
f48B_m1_puliti, risultato48Bm1["uf1"].loc[risultato48Bm1["f1"].isin(f48B_m1_puliti)]
|
|
)
|
|
f48B_m2, u48B_m2, chi2_48B_m2, dof_48B_m2, P_48B_m2 = media_pesata(
|
|
f48B_m2_puliti, risultato48Bm2["uf2b"].loc[risultato48Bm2["f2b"].isin(f48B_m2_puliti)]
|
|
)
|
|
f48B_m3, u48B_m3, chi2_48B_m3, dof_48B_m3, P_48B_m3 = media_pesata(
|
|
f48B_m3_puliti, risultato48Bm3["uf3"].loc[risultato48Bm3["f3"].isin(f48B_m3_puliti)]
|
|
)
|
|
|
|
f252B_m1, u252B_m1, chi2_252B_m1, dof_252B_m1, P_252B_m1 = media_pesata(
|
|
f252B_m1_puliti, risultato252Bm1["uf1"].loc[risultato252Bm1["f1"].isin(f252B_m1_puliti)]
|
|
)
|
|
f252B_m2, u252B_m2, chi2_252B_m2, dof_252B_m2, P_252B_m2 = media_pesata(
|
|
f252B_m2_puliti, risultato252Bm2["uf2b"].loc[risultato252Bm2["f2b"].isin(f252B_m2_puliti)]
|
|
)
|
|
f252B_m3, u252B_m3, chi2_252B_m3, dof_252B_m3, P_252B_m3 = media_pesata(
|
|
f252B_m3_puliti, risultato252Bm3["uf3"].loc[risultato252Bm3["f3"].isin(f252B_m3_puliti)]
|
|
)
|
|
|
|
risultati_finali = pd.DataFrame({
|
|
"48B - m1": [f48B_m1, u48B_m1, chi2_48B_m1, dof_48B_m1, P_48B_m1],
|
|
"48B - m2": [f48B_m2, u48B_m2, chi2_48B_m2, dof_48B_m2, P_48B_m2],
|
|
"48B - m3": [f48B_m3, u48B_m3, chi2_48B_m3, dof_48B_m3, P_48B_m3],
|
|
"252B - m1": [f252B_m1, u252B_m1, chi2_252B_m1, dof_252B_m1, P_252B_m1],
|
|
"252B - m2": [f252B_m2, u252B_m2, chi2_252B_m2, dof_252B_m2, P_252B_m2],
|
|
"252B - m3": [f252B_m3, u252B_m3, chi2_252B_m3, dof_252B_m3, P_252B_m3],
|
|
}, index=["f [cm]", "u [cm]", "chi2", "dof", "P"]).T
|
|
|
|
risultati_finali["u_corr [cm]"] = risultati_finali["u [cm]"] * np.sqrt(
|
|
np.maximum(1, risultati_finali["chi2"] / risultati_finali["dof"])
|
|
)
|
|
risultati_finali
|
|
return (risultati_finali,)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(
|
|
cartella_immagini,
|
|
media_pesata,
|
|
plot_gauss,
|
|
rimuovi_outlier,
|
|
risultati_finali,
|
|
risultato252Bm2_senza,
|
|
risultato48Bm2_senza,
|
|
):
|
|
f48B_m2_senza_puliti, _ = rimuovi_outlier(
|
|
risultato48Bm2_senza["f2b_senza"].to_numpy(),
|
|
risultato48Bm2_senza["uf2b_senza"].mean(),
|
|
)
|
|
f252B_m2_senza_puliti, _ = rimuovi_outlier(
|
|
risultato252Bm2_senza["f2b_senza"].to_numpy(),
|
|
risultato252Bm2_senza["uf2b_senza"].mean(),
|
|
)
|
|
f48B_m2_senza, u48B_m2_senza, _, _, _ = media_pesata(
|
|
f48B_m2_senza_puliti,
|
|
risultato48Bm2_senza["uf2b_senza"].loc[
|
|
risultato48Bm2_senza["f2b_senza"].isin(f48B_m2_senza_puliti)
|
|
],
|
|
)
|
|
f252B_m2_senza, u252B_m2_senza, _, _, _ = media_pesata(
|
|
f252B_m2_senza_puliti,
|
|
risultato252Bm2_senza["uf2b_senza"].loc[
|
|
risultato252Bm2_senza["f2b_senza"].isin(f252B_m2_senza_puliti)
|
|
],
|
|
)
|
|
|
|
plot_gauss([
|
|
(
|
|
risultati_finali.loc["48B - m1", "f [cm]"],
|
|
risultati_finali.loc["48B - m1", "u_corr [cm]"],
|
|
0,
|
|
"48B m1",
|
|
),
|
|
(
|
|
risultati_finali.loc["48B - m2", "f [cm]"],
|
|
risultati_finali.loc["48B - m2", "u_corr [cm]"],
|
|
1,
|
|
"48B m2",
|
|
),
|
|
(
|
|
risultati_finali.loc["48B - m3", "f [cm]"],
|
|
risultati_finali.loc["48B - m3", "u_corr [cm]"],
|
|
2,
|
|
"48B m3",
|
|
)
|
|
], cartella_immagini / "1.png", "Lente 48B - correzione angolare")
|
|
|
|
plot_gauss([
|
|
(
|
|
risultati_finali.loc["252B - m1", "f [cm]"],
|
|
risultati_finali.loc["252B - m1", "u_corr [cm]"],
|
|
3,
|
|
"252B m1",
|
|
),
|
|
(
|
|
risultati_finali.loc["252B - m2", "f [cm]"],
|
|
risultati_finali.loc["252B - m2", "u_corr [cm]"],
|
|
4,
|
|
"252B m2",
|
|
),
|
|
(
|
|
risultati_finali.loc["252B - m3", "f [cm]"],
|
|
risultati_finali.loc["252B - m3", "u_corr [cm]"],
|
|
5,
|
|
"252B m3",
|
|
),
|
|
], cartella_immagini / "2.png", "Lente 252B - correzione angolare")
|
|
|
|
plot_gauss([
|
|
(
|
|
risultati_finali.loc["48B - m1", "f [cm]"],
|
|
risultati_finali.loc["48B - m1", "u_corr [cm]"],
|
|
0,
|
|
"48B m1",
|
|
),
|
|
(f48B_m2_senza, u48B_m2_senza, 1, "48B m2 senza correzione"),
|
|
(
|
|
risultati_finali.loc["48B - m3", "f [cm]"],
|
|
risultati_finali.loc["48B - m3", "u_corr [cm]"],
|
|
2,
|
|
"48B m3",
|
|
),
|
|
], cartella_immagini / "3.png", "Lente 48B - senza correzione angolare")
|
|
|
|
plot_gauss([
|
|
(
|
|
risultati_finali.loc["252B - m1", "f [cm]"],
|
|
risultati_finali.loc["252B - m1", "u_corr [cm]"],
|
|
3,
|
|
"252B m1",
|
|
),
|
|
(f252B_m2_senza, u252B_m2_senza, 4, "252B m2 senza correzione"),
|
|
(
|
|
risultati_finali.loc["252B - m3", "f [cm]"],
|
|
risultati_finali.loc["252B - m3", "u_corr [cm]"],
|
|
5,
|
|
"252B m3",
|
|
),
|
|
], cartella_immagini / "4.png", "Lente 252B - senza correzione angolare")
|
|
return
|
|
|
|
|
|
@app.cell
|
|
def _(compat, pd, risultati_finali):
|
|
k_48B_m1_m2, diff_48B_m1_m2 = compat(
|
|
risultati_finali.loc["48B - m1", "f [cm]"],
|
|
risultati_finali.loc["48B - m2", "f [cm]"],
|
|
risultati_finali.loc["48B - m1", "u_corr [cm]"],
|
|
risultati_finali.loc["48B - m2", "u_corr [cm]"],
|
|
)
|
|
k_48B_m1_m3, diff_48B_m1_m3 = compat(
|
|
risultati_finali.loc["48B - m1", "f [cm]"],
|
|
risultati_finali.loc["48B - m3", "f [cm]"],
|
|
risultati_finali.loc["48B - m1", "u_corr [cm]"],
|
|
risultati_finali.loc["48B - m3", "u_corr [cm]"],
|
|
)
|
|
k_48B_m2_m3, diff_48B_m2_m3 = compat(
|
|
risultati_finali.loc["48B - m2", "f [cm]"],
|
|
risultati_finali.loc["48B - m3", "f [cm]"],
|
|
risultati_finali.loc["48B - m2", "u_corr [cm]"],
|
|
risultati_finali.loc["48B - m3", "u_corr [cm]"],
|
|
)
|
|
k_252B_m1_m2, diff_252B_m1_m2 = compat(
|
|
risultati_finali.loc["252B - m1", "f [cm]"],
|
|
risultati_finali.loc["252B - m2", "f [cm]"],
|
|
risultati_finali.loc["252B - m1", "u_corr [cm]"] ,
|
|
risultati_finali.loc["252B - m2", "u_corr [cm]"] ,
|
|
)
|
|
k_252B_m1_m3, diff_252B_m1_m3 = compat(
|
|
risultati_finali.loc["252B - m1", "f [cm]"],
|
|
risultati_finali.loc["252B - m3", "f [cm]"],
|
|
risultati_finali.loc["252B - m1", "u_corr [cm]"] ,
|
|
risultati_finali.loc["252B - m3", "u_corr [cm]"] ,
|
|
)
|
|
k_252B_m2_m3, diff_252B_m2_m3 = compat(
|
|
risultati_finali.loc["252B - m2", "f [cm]"],
|
|
risultati_finali.loc["252B - m3", "f [cm]"],
|
|
risultati_finali.loc["252B - m2", "u_corr [cm]"] ,
|
|
risultati_finali.loc["252B - m3", "u_corr [cm]"] ,
|
|
)
|
|
|
|
confronti_metodi = pd.DataFrame({
|
|
"48B m1 vs m2": [k_48B_m1_m2, diff_48B_m1_m2, k_48B_m1_m2 < 2],
|
|
"48B m1 vs m3": [k_48B_m1_m3, diff_48B_m1_m3, k_48B_m1_m3 < 2],
|
|
"48B m2 vs m3": [k_48B_m2_m3, diff_48B_m2_m3, k_48B_m2_m3 < 2],
|
|
"252B m1 vs m2": [k_252B_m1_m2, diff_252B_m1_m2, k_252B_m1_m2 < 2],
|
|
"252B m1 vs m3": [k_252B_m1_m3, diff_252B_m1_m3, k_252B_m1_m3 < 2],
|
|
"252B m2 vs m3": [k_252B_m2_m3, diff_252B_m2_m3, k_252B_m2_m3 < 2],
|
|
}, index=["k", "differenza [cm]", "compatibili (k < 2)"]).T
|
|
confronti_metodi
|
|
return
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(mo):
|
|
mo.md(r"""
|
|
# Parte interessante
|
|
Ora ragioniamo sul perché avvengono certi fenomeni.
|
|
Risulta facile comprendere che il metodo 2 è quello più _sballato_ perché?
|
|
|
|
Probabilmente abbiamo sofferto nel prendere h che subisce effetti di distorsione dovuti al fatto di avere lo schermo non fissato
|
|
una correzione di 15° è già sufficiente a sistemare il problema. Ovviamente oltre la correzione bisogna aggiungere degli errori su questa idea che sono $\sim$al valore stesso
|
|
|
|
Sicuramente ci sono altri errori strumentali non considerati correttamente in quanto i $\chi^2$ son completamente fuori scala
|
|
""")
|
|
return
|
|
|
|
|
|
if __name__ == "__main__":
|
|
app.run()
|