docs: def plot_compare_act_config(signal, sample_rate, file_name=None):
      """
      -----
      Brief
      -----
      By invoking this function, a gridplot will be presented, in order to show the effect in muscular
      activation detection, when some input parameters of the algorithm are changed.
  
      -----------
      Description
      -----------
      It will be generated a Bokeh figure with 3x2 format, comparing the results of muscular
      activation algorithm when his input parameters are changed.
  
      At the first column are presented three plot zones, each plot zone is formed by an EMG signal,
      the smoothed signal and the muscular activation detection threshold.
  
      The smoothing level (SL) and threshold (TH) are customizable parameters, so, between these three
      figures, at least one of the parameters changed (each row of the gridplot shows graphical
      results obtained through the use of a specific set of algorithm parameter values [SL, TH] =
      [20, 10]% or [20, 50]% or [70, 10]%).
  
      At the second column is shown the result of applying muscular activation detection algorithm
      with the original EMG signal and a rectangular signal defining the start and end of each
      muscular activation period.
  
      Applied in the Notebook "Fatigue Evaluation - Evolution of Median Power Frequency".
  
      ----------
      Parameters
      ----------
      signal : list
          List with EMG signal to present.
  
      sample_rate : int
          Acquisitions sampling rate.
  
      file_name : str
          Path containing the destination folder where the Bokeh figure will be stored.
      """
  
      # Generation of the HTML file where the plot will be stored.
      #file_name = _generate_bokeh_file(file_name)
  
      time = numpy.linspace(0, len(signal) / sample_rate, len(signal))[0:14000]
      signal = numpy.array(signal[0:14000]) - numpy.average(signal[0:14000])
  
      # Muscular Activation Detection.
      muscular_activation_begin_20_10, muscular_activation_end_20_10, smooth_signal_20_10, \
      threshold_level_20_10 = detect_emg_activations(list(signal), sample_rate, smooth_level=20,
                                                     threshold_level=10)
      threshold_level_20_10 = (numpy.max(signal) * threshold_level_20_10) / \
                              numpy.max(smooth_signal_20_10)
      smooth_signal_20_10 = (numpy.max(signal) * numpy.array(smooth_signal_20_10)) / \
                            numpy.max(smooth_signal_20_10)
      activation_20_10 = numpy.zeros(len(time))
      for activation in range(0, len(muscular_activation_begin_20_10)):
          activation_20_10[muscular_activation_begin_20_10[activation]:
                           muscular_activation_end_20_10[activation]] = numpy.max(signal)
  
      muscular_activation_begin_20_50, muscular_activation_end_20_50, smooth_signal_20_50, \
      threshold_level_20_50 = detect_emg_activations(list(signal), sample_rate, smooth_level=20,
                                                     threshold_level=50)
      threshold_level_20_50 = (numpy.max(signal) * threshold_level_20_50) / \
                              numpy.max(smooth_signal_20_50)
      smooth_signal_20_50 = (numpy.max(signal) * numpy.array(smooth_signal_20_50)) / \
                            numpy.max(smooth_signal_20_50)
      activation_20_50 = numpy.zeros(len(time))
      for activation in range(0, len(muscular_activation_begin_20_50)):
          activation_20_50[muscular_activation_begin_20_50[activation]:
                           muscular_activation_end_20_50[activation]] = numpy.max(signal)
  
      muscular_activation_begin_70_10, muscular_activation_end_70_10, smooth_signal_70_10, \
      threshold_level_70_10 = detect_emg_activations(list(signal), sample_rate, smooth_level=70,
                                                     threshold_level=10)
      threshold_level_70_10 = (numpy.max(signal) * threshold_level_70_10) / \
                              numpy.max(smooth_signal_70_10)
      smooth_signal_70_10 = (numpy.max(signal) * numpy.array(smooth_signal_70_10)) / \
                            numpy.max(smooth_signal_70_10)
      activation_70_10 = numpy.zeros(len(time))
      for activation in range(0, len(muscular_activation_begin_70_10)):
          activation_70_10[muscular_activation_begin_70_10[activation]:
                           muscular_activation_end_70_10[activation]] = numpy.max(signal)
  
      # Plotting of data in a 3x2 gridplot format.
      plot_list = plot([list([]), list([]), list([]), list([]), list([]), list([])],
                       [list([]), list([]), list([]), list([]), list([]), list([])],
                       grid_lines=3, grid_columns=2, grid_plot=True, get_fig_list=True,
                       show_plot=False)
  
      combination = ["Smooth Level: 20 %  Threshold Level: 10 %", "Smooth Level: 20 %  "
                                                                  "Threshold Level: 50 %",
                     "Smooth Level: 70 %  Threshold Level: 10 %"]
      detect_dict = {"Smooth Level: 20 %  Threshold Level: 10 %": [smooth_signal_20_10,
                                                                   threshold_level_20_10,
                                                                   activation_20_10],
                     "Smooth Level: 20 %  Threshold Level: 50 %": [smooth_signal_20_50,
                                                                   threshold_level_20_50,
                                                                   activation_20_50],
                     "Smooth Level: 70 %  Threshold Level: 10 %": [smooth_signal_70_10,
                                                                   threshold_level_70_10,
                                                                   activation_70_10]}
      for plot_aux in range(0, len(plot_list)):
          title = Title()
          combination_temp = combination[int(plot_aux / 2)]
          plot_list[plot_aux].line(time, signal, **opensignals_kwargs("line"))
          if plot_aux % 2 == 0:
              title.text = combination_temp
              plot_list[plot_aux].line(time, detect_dict[combination_temp][0],
                                   **opensignals_kwargs("line"))
              plot_list[plot_aux].line(time, detect_dict[combination_temp][1],
                                   **opensignals_kwargs("line"))
              plot_list[plot_aux].yaxis.axis_label = "Raw Data"
          else:
              title.text = "Result for " + combination_temp
              plot_list[plot_aux].line(time, detect_dict[combination_temp][2],
                                   **opensignals_kwargs("line"))
  
          # x axis labels.
          if plot_aux in [4, 5]:
              plot_list[plot_aux].xaxis.axis_label = "Time (s)"
  
          plot_list[plot_aux].title = title
  
      grid_plot_ref = gridplot([[plot_list[0], plot_list[1]], [plot_list[2], plot_list[3]],
                                [plot_list[4], plot_list[5]]], **opensignals_kwargs("gridplot"))
      show(grid_plot_ref)