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()