m-thesis-introduction/airshower_beacon_simulation/bd_antenna_phase_deltas.py

#!/usr/bin/env python3
# vim: fdm=indent ts=4

import h5py
from itertools import combinations, zip_longest
import matplotlib.pyplot as plt
from matplotlib.colors import Normalize
import matplotlib as mpl
import numpy as np
import json

import aa_generate_beacon as beacon
import lib
from lib import figlib


if __name__ == "__main__":
    from os import path
    import sys

    import os
    import matplotlib
    if os.name == 'posix' and "DISPLAY" not in os.environ:
        matplotlib.use('Agg')

    from scriptlib import MyArgumentParser
    parser = MyArgumentParser()
    args = parser.parse_args()

    figsize = (12,8)

    show_plots = args.show_plots
    ref_ant_id = None # leave None for all baselines

    ####
    fname_dir = args.data_dir
    antennas_fname = path.join(fname_dir, beacon.antennas_fname)
    time_diffs_fname = 'time_diffs.hdf5' if False else antennas_fname
    fig_dir = args.fig_dir # set None to disable saving
    beacon_snr_fname = path.join(fname_dir, beacon.beacon_snr_fname)

    basenames, time_diffs, f_beacons, clock_phase_diffs, k_periods = beacon.read_baseline_time_diffs_hdf5(time_diffs_fname)

    f_beacon, tx, antennas = beacon.read_beacon_hdf5(antennas_fname)

    # TODO: allow multiple frequencies
    if (f_beacon != f_beacons).any():
        raise NotImplementedError

    N_base = len(basenames)
    N_ant = len(antennas)

    # reshape time_diffs into N_ant x N_ant matrix
    clock_phase_matrix = np.full( (N_ant, N_ant), np.nan, dtype=float)

    ## set i=i terms to 0
    for i in range(N_ant):
        clock_phase_matrix[i,i] = 0

    ## fill matrix
    name2idx = lambda name: int(name)-1
    for i, b in enumerate(basenames):
        idx = (name2idx(b[0]), name2idx(b[1]))

        #if idx[1] < idx[0]:
        #    idx = (idx[1], idx[0])

        clock_phase_matrix[(idx[0], idx[1])] = lib.phase_mod(clock_phase_diffs[i])
        clock_phase_matrix[(idx[1], idx[0])] = lib.phase_mod(-1*clock_phase_diffs[i])

    mat_kwargs = dict(
        norm = Normalize(vmin=-np.pi, vmax=+np.pi),
        cmap = mpl.cm.get_cmap('Spectral_r')
    )

    # Show Matrix as figure
    if True:
        fig, ax = plt.subplots(figsize=figsize)
        ax.set_title("Measured clock phase differences Baseline i,j")
        ax.set_ylabel("Antenna no. i")
        ax.set_xlabel("Antenna no. j")

        im = ax.imshow(clock_phase_matrix, interpolation='none', **mat_kwargs)
        fig.colorbar(im, ax=ax)

        if fig_dir:
            fig.savefig(path.join(fig_dir, path.basename(__file__) + f".matrix.original.pdf"))

        plt.close(fig)


    # Modify the matrix to let each column represent multiple
    # measurements of the same baseline (j,0) phase difference
    if True:
        # for each row j subtract the 0,j element from the whole row
        # and apply phase_mod
        first_row = -1*(clock_phase_matrix[0,:] * np.ones_like(clock_phase_matrix)).T

        # Show subtraction Matrix as figure
        if True:
            fig, ax = plt.subplots(figsize=figsize)
            ax.set_title("Clock Phase Subtraction matrix i,j")
            ax.set_ylabel("Antenna no. i")
            ax.set_xlabel("Antenna no. j")

            im = ax.imshow(first_row, interpolation='none', **mat_kwargs)
            fig.colorbar(im, ax=ax)

            if fig_dir:
                fig.savefig(path.join(fig_dir, path.basename(__file__) + f".matrix.first_row.pdf"))

            plt.close(fig)

        clock_phase_matrix = clock_phase_matrix - first_row
        clock_phase_matrix = lib.phase_mod(clock_phase_matrix)

    # Except for the first row, these are all separate measurements
    # Condense into phase offset per antenna
    if True: # do not use the first row
        my_mask = np.arange(1, len(clock_phase_matrix), dtype=int)
    else:
        my_mask = np.arange(0, len(clock_phase_matrix), dtype=int)

    mean_clock_phase = np.nanmean(clock_phase_matrix[my_mask], axis=0)
    std_clock_phase  = np.nanstd( clock_phase_matrix[my_mask], axis=0)

    # Remove the mean from the matrix
    if False:
        clock_phase_matrix = clock_phase_matrix - np.mean(mean_clock_phase)
        mean_clock_phase = np.nanmean(clock_phase_matrix[my_mask], axis=0)
        std_clock_phase  = np.nanstd( clock_phase_matrix[my_mask], axis=0)

    # Show resulting matrix as figure
    if True:
        fig, axs = plt.subplots(2,1, sharex=True, figsize=figsize)
        axs[0].set_title("Modified clock phase differences Baseline 0,j")
        axs[0].set_ylabel("Antenna no. 0")
        axs[-1].set_xlabel("Antenna no. j")

        im = axs[0].imshow(clock_phase_matrix, interpolation='none', **mat_kwargs)
        fig.colorbar(im, ax=axs)
        axs[0].set_aspect('auto')

        colours = [mat_kwargs['cmap'](mat_kwargs['norm'](x)) for x in mean_clock_phase]
        axs[1].set_ylabel("Mean Baseline Phase (0, j)[rad]")
        axs[1].errorbar(np.arange(N_ant), mean_clock_phase, yerr=std_clock_phase, ls='none')
        axs[1].scatter(np.arange(N_ant), mean_clock_phase, c=colours,s=4)

        if fig_dir:
            fig.savefig(path.join(fig_dir, path.basename(__file__) + f".matrix.modified.pdf"))

        plt.close(fig)

    # write into antenna hdf5
    with h5py.File(antennas_fname, 'a') as fp:
        group = fp['antennas']

        freq_name = None
        for i, ant in enumerate(antennas):
            h5ant = group[ant.name]

            h5beacon_info = h5ant['beacon_info']

            # find out freq_name
            if freq_name is None:
                freq_name = [ k for k in h5beacon_info.keys() if np.isclose(h5beacon_info[k].attrs['freq'], f_beacon)][0]

            h5attrs = h5beacon_info[freq_name].attrs

            idx = name2idx(ant.name)
            h5attrs['clock_phase_mean'] = mean_clock_phase[idx]
            h5attrs['clock_phase_std']  =  std_clock_phase[idx]


    ##############################
    # Compare actual time shifts #
    ##############################
    beacon_snrs = beacon.read_snr_file(beacon_snr_fname)
    snr_str = f"$\\langle SNR \\rangle$ = {beacon_snrs['mean']: .1e}"

    actual_antenna_time_shifts = { a.name: a.attrs['clock_offset'] for a in sorted(antennas, key=lambda a: int(a.name)) }

    if True:
        actual_antenna_phase_shifts = [ -1*lib.phase_mod(2*np.pi*f_beacon*v) for k,v in actual_antenna_time_shifts.items() ]
        antenna_names = [int(k)-1 for k,v in actual_antenna_time_shifts.items() ]

        # Make sure to shift all antennas by a global phase
        global_phase_shift = actual_antenna_phase_shifts[0] - mean_clock_phase[0]
        actual_antenna_phase_shifts = lib.phase_mod(actual_antenna_phase_shifts - global_phase_shift )

        fit_info = {}
        for i in range(2):
            plot_residuals = i == 1
            true_phases = actual_antenna_phase_shifts
            measured_phases = mean_clock_phase

            hist_kwargs = {}
            if plot_residuals:
                measured_phases = lib.phase_mod(measured_phases - actual_antenna_phase_shifts)

            fig, _fit_info = figlib.phase_comparison_figure(
                    measured_phases,
                    true_phases,
                    plot_residuals=plot_residuals,
                    f_beacon=f_beacon,
                    figsize=figsize,
                    hist_kwargs=hist_kwargs,
                    fit_gaussian=plot_residuals,
                    fit_randomphasesum=plot_residuals,
                    return_fit_info = True,
                    )

            axs = fig.get_axes()
            axs[0].legend(title=snr_str)

            if plot_residuals:
                axs[0].set_title("Difference between Measured and Actual phases (minus global phase)\n for Antenna $i$")
                axs[-1].set_xlabel("Antenna Mean Phase Residual $\\Delta_\\varphi$")
            else:
                axs[0].set_title("Comparison Measured and Actual phases (minus global phase)\n for Antenna $i$")
                axs[-1].set_xlabel("Antenna Mean Phase $\\varphi$")

            i=1
            axs[i].set_ylabel("Antenna no.")
            #axs[i].errorbar(mean_clock_phase, np.arange(N_ant), yerr=std_clock_phase, marker='4', alpha=0.7, ls='none', color=colors[0], label='Measured')

            fig.tight_layout()

            if fig_dir:
                extra_name = "measured"
                if plot_residuals:
                    extra_name = "residuals"
                fig.savefig(path.join(fig_dir, path.basename(__file__) + f".phase.{extra_name}.pdf"))

            # Save fit_info to data file
            if fname_dir and plot_residuals:
                with open(path.join(fname_dir, 'phase_time_residuals.json'), 'w') as fp:
                    json.dump(
                        {
                            'mean': np.mean(measured_phases),
                            'std': np.std(measured_phases),
                            'values': measured_phases.tolist(),
                        },
                        fp)



    ##########################
    ##########################
    ##########################

    actual_baseline_time_shifts = []
    for i,b in enumerate(basenames):
        actual_baseline_time_shift = actual_antenna_time_shifts[b[0]] - actual_antenna_time_shifts[b[1]]

        actual_baseline_time_shifts.append(actual_baseline_time_shift)

    # unpack mean_clock_phase back into a list of time diffs
    measured_baseline_time_diffs = []
    for i,b in enumerate(basenames):
        phase0, phase1 = mean_clock_phase[name2idx(b[0])], mean_clock_phase[name2idx(b[1])]
        measured_baseline_time_diffs.append(lib.phase_mod(phase1 - phase0)/(2*np.pi*f_beacon))

    # Make a plot
    if True:
        for i in range(2):
            fig, ax = plt.subplots(figsize=figsize)
            ax.set_title("Baseline Time difference reconstruction" + ( '' if i == 0 else ' (wrapped time)'))
            ax.set_xlabel("Baseline no.")
            ax.set_ylabel("Time $\\Delta t$ [ns]")
            if True:
                forward = lambda x: x/(2*np.pi*f_beacon)
                inverse = lambda x: 2*np.pi*x*f_beacon
                secax = ax.secondary_yaxis('right', functions=(inverse, forward))
                secax.set_ylabel('Phase $\\Delta \\varphi$ [rad]')

            if True: # indicate single beacon period span
                ax.plot((-1, -1), (-1/(2*f_beacon), 1/(2*f_beacon)), marker='3', ms=10, label='1/f_beacon')
            if i == 0:
                ax.plot(np.arange(N_base), actual_baseline_time_shifts, ls='none', marker='h', alpha=0.8, label='actual time shifts')
            else:
                ax.plot(np.arange(N_base), (actual_baseline_time_shifts+1/(2*f_beacon))%(1/f_beacon) - 1/(2*f_beacon), ls='none', marker='h', label='actual time shifts', alpha=0.8)
            ax.plot(np.arange(N_base), measured_baseline_time_diffs, ls='none', alpha=0.8, marker='x', label='calculated')

            ax.legend(title=snr_str)
            if fig_dir:
                extra_name = ''
                if i == 1:
                    extra_name = '.wrapped'

                old_lims = (ax.get_xlim(), ax.get_ylim())
                for j in range(2):
                    if j == 1:
                        ax.set_xlim(-5, 50)
                        extra_name += '.n50'
                    fig.savefig(path.join(fig_dir, path.basename(__file__) + f".time_comparison{extra_name}.pdf"))

                ax.set_xlim(*old_lims[0])
                ax.set_ylim(*old_lims[1])

    if show_plots:
        plt.show()