//  [python]
def plot_per_observable(self):
        """Plot observables with _experiments on same graph.
        i.e. variable x in treated and control conditions
        will be plotted together.

        Args:

        Returns:

        """
        if self.y == None:
            self.y = [i for i in list(self.observables) if i in list(self.ensemble_data.keys())]

        if isinstance(self.y, list) != True:
            self.y = [self.y]

        for param in self.y:
            if param not in list(self.ensemble_data.keys()):
                raise errors.InputError('{} not in your data set. {}'.format(param, sorted(self.ensemble_data.keys())))

        # data = {i.reset_index(level=1, drop=True) for i in self.ensemble_data}
        data = self.ensemble_data[sorted(self.ensemble_data.keys())]  # .reset_index()
        ## remove the existing time column so we can get it back again by resetting index
        data = data.drop('Time', axis=1)
        data = data.reset_index(level=[1, 2])

        experiments = sorted(list(set(data.index)))

        for parameter in sorted(self.y):
            if parameter not in ['ParameterFitIndex', 'Time']:
                LOG.info('Plotting "{}"'.format(parameter))
                fig, ax = plt.subplots()
                plot_data = data.reset_index()

                ax1 = seaborn.lineplot(
                    data=plot_data,
                    x='Time',
                    y=parameter,
                    hue='Experiment',
                    units='Index',
                    err_style=self.err_style,
                    palette=self.err_palette,
                    err_kws=self.err_kws,
                    estimator=self.estimator,
                    n_boot=self.n_boot,
                    ci=self.ci,
                    legend=self.legend,
                )

                for exp in sorted(self.experimental_data):
                    df = self.experimental_data[exp]
                    exp = os.path.split(exp)[1][:-4]
                    if parameter in list(df.keys()):
                        if df.columns[0] == 'time':
                            df = df.rename(columns={'time': 'Time'})
                        # plt.figure()
                        df_keys = list(df[parameter].keys())

                        if len(df_keys) > 1:
                            # for i in range(len(df_keys)):
                            plt.plot(list(df['Time']), df[parameter], '--',
                                     label=exp, alpha=0.4, marker='o')
                        else:
                            plt.plot(list(df['Time']), sorted(list(df[parameter])), '--',
                                     label=exp, alpha=0.4, marker='o')
                if self.legend:
                    # sim_patch = mpatches.Patch(color=self.color, label='Sim', alpha=0.4)
                    # exp_patch = mpatches.Patch(color=self.exp_color, label='Exp', alpha=0.4)
                    # plt.legend(handles=[sim_patch, exp_patch], loc=(1, 0.5))
                    plt.legend(loc=self.legend_loc)
                    if self.legend_labels is not None:
                        handle, labels = ax1.get_legend_handles_labels()
                        new_labels = []
                        for lab in labels:
                            if lab in self.legend_labels:
                                new_labels.append(self.legend_labels[lab])

                            else:
                                new_labels.append(lab)
                        assert len(labels) == len(new_labels)

                        plt.legend(handle, new_labels, loc=self.legend_loc)

            if self.despine:
                seaborn.despine(ax=ax1, top=True, right=True)

            if self.title is None:
                plt.title('{} (n={})'.format(parameter, self.data.shape[0]))

            else:
                plt.title(self.title)

            if self.ylabel is None:
                plt.ylabel('{}/{}'.format(self.cls.model.quantity_unit,
                                          self.cls.model.volume_unit) + '$^{-1}$')

            else:
                plt.ylabel(self.ylabel)

            if self.xlabel is None:
                plt.xlabel('Time ({})'.format(self.cls.model.time_unit))

            else:
                plt.xlabel(self.xlabel)

            if self.ymin is not None:
                plt.ylim(ymin=self.ymin)

            if self.ymax is not None:
                plt.ylim(ymax=self.ymax)

            if self.savefig:
                self.results_directory = self.create_directory()
                fname = os.path.join(self.results_directory, '{}.{}'.format(
                    utils.RemoveNonAscii(parameter).filter, self.ext))
                plt.savefig(fname, dpi=self.dpi, bbox_inches='tight')
            if self.show:
                plt.show()