Example #1
0
def create_input_table(all_results_dirs, savepath):

    column_labels = [
        "Case " + str(int(all_results_dirs[i].split("_")[-1]) + 1)
        for i in range(len(all_results_dirs))
    ]
    row_labels = [
        "$Noise standard deviation (m) $", "Correlation distance (m)",
        "Monte-Carlo samples (-)"
    ]

    res = np.zeros([3, len(all_results_dirs)])

    for i in range(len(all_results_dirs)):
        with open(all_results_dirs[i] + "/input_file.json") as f:
            data = json.load(f)
        res[0, i] = data["ERROR_STANDARD_DEV"]
        res[1, i] = data["CORRELATION_DISTANCE"]
        res[2, i] = int(data["N_MONTE_CARLO"])

    np_array_to_latex(res,
                      savepath,
                      row_headers=row_labels,
                      column_headers=column_labels,
                      column=True,
                      type='f',
                      decimals=2,
                      ante_decimals=6)
Example #2
0
                         len(col_headers_array)] = int(data["NUMBER_OF_EDGES"])
        parameter_matrix[2, len(col_headers_array)] = int(
            data["USE_BEZIER_SHAPE"])
        parameter_matrix[3, len(col_headers_array)] = 1000 * float(
            data["INSTRUMENT_FREQUENCY_SHAPE"])
        col_headers_array += [directory.replace("_", " ")]

    if (len(col_headers_array) == array_length):

        col_headers_arrays += [col_headers_array]
        parameter_matrices_arrays += [parameter_matrix]

        np_array_to_latex.np_array_to_latex(
            parameter_matrix,
            "/Users/bbercovici/GDrive/CUBoulder/Research/conferences/GNSKi_2019/paper/Figures/inputs_"
            + str(col_headers_array[0]).split(" ")[1] + "_" +
            str(col_headers_array[-1]).split(" ")[1],
            row_headers=row_headers,
            column_headers=col_headers_array)

        parameter_matrix = np.zeros([
            4,
            min(
                array_length,
                len(dir_list) - int(str(col_headers_array[-1]).split(" ")[1]) -
                1)
        ])
        col_headers_array = []

linestyles = ['-.', '--', '-d', '-v', '-D', '+', '*']
w
Example #3
0
import numpy as np
from np_array_to_latex import np_array_to_latex

## Export an np.array to the bmatrix format
a = np.array(range(0,16)).reshape([4,4])
# a == [[ 0  1  2  3]
#    [ 4  5  6  7]
#    [ 8  9 10 11]
#    [12 13 14 15]]

np_array_to_latex(a,'a_to_latex')
# a_to_latex.tex:
# \begin{bmatrix}
# 0 & 1 & 2 & 3\\
# 4 & 5 & 6 & 7\\
# 8 & 9 & 10 & 11\\
# 12 & 13 & 14 & 15\\
# \end{bmatrix}






## Export a one-dimensional np.array to the bmatrix format,
# choosing between column vector or row vector format
b = a[0,:]
# b ==  [[0 1 2 3]

# column vector format
np_array_to_latex(b,'b_to_latex_column')
Example #4
0
def plot_all_results(input_dir, output_dir=""):

    prefix = input_dir.split("/")[-1] + "_"

    print("Plotting case " + prefix + "\n")

    slices_x = [input_dir + "/slice_x_" + str(i) + ".txt" for i in range(20)]
    slices_y = [input_dir + "/slice_y_" + str(i) + ".txt" for i in range(20)]
    slices_z = [input_dir + "/slice_z_" + str(i) + ".txt" for i in range(20)]

    slices_x = [input_dir + "/slice_x_baseline.txt"] + slices_x
    slices_y = [input_dir + "/slice_y_baseline.txt"] + slices_y
    slices_z = [input_dir + "/slice_z_baseline.txt"] + slices_z

    cov_cm_mc = 1e6 * np.loadtxt(input_dir + "/cov_cm_mc.txt")
    cov_cm_model = 1e6 * np.loadtxt(input_dir + "/cm_cov.txt")
    cm = 1e3 * np.loadtxt(input_dir + "/cm_spread.txt")

    cov_inertia_mc = np.loadtxt(input_dir + "/cov_inertia_mc.txt")
    cov_inertia_model = np.loadtxt(input_dir + "/inertia_cov.txt")
    inertia = np.loadtxt(input_dir + "/inertia_spread.txt")
    inertia = (inertia.T - np.mean(inertia, axis=1)).T

    cov_moments_mc = np.loadtxt(input_dir + "/cov_moments_mc.txt")
    cov_moments_model = np.loadtxt(input_dir + "/moments_cov.txt")
    moments = np.loadtxt(input_dir + "/moments_spread.txt")
    moments = (moments.T - np.mean(moments, axis=1)).T

    cov_dims_mc = np.loadtxt(input_dir + "/cov_dims_mc.txt")
    cov_dims_model = np.loadtxt(input_dir + "/dims_cov.txt")
    dims = np.loadtxt(input_dir + "/dims_spread.txt")
    dims = (dims.T - np.mean(dims, axis=1)).T

    cov_mrp_mc = np.loadtxt(input_dir + "/cov_mrp_mc.txt")
    cov_mrp_model = np.loadtxt(input_dir + "/mrp_cov.txt")
    mrp = np.loadtxt(input_dir + "/mrp_spread.txt")
    mrp = (mrp.T - np.mean(mrp, axis=1)).T

    fig = plt.figure()

    if (len(output_dir) > 0):
        create_output_table(cov_mrp_model, cov_mrp_mc, cov_cm_model, cov_cm_mc,
                            cov_inertia_model, cov_inertia_mc, cov_dims_model,
                            cov_dims_mc, cov_moments_model, cov_moments_mc,
                            prefix, output_dir)

        inertia_tensor = np.zeros([3, 3])
        inertia_vector = np.loadtxt(input_dir + "/I.txt")
        inertia_tensor[0, 0] = inertia_vector[0]
        inertia_tensor[1, 1] = inertia_vector[1]
        inertia_tensor[2, 2] = inertia_vector[2]
        inertia_tensor[0, 1] = inertia_vector[3]
        inertia_tensor[0, 2] = inertia_vector[4]
        inertia_tensor[1, 2] = inertia_vector[5]

        moments_mean = np.loadtxt(input_dir + "/moments.txt")[0:3]
        np_array_to_latex(moments_mean,
                          output_dir + "/" + prefix + "moments",
                          decimals=3,
                          type="e")

        dims_mean = np.loadtxt(input_dir + "/dims.txt")
        np_array_to_latex(dims_mean,
                          output_dir + "/" + prefix + "dims",
                          decimals=3,
                          type="e")

    draw_slice(0, slices_x, output_dir=output_dir, prefix=prefix)
    draw_slice(1, slices_y, output_dir=output_dir, prefix=prefix)
    draw_slice(2, slices_z, output_dir=output_dir, prefix=prefix)

    draw_dispersions("com",
                     0,
                     cm,
                     cov_cm_mc,
                     cov_cm_model, [
                         r"$\delta \mathbf{c}_{m,x}$ ($\mathrm{m}$)",
                         r"$\delta \mathbf{c}_{m,y}$ ($\mathrm{m}$)",
                         r"$\delta \mathbf{c}_{m,z}$ ($\mathrm{m}$)"
                     ],
                     output_dir=output_dir,
                     prefix=prefix)
    draw_dispersions("com",
                     1,
                     cm,
                     cov_cm_mc,
                     cov_cm_model, [
                         r"$\delta \mathbf{c}_{m,x}$ ($\mathrm{m}$)",
                         r"$\delta \mathbf{c}_{m,y}$ ($\mathrm{m}$)",
                         r"$\delta \mathbf{c}_{m,z}$ ($\mathrm{m}$)"
                     ],
                     output_dir=output_dir,
                     prefix=prefix)
    draw_dispersions("com",
                     2,
                     cm,
                     cov_cm_mc,
                     cov_cm_model, [
                         r"$\delta \mathbf{c}_{m,x}$ ($\mathrm{m}$)",
                         r"$\delta \mathbf{c}_{m,y}$ ($\mathrm{m}$)",
                         r"$\delta \mathbf{c}_{m,z}$ ($\mathrm{m}$)"
                     ],
                     output_dir=output_dir,
                     prefix=prefix)

    draw_dispersions(
        "dims",
        0,
        dims,
        cov_dims_mc,
        cov_dims_model, [
            r"$\delta a$ ($\mathrm{km}$)", r"$\delta b$ ($\mathrm{km}$)",
            r"$\delta c$ ($\mathrm{km}$)"
        ],
        output_dir=output_dir,
        prefix=prefix)
    draw_dispersions(
        "dims",
        1,
        dims,
        cov_dims_mc,
        cov_dims_model, [
            r"$\delta a$ ($\mathrm{km}$)", r"$\delta b$ ($\mathrm{km}$)",
            r"$\delta c$ ($\mathrm{km}$)"
        ],
        output_dir=output_dir,
        prefix=prefix)
    draw_dispersions(
        "dims",
        2,
        dims,
        cov_dims_mc,
        cov_dims_model, [
            r"$\delta a$ ($\mathrm{km}$)", r"$\delta b$ ($\mathrm{km}$)",
            r"$\delta c$ ($\mathrm{km}$)"
        ],
        output_dir=output_dir,
        prefix=prefix)

    draw_dispersions("moments",
                     0,
                     1000 * moments,
                     1e6 * cov_moments_mc,
                     1e6 * cov_moments_model, [
                         r"$1000\cdot\delta A/\rho$ ($\mathrm{km}^5$)",
                         r"$1000\cdot\delta B/\rho$ ($\mathrm{km}^5$)",
                         r"$1000\cdot\delta C/\rho$ ($\mathrm{km}^5$)"
                     ],
                     output_dir=output_dir,
                     prefix=prefix)
    draw_dispersions("moments",
                     1,
                     1000 * moments,
                     1e6 * cov_moments_mc,
                     1e6 * cov_moments_model, [
                         r"$1000\cdot\delta A/\rho$ ($\mathrm{km}^5$)",
                         r"$1000\cdot\delta B/\rho$ ($\mathrm{km}^5$)",
                         r"$1000\cdot\delta C/\rho$ ($\mathrm{km}^5$)"
                     ],
                     output_dir=output_dir,
                     prefix=prefix)
    draw_dispersions("moments",
                     2,
                     1000 * moments,
                     1e6 * cov_moments_mc,
                     1e6 * cov_moments_model, [
                         r"$1000\cdot\delta A/\rho$ ($\mathrm{km}^5$)",
                         r"$1000\cdot\delta B/\rho$ ($\mathrm{km}^5$)",
                         r"$1000\cdot\delta C/\rho$ ($\mathrm{km}^5$)"
                     ],
                     output_dir=output_dir,
                     prefix=prefix)

    draw_dispersions(
        "mrp",
        0,
        mrp,
        cov_mrp_mc,
        cov_mrp_model,
        [r"$\delta \sigma_1$", r"$\delta \sigma_2$", r"$\delta \sigma_3$"],
        output_dir=output_dir,
        prefix=prefix)
    draw_dispersions(
        "mrp",
        1,
        mrp,
        cov_mrp_mc,
        cov_mrp_model,
        [r"$\delta \sigma_1$", r"$\delta \sigma_2$", r"$\delta \sigma_3$"],
        output_dir=output_dir,
        prefix=prefix)
    draw_dispersions(
        "mrp",
        2,
        mrp,
        cov_mrp_mc,
        cov_mrp_model,
        [r"$\delta \sigma_1$", r"$\delta \sigma_2$", r"$\delta \sigma_3$"],
        output_dir=output_dir,
        prefix=prefix)
Example #5
0
def create_output_table(cov_mrp_model, cov_mrp_mc, cov_cm_model, cov_cm_mc,
                        cov_inertia_model, cov_inertia_mc, cov_dims_model,
                        cov_dims_mc, cov_moments_model, cov_moments_mc, prefix,
                        output_dir):

    np_array_to_latex(cov_mrp_model,
                      output_dir + "/" + prefix + "mrp_cov",
                      decimals=3,
                      type="e",
                      is_symmetric="upper")
    np_array_to_latex(cov_mrp_mc,
                      output_dir + "/" + prefix + "cov_mrp_mc",
                      decimals=3,
                      type="e",
                      is_symmetric="upper")
    np_array_to_latex((cov_mrp_model - cov_mrp_mc) / cov_mrp_mc * 100,
                      output_dir + "/" + prefix + "cov_mrp_dev",
                      decimals=3,
                      is_symmetric="upper")

    np_array_to_latex(cov_cm_model,
                      output_dir + "/" + prefix + "cm_cov",
                      decimals=3,
                      is_symmetric="upper",
                      type="e")
    np_array_to_latex(cov_cm_mc,
                      output_dir + "/" + prefix + "cov_cm_mc",
                      decimals=3,
                      is_symmetric="upper",
                      type="e")
    np_array_to_latex((cov_cm_model - cov_cm_mc) / cov_cm_mc * 100,
                      output_dir + "/" + prefix + "cov_cm_dev",
                      decimals=3,
                      is_symmetric="upper")

    np_array_to_latex(cov_inertia_model,
                      output_dir + "/" + prefix + "inertia_cov",
                      decimals=3,
                      is_symmetric="upper",
                      type="e")
    np_array_to_latex(cov_inertia_mc,
                      output_dir + "/" + prefix + "cov_inertia_mc",
                      decimals=3,
                      is_symmetric="upper",
                      type="e")
    np_array_to_latex(
        (cov_inertia_model - cov_inertia_mc) / cov_inertia_mc * 100,
        output_dir + "/" + prefix + "cov_inertia_dev",
        decimals=3,
        is_symmetric="upper")

    np_array_to_latex(cov_dims_model,
                      output_dir + "/" + prefix + "dims_cov",
                      decimals=3,
                      is_symmetric="upper",
                      type="e")
    np_array_to_latex(cov_dims_mc,
                      output_dir + "/" + prefix + "cov_dims_mc",
                      decimals=3,
                      is_symmetric="upper",
                      type="e")
    np_array_to_latex((cov_dims_model - cov_dims_mc) / cov_dims_mc * 100,
                      output_dir + "/" + prefix + "cov_dims_dev",
                      decimals=3,
                      is_symmetric="upper")

    np_array_to_latex(cov_moments_model[0:3, 0:3],
                      output_dir + "/" + prefix + "moments_cov",
                      decimals=3,
                      type="e",
                      is_symmetric="upper")
    np_array_to_latex(cov_moments_mc[0:3, 0:3],
                      output_dir + "/" + prefix + "cov_moments_mc",
                      decimals=3,
                      type="e",
                      is_symmetric="upper")
    np_array_to_latex(
        (cov_moments_model[0:3, 0:3] - cov_moments_mc[0:3, 0:3]) /
        cov_moments_mc[0:3, 0:3] * 100,
        output_dir + "/" + prefix + "cov_moments_dev",
        decimals=3,
        is_symmetric="upper")
Example #6
0
def create_input_tables(all_results_dirs, save_path, table_size=10):
    n_tables = int(float(len(all_results_dirs)) / table_size)
    size_last_table = len(all_results_dirs) - n_tables * table_size

    print((len(all_results_dirs), n_tables, size_last_table))
    for table_index in range(n_tables):

        table = np.zeros([5, table_size])

        for i in range(table_size):
            data = {}
            with open(all_results_dirs[table_index * table_size + i] +
                      "/input_file.json") as f:
                data = json.load(f)

            table[0, i] = data["LOS_NOISE_SD_BASELINE"]
            table[1, i] = 1e9 * data["PROCESS_NOISE_SIGMA_VEL"]
            table[2, i] = 1e9 * data["PROCESS_NOISE_SIGMA_OMEG"]
            table[3, i] = int(1. / data["INSTRUMENT_FREQUENCY_NAV"])
            table[4, i] = str(
                int(data["SHAPE_RECONSTRUCTION_OUTPUT_DIR"].split("_")[-1][0])
                + 1 + (6 if "robustness" in
                       str(data["SHAPE_RECONSTRUCTION_OUTPUT_DIR"]) else 0))

            print([table_index * table_size + i, table[4, i]])

        np_array_to_latex(
            table,
            save_path + "/input_table_case_" +
            str(table_index * table_size + 1) + "_to_" +
            str(table_index * table_size + table_size),
            row_headers=[
                r"$\sigma_{\rho}$ ($\mathrm{m}$)",
                r"$\sigma_{\ddot{\mathbf{r}}}$ ($\mathrm{nm/s^2}$)",
                r"$\sigma_{\dot{\boldsymbol{\omega}}}$ ($\mathrm{nrad/s^2}$)",
                r"$T_{\mathrm{obs}}$ ($\mathrm{s}$)", "Input Case"
            ],
            column_headers=[
                "Case " + str(i)
                for i in range(table_index * table_size +
                               1, table_index * table_size + 1 + table_size +
                               1)
            ],
            column=True,
            type='f',
            decimals=2,
            ante_decimals=6,
            is_symmetric="no",
            pretty=True,
            integer_row=[3, 4])

    table = np.zeros([5, size_last_table])
    if (size_last_table > 0):
        for i in range(size_last_table):
            data = {}
            with open(all_results_dirs[n_tables * table_size + i] +
                      "/input_file.json") as f:
                data = json.load(f)

            table[0, i] = data["LOS_NOISE_SD_BASELINE"]
            table[1, i] = 1e9 * data["PROCESS_NOISE_SIGMA_VEL"]
            table[2, i] = 1e9 * data["PROCESS_NOISE_SIGMA_OMEG"]
            table[3, i] = int(1. / data["INSTRUMENT_FREQUENCY_NAV"])
            table[4, i] = str(
                int(data["SHAPE_RECONSTRUCTION_OUTPUT_DIR"].split("_")[-1][0])
                + 1 + (6 if "robustness" in
                       str(data["SHAPE_RECONSTRUCTION_OUTPUT_DIR"]) else 0))

        np_array_to_latex(
            table,
            save_path + "/input_table_case_" + str(n_tables * table_size + 1) +
            "_to_" + str((n_tables) * table_size + size_last_table),
            row_headers=[
                r"$\sigma_{\rho}$ ($\mathrm{m}$)",
                r"$\sigma_{\ddot{\mathbf{r}}}$ ($\mathrm{nm/s^2}$)",
                r"$\sigma_{\dot{\boldsymbol{\omega}}}$ ($\mathrm{nrad/s^2}$)",
                r"$T_{\mathrm{obs}}$ ($\mathrm{s}$)", "Input Case"
            ],
            column_headers=[
                "Case " + str(i) for i in range((n_tables) * table_size +
                                                1, (n_tables) * table_size +
                                                1 + size_last_table)
            ],
            column=True,
            type='f',
            decimals=2,
            ante_decimals=6,
            is_symmetric="no",
            pretty=True,
            integer_row=[3, 4])
Example #7
0
def create_output_tables(all_results_dirs, save_path, table_size=10):
    n_tables = int(float(len(all_results_dirs)) / table_size)
    size_last_table = len(all_results_dirs) - n_tables * table_size

    full_output_table = np.zeros([6, len(all_results_dirs)])

    row_headers = [
        r"$\sigma_{\mathbf{r}}$ ($\mathrm{m}$)",
        r"$\sigma_{\dot{\mathbf{r}}}$ ($\mathrm{mm/s}$)",
        r"$\sigma_{\boldsymbol{\sigma}}$ ($\mathrm{deg}$)",
        r"$\sigma_{\boldsymbol{\omega}}$ ($\mathrm{\mu deg/s}$)",
        r"$\sigma_{\mu}$ ($\mathrm{cm^3/s^2}$)", r"$\sigma_{C_r}$"
    ]

    for table_index in range(n_tables):

        table = np.zeros([6, table_size])
        table[:] = np.nan

        for i in range(table_size):

            input_path = all_results_dirs[table_index * table_size + i]

            try:
                X_true = np.loadtxt(input_path + "/X_true.txt")
                X_hat = np.loadtxt(input_path + "/X_hat.txt")
            except IOError:
                print("Skipping " + str(input_path) + ", can't find outputs")
                continue

            dX = X_hat - X_true

            mrp_error = np.zeros([3, dX.shape[1]])
            principal_angle_error = np.zeros(dX.shape[1])
            for t in range(dX.shape[1]):
                mrp_error[:, t] = RBK.dcm_to_mrp(
                    RBK.mrp_to_dcm(X_true[6:9, t]).T.dot(
                        RBK.mrp_to_dcm(X_hat[6:9, t])))
                principal_angle_error[t] = 4 * np.arctan(
                    np.linalg.norm(mrp_error[:, t]))

            mean_dX_position = np.mean(dX[0:3, :], axis=1)
            mean_dX_velocity = np.mean(dX[3:6, :], axis=1)
            mean_dX_principal_angle = np.mean(principal_angle_error)
            mean_dX_omega = np.mean(dX[9:12, :], axis=1)
            mean_dX_Mu = np.mean(dX[12, :])
            mean_dX_Cr = np.mean(dX[13, :])

            sd_position = 0
            sd_velocity = 0
            sd_mrp = 0
            sd_omega = 0
            sd_mu = 0
            sd_Cr = 0

            for t in range(dX.shape[1]):
                sd_position += 1. / (dX.shape[1] -
                                     1) * np.linalg.norm(dX[0:3, t] -
                                                         mean_dX_position)**2
                sd_velocity += 1. / (dX.shape[1] -
                                     1) * np.linalg.norm(dX[3:6, t] -
                                                         mean_dX_velocity)**2
                sd_mrp += 1. / (dX.shape[1] - 1) * (principal_angle_error[t] -
                                                    mean_dX_principal_angle)**2
                sd_omega += 1. / (dX.shape[1] -
                                  1) * np.linalg.norm(dX[9:12, t] -
                                                      mean_dX_omega)**2
                sd_mu += 1. / (dX.shape[1] - 1) * (dX[12, t] - mean_dX_Mu)**2
                sd_Cr += 1. / (dX.shape[1] - 1) * (dX[13, t] - mean_dX_Cr)**2

            sd_position = np.sqrt(sd_position)
            sd_velocity = 1e3 * np.sqrt(sd_velocity)
            sd_mrp = 180. / np.pi * np.sqrt(sd_mrp)
            sd_omega = 1e6 * 180. / np.pi * np.sqrt(sd_omega)
            sd_mu = 1e6 * np.sqrt(sd_mu)
            sd_Cr = np.sqrt(sd_Cr)

            table[0, i] = sd_position
            table[1, i] = sd_velocity
            table[2, i] = sd_mrp
            table[3, i] = sd_omega
            table[4, i] = sd_mu
            table[5, i] = sd_Cr

        full_output_table[:,
                          table_index * table_size:table_index * table_size +
                          table_size] = table
        np_array_to_latex(
            table,
            save_path + "/output_table_case_" +
            str(table_index * table_size + 1) + "_to_" +
            str(table_index * table_size + table_size),
            row_headers=row_headers,
            column_headers=[
                "Case " + str(i)
                for i in range(table_index * table_size +
                               1, table_index * table_size + 1 + table_size +
                               1)
            ],
            column=True,
            type='f',
            decimals=3,
            ante_decimals=6,
            is_symmetric="no",
            pretty=True)

    table = np.zeros([6, size_last_table])
    table[:] = np.nan

    if (size_last_table > 0):
        for i in range(size_last_table):

            input_path = all_results_dirs[(n_tables) * table_size + i]

            try:
                X_true = np.loadtxt(input_path + "/X_true.txt")
                X_hat = np.loadtxt(input_path + "/X_hat.txt")
            except IOError:
                print("Skipping " + str(input_path) + ", can't find outputs")

                continue

            dX = X_hat - X_true

            mrp_error = np.zeros([3, dX.shape[1]])
            principal_angle_error = np.zeros(dX.shape[1])
            for t in range(dX.shape[1]):
                mrp_error[:, t] = RBK.dcm_to_mrp(
                    RBK.mrp_to_dcm(X_true[6:9, t]).T.dot(
                        RBK.mrp_to_dcm(X_hat[6:9, t])))
                principal_angle_error[t] = 4 * np.arctan(
                    np.linalg.norm(mrp_error[:, t]))

            mean_dX_position = np.mean(dX[0:3, :], axis=1)
            mean_dX_velocity = np.mean(dX[3:6, :], axis=1)
            mean_dX_omega = np.mean(dX[9:12, :], axis=1)
            mean_dX_principal_angle = np.mean(principal_angle_error)
            mean_dX_Mu = np.mean(dX[12, :])
            mean_dX_Cr = np.mean(dX[13, :])

            sd_position = 0
            sd_velocity = 0
            sd_mrp = 0
            sd_omega = 0
            sd_mu = 0
            sd_Cr = 0

            for t in range(dX.shape[1]):
                sd_position += 1. / (dX.shape[1] -
                                     1) * np.linalg.norm(dX[0:3, t] -
                                                         mean_dX_position)**2
                sd_velocity += 1. / (dX.shape[1] -
                                     1) * np.linalg.norm(dX[3:6, t] -
                                                         mean_dX_velocity)**2
                sd_mrp += 1. / (dX.shape[1] - 1) * (principal_angle_error[t] -
                                                    mean_dX_principal_angle)**2
                sd_omega += 1. / (dX.shape[1] -
                                  1) * np.linalg.norm(dX[9:12, t] -
                                                      mean_dX_omega)**2
                sd_mu += 1. / (dX.shape[1] - 1) * (dX[12, t] - mean_dX_Mu)**2
                sd_Cr += 1. / (dX.shape[1] - 1) * (dX[13, t] - mean_dX_Cr)**2

            sd_position = np.sqrt(sd_position)
            sd_velocity = 1e3 * np.sqrt(sd_velocity)
            sd_mrp = 180. / np.pi * np.sqrt(sd_mrp)
            sd_omega = 1e6 * 180. / np.pi * np.sqrt(sd_omega)
            sd_mu = 1e6 * np.sqrt(sd_mu)
            sd_Cr = np.sqrt(sd_Cr)

            table[0, i] = sd_position
            table[1, i] = sd_velocity
            table[2, i] = sd_mrp
            table[3, i] = sd_omega
            table[4, i] = sd_mu
            table[5, i] = sd_Cr

        np_array_to_latex(table,
                          save_path + "/output_table_case_" +
                          str(n_tables * table_size + 1) + "_to_" +
                          str((n_tables) * table_size + size_last_table),
                          row_headers=row_headers,
                          column_headers=[
                              "Case " + str(i)
                              for i in range((n_tables) * table_size +
                                             1, (n_tables) * table_size + 1 +
                                             size_last_table)
                          ],
                          column=True,
                          type='f',
                          decimals=3,
                          ante_decimals=6,
                          is_symmetric="no",
                          pretty=True)

        full_output_table[:, n_tables * table_size:(n_tables) * table_size +
                          size_last_table] = table

        np.savetxt(save_path + "/all_nav_results_table.txt", full_output_table)