Plotting.py

# -*- coding: utf-8 -*-
"""
@author: Laura C. Kühle

TODO: Give option to select plotting color
TODO: Add documentation to plot_boxplot()
TODO: Adjust documentation for plot_classification_accuracy()

"""
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sympy import Symbol


x = Symbol('x')
z = Symbol('z')
sns.set()


def plot_solution_and_approx(grid, exact, approx, color_exact, color_approx):
    """"Plots approximate and exact solution against each other.

    Parameters
    ----------
    grid : np.array
        List of mesh evaluation points.
    exact : np.array
        Array containing exact evaluation of a function.
    approx : np.array
        Array containing approximate evaluation of a function.
    color_exact : str
        String describing color to plot exact solution.
    color_approx : str
        String describing color to plot approximate solution.

    """
    print(color_exact, color_approx)
    plt.figure('exact_and_approx')
    plt.plot(grid[0], exact[0], color_exact)
    plt.plot(grid[0], approx[0], color_approx)
    plt.xlabel('x')
    plt.ylabel('u(x,t)')
    plt.title('Solution and Approximation')


def plot_semilog_error(grid, pointwise_error):
    """"Plots semi-logarithmic error between approximate and exact solution.

    Parameters
    ----------
    grid : np.array
        List of mesh evaluation points.
    pointwise_error : np.array
        Array containing pointwise difference between exact and approximate solution.

    """
    plt.figure('semilog_error')
    plt.semilogy(grid[0], pointwise_error[0])
    plt.xlabel('x')
    plt.ylabel('|u(x,t)-uh(x,t)|')
    plt.title('Semilog Error plotted at Evaluation points')


def plot_error(grid, exact, approx):
    """"Plots error between approximate and exact solution.

    Parameters
    ----------
    grid : np.array
        List of mesh evaluation points.
    exact : np.array
        Array containing exact evaluation of a function.
    approx : np.array
        Array containing approximate evaluation of a function.

    """
    plt.figure('error')
    plt.plot(grid[0], exact[0]-approx[0])
    plt.xlabel('X')
    plt.ylabel('u(x,t)-uh(x,t)')
    plt.title('Errors')


def plot_shock_tube(num_grid_cells, troubled_cell_history, time_history):
    """"Plots shock tube.

    Plots detected troubled cells over time to depict the evolution of shocks as shock tubes.

    Parameters
    ----------
    num_grid_cells : int
        Number of cells in the mesh. Usually exponential of 2.
    troubled_cell_history : list
        List of detected troubled cells for each time step.
    time_history:
        List of value of each time step.

    """
    plt.figure('shock_tube')
    for pos in range(len(time_history)):
        current_cells = troubled_cell_history[pos]
        for cell in current_cells:
            plt.plot(cell, time_history[pos], 'k.')
    plt.xlim((0, num_grid_cells // 2))
    plt.xlabel('Cell')
    plt.ylabel('Time')
    plt.title('Shock Tubes')


def plot_details(fine_projection, fine_mesh, coarse_projection, basis, wavelet, multiwavelet_coeffs,
                 num_coarse_grid_cells, polynomial_degree):
    """"Plots details of projection to coarser mesh..

    Parameters
    ----------
    fine_projection, coarse_projection : np.array
        Matrix of projection for each polynomial degree.
    fine_mesh : np.array
        List of evaluation points for fine mesh.
    basis : np.array
        Basis vector for calculation.
    wavelet : np.array
        Wavelet vector for calculation.
    multiwavelet_coeffs : np.array
        Matrix of multiwavelet coefficients.
    num_coarse_grid_cells : int
        Number of cells in the coarse mesh (half the cells of the fine mesh).
        Usually exponential of 2.
    polynomial_degree : int
        Polynomial degree.

    """
    averaged_projection = [[coarse_projection[degree][cell] * basis[degree].subs(x, value)
                            for cell in range(num_coarse_grid_cells)
                            for value in [-0.5, 0.5]]
                           for degree in range(polynomial_degree + 1)]

    wavelet_projection = [[multiwavelet_coeffs[degree][cell] * wavelet[degree].subs(z, 0.5) * value
                           for cell in range(num_coarse_grid_cells)
                           for value in [(-1) ** (polynomial_degree + degree + 1), 1]]
                          for degree in range(polynomial_degree + 1)]

    projected_coarse = np.sum(averaged_projection, axis=0)
    projected_fine = np.sum([fine_projection[degree] * basis[degree].subs(x, 0)
                             for degree in range(polynomial_degree + 1)], axis=0)
    projected_wavelet_coeffs = np.sum(wavelet_projection, axis=0)

    plt.figure('coeff_details')
    plt.plot(fine_mesh, projected_fine - projected_coarse, 'm-.')
    plt.plot(fine_mesh, projected_wavelet_coeffs, 'y')
    plt.legend(['Fine-Coarse', 'Wavelet Coeff'])
    plt.xlabel('X')
    plt.ylabel('Detail Coefficients')
    plt.title('Wavelet Coefficients')


def calculate_approximate_solution(projection, points, polynomial_degree, basis):
    """"Calculates approximate solution.

    Parameters
    ----------
    projection : np.array
        Matrix of projection for each polynomial degree.
    points : np.array
        List of evaluation points for mesh.
    polynomial_degree : int
        Polynomial degree.
    basis : np.array
        Basis vector for calculation.

    Returns
    -------
    np.array
        Array containing approximate evaluation of a function.

    """
    num_points = len(points)

    basis_matrix = [[basis[degree].subs(x, points[point]) for point in range(num_points)]
                    for degree in range(polynomial_degree+1)]

    approx = [[sum(projection[degree][cell] * basis_matrix[degree][point]
                   for degree in range(polynomial_degree+1))
               for point in range(num_points)]
              for cell in range(len(projection[0]))]

    return np.reshape(np.array(approx), (1, len(approx) * num_points))


def calculate_exact_solution(mesh, cell_len, wave_speed, final_time, interval_len, quadrature,
                             init_cond):
    """Calculates exact solution.

    Parameters
    ----------
    mesh : array
        List of mesh valuation points.
    cell_len : float
        Length of a cell in mesh.
    wave_speed : float
        Speed of wave in rightward direction.
    final_time : float
        Final time for which approximation is calculated.
    interval_len : float
        Length of the interval between left and right boundary.
    quadrature : Quadrature object
        Quadrature for evaluation.
    init_cond : InitialCondition object
        Initial condition for evaluation.

    Returns
    -------
    np.array
        Array containing exact evaluation of a function.

    """
    grid = []
    exact = []
    num_periods = np.floor(wave_speed * final_time / interval_len)

    for cell in range(len(mesh)):
        eval_points = mesh[cell]+cell_len / 2 * quadrature.get_eval_points()

        eval_values = []
        for point in range(len(eval_points)):
            new_entry = init_cond.calculate(eval_points[point] - wave_speed * final_time
                                            + num_periods * interval_len)
            eval_values.append(new_entry)

        grid.append(eval_points)
        exact.append(eval_values)

    exact = np.reshape(np.array(exact), (1, len(exact) * len(exact[0])))
    grid = np.reshape(np.array(grid), (1, len(grid) * len(grid[0])))

    return grid, exact


def plot_classification_accuracy(evaluation_dict, colors):
    """Plots classification accuracy.

    Plots the accuracy, precision, and recall in a bar plot.

    Parameters
    ----------
    precision : float
        Precision of classification.
    recall : float
        Recall of classification.
    accuracy : float
        Accuracy of classification.
    xlabels : list
        List of strings for x-axis labels.

    """
    model_names = evaluation_dict[list(colors.keys())[0]].keys()
    font_size = 16 - (len(max(model_names, key=len))//3)
    pos = np.arange(len(model_names))
    width = 1/(3*len(model_names))
    fig = plt.figure('classification_accuracy')
    ax = fig.add_axes([0.15, 0.3, 0.75, 0.6])
    step_len = 1
    adjustment = -(len(model_names)//2)*step_len
    for measure in evaluation_dict:
        model_eval = [evaluation_dict[measure][model] for model in evaluation_dict[measure]]
        ax.bar(pos + adjustment*width, model_eval, width, label=measure, color=colors[measure])
        adjustment += step_len
    ax.set_xticks(pos)
    ax.set_xticklabels(model_names, rotation=50, ha='right', fontsize=font_size)
    ax.set_ylabel('Classification (%)')
    ax.set_ylim(bottom=-0.02)
    ax.set_ylim(top=1.02)
    ax.set_title('Classification Evaluation (Barplot)')
    ax.legend(loc='upper right')
    # fig.tight_layout()


def plot_boxplot(evaluation_dict, colors):
    model_names = evaluation_dict[list(colors.keys())[0]].keys()
    font_size = 16 - (len(max(model_names, key=len))//3)
    fig = plt.figure('boxplot_accuracy')
    ax = fig.add_axes([0.15, 0.3, 0.75, 0.6])
    step_len = 1.5
    boxplots = []
    adjustment = -(len(model_names)//2)*step_len
    pos = np.arange(len(model_names))
    width = 1/(5*len(model_names))
    for measure in evaluation_dict:
        model_eval = [evaluation_dict[measure][model] for model in evaluation_dict[measure]]
        boxplot = ax.boxplot(model_eval, positions=pos + adjustment*width, widths=width,
                             meanline=True, showmeans=True, patch_artist=True)
        for patch in boxplot['boxes']:
            patch.set(facecolor=colors[measure])
        boxplots.append(boxplot)
        adjustment += step_len

    ax.set_xticks(pos)
    ax.set_xticklabels(model_names, rotation=50, ha='right', fontsize=font_size)
    ax.set_ylim(bottom=-0.02)
    ax.set_ylim(top=1.02)
    ax.set_ylabel('Classification (%)')
    ax.set_title('Classification Evaluation (Boxplot)')
    ax.legend([bp["boxes"][0] for bp in boxplots], evaluation_dict.keys(), loc='upper right')