# `analysis.simulatedAnnealing` module

Plots the evolution of the simulated annealing algorithm from a log file

Source code

    """Plots the evolution of the simulated annealing algorithm from a log file"""

    import matplotlib.pyplot as plt
    import numpy as np
    import pickle
    import pandas
    from scipy.signal import savgol_filter

    from analysis import utils

    def deroll(arr, limits, start=0):
        """Derolls a log array. It returns a likely guess of what an array would
        have been before applying a mod operator to bring it into the limits
        region. Example, for limits = [0, 1] the array [0.5, 0.7, 0.9, 0.1] would
        return [0.5, 0.7, 0.9, 1.1].

        Parameters:
            arr (array): array to deroll
            limit (tuple): (lower limit, upper limit)
            start (int): the first start values of the array will not be derolled

        Returns:
            The derolled array.
        """
        for i in range(start,len(arr)-1): # Do not deroll before start
            if np.abs(arr[i+1]-arr[i]) > (limits[1]-limits[0])/2:
                # Continue the array in the closest possible way
                if arr[i+1]>arr[i]: arr[i+1:] -= (limits[1]-limits[0])
                else: arr[i+1:] += (limits[1]-limits[0])
        return arr

    def returnBars(arr, n):
        """Calculates the 10th-90th percentile running confidence interval

        Parameters:
            arr (arr): The array to calculate error bars for
            n (int): The smoothing of the confidence interval

        Returns:
            The smoothed running confidence interval
        """
        r = pandas.Series(arr).rolling(window = n, center = False)
        s1, s2 =  r.quantile(.90), r.quantile(.1)
        return savgol_filter(s1[n:], 101, 3), savgol_filter(s2[n:], 101, 3)

    # Load the data saved by the simulating annealing algorithm
    log = pickle.load(open('data/logs/log.pickle', "rb" ) )[:1400]

    # Define the parameters we wish to plot
    mask = [0,1,2,3,5,7,8] #Non-fixed parameters
    limits = np.array([[0, np.pi], [-np.pi, np.pi],
        [0, np.pi], [-np.pi, np.pi],
        [.5,1.0], [.55,.8], [.55,.8]])
    labels = [r'$i_1$ / rad', r'$\omega_1$ / rad',
        r'$i_2$ / rad', r'$\omega_2$ / rad',
        'e', r'$R_1$', r'$R_2$', r'$\mu$']
    ticks = [[0, np.pi], [-np.pi,0, np.pi],
        [0, np.pi],[-np.pi, 0, np.pi],
        [.5, 1.0], [.55, .8], [.55, .8]]
    ticklabels = [[0,r'$\pi$'],[r'$-\pi$',0,r'$\pi$'],
        [0,r'$\pi$'],[r'$-\pi$',0,r'$\pi$'],
        ['.5','1.0'], ['.55','.8'], ['.55','.8']]

    # Mask away the parameters we don't want to plot
    scores = np.array([l[0] for l in log])
    paramss = np.array([l[1] for l in log])[:,mask]
    # Fix conventions for inclination
    paramss[:,0] = paramss[:,0] - np.pi
    paramss[:,2] = np.pi - paramss[:,2]

    # Start plotting
    i = np.arange(len(log))
    f, axs = plt.subplots(1+len(paramss[0]), 1,  figsize=(10, 10),
        sharex=True, gridspec_kw = {'height_ratios':[2., 1., 1, 1, 1, 1, 1, 1]})
    plt.tight_layout()
    utils.stylizePlot(axs)

    # Plot metric
    axs[0].scatter(i, scores, marker='x', c='black', s=5, linewidth=.5)
    axs[0].fill_between(i[20:], *returnBars(scores, 20), color='r', alpha=.2)
    utils.setSize(axs[0], x=(0, None), y=(0.8, None))
    utils.setAxes(axs[0], y='Metric')
    # Get twin axis to mark temperature in it
    ax2 = axs[0].twiny()
    ax2.set_xscale('log')
    ax2.set_xlabel('Temperature', fontsize=14)
    ax2.invert_xaxis()
    ax2.set_xlim((.25, 0.015129))
    ax2.set_xticks([.2, .1, .09, .08, .07, .06, .05, .04, .03, .02, .01])
    ax2.set_xticklabels([str(i)
        for i in [.2, .1, .09, .08, .07, .06, .05, .04, .03, .02, .01]])

    # Plot parameters one by one
    for j in range(0, len(paramss[0])):
        utils.setSize(axs[j+1], x=(0, len(log)), y=limits[j])
        axs[j+1].set_ylabel(labels[j], fontsize=14)
        axs[j+1].set_yticks(ticks[j])
        axs[j+1].set_yticklabels(ticklabels[j])
        # Be careful plotting cyclic parameters
        derolled = deroll(paramss[:,j], limits[j], start=500)
        bar1, bar2 = returnBars(paramss[:,j], 20)
        for k in range(-3, 3): #
            # Plot the confidence intervals an data multiple times
            # to deal with cyclic parameters
            axs[j+1].scatter(i, derolled + k*(limits[j][1]-limits[j][0]),
                marker='x', c='black', s=5, linewidth=.5)
            axs[j+1].fill_between(i[20:], bar1 + k*(limits[j][1]-limits[j][0]),
                bar2 + k*(limits[j][1]-limits[j][0]), color='r', alpha=.2)

    f.align_ylabels(axs[:])
    axs[-1].set_xlabel('Iteration', fontsize=14)
    plt.show()

## Functions

`def deroll(arr, limits, start=0)`

  Derolls a log array. It returns a likely guess of what an array would have been before applying a mod operator to bring it into the limits region. Example, for limits = [0, 1] the array [0.5, 0.7, 0.9, 0.1] would return [0.5, 0.7, 0.9, 1.1].

  ## Parameters

  `arr` :`array`
    array to deroll
  `limit` :`tuple`
    (lower limit, upper limit)
  `start` :`int`
    the first start values of the array will not be derolled

  ## Returns

  The derolled array.

  Source code

      def deroll(arr, limits, start=0):
          """Derolls a log array. It returns a likely guess of what an array would
          have been before applying a mod operator to bring it into the limits
          region. Example, for limits = [0, 1] the array [0.5, 0.7, 0.9, 0.1] would
          return [0.5, 0.7, 0.9, 1.1].

          Parameters:
              arr (array): array to deroll
              limit (tuple): (lower limit, upper limit)
              start (int): the first start values of the array will not be derolled

          Returns:
              The derolled array.
          """
          for i in range(start,len(arr)-1): # Do not deroll before start
              if np.abs(arr[i+1]-arr[i]) > (limits[1]-limits[0])/2:
                  # Continue the array in the closest possible way
                  if arr[i+1]>arr[i]: arr[i+1:] -= (limits[1]-limits[0])
                  else: arr[i+1:] += (limits[1]-limits[0])
          return arr

`def returnBars(arr, n)`

  Calculates the 10th-90th percentile running confidence interval

  ## Parameters

  `arr` :`arr`
    The array to calculate error bars for
  `n` :`int`
    The smoothing of the confidence interval

  ## Returns

  The smoothed running confidence interval

  Source code

      def returnBars(arr, n):
          """Calculates the 10th-90th percentile running confidence interval

          Parameters:
              arr (arr): The array to calculate error bars for
              n (int): The smoothing of the confidence interval

          Returns:
              The smoothed running confidence interval
          """
          r = pandas.Series(arr).rolling(window = n, center = False)
          s1, s2 =  r.quantile(.90), r.quantile(.1)
          return savgol_filter(s1[n:], 101, 3), savgol_filter(s2[n:], 101, 3)