def plot_uncertainty_zenith_angular_distance(group):
    group = group.E_1PeV
    rec = DirectionReconstruction

    N = 2

    # constants for uncertainty estimation
    # BEWARE: stations must be the same over all reconstruction tables used
    station = group.zenith_0.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    figure()
    graph = GraphArtist()
    # Uncertainty estimate
    x = linspace(0, deg2rad(45), 50)
    #x = array([pi / 8])
    phis = linspace(-pi, pi, 50)
    y, y2 = [], []
    for t in x:
        y.append(mean(rec.rel_phi_errorsq(t, phis, phi1, phi2, r1, r2)))
        y2.append(mean(rec.rel_theta1_errorsq(t, phis, phi1, phi2, r1, r2)))
    y = TIMING_ERROR * sqrt(array(y))
    y2 = TIMING_ERROR * sqrt(array(y2))
    ang_dist = sqrt((y * sin(x))**2 + y2**2)
    #plot(rad2deg(x), rad2deg(y), label="Estimate Phi")
    #plot(rad2deg(x), rad2deg(y2), label="Estimate Theta")
    plot(rad2deg(x), rad2deg(ang_dist), label="Angular distance")
    graph.plot(rad2deg(x), rad2deg(ang_dist), mark=None)
    print rad2deg(x)
    print rad2deg(y)
    print rad2deg(y2)
    print rad2deg(y * sin(x))
    print rad2deg(ang_dist)

    # Labels etc.
    xlabel("Shower zenith angle [deg]")
    ylabel("Angular distance [deg]")
    graph.set_xlabel(r"Shower zenith angle [\si{\degree}]")
    graph.set_ylabel(r"Angular distance [\si{\degree}]")
    graph.set_ylimits(min=6)
    #title(r"$N_{MIP} \geq %d$" % N)
    #ylim(0, 100)
    #legend(numpoints=1)
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
def plot_uncertainty_zenith_angular_distance(group):
    group = group.E_1PeV
    rec = DirectionReconstruction

    N = 2

    # constants for uncertainty estimation
    # BEWARE: stations must be the same over all reconstruction tables used
    station = group.zenith_0.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    figure()
    graph = GraphArtist()
    # Uncertainty estimate
    x = linspace(0, deg2rad(45), 50)
    #x = array([pi / 8])
    phis = linspace(-pi, pi, 50)
    y, y2 = [], []
    for t in x:
        y.append(mean(rec.rel_phi_errorsq(t, phis, phi1, phi2, r1, r2)))
        y2.append(mean(rec.rel_theta1_errorsq(t, phis, phi1, phi2, r1, r2)))
    y = TIMING_ERROR * sqrt(array(y))
    y2 = TIMING_ERROR * sqrt(array(y2))
    ang_dist = sqrt((y * sin(x)) ** 2 + y2 ** 2)
    #plot(rad2deg(x), rad2deg(y), label="Estimate Phi")
    #plot(rad2deg(x), rad2deg(y2), label="Estimate Theta")
    plot(rad2deg(x), rad2deg(ang_dist), label="Angular distance")
    graph.plot(rad2deg(x), rad2deg(ang_dist), mark=None)
    print rad2deg(x)
    print rad2deg(y)
    print rad2deg(y2)
    print rad2deg(y * sin(x))
    print rad2deg(ang_dist)

    # Labels etc.
    xlabel("Shower zenith angle [deg]")
    ylabel("Angular distance [deg]")
    graph.set_xlabel(r"Shower zenith angle [\si{\degree}]")
    graph.set_ylabel(r"Angular distance [\si{\degree}]")
    graph.set_ylimits(min=6)
    #title(r"$N_{MIP} \geq %d$" % N)
    #ylim(0, 100)
    #legend(numpoints=1)
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
    def plot_detection_efficiency(self):
        integrals, dens = self.get_integrals_and_densities()

        popt = self.full_fit_on_data(integrals,
                                     (1., 1., 5e3 / .32, 3.38 / 5000, 1.))

        x, y, yerr = [], [], []
        dens_bins = np.linspace(0, 10, 51)
        for low, high in zip(dens_bins[:-1], dens_bins[1:]):
            sel = integrals.compress((low <= dens) & (dens < high))
            x.append((low + high) / 2)
            frac = self.determine_charged_fraction(sel, popt)
            y.append(frac)
            yerr.append(np.sqrt(frac * len(sel)) / len(sel))
            print(low + high) / 2, len(sel)
            self.plot_full_spectrum_fit_in_density_range(sel, popt, low, high)
        print

        plt.figure()
        plt.errorbar(x, y, yerr, fmt='o', label='data', markersize=3.)

        popt, pcov = optimize.curve_fit(self.conv_p_detection, x, y, p0=(1., ))
        print "Sigma Gauss:", popt

        x2 = plt.linspace(0, 10, 101)
        plt.plot(x2, self.p_detection(x2), label='poisson')
        plt.plot(x2, self.conv_p_detection(x2, *popt), label='poisson/gauss')

        plt.xlabel("Charged particle density [$m^{-2}$]")
        plt.ylabel("Detection probability")
        plt.ylim(0, 1.)
        plt.legend(loc='best')
        utils.saveplot()

        graph = GraphArtist()
        graph.plot(x2, self.p_detection(x2), mark=None)
        graph.plot(x2,
                   self.conv_p_detection(x2, *popt),
                   mark=None,
                   linestyle='dashed')
        graph.plot(x, y, yerr=yerr, linestyle=None)
        graph.set_xlabel(r"Charged particle density [\si{\per\square\meter}]")
        graph.set_ylabel("Detection probability")
        graph.set_xlimits(min=0)
        graph.set_ylimits(min=0)
        artist.utils.save_graph(graph, dirname='plots')
    def plot_gamma_landau_fit(self):
        events = self.data.root.hisparc.cluster_kascade.station_601.events
        ph0 = events.col('integrals')[:, 0]

        bins = np.linspace(0, RANGE_MAX, N_BINS + 1)
        n, bins = np.histogram(ph0, bins=bins)
        x = (bins[:-1] + bins[1:]) / 2

        p_gamma, p_landau = self.full_spectrum_fit(
            x, n, (1., 1.), (5e3 / .32, 3.38 / 5000, 1.))
        print "FULL FIT"
        print p_gamma, p_landau

        n /= 10
        p_gamma, p_landau = self.constrained_full_spectrum_fit(
            x, n, p_gamma, p_landau)
        print "CONSTRAINED FIT"
        print p_gamma, p_landau

        plt.figure()
        print self.calc_charged_fraction(x, n, p_gamma, p_landau)

        plt.plot(x * VNS, n)
        self.plot_landau_and_gamma(x, p_gamma, p_landau)
        #plt.plot(x, n - self.gamma_func(x, *p_gamma))
        plt.xlabel("Pulse integral [V ns]")
        plt.ylabel("Count")
        plt.yscale('log')
        plt.xlim(0, 30)
        plt.ylim(1e1, 1e4)
        plt.legend()
        utils.saveplot()

        graph = GraphArtist('semilogy')
        graph.histogram(n, bins * VNS, linestyle='gray')
        self.artistplot_landau_and_gamma(graph, x, p_gamma, p_landau)
        graph.set_xlabel(r"Pulse integral [\si{\volt\nano\second}]")
        graph.set_ylabel("Count")
        graph.set_xlimits(0, 30)
        graph.set_ylimits(1e1, 1e4)
        artist.utils.save_graph(graph, dirname='plots')
Пример #5
0
def plot_arrival_times():
    graph = GraphArtist()

    figure()
    sim = data.root.showers.E_1PeV.zenith_22_5
    t = get_front_arrival_time(sim, 20, 5, pi / 8)
    n, bins = histogram(t, bins=linspace(0, 50, 201))
    mct = monte_carlo_timings(n, bins, 100000)
    n, bins, patches = hist(mct, bins=linspace(0, 20, 101), histtype='step')
    graph.histogram(n, bins, linestyle='black!50')

    mint = my_t_draw_something(data, 2, 100000)
    n, bins, patches = hist(mint, bins=linspace(0, 20, 101), histtype='step')
    graph.histogram(n, bins)

    xlabel("Arrival time [ns]")
    ylabel("Number of events")

    graph.set_xlabel(r"Arrival time [\si{\nano\second}]")
    graph.set_ylabel("Number of events")
    graph.set_xlimits(0, 20)
    graph.set_ylimits(min=0)
    graph.save('plots/SIM-T')

    print(median(t), median(mct), median(mint))
Пример #6
0
def plot_front_passage():
    sim = data.root.showers.E_1PeV.zenith_0.shower_0
    leptons = sim.leptons
    R = 40
    dR = 2
    low = R - dR
    high = R + dR
    global t
    t = leptons.read_where('(low < core_distance) & (core_distance <= high)',
                          field='arrival_time')

    n, bins, patches = hist(t, bins=linspace(0, 30, 31), histtype='step')

    graph = GraphArtist()
    graph.histogram(n, bins)
    graph.set_xlabel(r"Arrival time [\si{\nano\second}]")
    graph.set_ylabel("Number of leptons")
    graph.set_ylimits(min=0)
    graph.set_xlimits(0, 30)
    graph.save('plots/front-passage')
def plot_detection_efficiency_vs_R_for_angles(N):
    figure()
    graph = GraphArtist()
    locations = iter(['right', 'left', 'below left'])
    positions = iter([.18, .14, .15])

    bin_edges = linspace(0, 100, 20)
    x = (bin_edges[:-1] + bin_edges[1:]) / 2.

    for angle in [0, 22.5, 35]:
        angle_str = str(angle).replace('.', '_')
        shower_group = '/simulations/E_1PeV/zenith_%s' % angle_str

        efficiencies = []
        for low, high in zip(bin_edges[:-1], bin_edges[1:]):
            shower_results = []
            for shower in data.list_nodes(shower_group):
                sel_query = '(low <= r) & (r < high)'
                coinc_sel = shower.coincidences.read_where(sel_query)
                ids = coinc_sel['id']
                obs_sel = shower.observables.read_coordinates(ids)
                assert (obs_sel['id'] == ids).all()

                o = obs_sel
                sel = obs_sel.compress((o['n1'] >= N) & (o['n3'] >= N) &
                                       (o['n4'] >= N))
                shower_results.append(len(sel) / len(obs_sel))
            efficiencies.append(mean(shower_results))

        plot(x, efficiencies, label=r'$\theta = %s^\circ$' % angle)
        graph.plot(x, efficiencies, mark=None)
        graph.add_pin(r'\SI{%s}{\degree}' % angle,
                      location=locations.next(), use_arrow=True,
                      relative_position=positions.next())

    xlabel("Core distance [m]")
    graph.set_xlabel(r"Core distance [\si{\meter}]")
    ylabel("Detection efficiency")
    graph.set_ylabel("Detection efficiency")
    #title(r"$N_{MIP} \geq %d$" % N)
    legend()
    graph.set_xlimits(0, 100)
    graph.set_ylimits(0, 1)

    utils.saveplot(N)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
def plot_uncertainty_size(group):
    group = group.E_1PeV
    rec = DirectionReconstruction

    N = 2

    graph = GraphArtist()

    # constants for uncertainty estimation
    # BEWARE: stations must be the same shape(!) over all reconstruction tables used
    station = group.zenith_22_5.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)
    del r1, r2

    figure()
    x, y, y2 = [], [], []
    for size in [5, 10, 20]:
        x.append(size)
        if size != 10:
            table = group._f_getChild('zenith_22_5_size%d' % size)
        else:
            table = group._f_getChild('zenith_22_5')

        events = table.readWhere('min_n134 >= N')
        print size, len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)
    plot(x, rad2deg(y), '^', label="Theta")
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    plot(x, rad2deg(y2), 'v', label="Phi")
    graph.plot(x, rad2deg(y2), mark='*', linestyle=None)
    print
    print "stationsize: size, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print

    # Uncertainty estimate
    x = linspace(5, 20, 50)
    phis = linspace(-pi, pi, 50)
    y, y2 = [], []
    for s in x:
        y.append(
            mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1=s, r2=s)))
        y2.append(
            mean(rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1=s, r2=s)))
    y = TIMING_ERROR * sqrt(array(y))
    y2 = TIMING_ERROR * sqrt(array(y2))
    plot(x, rad2deg(y), label="Estimate Phi")
    graph.plot(x, rad2deg(y), mark=None)
    plot(x, rad2deg(y2), label="Estimate Theta")
    graph.plot(x, rad2deg(y2), mark=None)

    # Labels etc.
    xlabel("Station size [m]")
    graph.set_xlabel(r"Station size [\si{\meter}]")
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    graph.set_ylimits(0, 25)
    #title(r"$\theta = 22.5^\circ, N_{MIP} \geq %d$" % N)
    legend(numpoints=1)
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
def plot_detection_efficiency_vs_R_for_angles(N):
    figure()
    graph = GraphArtist()
    locations = iter(['right', 'left', 'below left'])
    positions = iter([.18, .14, .15])

    bin_edges = linspace(0, 100, 20)
    x = (bin_edges[:-1] + bin_edges[1:]) / 2.

    for angle in [0, 22.5, 35]:
        angle_str = str(angle).replace('.', '_')
        shower_group = '/simulations/E_1PeV/zenith_%s' % angle_str

        efficiencies = []
        for low, high in zip(bin_edges[:-1], bin_edges[1:]):
            shower_results = []
            for shower in data.listNodes(shower_group):
                sel_query = '(low <= r) & (r < high)'
                coinc_sel = shower.coincidences.readWhere(sel_query)
                ids = coinc_sel['id']
                obs_sel = shower.observables.readCoordinates(ids)
                assert (obs_sel['id'] == ids).all()

                o = obs_sel
                sel = obs_sel.compress((o['n1'] >= N) & (o['n3'] >= N)
                                       & (o['n4'] >= N))
                shower_results.append(len(sel) / len(obs_sel))
            efficiencies.append(mean(shower_results))

        plot(x, efficiencies, label=r'$\theta = %s^\circ$' % angle)
        graph.plot(x, efficiencies, mark=None)
        graph.add_pin(r'\SI{%s}{\degree}' % angle,
                      location=locations.next(),
                      use_arrow=True,
                      relative_position=positions.next())

    xlabel("Core distance [m]")
    graph.set_xlabel(r"Core distance [\si{\meter}]")
    ylabel("Detection efficiency")
    graph.set_ylabel("Detection efficiency")
    #title(r"$N_{MIP} \geq %d$" % N)
    legend()
    graph.set_xlimits(0, 100)
    graph.set_ylimits(0, 1)

    utils.saveplot(N)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
def boxplot_theta_reconstruction_results_for_MIP(group, N):
    group = group.E_1PeV

    figure()

    angles = [0, 5, 10, 15, 22.5, 30, 35, 45]
    r_dtheta = []
    d25, d50, d75 = [], [], []
    for angle in angles:
        table = group._f_get_child('zenith_%s' % str(angle).replace('.', '_'))
        sel = table.read_where('min_n134 >= %d' % N)
        dtheta = sel[:]['reconstructed_theta'] - sel[:]['reference_theta']
        r_dtheta.append(rad2deg(dtheta))

        d25.append(scoreatpercentile(rad2deg(dtheta), 25))
        d50.append(scoreatpercentile(rad2deg(dtheta), 50))
        d75.append(scoreatpercentile(rad2deg(dtheta), 75))

    fill_between(angles, d25, d75, color='0.75')
    plot(angles, d50, 'o-', color='black')

    xlabel(r"$\theta_{simulated}$ [deg]")
    ylabel(r"$\theta_{reconstructed} - \theta_{simulated}$ [deg]")
    #title(r"$N_{MIP} \geq %d$" % N)

    axhline(0, color='black')
    ylim(-10, 25)

    utils.saveplot(N)

    graph = GraphArtist()
    graph.draw_horizontal_line(0, linestyle='gray')
    graph.shade_region(angles, d25, d75)
    graph.plot(angles, d50, linestyle=None)
    graph.set_xlabel(r"$\theta_\mathrm{sim}$ [\si{\degree}]")
    graph.set_ylabel(r"$\theta_\mathrm{rec} - \theta_\mathrm{sim}$ [\si{\degree}]")
    graph.set_title(r"$N_\mathrm{MIP} \geq %d$" % N)
    graph.set_ylimits(-8, 22)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
def boxplot_arrival_times(group, N):
    table = group.E_1PeV.zenith_0

    sel = table.readWhere('min_n134 >= N')
    t1 = sel[:]['t1']
    t3 = sel[:]['t3']
    t4 = sel[:]['t4']
    ts = concatenate([t1, t3, t4])
    print "Median arrival time delay over all detected events", median(ts)

    figure()

    bin_edges = linspace(0, 100, 11)
    x, arrival_times = [], []
    t25, t50, t75 = [], [], []
    for low, high in zip(bin_edges[:-1], bin_edges[1:]):
        query = '(min_n134 >= N) & (low <= r) & (r < high)'
        sel = table.readWhere(query)
        t1 = sel[:]['t1']
        t2 = sel[:]['t2']
        ct1 = t1.compress((t1 > -999) & (t2 > -999))
        ct2 = t2.compress((t1 > -999) & (t2 > -999))
        ts = abs(ct2 - ct1)

        t25.append(scoreatpercentile(ts, 25))
        t50.append(scoreatpercentile(ts, 50))
        t75.append(scoreatpercentile(ts, 75))
        x.append((low + high) / 2)

    fill_between(x, t25, t75, color='0.75')
    plot(x, t50, 'o-', color='black')

    xlabel("Core distance [m]")
    ylabel("Arrival time delay [ns]")
    #title(r"$N_{MIP} \geq %d, \quad \theta = 0^\circ$" % N)

    xticks(arange(0, 100.5, 10))

    utils.savedata((x, t25, t50, t75), N)
    utils.saveplot(N)

    graph = GraphArtist()
    graph.shade_region(x, t25, t75)
    graph.plot(x, t50, linestyle=None)
    graph.set_xlabel(r"Core distance [\si{\meter}]")
    graph.set_ylabel(
        r"Arrival time difference $|t_2 - t_1|$ [\si{\nano\second}]")
    graph.set_xlimits(0, 100)
    graph.set_ylimits(min=0)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
def boxplot_core_distances_for_mips(group):
    table = group.E_1PeV.zenith_22_5

    figure()

    r_list = []
    r25, r50, r75 = [], [], []
    x = []
    for N in range(1, 5):
        sel = table.readWhere('min_n134 >= N')
        r = sel[:]['r']
        r_list.append(r)
        x.append(N)

        r25.append(scoreatpercentile(r, 25))
        r50.append(scoreatpercentile(r, 50))
        r75.append(scoreatpercentile(r, 75))

    fill_between(x, r25, r75, color='0.75')
    plot(x, r50, 'o-', color='black')

    xticks(range(1, 5))
    xlabel("Minimum number of particles")
    ylabel("Core distance [m]")
    #title(r"$\theta = 22.5^\circ$")

    utils.saveplot()

    graph = GraphArtist()
    graph.shade_region(x, r25, r75)
    graph.plot(x, r50, linestyle=None)
    graph.set_xlabel("Minimum number of particles")
    graph.set_ylabel(r"Core distance [\si{\meter}]")
    graph.set_ylimits(min=0)
    graph.set_xticks(range(5))
    artist.utils.save_graph(graph, dirname='plots')
def boxplot_phi_reconstruction_results_for_MIP(group, N):
    table = group.E_1PeV.zenith_22_5

    figure()

    bin_edges = linspace(-180, 180, 18)
    x, r_dphi = [], []
    d25, d50, d75 = [], [], []
    for low, high in zip(bin_edges[:-1], bin_edges[1:]):
        rad_low = deg2rad(low)
        rad_high = deg2rad(high)
        query = '(min_n134 >= N) & (rad_low < reference_phi) & (reference_phi < rad_high)'
        sel = table.readWhere(query)
        dphi = sel[:]['reconstructed_phi'] - sel[:]['reference_phi']
        dphi = (dphi + pi) % (2 * pi) - pi
        r_dphi.append(rad2deg(dphi))

        d25.append(scoreatpercentile(rad2deg(dphi), 25))
        d50.append(scoreatpercentile(rad2deg(dphi), 50))
        d75.append(scoreatpercentile(rad2deg(dphi), 75))
        x.append((low + high) / 2)

    fill_between(x, d25, d75, color='0.75')
    plot(x, d50, 'o-', color='black')

    xlabel(r"$\phi_{simulated}$ [deg]")
    ylabel(r"$\phi_{reconstructed} - \phi_{simulated}$ [deg]")
    #title(r"$N_{MIP} \geq %d, \quad \theta = 22.5^\circ$" % N)

    xticks(linspace(-180, 180, 9))
    axhline(0, color='black')
    ylim(-15, 15)

    utils.saveplot(N)

    graph = GraphArtist()
    graph.draw_horizontal_line(0, linestyle='gray')
    graph.shade_region(x, d25, d75)
    graph.plot(x, d50, linestyle=None)
    graph.set_xlabel(r"$\phi_\mathrm{sim}$ [\si{\degree}]")
    graph.set_ylabel(r"$\phi_\mathrm{rec} - \phi_\mathrm{sim}$ [\si{\degree}]")
    graph.set_title(r"$N_\mathrm{MIP} \geq %d$" % N)
    graph.set_xticks([-180, -90, '...', 180])
    graph.set_xlimits(-180, 180)
    graph.set_ylimits(-17, 17)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
def boxplot_theta_reconstruction_results_for_MIP(group, N):
    group = group.E_1PeV

    figure()

    angles = [0, 5, 10, 15, 22.5, 30, 35, 45]
    r_dtheta = []
    d25, d50, d75 = [], [], []
    for angle in angles:
        table = group._f_getChild('zenith_%s' % str(angle).replace('.', '_'))
        sel = table.readWhere('min_n134 >= %d' % N)
        dtheta = sel[:]['reconstructed_theta'] - sel[:]['reference_theta']
        r_dtheta.append(rad2deg(dtheta))

        d25.append(scoreatpercentile(rad2deg(dtheta), 25))
        d50.append(scoreatpercentile(rad2deg(dtheta), 50))
        d75.append(scoreatpercentile(rad2deg(dtheta), 75))

    fill_between(angles, d25, d75, color='0.75')
    plot(angles, d50, 'o-', color='black')

    xlabel(r"$\theta_{simulated}$ [deg]")
    ylabel(r"$\theta_{reconstructed} - \theta_{simulated}$ [deg]")
    #title(r"$N_{MIP} \geq %d$" % N)

    axhline(0, color='black')
    ylim(-10, 25)

    utils.saveplot(N)

    graph = GraphArtist()
    graph.draw_horizontal_line(0, linestyle='gray')
    graph.shade_region(angles, d25, d75)
    graph.plot(angles, d50, linestyle=None)
    graph.set_xlabel(r"$\theta_\mathrm{sim}$ [\si{\degree}]")
    graph.set_ylabel(
        r"$\theta_\mathrm{rec} - \theta_\mathrm{sim}$ [\si{\degree}]")
    graph.set_title(r"$N_\mathrm{MIP} \geq %d$" % N)
    graph.set_ylimits(-8, 22)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
def plot_uncertainty_binsize(group):
    group = group.E_1PeV
    rec = DirectionReconstruction

    N = 2

    graph = GraphArtist()

    # constants for uncertainty estimation
    # BEWARE: stations must be the same over all reconstruction tables used
    station = group.zenith_22_5.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    figure()
    x, y, y2 = [], [], []
    for bin_size in [0, 1, 2.5, 5]:
        x.append(bin_size)
        if bin_size != 0:
            table = group._f_getChild('zenith_22_5_binned_randomized_%s' %
                                      str(bin_size).replace('.', '_'))
        else:
            table = group.zenith_22_5
        events = table.readWhere('min_n134 >= 2')

        print bin_size, len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)
    plot(x, rad2deg(y), '^', label="Theta")
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    plot(x, rad2deg(y2), 'v', label="Phi")
    graph.plot(x, rad2deg(y2), mark='*', linestyle=None)
    print
    print "binsize: size, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print

    # Uncertainty estimate
    x = linspace(0, 5, 50)
    phis = linspace(-pi, pi, 50)
    y, y2 = [], []
    phi_errorsq = mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    theta_errorsq = mean(
        rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    for t in x:
        y.append(sqrt((TIMING_ERROR**2 + t**2 / 12) * phi_errorsq))
        y2.append(sqrt((TIMING_ERROR**2 + t**2 / 12) * theta_errorsq))
    y = array(y)
    y2 = array(y2)
    plot(x, rad2deg(y), label="Estimate Phi")
    graph.plot(x, rad2deg(y), mark=None)
    plot(x, rad2deg(y2), label="Estimate Theta")
    graph.plot(x, rad2deg(y2), mark=None)

    # Labels etc.
    xlabel("Sampling time [ns]")
    graph.set_xlabel(r"Sampling time [\si{\nano\second}]")
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    graph.set_ylimits(0, 20)
    #title(r"$\theta = 22.5^\circ, N_{MIP} \geq %d$" % N)
    legend(loc='upper left', numpoints=1)
    ylim(0, 20)
    xlim(-0.1, 5.5)
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
def plot_uncertainty_mip(group):
    table = group.E_1PeV.zenith_22_5
    rec = DirectionReconstruction

    # constants for uncertainty estimation
    station = table.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    R_list = get_median_core_distances_for_mips(group, range(1, 6))

    figure()
    x, y, y2 = [], [], []
    for N in range(1, 5):
        x.append(N)
        events = table.read_where('min_n134>=%d' % N)
        #query = '(n1 == N) & (n3 == N) & (n4 == N)'
        #vents = table.read_where(query)
        print len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)
        print "YYY", rad2deg(scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17))

    plot(x, rad2deg(y), '^', label="Theta")
    plot(x, rad2deg(y2), 'v', label="Phi")
    Sx = x
    Sy = y
    Sy2 = y2
    print
    print "mip: min_n134, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print
    utils.savedata((x, y, y2))

    # Uncertainty estimate
    x = [1, 2, 3, 4, 5]
    phis = linspace(-pi, pi, 50)
    phi_errsq = mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    theta_errsq = mean(rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    y = TIMING_ERROR * std_t(x) * sqrt(phi_errsq)
    y2 = TIMING_ERROR * std_t(x) * sqrt(theta_errsq)

    mc = my_std_t_for_R(data, x, R_list)
    for u, v in zip(mc, R_list):
        print v, u, sqrt(u ** 2 + 1.2 ** 2), sqrt((.66 * u) ** 2 + 1.2 ** 2)
    mc = sqrt(mc ** 2 + 1.2 ** 2)
    y3 = mc * sqrt(phi_errsq)
    y4 = mc * sqrt(theta_errsq)

    nx = linspace(1, 4, 100)
    y = spline(x, y, nx)
    y2 = spline(x, y2, nx)
    y3 = spline(x, y3, nx)
    y4 = spline(x, y4, nx)

    plot(nx, rad2deg(y), label="Gauss Phi")
    plot(nx, rad2deg(y2), label="Gauss Theta")
    plot(nx, rad2deg(y3), label="Monte Carlo Phi")
    plot(nx, rad2deg(y4), label="Monte Carlo Theta")
    # Labels etc.
    xlabel("Minimum number of particles")
    ylabel("Angle reconstruction uncertainty [deg]")
    #title(r"$\theta = 22.5^\circ$")
    legend(numpoints=1)
    xlim(.5, 4.5)
    utils.saveplot()
    print

    graph = GraphArtist()
    graph.plot(Sx, rad2deg(Sy), mark='o', linestyle='only marks')
    graph.plot(Sx, rad2deg(Sy2), mark='*', linestyle='only marks')
    graph.plot(nx, rad2deg(y), mark=None, linestyle='dashed,smooth')
    graph.plot(nx, rad2deg(y2), mark=None, linestyle='dashed,smooth')
    graph.set_xlabel("Minimum number of particles")
    graph.set_ylabel(r"Reconstruction uncertainty [\si{\degree}]")
    graph.set_xticks(range(1, 5))
    graph.set_ylimits(0, 32)
    artist.utils.save_graph(graph, dirname='plots')
    graph.plot(nx, rad2deg(y3), mark=None, linestyle='smooth')
    graph.plot(nx, rad2deg(y4), mark=None, linestyle='smooth')
    artist.utils.save_graph(graph, suffix='full', dirname='plots')
def artistplot_reconstruction_efficiency_vs_R_for_angles(N):
    filename = 'DIR-plot_reconstruction_efficiency_vs_R_for_angles-%d.txt' % N
    all_data = loadtxt(os.path.join('plots/', filename))

    graph = GraphArtist()
    locations = iter(['above right', 'below left', 'below left'])
    positions = iter([.9, .2, .2])

    x = all_data[:, 0]

    for angle, efficiencies in zip([0, 22.5, 35], all_data[:, 1:].T):
        graph.plot(x, efficiencies, mark=None)
        graph.add_pin(r'\SI{%s}{\degree}' % angle,
                      use_arrow=True,
                      location=locations.next(),
                      relative_position=positions.next())

    graph.set_xlabel("Core distance [\si{\meter}]")
    graph.set_ylabel("Reconstruction efficiency")
    graph.set_xlimits(0, 100)
    graph.set_ylimits(max=1)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
def plot_uncertainty_size(group):
    group = group.E_1PeV
    rec = DirectionReconstruction

    N = 2

    graph = GraphArtist()

    # constants for uncertainty estimation
    # BEWARE: stations must be the same shape(!) over all reconstruction tables used
    station = group.zenith_22_5.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)
    del r1, r2

    figure()
    x, y, y2 = [], [], []
    for size in [5, 10, 20]:
        x.append(size)
        if size != 10:
            table = group._f_get_child('zenith_22_5_size%d' % size)
        else:
            table = group._f_get_child('zenith_22_5')

        events = table.read_where('min_n134 >= N')
        print size, len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)
    plot(x, rad2deg(y), '^', label="Theta")
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    plot(x, rad2deg(y2), 'v', label="Phi")
    graph.plot(x, rad2deg(y2), mark='*', linestyle=None)
    print
    print "stationsize: size, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print

    # Uncertainty estimate
    x = linspace(5, 20, 50)
    phis = linspace(-pi, pi, 50)
    y, y2 = [], []
    for s in x:
        y.append(mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1=s, r2=s)))
        y2.append(mean(rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1=s, r2=s)))
    y = TIMING_ERROR * sqrt(array(y))
    y2 = TIMING_ERROR * sqrt(array(y2))
    plot(x, rad2deg(y), label="Estimate Phi")
    graph.plot(x, rad2deg(y), mark=None)
    plot(x, rad2deg(y2), label="Estimate Theta")
    graph.plot(x, rad2deg(y2), mark=None)

    # Labels etc.
    xlabel("Station size [m]")
    graph.set_xlabel(r"Station size [\si{\meter}]")
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    graph.set_ylimits(0, 25)
    #title(r"$\theta = 22.5^\circ, N_{MIP} \geq %d$" % N)
    legend(numpoints=1)
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
Пример #19
0
def plot_uncertainty_core_distance(table):
    N = 2
    THETA = deg2rad(22.5)
    DTHETA = deg2rad(5.)
    DN = .5
    DR = 10
    LOGENERGY = 15
    DLOGENERGY = .5

    figure()
    x, y, y2 = [], [], []
    for R in range(0, 81, 20):
        x.append(R)
        events = table.read_where('(abs(min_n134 - N) <= DN) & (abs(reference_theta - THETA) <= DTHETA) & (abs(r - R) <= DR) & (abs(log10(k_energy) - LOGENERGY) <= DLOGENERGY)')
        print(len(events),)
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)

    print()
    print("R: theta_std, phi_std")
    for u, v, w in zip(x, y, y2):
        print(u, v, w)
    print()

#    # Simulation data
    sx, sy, sy2 = loadtxt(os.path.join(DATADIR, 'DIR-plot_uncertainty_core_distance.txt'))

    graph = GraphArtist()

    # Plots
    plot(x, rad2deg(y), '^-', label="Theta")
    graph.plot(x[:-1], rad2deg(y[:-1]), mark='o')
    plot(sx, rad2deg(sy), '^-', label="Theta (sim)")
    graph.plot(sx[:-1], rad2deg(sy[:-1]), mark='square')
    plot(x, rad2deg(y2), 'v-', label="Phi")
    graph.plot(x[:-1], rad2deg(y2[:-1]), mark='*')
    plot(sx, rad2deg(sy2), 'v-', label="Phi (sim)")
    graph.plot(sx[:-1], rad2deg(sy2[:-1]), mark='square*')

    # Labels etc.
    xlabel("Core distance [m] $\pm %d$" % DR)
    graph.set_xlabel(r"Core distance [\si{\meter}] $\pm \SI{%d}{\meter}$" % DR)
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    title(r"$N_{MIP} = %d \pm %.1f, \theta = 22.5^\circ \pm %d^\circ, %.1f \leq \log(E) \leq %.1f$" % (N, DN, rad2deg(DTHETA), LOGENERGY - DLOGENERGY, LOGENERGY + DLOGENERGY))
    ylim(ymin=0)
    graph.set_ylimits(min=0)
    xlim(-2, 62)
    legend(numpoints=1, loc='best')
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
def boxplot_arrival_times(group, N):
    table = group.E_1PeV.zenith_0

    sel = table.read_where('min_n134 >= N')
    t1 = sel[:]['t1']
    t3 = sel[:]['t3']
    t4 = sel[:]['t4']
    ts = concatenate([t1, t3, t4])
    print "Median arrival time delay over all detected events", median(ts)

    figure()

    bin_edges = linspace(0, 100, 11)
    x, arrival_times = [], []
    t25, t50, t75 = [], [], []
    for low, high in zip(bin_edges[:-1], bin_edges[1:]):
        query = '(min_n134 >= N) & (low <= r) & (r < high)'
        sel = table.read_where(query)
        t1 = sel[:]['t1']
        t2 = sel[:]['t2']
        ct1 = t1.compress((t1 > -999) & (t2 > -999))
        ct2 = t2.compress((t1 > -999) & (t2 > -999))
        ts = abs(ct2 - ct1)

        t25.append(scoreatpercentile(ts, 25))
        t50.append(scoreatpercentile(ts, 50))
        t75.append(scoreatpercentile(ts, 75))
        x.append((low + high) / 2)

    fill_between(x, t25, t75, color='0.75')
    plot(x, t50, 'o-', color='black')

    xlabel("Core distance [m]")
    ylabel("Arrival time delay [ns]")
    #title(r"$N_{MIP} \geq %d, \quad \theta = 0^\circ$" % N)

    xticks(arange(0, 100.5, 10))

    utils.savedata((x, t25, t50, t75), N)
    utils.saveplot(N)

    graph = GraphArtist()
    graph.shade_region(x, t25, t75)
    graph.plot(x, t50, linestyle=None)
    graph.set_xlabel(r"Core distance [\si{\meter}]")
    graph.set_ylabel(r"Arrival time difference $|t_2 - t_1|$ [\si{\nano\second}]")
    graph.set_xlimits(0, 100)
    graph.set_ylimits(min=0)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
Пример #21
0
def plot_uncertainty_mip(table):
    rec = DirectionReconstruction

    # constants for uncertainty estimation
    station = table.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    THETA = deg2rad(22.5)
    DTHETA = deg2rad(5.)
    DN = .1
    LOGENERGY = 15
    DLOGENERGY = .5

    figure()
    x, y, y2 = [], [], []
    for N in range(1, 6):
        x.append(N)
        events = table.read_where('(abs(min_n134 - N) <= DN) & (abs(reference_theta - THETA) <= DTHETA) & (abs(log10(k_energy) - LOGENERGY) <= DLOGENERGY)')
        print(len(events),)
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)

    print()
    print("mip: min_n134, theta_std, phi_std")
    for u, v, w in zip(x, y, y2):
        print(u, v, w)
    print()

    # Simulation data
    sx, sy, sy2 = loadtxt(os.path.join(DATADIR, 'DIR-plot_uncertainty_mip.txt'))

    # Uncertainty estimate
    ex = linspace(1, 5, 50)
    phis = linspace(-pi, pi, 50)
    phi_errsq = mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    theta_errsq = mean(rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    #ey = TIMING_ERROR * std_t(ex) * sqrt(phi_errsq)
    #ey2 = TIMING_ERROR * std_t(ex) * sqrt(theta_errsq)

    R_list = [30, 20, 16, 14, 12]
    with tables.open_file('master-ch4v2.h5') as data2:
        mc = my_std_t_for_R(data2, x, R_list)
    mc = sqrt(mc ** 2 + 1.2 ** 2 + 2.5 ** 2)
    print(mc)
    ey = mc * sqrt(phi_errsq)
    ey2 = mc * sqrt(theta_errsq)

    nx = linspace(1, 4, 100)
    ey = spline(x, ey, nx)
    ey2 = spline(x, ey2, nx)

    # Plots
    plot(x, rad2deg(y), '^', label="Theta")
    plot(sx, rad2deg(sy), '^', label="Theta (sim)")
    plot(nx, rad2deg(ey2))#, label="Estimate Theta")
    plot(x, rad2deg(y2), 'v', label="Phi")
    plot(sx, rad2deg(sy2), 'v', label="Phi (sim)")
    plot(nx, rad2deg(ey))#, label="Estimate Phi")

    # Labels etc.
    xlabel("$N_{MIP} \pm %.1f$" % DN)
    ylabel("Angle reconstruction uncertainty [deg]")
    title(r"$\theta = 22.5^\circ \pm %d^\circ \quad %.1f \leq \log(E) \leq %.1f$" % (rad2deg(DTHETA), LOGENERGY - DLOGENERGY, LOGENERGY + DLOGENERGY))
    legend(numpoints=1)
    xlim(0.5, 4.5)
    utils.saveplot()
    print

    graph = GraphArtist()
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    graph.plot(sx, rad2deg(sy), mark='square', linestyle=None)
    graph.plot(nx, rad2deg(ey2), mark=None)
    graph.plot(x, rad2deg(y2), mark='*', linestyle=None)
    graph.plot(sx, rad2deg(sy2), mark='square*', linestyle=None)
    graph.plot(nx, rad2deg(ey), mark=None)
    graph.set_xlabel(r"$N_\mathrm{MIP} \pm %.1f$" % DN)
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    graph.set_xlimits(max=4.5)
    graph.set_ylimits(0, 40)
    graph.set_xticks(range(5))
    artist.utils.save_graph(graph, dirname='plots')
Пример #22
0
def plot_front_passage():
    sim = data.root.showers.E_1PeV.zenith_0.shower_0
    leptons = sim.leptons
    R = 40
    dR = 2
    low = R - dR
    high = R + dR
    global t
    t = leptons.read_where('(low < core_distance) & (core_distance <= high)',
                          field='arrival_time')

    n, bins, patches = hist(t, bins=linspace(0, 30, 31), histtype='step')

    graph = GraphArtist()
    graph.histogram(n, bins)
    graph.set_xlabel(r"Arrival time [\si{\nano\second}]")
    graph.set_ylabel("Number of leptons")
    graph.set_ylimits(min=0)
    graph.set_xlimits(0, 30)
    graph.save('plots/front-passage')
def plot_uncertainty_zenith(group):
    group = group.E_1PeV
    rec = DirectionReconstruction

    N = 2

    graph = GraphArtist()

    # constants for uncertainty estimation
    # BEWARE: stations must be the same over all reconstruction tables used
    station = group.zenith_0.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    figure()
    x, y, y2 = [], [], []
    for THETA in 0, 5, 10, 15, 22.5, 30, 35, 45:
        x.append(THETA)
        table = group._f_getChild('zenith_%s' % str(THETA).replace('.', '_'))
        events = table.readWhere('min_n134 >= N')
        print THETA, len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)
    plot(x, rad2deg(y), '^', label="Theta")
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    # Azimuthal angle undefined for zenith = 0
    plot(x[1:], rad2deg(y2[1:]), 'v', label="Phi")
    graph.plot(x[1:], rad2deg(y2[1:]), mark='*', linestyle=None)
    print
    print "zenith: theta, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print
    utils.savedata((x, y, y2))

    # Uncertainty estimate
    x = linspace(0, deg2rad(45), 50)
    phis = linspace(-pi, pi, 50)
    y, y2 = [], []
    for t in x:
        y.append(mean(rec.rel_phi_errorsq(t, phis, phi1, phi2, r1, r2)))
        y2.append(mean(rec.rel_theta1_errorsq(t, phis, phi1, phi2, r1, r2)))
    y = TIMING_ERROR * sqrt(array(y))
    y2 = TIMING_ERROR * sqrt(array(y2))
    plot(rad2deg(x), rad2deg(y), label="Estimate Phi")
    graph.plot(rad2deg(x), rad2deg(y), mark=None)
    plot(rad2deg(x), rad2deg(y2), label="Estimate Theta")
    graph.plot(rad2deg(x), rad2deg(y2), mark=None)

    # Labels etc.
    xlabel("Shower zenith angle [deg]")
    graph.set_xlabel(r"Shower zenith angle [\si{\degree}]")
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    #title(r"$N_{MIP} \geq %d$" % N)
    ylim(0, 100)
    graph.set_ylimits(0, 60)
    legend(numpoints=1)
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
Пример #24
0
def boxplot_phi_reconstruction_results_for_MIP(table, N):
    figure()

    THETA = deg2rad(22.5)
    DTHETA = deg2rad(5.)

    bin_edges = linspace(-180, 180, 18)
    x, r_dphi = [], []
    d25, d50, d75 = [], [], []
    for low, high in zip(bin_edges[:-1], bin_edges[1:]):
        rad_low = deg2rad(low)
        rad_high = deg2rad(high)
        query = '(min_n134 >= N) & (rad_low < reference_phi) & (reference_phi < rad_high) & (abs(reference_theta - THETA) <= DTHETA)'
        sel = table.read_where(query)
        dphi = sel[:]['reconstructed_phi'] - sel[:]['reference_phi']
        dphi = (dphi + pi) % (2 * pi) - pi
        r_dphi.append(rad2deg(dphi))

        d25.append(scoreatpercentile(rad2deg(dphi), 25))
        d50.append(scoreatpercentile(rad2deg(dphi), 50))
        d75.append(scoreatpercentile(rad2deg(dphi), 75))
        x.append((low + high) / 2)

    #boxplot(r_dphi, positions=x, widths=1 * (high - low), sym='')
    fill_between(x, d25, d75, color='0.75')
    plot(x, d50, 'o-', color='black')

    xlabel(r"$\phi_K$ [deg]")
    ylabel(r"$\phi_H - \phi_K$ [deg]")
    title(r"$N_{MIP} \geq %d, \quad \theta = 22.5^\circ \pm %d^\circ$" % (N, rad2deg(DTHETA)))

    xticks(linspace(-180, 180, 9))
    axhline(0, color='black')

    utils.saveplot(N)

    graph = GraphArtist()
    graph.draw_horizontal_line(0, linestyle='gray')
    graph.shade_region(x, d25, d75)
    graph.plot(x, d50, linestyle=None)
    graph.set_xlabel(r"$\phi_K$ [\si{\degree}]")
    graph.set_ylabel(r"$\phi_H - \phi_K$ [\si{\degree}]")
    graph.set_xticks([-180, -90, '...', 180])
    graph.set_xlimits(-180, 180)
    graph.set_ylimits(-23, 23)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
Пример #25
0
def boxplot_core_distance_vs_time():
    plt.figure()

    sim = data.root.showers.E_1PeV.zenith_0.shower_0
    leptons = sim.leptons

    #bins = np.logspace(0, 2, 25)
    bins = np.linspace(0, 100, 15)
    x, arrival_time, widths = [], [], []
    t25, t50, t75 = [], [], []
    for low, high in zip(bins[:-1], bins[1:]):
        sel = leptons.read_where('(low < core_distance) & (core_distance <= high)')
        x.append(np.mean([low, high]))
        arrival_time.append(sel[:]['arrival_time'])
        widths.append((high - low) / 2)
        ts = sel[:]['arrival_time']
        t25.append(scoreatpercentile(ts, 25))
        t50.append(scoreatpercentile(ts, 50))
        t75.append(scoreatpercentile(ts, 75))

    fill_between(x, t25, t75, color='0.75')
    plot(x, t50, 'o-', color='black')

    plt.xlabel("Core distance [m]")
    plt.ylabel("Arrival time [ns]")

    #utils.title("Shower front timing structure")
    utils.saveplot()

    graph = GraphArtist()
    graph.plot(x, t50, linestyle=None)
    graph.shade_region(x, t25, t75)
    graph.set_xlabel(r"Core distance [\si{\meter}]")
    graph.set_ylabel(r"Arrival time [\si{\nano\second}]")
    graph.set_ylimits(0, 30)
    graph.set_xlimits(0, 100)
    graph.save('plots/front-passage-vs-R')
def plot_uncertainty_mip(group):
    table = group.E_1PeV.zenith_22_5
    rec = DirectionReconstruction

    # constants for uncertainty estimation
    station = table.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    R_list = get_median_core_distances_for_mips(group, range(1, 6))

    figure()
    x, y, y2 = [], [], []
    for N in range(1, 5):
        x.append(N)
        events = table.readWhere('min_n134>=%d' % N)
        #query = '(n1 == N) & (n3 == N) & (n4 == N)'
        #vents = table.readWhere(query)
        print len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)
        print "YYY", rad2deg(
            scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17))

    plot(x, rad2deg(y), '^', label="Theta")
    plot(x, rad2deg(y2), 'v', label="Phi")
    Sx = x
    Sy = y
    Sy2 = y2
    print
    print "mip: min_n134, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print
    utils.savedata((x, y, y2))

    # Uncertainty estimate
    x = [1, 2, 3, 4, 5]
    phis = linspace(-pi, pi, 50)
    phi_errsq = mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    theta_errsq = mean(rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1,
                                              r2))
    y = TIMING_ERROR * std_t(x) * sqrt(phi_errsq)
    y2 = TIMING_ERROR * std_t(x) * sqrt(theta_errsq)

    mc = my_std_t_for_R(data, x, R_list)
    for u, v in zip(mc, R_list):
        print v, u, sqrt(u**2 + 1.2**2), sqrt((.66 * u)**2 + 1.2**2)
    mc = sqrt(mc**2 + 1.2**2)
    y3 = mc * sqrt(phi_errsq)
    y4 = mc * sqrt(theta_errsq)

    nx = linspace(1, 4, 100)
    y = spline(x, y, nx)
    y2 = spline(x, y2, nx)
    y3 = spline(x, y3, nx)
    y4 = spline(x, y4, nx)

    plot(nx, rad2deg(y), label="Gauss Phi")
    plot(nx, rad2deg(y2), label="Gauss Theta")
    plot(nx, rad2deg(y3), label="Monte Carlo Phi")
    plot(nx, rad2deg(y4), label="Monte Carlo Theta")
    # Labels etc.
    xlabel("Minimum number of particles")
    ylabel("Angle reconstruction uncertainty [deg]")
    #title(r"$\theta = 22.5^\circ$")
    legend(numpoints=1)
    xlim(.5, 4.5)
    utils.saveplot()
    print

    graph = GraphArtist()
    graph.plot(Sx, rad2deg(Sy), mark='o', linestyle='only marks')
    graph.plot(Sx, rad2deg(Sy2), mark='*', linestyle='only marks')
    graph.plot(nx, rad2deg(y), mark=None, linestyle='dashed,smooth')
    graph.plot(nx, rad2deg(y2), mark=None, linestyle='dashed,smooth')
    graph.set_xlabel("Minimum number of particles")
    graph.set_ylabel(r"Reconstruction uncertainty [\si{\degree}]")
    graph.set_xticks(range(1, 5))
    graph.set_ylimits(0, 32)
    artist.utils.save_graph(graph, dirname='plots')
    graph.plot(nx, rad2deg(y3), mark=None, linestyle='smooth')
    graph.plot(nx, rad2deg(y4), mark=None, linestyle='smooth')
    artist.utils.save_graph(graph, suffix='full', dirname='plots')
Пример #27
0
def plot_pulseheight_histogram(data):
    events = data.root.hisparc.cluster_kascade.station_601.events
    ph = events.col('pulseheights')

    s = landau.Scintillator()
    mev_scale = 3.38 / 340
    count_scale = 6e3 / .32

    clf()
    n, bins, patches = hist(ph[:, 0],
                            bins=arange(0, 1501, 10),
                            histtype='step')
    x = linspace(0, 1500, 1500)
    plot(x, s.conv_landau_for_x(x,
                                mev_scale=mev_scale,
                                count_scale=count_scale))
    plot(x, count_scale * s.landau_pdf(x * mev_scale))
    ylim(ymax=25000)
    xlim(xmax=1500)

    # Remove one statistical fluctuation from data.  It is not important
    # for the graph, but it detracts from the main message
    index = bins.searchsorted(370)
    n[index] = mean([n[index - 1], n[index + 1]])

    graph = GraphArtist()
    n_trunc = where(n <= 100000, n, 100000)
    graph.histogram(n_trunc, bins, linestyle='gray')
    graph.add_pin('data', x=800, location='above right', use_arrow=True)
    graph.add_pin('$\gamma$', x=90, location='above right', use_arrow=True)
    graph.plot(x,
               s.conv_landau_for_x(x,
                                   mev_scale=mev_scale,
                                   count_scale=count_scale),
               mark=None)
    graph.add_pin('convolved Landau',
                  x=450,
                  location='above right',
                  use_arrow=True)
    graph.plot(x,
               count_scale * s.landau_pdf(x * mev_scale),
               mark=None,
               linestyle='black')
    graph.add_pin('Landau', x=380, location='above right', use_arrow=True)

    graph.set_xlabel(r"Pulseheight [\adc{}]")
    graph.set_ylabel(r"Number of events")
    graph.set_xlimits(0, 1400)
    graph.set_ylimits(0, 21000)
    graph.save("plots/plot_pulseheight_histogram")
Пример #28
0
def plot_trace(station_group, idx):
    events = station_group.events
    blobs = station_group.blobs

    traces_idx = events[idx]['traces']
    traces = get_traces(blobs, traces_idx)
    traces = array(traces)
    x = arange(traces.shape[1])
    x *= 2.5

    clf()
    plot(x, traces.T)
    xlim(0, 200)

    #line_styles = ['solid', 'dashed', 'dotted', 'dashdotted']
    line_styles = ['black', 'black!80', 'black!60', 'black!40']
    styles = (u for u in line_styles)

    graph = GraphArtist(width=r'.5\linewidth')
    for trace in traces:
        graph.plot(x, trace / 1000, mark=None, linestyle=styles.next())
    graph.set_xlabel(r"Time [\si{\nano\second}]")
    graph.set_ylabel(r"Signal [\si{\volt}]")
    graph.set_xlimits(0, 200)
    graph.save('plots/traces')
Пример #29
0
def plot_uncertainty_zenith(table):
    rec = DirectionReconstruction

    # constants for uncertainty estimation
    station = table.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    N = 2
    DTHETA = deg2rad(1.)
    DN = .1
    LOGENERGY = 15
    DLOGENERGY = .5

    figure()
    rcParams['text.usetex'] = False
    x, y, y2 = [], [], []
    for theta in 5, 10, 15, 22.5, 30, 35:
        x.append(theta)
        THETA = deg2rad(theta)
        events = table.readWhere(
            '(min_n134 >= N) & (abs(reference_theta - THETA) <= DTHETA) & (abs(log10(k_energy) - LOGENERGY) <= DLOGENERGY)'
        )
        print theta, len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)
    print
    print "zenith: theta, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print

    # Simulation data
    sx, sy, sy2 = loadtxt(
        os.path.join(DATADIR, 'DIR-plot_uncertainty_zenith.txt'))

    # Uncertainty estimate
    ex = linspace(0, deg2rad(35), 50)
    phis = linspace(-pi, pi, 50)
    ey, ey2, ey3 = [], [], []
    for t in ex:
        ey.append(mean(rec.rel_phi_errorsq(t, phis, phi1, phi2, r1, r2)))
        ey3.append(
            mean(rec.rel_phi_errorsq(t, phis, phi1, phi2, r1, r2)) * sin(t)**2)
        ey2.append(mean(rec.rel_theta1_errorsq(t, phis, phi1, phi2, r1, r2)))
    ey = TIMING_ERROR * sqrt(array(ey))
    ey3 = TIMING_ERROR * sqrt(array(ey3))
    ey2 = TIMING_ERROR * sqrt(array(ey2))

    graph = GraphArtist()

    # Plots
    plot(x, rad2deg(y), '^', label="Theta")
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    #plot(sx, rad2deg(sy), '^', label="Theta (sim)")
    plot(rad2deg(ex), rad2deg(ey2))  #, label="Estimate Theta")
    graph.plot(rad2deg(ex), rad2deg(ey2), mark=None)
    # Azimuthal angle undefined for zenith = 0
    plot(x[1:], rad2deg(y2[1:]), 'v', label="Phi")
    graph.plot(x[1:], rad2deg(y2[1:]), mark='*', linestyle=None)
    #plot(sx[1:], rad2deg(sy2[1:]), 'v', label="Phi (sim)")
    plot(rad2deg(ex), rad2deg(ey))  #, label="Estimate Phi")
    graph.plot(rad2deg(ex), rad2deg(ey), mark=None)
    #plot(rad2deg(ex), rad2deg(ey3), label="Estimate Phi * sin(Theta)")

    # Labels etc.
    xlabel(r"Shower zenith angle [deg $\pm %d^\circ$]" % rad2deg(DTHETA))
    graph.set_xlabel(
        r"Shower zenith angle [\si{\degree}] $\pm \SI{%d}{\degree}$" %
        rad2deg(DTHETA))
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    title(r"$N_{MIP} \geq %d, \quad %.1f \leq \log(E) \leq %.1f$" %
          (N, LOGENERGY - DLOGENERGY, LOGENERGY + DLOGENERGY))
    ylim(0, 60)
    graph.set_ylimits(0, 60)
    xlim(-.5, 37)
    legend(numpoints=1)
    if USE_TEX:
        rcParams['text.usetex'] = True
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
Пример #30
0
def boxplot_core_distance_vs_time():
    plt.figure()

    sim = data.root.showers.E_1PeV.zenith_0.shower_0
    leptons = sim.leptons

    #bins = np.logspace(0, 2, 25)
    bins = np.linspace(0, 100, 15)
    x, arrival_time, widths = [], [], []
    t25, t50, t75 = [], [], []
    for low, high in zip(bins[:-1], bins[1:]):
        sel = leptons.read_where('(low < core_distance) & (core_distance <= high)')
        x.append(np.mean([low, high]))
        arrival_time.append(sel[:]['arrival_time'])
        widths.append((high - low) / 2)
        ts = sel[:]['arrival_time']
        t25.append(scoreatpercentile(ts, 25))
        t50.append(scoreatpercentile(ts, 50))
        t75.append(scoreatpercentile(ts, 75))

    fill_between(x, t25, t75, color='0.75')
    plot(x, t50, 'o-', color='black')

    plt.xlabel("Core distance [m]")
    plt.ylabel("Arrival time [ns]")

    #utils.title("Shower front timing structure")
    utils.saveplot()

    graph = GraphArtist()
    graph.plot(x, t50, linestyle=None)
    graph.shade_region(x, t25, t75)
    graph.set_xlabel(r"Core distance [\si{\meter}]")
    graph.set_ylabel(r"Arrival time [\si{\nano\second}]")
    graph.set_ylimits(0, 30)
    graph.set_xlimits(0, 100)
    graph.save('plots/front-passage-vs-R')
Пример #31
0
def plot_uncertainty_core_distance(table):
    N = 2
    THETA = deg2rad(22.5)
    DTHETA = deg2rad(5.)
    DN = .5
    DR = 10
    LOGENERGY = 15
    DLOGENERGY = .5

    figure()
    x, y, y2 = [], [], []
    for R in range(0, 81, 20):
        x.append(R)
        events = table.readWhere(
            '(abs(min_n134 - N) <= DN) & (abs(reference_theta - THETA) <= DTHETA) & (abs(r - R) <= DR) & (abs(log10(k_energy) - LOGENERGY) <= DLOGENERGY)'
        )
        print len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)

    print
    print "R: theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print

    #    # Simulation data
    sx, sy, sy2 = loadtxt(
        os.path.join(DATADIR, 'DIR-plot_uncertainty_core_distance.txt'))

    graph = GraphArtist()

    # Plots
    plot(x, rad2deg(y), '^-', label="Theta")
    graph.plot(x[:-1], rad2deg(y[:-1]), mark='o')
    plot(sx, rad2deg(sy), '^-', label="Theta (sim)")
    graph.plot(sx[:-1], rad2deg(sy[:-1]), mark='square')
    plot(x, rad2deg(y2), 'v-', label="Phi")
    graph.plot(x[:-1], rad2deg(y2[:-1]), mark='*')
    plot(sx, rad2deg(sy2), 'v-', label="Phi (sim)")
    graph.plot(sx[:-1], rad2deg(sy2[:-1]), mark='square*')

    # Labels etc.
    xlabel("Core distance [m] $\pm %d$" % DR)
    graph.set_xlabel(r"Core distance [\si{\meter}] $\pm \SI{%d}{\meter}$" % DR)
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    title(
        r"$N_{MIP} = %d \pm %.1f, \theta = 22.5^\circ \pm %d^\circ, %.1f \leq \log(E) \leq %.1f$"
        % (N, DN, rad2deg(DTHETA), LOGENERGY - DLOGENERGY,
           LOGENERGY + DLOGENERGY))
    ylim(ymin=0)
    graph.set_ylimits(min=0)
    xlim(-2, 62)
    legend(numpoints=1, loc='best')
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
    def plot_full_spectrum_fit_in_density_range(self, sel, popt, low, high):
        bins = np.linspace(0, RANGE_MAX, N_BINS + 1)
        n, bins = np.histogram(sel, bins=bins)
        x = (bins[:-1] + bins[1:]) / 2

        p_gamma, p_landau = self.constrained_full_spectrum_fit(
            x, n, popt[:2], popt[2:])

        plt.figure()
        plt.plot(x * VNS, n, label='data')
        self.plot_landau_and_gamma(x, p_gamma, p_landau)

        y_charged = self.calc_charged_spectrum(x, n, p_gamma, p_landau)
        plt.plot(x * VNS, y_charged, label='charged particles')

        plt.yscale('log')
        plt.xlim(0, 50)
        plt.ylim(ymin=1)
        plt.xlabel("Pulse integral [V ns]")
        plt.ylabel("Count")
        plt.legend()
        suffix = '%.1f-%.1f' % (low, high)
        suffix = suffix.replace('.', '_')
        utils.saveplot(suffix)

        n = np.where(n > 0, n, 1e-99)
        y_charged = np.where(y_charged > 0, y_charged, 1e-99)

        graph = GraphArtist('semilogy')
        graph.histogram(n, bins * VNS, linestyle='gray')
        self.artistplot_alt_landau_and_gamma(graph, x, p_gamma, p_landau)
        graph.histogram(y_charged, bins * VNS)
        graph.set_xlabel(r"Pulse integral [\si{\volt\nano\second}]")
        graph.set_ylabel("Count")
        graph.set_title(
            r"$\SI{%.1f}{\per\square\meter} \leq \rho_\mathrm{charged}$ < $\SI{%.1f}{\per\square\meter}$"
            % (low, high))
        graph.set_xlimits(0, 30)
        graph.set_ylimits(1e0, 1e4)
        artist.utils.save_graph(graph, suffix, dirname='plots')
Пример #33
0
def boxplot_theta_reconstruction_results_for_MIP(table, N):
    figure()

    DTHETA = deg2rad(1.)

    angles = [0, 5, 10, 15, 22.5, 35]
    r_dtheta = []
    x = []
    d25, d50, d75 = [], [], []
    for angle in angles:
        theta = deg2rad(angle)
        sel = table.readWhere(
            '(min_n134 >= N) & (abs(reference_theta - theta) <= DTHETA)')
        dtheta = rad2deg(sel[:]['reconstructed_theta'] -
                         sel[:]['reference_theta'])
        r_dtheta.append(dtheta)

        d25.append(scoreatpercentile(dtheta, 25))
        d50.append(scoreatpercentile(dtheta, 50))
        d75.append(scoreatpercentile(dtheta, 75))
        x.append(angle)

    #boxplot(r_dtheta, sym='', positions=angles, widths=2.)
    fill_between(x, d25, d75, color='0.75')
    plot(x, d50, 'o-', color='black')

    xlabel(r"$\theta_K$ [deg]")
    ylabel(r"$\theta_H - \theta_K$ [deg]")
    title(r"$N_{MIP} \geq %d$" % N)

    axhline(0, color='black')
    ylim(-20, 25)
    xlim(0, 35)

    utils.saveplot(N)

    graph = GraphArtist()
    graph.draw_horizontal_line(0, linestyle='gray')
    graph.shade_region(angles, d25, d75)
    graph.plot(angles, d50, linestyle=None)
    graph.set_xlabel(r"$\theta_K$ [\si{\degree}]")
    graph.set_ylabel(r"$\theta_H - \theta_K$ [\si{\degree}]")
    graph.set_ylimits(-5, 15)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
Пример #34
0
def plot_pulseheight_histogram(data):
    events = data.root.hisparc.cluster_kascade.station_601.events
    ph = events.col("pulseheights")

    s = landau.Scintillator()
    mev_scale = 3.38 / 340
    count_scale = 6e3 / 0.32

    clf()
    n, bins, patches = hist(ph[:, 0], bins=arange(0, 1501, 10), histtype="step")
    x = linspace(0, 1500, 1500)
    plot(x, s.conv_landau_for_x(x, mev_scale=mev_scale, count_scale=count_scale))
    plot(x, count_scale * s.landau_pdf(x * mev_scale))
    ylim(ymax=25000)
    xlim(xmax=1500)

    # Remove one statistical fluctuation from data.  It is not important
    # for the graph, but it detracts from the main message
    index = bins.searchsorted(370)
    n[index] = mean([n[index - 1], n[index + 1]])

    graph = GraphArtist()
    n_trunc = where(n <= 100000, n, 100000)
    graph.histogram(n_trunc, bins, linestyle="gray")
    graph.add_pin("data", x=800, location="above right", use_arrow=True)
    graph.add_pin("$\gamma$", x=90, location="above right", use_arrow=True)
    graph.plot(x, s.conv_landau_for_x(x, mev_scale=mev_scale, count_scale=count_scale), mark=None)
    graph.add_pin("convolved Landau", x=450, location="above right", use_arrow=True)
    graph.plot(x, count_scale * s.landau_pdf(x * mev_scale), mark=None, linestyle="black")
    graph.add_pin("Landau", x=380, location="above right", use_arrow=True)

    graph.set_xlabel(r"Pulseheight [\adc{}]")
    graph.set_ylabel(r"Number of events")
    graph.set_xlimits(0, 1400)
    graph.set_ylimits(0, 21000)
    graph.save("plots/plot_pulseheight_histogram")
Пример #35
0
def boxplot_phi_reconstruction_results_for_MIP(table, N):
    figure()

    THETA = deg2rad(22.5)
    DTHETA = deg2rad(5.)

    bin_edges = linspace(-180, 180, 18)
    x, r_dphi = [], []
    d25, d50, d75 = [], [], []
    for low, high in zip(bin_edges[:-1], bin_edges[1:]):
        rad_low = deg2rad(low)
        rad_high = deg2rad(high)
        query = '(min_n134 >= N) & (rad_low < reference_phi) & (reference_phi < rad_high) & (abs(reference_theta - THETA) <= DTHETA)'
        sel = table.readWhere(query)
        dphi = sel[:]['reconstructed_phi'] - sel[:]['reference_phi']
        dphi = (dphi + pi) % (2 * pi) - pi
        r_dphi.append(rad2deg(dphi))

        d25.append(scoreatpercentile(rad2deg(dphi), 25))
        d50.append(scoreatpercentile(rad2deg(dphi), 50))
        d75.append(scoreatpercentile(rad2deg(dphi), 75))
        x.append((low + high) / 2)

    #boxplot(r_dphi, positions=x, widths=1 * (high - low), sym='')
    fill_between(x, d25, d75, color='0.75')
    plot(x, d50, 'o-', color='black')

    xlabel(r"$\phi_K$ [deg]")
    ylabel(r"$\phi_H - \phi_K$ [deg]")
    title(r"$N_{MIP} \geq %d, \quad \theta = 22.5^\circ \pm %d^\circ$" %
          (N, rad2deg(DTHETA)))

    xticks(linspace(-180, 180, 9))
    axhline(0, color='black')

    utils.saveplot(N)

    graph = GraphArtist()
    graph.draw_horizontal_line(0, linestyle='gray')
    graph.shade_region(x, d25, d75)
    graph.plot(x, d50, linestyle=None)
    graph.set_xlabel(r"$\phi_K$ [\si{\degree}]")
    graph.set_ylabel(r"$\phi_H - \phi_K$ [\si{\degree}]")
    graph.set_xticks([-180, -90, '...', 180])
    graph.set_xlimits(-180, 180)
    graph.set_ylimits(-23, 23)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
def plot_uncertainty_zenith(group):
    group = group.E_1PeV
    rec = DirectionReconstruction

    N = 2

    graph = GraphArtist()

    # constants for uncertainty estimation
    # BEWARE: stations must be the same over all reconstruction tables used
    station = group.zenith_0.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    figure()
    x, y, y2 = [], [], []
    for THETA in 0, 5, 10, 15, 22.5, 30, 35, 45:
        x.append(THETA)
        table = group._f_get_child('zenith_%s' % str(THETA).replace('.', '_'))
        events = table.read_where('min_n134 >= N')
        print THETA, len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)
    plot(x, rad2deg(y), '^', label="Theta")
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    # Azimuthal angle undefined for zenith = 0
    plot(x[1:], rad2deg(y2[1:]), 'v', label="Phi")
    graph.plot(x[1:], rad2deg(y2[1:]), mark='*', linestyle=None)
    print
    print "zenith: theta, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print
    utils.savedata((x, y, y2))

    # Uncertainty estimate
    x = linspace(0, deg2rad(45), 50)
    phis = linspace(-pi, pi, 50)
    y, y2 = [], []
    for t in x:
        y.append(mean(rec.rel_phi_errorsq(t, phis, phi1, phi2, r1, r2)))
        y2.append(mean(rec.rel_theta1_errorsq(t, phis, phi1, phi2, r1, r2)))
    y = TIMING_ERROR * sqrt(array(y))
    y2 = TIMING_ERROR * sqrt(array(y2))
    plot(rad2deg(x), rad2deg(y), label="Estimate Phi")
    graph.plot(rad2deg(x), rad2deg(y), mark=None)
    plot(rad2deg(x), rad2deg(y2), label="Estimate Theta")
    graph.plot(rad2deg(x), rad2deg(y2), mark=None)

    # Labels etc.
    xlabel("Shower zenith angle [deg]")
    graph.set_xlabel(r"Shower zenith angle [\si{\degree}]")
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    #title(r"$N_{MIP} \geq %d$" % N)
    ylim(0, 100)
    graph.set_ylimits(0, 60)
    legend(numpoints=1)
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
Пример #37
0
def plot_fsot_vs_lint_for_zenith(fsot, lint):
    bins = linspace(0, 35, 21)

    min_N = 1

    x, f_y, f_y2, l_y, l_y2 = [], [], [], [], []
    for low, high in zip(bins[:-1], bins[1:]):
        rad_low = deg2rad(low)
        rad_high = deg2rad(high)

        query = '(min_n134 >= min_N) & (rad_low <= reference_theta) & (reference_theta < rad_high)'
        f_sel = fsot.readWhere(query)
        l_sel = lint.readWhere(query)

        errors = f_sel['reconstructed_phi'] - f_sel['reference_phi']
        errors2 = f_sel['reconstructed_theta'] - f_sel['reference_theta']
        #f_y.append(std(errors))
        #f_y2.append(std(errors2))
        f_y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        f_y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)

        errors = l_sel['reconstructed_phi'] - l_sel['reference_phi']
        errors2 = l_sel['reconstructed_theta'] - l_sel['reference_theta']
        #l_y.append(std(errors))
        #l_y2.append(std(errors2))
        l_y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        l_y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)

        x.append((low + high) / 2)

        print x[-1], len(f_sel), len(l_sel)

    clf()
    plot(x, rad2deg(f_y), label="FSOT phi")
    plot(x, rad2deg(f_y2), label="FSOT theta")
    plot(x, rad2deg(l_y), label="LINT phi")
    plot(x, rad2deg(l_y2), label="LINT theta")
    legend()
    xlabel("Shower zenith angle [deg]")
    ylabel("Angle reconstruction uncertainty [deg]")
    title(r"$N_{MIP} \geq %d$" % min_N)
    utils.saveplot()

    graph = GraphArtist()
    graph.plot(x, rad2deg(f_y), mark=None)
    graph.plot(x, rad2deg(l_y), mark=None, linestyle='dashed')
    graph.plot(x, rad2deg(f_y2), mark=None)
    graph.plot(x, rad2deg(l_y2), mark=None, linestyle='dashed')
    graph.set_xlabel(r"Shower zenith angle [\si{\degree}]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    artist.utils.save_graph(graph, dirname='plots')
def plot_uncertainty_binsize(group):
    group = group.E_1PeV
    rec = DirectionReconstruction

    N = 2

    graph = GraphArtist()

    # constants for uncertainty estimation
    # BEWARE: stations must be the same over all reconstruction tables used
    station = group.zenith_22_5.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    figure()
    x, y, y2 = [], [], []
    for bin_size in [0, 1, 2.5, 5]:
        x.append(bin_size)
        if bin_size != 0:
            table = group._f_get_child('zenith_22_5_binned_randomized_%s' % str(bin_size).replace('.', '_'))
        else:
            table = group.zenith_22_5
        events = table.read_where('min_n134 >= 2')

        print bin_size, len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)
    plot(x, rad2deg(y), '^', label="Theta")
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    plot(x, rad2deg(y2), 'v', label="Phi")
    graph.plot(x, rad2deg(y2), mark='*', linestyle=None)
    print
    print "binsize: size, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print

    # Uncertainty estimate
    x = linspace(0, 5, 50)
    phis = linspace(-pi, pi, 50)
    y, y2 = [], []
    phi_errorsq = mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    theta_errorsq = mean(rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    for t in x:
        y.append(sqrt((TIMING_ERROR ** 2 + t ** 2 / 12) * phi_errorsq))
        y2.append(sqrt((TIMING_ERROR ** 2 + t ** 2 / 12) * theta_errorsq))
    y = array(y)
    y2 = array(y2)
    plot(x, rad2deg(y), label="Estimate Phi")
    graph.plot(x, rad2deg(y), mark=None)
    plot(x, rad2deg(y2), label="Estimate Theta")
    graph.plot(x, rad2deg(y2), mark=None)

    # Labels etc.
    xlabel("Sampling time [ns]")
    graph.set_xlabel(r"Sampling time [\si{\nano\second}]")
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    graph.set_ylimits(0, 20)
    #title(r"$\theta = 22.5^\circ, N_{MIP} \geq %d$" % N)
    legend(loc='upper left', numpoints=1)
    ylim(0, 20)
    xlim(-0.1, 5.5)
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
Пример #39
0
def plot_uncertainty_mip(table):
    rec = DirectionReconstruction

    # constants for uncertainty estimation
    station = table.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    THETA = deg2rad(22.5)
    DTHETA = deg2rad(5.)
    DN = .1
    LOGENERGY = 15
    DLOGENERGY = .5

    figure()
    x, y, y2 = [], [], []
    for N in range(1, 6):
        x.append(N)
        events = table.readWhere(
            '(abs(min_n134 - N) <= DN) & (abs(reference_theta - THETA) <= DTHETA) & (abs(log10(k_energy) - LOGENERGY) <= DLOGENERGY)'
        )
        print len(events),
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append(
            (scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) /
            2)
        y2.append(
            (scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) /
            2)

    print
    print "mip: min_n134, theta_std, phi_std"
    for u, v, w in zip(x, y, y2):
        print u, v, w
    print

    # Simulation data
    sx, sy, sy2 = loadtxt(os.path.join(DATADIR,
                                       'DIR-plot_uncertainty_mip.txt'))

    # Uncertainty estimate
    ex = linspace(1, 5, 50)
    phis = linspace(-pi, pi, 50)
    phi_errsq = mean(rec.rel_phi_errorsq(pi / 8, phis, phi1, phi2, r1, r2))
    theta_errsq = mean(rec.rel_theta1_errorsq(pi / 8, phis, phi1, phi2, r1,
                                              r2))
    #ey = TIMING_ERROR * std_t(ex) * sqrt(phi_errsq)
    #ey2 = TIMING_ERROR * std_t(ex) * sqrt(theta_errsq)

    R_list = [30, 20, 16, 14, 12]
    with tables.openFile('master-ch4v2.h5') as data2:
        mc = my_std_t_for_R(data2, x, R_list)
    mc = sqrt(mc**2 + 1.2**2 + 2.5**2)
    print mc
    ey = mc * sqrt(phi_errsq)
    ey2 = mc * sqrt(theta_errsq)

    nx = linspace(1, 4, 100)
    ey = spline(x, ey, nx)
    ey2 = spline(x, ey2, nx)

    # Plots
    plot(x, rad2deg(y), '^', label="Theta")
    plot(sx, rad2deg(sy), '^', label="Theta (sim)")
    plot(nx, rad2deg(ey2))  #, label="Estimate Theta")
    plot(x, rad2deg(y2), 'v', label="Phi")
    plot(sx, rad2deg(sy2), 'v', label="Phi (sim)")
    plot(nx, rad2deg(ey))  #, label="Estimate Phi")

    # Labels etc.
    xlabel("$N_{MIP} \pm %.1f$" % DN)
    ylabel("Angle reconstruction uncertainty [deg]")
    title(
        r"$\theta = 22.5^\circ \pm %d^\circ \quad %.1f \leq \log(E) \leq %.1f$"
        % (rad2deg(DTHETA), LOGENERGY - DLOGENERGY, LOGENERGY + DLOGENERGY))
    legend(numpoints=1)
    xlim(0.5, 4.5)
    utils.saveplot()
    print

    graph = GraphArtist()
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    graph.plot(sx, rad2deg(sy), mark='square', linestyle=None)
    graph.plot(nx, rad2deg(ey2), mark=None)
    graph.plot(x, rad2deg(y2), mark='*', linestyle=None)
    graph.plot(sx, rad2deg(sy2), mark='square*', linestyle=None)
    graph.plot(nx, rad2deg(ey), mark=None)
    graph.set_xlabel(r"$N_\mathrm{MIP} \pm %.1f$" % DN)
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    graph.set_xlimits(max=4.5)
    graph.set_ylimits(0, 40)
    graph.set_xticks(range(5))
    artist.utils.save_graph(graph, dirname='plots')
def boxplot_phi_reconstruction_results_for_MIP(group, N):
    table = group.E_1PeV.zenith_22_5

    figure()

    bin_edges = linspace(-180, 180, 18)
    x, r_dphi = [], []
    d25, d50, d75 = [], [], []
    for low, high in zip(bin_edges[:-1], bin_edges[1:]):
        rad_low = deg2rad(low)
        rad_high = deg2rad(high)
        query = '(min_n134 >= N) & (rad_low < reference_phi) & (reference_phi < rad_high)'
        sel = table.read_where(query)
        dphi = sel[:]['reconstructed_phi'] - sel[:]['reference_phi']
        dphi = (dphi + pi) % (2 * pi) - pi
        r_dphi.append(rad2deg(dphi))

        d25.append(scoreatpercentile(rad2deg(dphi), 25))
        d50.append(scoreatpercentile(rad2deg(dphi), 50))
        d75.append(scoreatpercentile(rad2deg(dphi), 75))
        x.append((low + high) / 2)

    fill_between(x, d25, d75, color='0.75')
    plot(x, d50, 'o-', color='black')

    xlabel(r"$\phi_{simulated}$ [deg]")
    ylabel(r"$\phi_{reconstructed} - \phi_{simulated}$ [deg]")
    #title(r"$N_{MIP} \geq %d, \quad \theta = 22.5^\circ$" % N)

    xticks(linspace(-180, 180, 9))
    axhline(0, color='black')
    ylim(-15, 15)

    utils.saveplot(N)

    graph = GraphArtist()
    graph.draw_horizontal_line(0, linestyle='gray')
    graph.shade_region(x, d25, d75)
    graph.plot(x, d50, linestyle=None)
    graph.set_xlabel(r"$\phi_\mathrm{sim}$ [\si{\degree}]")
    graph.set_ylabel(r"$\phi_\mathrm{rec} - \phi_\mathrm{sim}$ [\si{\degree}]")
    graph.set_title(r"$N_\mathrm{MIP} \geq %d$" % N)
    graph.set_xticks([-180, -90, '...', 180])
    graph.set_xlimits(-180, 180)
    graph.set_ylimits(-17, 17)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
    def plot_detection_efficiency(self):
        integrals, dens = self.get_integrals_and_densities()

        popt = self.full_fit_on_data(integrals,
                                      (1., 1., 5e3 / .32, 3.38 / 5000, 1.))

        x, y, yerr = [], [], []
        dens_bins = np.linspace(0, 10, 51)
        for low, high in zip(dens_bins[:-1], dens_bins[1:]):
            sel = integrals.compress((low <= dens) & (dens < high))
            x.append((low + high) / 2)
            frac = self.determine_charged_fraction(sel, popt)
            y.append(frac)
            yerr.append(np.sqrt(frac * len(sel)) / len(sel))
            print (low + high) / 2, len(sel)
            self.plot_full_spectrum_fit_in_density_range(sel, popt, low, high)
        print

        plt.figure()
        plt.errorbar(x, y, yerr, fmt='o', label='data', markersize=3.)

        popt, pcov = optimize.curve_fit(self.conv_p_detection, x, y, p0=(1.,))
        print "Sigma Gauss:", popt

        x2 = plt.linspace(0, 10, 101)
        plt.plot(x2, self.p_detection(x2), label='poisson')
        plt.plot(x2, self.conv_p_detection(x2, *popt), label='poisson/gauss')

        plt.xlabel("Charged particle density [$m^{-2}$]")
        plt.ylabel("Detection probability")
        plt.ylim(0, 1.)
        plt.legend(loc='best')
        utils.saveplot()

        graph = GraphArtist()
        graph.plot(x2, self.p_detection(x2), mark=None)
        graph.plot(x2, self.conv_p_detection(x2, *popt), mark=None,
                   linestyle='dashed')
        graph.plot(x, y, yerr=yerr, linestyle=None)
        graph.set_xlabel(
            r"Charged particle density [\si{\per\square\meter}]")
        graph.set_ylabel("Detection probability")
        graph.set_xlimits(min=0)
        graph.set_ylimits(min=0)
        artist.utils.save_graph(graph, dirname='plots')
def boxplot_core_distances_for_mips(group):
    table = group.E_1PeV.zenith_22_5

    figure()

    r_list = []
    r25, r50, r75 = [], [], []
    x = []
    for N in range(1, 5):
        sel = table.read_where('min_n134 >= N')
        r = sel[:]['r']
        r_list.append(r)
        x.append(N)

        r25.append(scoreatpercentile(r, 25))
        r50.append(scoreatpercentile(r, 50))
        r75.append(scoreatpercentile(r, 75))

    fill_between(x, r25, r75, color='0.75')
    plot(x, r50, 'o-', color='black')

    xticks(range(1, 5))
    xlabel("Minimum number of particles")
    ylabel("Core distance [m]")
    #title(r"$\theta = 22.5^\circ$")

    utils.saveplot()

    graph = GraphArtist()
    graph.shade_region(x, r25, r75)
    graph.plot(x, r50, linestyle=None)
    graph.set_xlabel("Minimum number of particles")
    graph.set_ylabel(r"Core distance [\si{\meter}]")
    graph.set_ylimits(min=0)
    graph.set_xticks(range(5))
    artist.utils.save_graph(graph, dirname='plots')
    def plot_full_spectrum_fit_in_density_range(self, sel, popt, low, high):
        bins = np.linspace(0, RANGE_MAX, N_BINS + 1)
        n, bins = np.histogram(sel, bins=bins)
        x = (bins[:-1] + bins[1:]) / 2

        p_gamma, p_landau = self.constrained_full_spectrum_fit(x, n, popt[:2], popt[2:])

        plt.figure()
        plt.plot(x * VNS, n, label='data')
        self.plot_landau_and_gamma(x, p_gamma, p_landau)

        y_charged = self.calc_charged_spectrum(x, n, p_gamma, p_landau)
        plt.plot(x * VNS, y_charged, label='charged particles')

        plt.yscale('log')
        plt.xlim(0, 50)
        plt.ylim(ymin=1)
        plt.xlabel("Pulse integral [V ns]")
        plt.ylabel("Count")
        plt.legend()
        suffix = '%.1f-%.1f' % (low, high)
        suffix = suffix.replace('.', '_')
        utils.saveplot(suffix)

        n = np.where(n > 0, n, 1e-99)
        y_charged = np.where(y_charged > 0, y_charged, 1e-99)

        graph = GraphArtist('semilogy')
        graph.histogram(n, bins * VNS, linestyle='gray')
        self.artistplot_alt_landau_and_gamma(graph, x, p_gamma, p_landau)
        graph.histogram(y_charged, bins * VNS)
        graph.set_xlabel(r"Pulse integral [\si{\volt\nano\second}]")
        graph.set_ylabel("Count")
        graph.set_title(r"$\SI{%.1f}{\per\square\meter} \leq \rho_\mathrm{charged}$ < $\SI{%.1f}{\per\square\meter}$" % (low, high))
        graph.set_xlimits(0, 30)
        graph.set_ylimits(1e0, 1e4)
        artist.utils.save_graph(graph, suffix, dirname='plots')
def artistplot_reconstruction_efficiency_vs_R_for_angles(N):
    filename = 'DIR-plot_reconstruction_efficiency_vs_R_for_angles-%d.txt' % N
    all_data = loadtxt(os.path.join('plots/', filename))

    graph = GraphArtist()
    locations = iter(['above right', 'below left', 'below left'])
    positions = iter([.9, .2, .2])

    x = all_data[:, 0]

    for angle, efficiencies in zip([0, 22.5, 35], all_data[:, 1:].T):
        graph.plot(x, efficiencies, mark=None)
        graph.add_pin(r'\SI{%s}{\degree}' % angle, use_arrow=True,
                      location=locations.next(),
                      relative_position=positions.next())

    graph.set_xlabel("Core distance [\si{\meter}]")
    graph.set_ylabel("Reconstruction efficiency")
    graph.set_xlimits(0, 100)
    graph.set_ylimits(max=1)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
    def plot_gamma_landau_fit(self):
        events = self.data.root.hisparc.cluster_kascade.station_601.events
        ph0 = events.col('integrals')[:, 0]

        bins = np.linspace(0, RANGE_MAX, N_BINS + 1)
        n, bins = np.histogram(ph0, bins=bins)
        x = (bins[:-1] + bins[1:]) / 2

        p_gamma, p_landau = self.full_spectrum_fit(x, n, (1., 1.),
                                                   (5e3 / .32, 3.38 / 5000, 1.))
        print "FULL FIT"
        print p_gamma, p_landau

        n /= 10
        p_gamma, p_landau = self.constrained_full_spectrum_fit(x, n, p_gamma, p_landau)
        print "CONSTRAINED FIT"
        print p_gamma, p_landau

        plt.figure()
        print self.calc_charged_fraction(x, n, p_gamma, p_landau)

        plt.plot(x * VNS, n)
        self.plot_landau_and_gamma(x, p_gamma, p_landau)
        #plt.plot(x, n - self.gamma_func(x, *p_gamma))
        plt.xlabel("Pulse integral [V ns]")
        plt.ylabel("Count")
        plt.yscale('log')
        plt.xlim(0, 30)
        plt.ylim(1e1, 1e4)
        plt.legend()
        utils.saveplot()

        graph = GraphArtist('semilogy')
        graph.histogram(n, bins * VNS, linestyle='gray')
        self.artistplot_landau_and_gamma(graph, x, p_gamma, p_landau)
        graph.set_xlabel(r"Pulse integral [\si{\volt\nano\second}]")
        graph.set_ylabel("Count")
        graph.set_xlimits(0, 30)
        graph.set_ylimits(1e1, 1e4)
        artist.utils.save_graph(graph, dirname='plots')
Пример #46
0
def plot_uncertainty_zenith(table):
    rec = DirectionReconstruction

    # constants for uncertainty estimation
    station = table.attrs.cluster.stations[0]
    r1, phi1 = station.calc_r_and_phi_for_detectors(1, 3)
    r2, phi2 = station.calc_r_and_phi_for_detectors(1, 4)

    N = 2
    DTHETA = deg2rad(1.)
    DN = .1
    LOGENERGY = 15
    DLOGENERGY = .5

    figure()
    rcParams['text.usetex'] = False
    x, y, y2 = [], [], []
    for theta in 5, 10, 15, 22.5, 30, 35:
        x.append(theta)
        THETA = deg2rad(theta)
        events = table.read_where('(min_n134 >= N) & (abs(reference_theta - THETA) <= DTHETA) & (abs(log10(k_energy) - LOGENERGY) <= DLOGENERGY)')
        print(theta, len(events),)
        errors = events['reference_theta'] - events['reconstructed_theta']
        # Make sure -pi < errors < pi
        errors = (errors + pi) % (2 * pi) - pi
        errors2 = events['reference_phi'] - events['reconstructed_phi']
        # Make sure -pi < errors2 < pi
        errors2 = (errors2 + pi) % (2 * pi) - pi
        #y.append(std(errors))
        #y2.append(std(errors2))
        y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)
    print()
    print("zenith: theta, theta_std, phi_std")
    for u, v, w in zip(x, y, y2):
        print(u, v, w)
    print()

    # Simulation data
    sx, sy, sy2 = loadtxt(os.path.join(DATADIR, 'DIR-plot_uncertainty_zenith.txt'))

    # Uncertainty estimate
    ex = linspace(0, deg2rad(35), 50)
    phis = linspace(-pi, pi, 50)
    ey, ey2, ey3 = [], [], []
    for t in ex:
        ey.append(mean(rec.rel_phi_errorsq(t, phis, phi1, phi2, r1, r2)))
        ey3.append(mean(rec.rel_phi_errorsq(t, phis, phi1, phi2, r1, r2)) * sin(t) ** 2)
        ey2.append(mean(rec.rel_theta1_errorsq(t, phis, phi1, phi2, r1, r2)))
    ey = TIMING_ERROR * sqrt(array(ey))
    ey3 = TIMING_ERROR * sqrt(array(ey3))
    ey2 = TIMING_ERROR * sqrt(array(ey2))

    graph = GraphArtist()

    # Plots
    plot(x, rad2deg(y), '^', label="Theta")
    graph.plot(x, rad2deg(y), mark='o', linestyle=None)
    #plot(sx, rad2deg(sy), '^', label="Theta (sim)")
    plot(rad2deg(ex), rad2deg(ey2))#, label="Estimate Theta")
    graph.plot(rad2deg(ex), rad2deg(ey2), mark=None)
    # Azimuthal angle undefined for zenith = 0
    plot(x[1:], rad2deg(y2[1:]), 'v', label="Phi")
    graph.plot(x[1:], rad2deg(y2[1:]), mark='*', linestyle=None)
    #plot(sx[1:], rad2deg(sy2[1:]), 'v', label="Phi (sim)")
    plot(rad2deg(ex), rad2deg(ey))#, label="Estimate Phi")
    graph.plot(rad2deg(ex), rad2deg(ey), mark=None)
    #plot(rad2deg(ex), rad2deg(ey3), label="Estimate Phi * sin(Theta)")

    # Labels etc.
    xlabel(r"Shower zenith angle [deg $\pm %d^\circ$]" % rad2deg(DTHETA))
    graph.set_xlabel(r"Shower zenith angle [\si{\degree}] $\pm \SI{%d}{\degree}$" % rad2deg(DTHETA))
    ylabel("Angle reconstruction uncertainty [deg]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    title(r"$N_{MIP} \geq %d, \quad %.1f \leq \log(E) \leq %.1f$" % (N, LOGENERGY - DLOGENERGY, LOGENERGY + DLOGENERGY))
    ylim(0, 60)
    graph.set_ylimits(0, 60)
    xlim(-.5, 37)
    legend(numpoints=1)
    if USE_TEX:
        rcParams['text.usetex'] = True
    utils.saveplot()
    artist.utils.save_graph(graph, dirname='plots')
    print
Пример #47
0
def plot_R():
    graph = GraphArtist(width=r'.45\linewidth')

    n, bins, patches = hist(
        data.root.simulations.E_1PeV.zenith_22_5.shower_0.coincidences.col(
            'r'),
        bins=100,
        histtype='step')
    graph.histogram(n, bins, linestyle='black!50')

    shower = data.root.simulations.E_1PeV.zenith_22_5.shower_0
    ids = shower.observables.get_where_list(
        '(n1 >= 1) & (n3 >= 1) & (n4 >= 1)')
    R = shower.coincidences.read_coordinates(ids, field='r')
    n, bins, patches = hist(R, bins=100, histtype='step')
    graph.histogram(n, bins)

    xlabel("Core distance [m]")
    ylabel("Number of events")

    print "mean", mean(R)
    print "median", median(R)

    graph.set_xlabel(r"Core distance [\si{\meter}]")
    graph.set_ylabel("Number of events")
    graph.set_xlimits(min=0)
    graph.set_ylimits(min=0)
    graph.save('plots/SIM-R')
Пример #48
0
def boxplot_theta_reconstruction_results_for_MIP(table, N):
    figure()

    DTHETA = deg2rad(1.)

    angles = [0, 5, 10, 15, 22.5, 35]
    r_dtheta = []
    x = []
    d25, d50, d75 = [], [], []
    for angle in angles:
        theta = deg2rad(angle)
        sel = table.read_where('(min_n134 >= N) & (abs(reference_theta - theta) <= DTHETA)')
        dtheta = rad2deg(sel[:]['reconstructed_theta'] - sel[:]['reference_theta'])
        r_dtheta.append(dtheta)

        d25.append(scoreatpercentile(dtheta, 25))
        d50.append(scoreatpercentile(dtheta, 50))
        d75.append(scoreatpercentile(dtheta, 75))
        x.append(angle)

    #boxplot(r_dtheta, sym='', positions=angles, widths=2.)
    fill_between(x, d25, d75, color='0.75')
    plot(x, d50, 'o-', color='black')

    xlabel(r"$\theta_K$ [deg]")
    ylabel(r"$\theta_H - \theta_K$ [deg]")
    title(r"$N_{MIP} \geq %d$" % N)

    axhline(0, color='black')
    ylim(-20, 25)
    xlim(0, 35)

    utils.saveplot(N)

    graph = GraphArtist()
    graph.draw_horizontal_line(0, linestyle='gray')
    graph.shade_region(angles, d25, d75)
    graph.plot(angles, d50, linestyle=None)
    graph.set_xlabel(r"$\theta_K$ [\si{\degree}]")
    graph.set_ylabel(r"$\theta_H - \theta_K$ [\si{\degree}]")
    graph.set_ylimits(-5, 15)
    artist.utils.save_graph(graph, suffix=N, dirname='plots')
Пример #49
0
def plot_arrival_times():
    graph = GraphArtist()

    figure()
    sim = data.root.showers.E_1PeV.zenith_22_5
    t = get_front_arrival_time(sim, 20, 5, pi / 8)
    n, bins = histogram(t, bins=linspace(0, 50, 201))
    mct = monte_carlo_timings(n, bins, 100000)
    n, bins, patches = hist(mct, bins=linspace(0, 20, 101), histtype='step')
    graph.histogram(n, bins, linestyle='black!50')

    mint = my_t_draw_something(data, 2, 100000)
    n, bins, patches = hist(mint, bins=linspace(0, 20, 101), histtype='step')
    graph.histogram(n, bins)

    xlabel("Arrival time [ns]")
    ylabel("Number of events")

    graph.set_xlabel(r"Arrival time [\si{\nano\second}]")
    graph.set_ylabel("Number of events")
    graph.set_xlimits(0, 20)
    graph.set_ylimits(min=0)
    graph.save('plots/SIM-T')

    print median(t), median(mct), median(mint)
Пример #50
0
def plot_fsot_vs_lint_for_zenith(fsot, lint):
    bins = linspace(0, 35, 21)

    min_N = 1

    x, f_y, f_y2, l_y, l_y2 = [], [], [], [], []
    for low, high in zip(bins[:-1], bins[1:]):
        rad_low = deg2rad(low)
        rad_high = deg2rad(high)

        query = '(min_n134 >= min_N) & (rad_low <= reference_theta) & (reference_theta < rad_high)'
        f_sel = fsot.read_where(query)
        l_sel = lint.read_where(query)

        errors = f_sel['reconstructed_phi'] - f_sel['reference_phi']
        errors2 = f_sel['reconstructed_theta'] - f_sel['reference_theta']
        #f_y.append(std(errors))
        #f_y2.append(std(errors2))
        f_y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        f_y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)

        errors = l_sel['reconstructed_phi'] - l_sel['reference_phi']
        errors2 = l_sel['reconstructed_theta'] - l_sel['reference_theta']
        #l_y.append(std(errors))
        #l_y2.append(std(errors2))
        l_y.append((scoreatpercentile(errors, 83) - scoreatpercentile(errors, 17)) / 2)
        l_y2.append((scoreatpercentile(errors2, 83) - scoreatpercentile(errors2, 17)) / 2)

        x.append((low + high) / 2)

        print(x[-1], len(f_sel), len(l_sel))

    clf()
    plot(x, rad2deg(f_y), label="FSOT phi")
    plot(x, rad2deg(f_y2), label="FSOT theta")
    plot(x, rad2deg(l_y), label="LINT phi")
    plot(x, rad2deg(l_y2), label="LINT theta")
    legend()
    xlabel("Shower zenith angle [deg]")
    ylabel("Angle reconstruction uncertainty [deg]")
    title(r"$N_{MIP} \geq %d$" % min_N)
    utils.saveplot()

    graph = GraphArtist()
    graph.plot(x, rad2deg(f_y), mark=None)
    graph.plot(x, rad2deg(l_y), mark=None, linestyle='dashed')
    graph.plot(x, rad2deg(f_y2), mark=None)
    graph.plot(x, rad2deg(l_y2), mark=None, linestyle='dashed')
    graph.set_xlabel(r"Shower zenith angle [\si{\degree}]")
    graph.set_ylabel(r"Angle reconstruction uncertainty [\si{\degree}]")
    artist.utils.save_graph(graph, dirname='plots')
Пример #51
0
def plot_nearest_neighbors(data, limit=None):
    global coincidences
    hisparc_group = data.root.hisparc.cluster_kascade.station_601
    kascade_group = data.root.kascade

    coincidences = KascadeCoincidences(data, hisparc_group, kascade_group,
                                       ignore_existing=True)

    #dt_opt = find_optimum_dt(coincidences, p0=-13, limit=1000)
    #print dt_opt

    graph = GraphArtist(axis='semilogy')
    styles = iter(['solid', 'dashed', 'dashdotted'])

    uncorrelated = None
    figure()
    #for shift in -12, -13, dt_opt, -14:
    for shift in -12, -13, -14:
        print "Shifting", shift
        coincidences.search_coincidences(shift, dtlimit=1, limit=limit)
        print "."
        dts = coincidences.coincidences['dt']
        n, bins, p = hist(abs(dts) / 1e9, bins=linspace(0, 1, 101),
                          histtype='step', label='%.3f s' % shift)
        n = [u if u else 1e-99 for u in n]
        graph.histogram(n, bins, linestyle=styles.next() + ',gray')
        if uncorrelated is None:
            uncorrelated = n, bins

    y, bins = uncorrelated
    x = (bins[:-1] + bins[1:]) / 2
    f = lambda x, N, a: N * exp(-a * x)
    popt, pcov = curve_fit(f, x, y)
    plot(x, f(x, *popt), label=r"$\lambda = %.2f$ Hz" % popt[1])
    graph.plot(x, f(x, *popt), mark=None)

    yscale('log')
    xlabel("Time difference [s]")
    graph.set_xlabel(r"Time difference [\si{\second}]")
    ylabel("Counts")
    graph.set_ylabel("Counts")
    legend()
    graph.set_ylimits(min=10)
    utils.saveplot()
    graph.save('plots/MAT-nearest-neighbors')
Пример #52
0
def plot_nearest_neighbors(data, limit=None):
    global coincidences
    hisparc_group = data.root.hisparc.cluster_kascade.station_601
    kascade_group = data.root.kascade

    coincidences = KascadeCoincidences(data,
                                       hisparc_group,
                                       kascade_group,
                                       ignore_existing=True)

    #dt_opt = find_optimum_dt(coincidences, p0=-13, limit=1000)
    #print(dt_opt)

    graph = GraphArtist(axis='semilogy')
    styles = iter(['solid', 'dashed', 'dashdotted'])

    uncorrelated = None
    figure()
    #for shift in -12, -13, dt_opt, -14:
    for shift in -12, -13, -14:
        print("Shifting", shift)
        coincidences.search_coincidences(shift, dtlimit=1, limit=limit)
        print(".")
        dts = coincidences.coincidences['dt']
        n, bins, p = hist(abs(dts) / 1e9,
                          bins=linspace(0, 1, 101),
                          histtype='step',
                          label='%.3f s' % shift)
        n = [u if u else 1e-99 for u in n]
        graph.histogram(n, bins, linestyle=styles.next() + ',gray')
        if uncorrelated is None:
            uncorrelated = n, bins

    y, bins = uncorrelated
    x = (bins[:-1] + bins[1:]) / 2
    f = lambda x, N, a: N * exp(-a * x)
    popt, pcov = curve_fit(f, x, y)
    plot(x, f(x, *popt), label=r"$\lambda = %.2f$ Hz" % popt[1])
    graph.plot(x, f(x, *popt), mark=None)

    yscale('log')
    xlabel("Time difference [s]")
    graph.set_xlabel(r"Time difference [\si{\second}]")
    ylabel("Counts")
    graph.set_ylabel("Counts")
    legend()
    graph.set_ylimits(min=10)
    utils.saveplot()
    graph.save('plots/MAT-nearest-neighbors')
Пример #53
0
def plot_R():
    graph = GraphArtist(width=r'.45\linewidth')

    n, bins, patches = hist(data.root.simulations.E_1PeV.zenith_22_5.shower_0.coincidences.col('r'), bins=100, histtype='step')
    graph.histogram(n, bins, linestyle='black!50')

    shower = data.root.simulations.E_1PeV.zenith_22_5.shower_0
    ids = shower.observables.get_where_list('(n1 >= 1) & (n3 >= 1) & (n4 >= 1)')
    R = shower.coincidences.read_coordinates(ids, field='r')
    n, bins, patches = hist(R, bins=100, histtype='step')
    graph.histogram(n, bins)

    xlabel("Core distance [m]")
    ylabel("Number of events")

    print("mean", mean(R))
    print("median", median(R))

    graph.set_xlabel(r"Core distance [\si{\meter}]")
    graph.set_ylabel("Number of events")
    graph.set_xlimits(min=0)
    graph.set_ylimits(min=0)
    graph.save('plots/SIM-R')