pipeline/plotter.py

# coding: utf-8

import sys
import os
import tables
import numpy as np
import matplotlib as mpl

if os.environ.get("DISPLAY", "") == "":
    print("No display found. Using non-interactive Agg backend")
    mpl.use("Agg")
from matplotlib.patches import Polygon
import pylab as P
from scipy.stats import linregress
import matplotlib.patches as mpatches
from matplotlib.collections import PatchCollection
from functools import partial
from numpy.polynomial.polynomial import polyfit
from scipy.ndimage.filters import gaussian_filter1d

from postprocessor import *


P.rcParams["image.cmap"] = "plasma"
P.rcParams["savefig.dpi"] = 400

tex_params = {"text.latex.preamble": [r"\usepackage{amsmath}"]}
P.rcParams.update(tex_params)


class PlotRule(Rule):
    def plot(self, save, arg, **kwargs):
        self.postproc.save = save
        return self.process_fn(arg, **kwargs)

    def is_valid(self, arg):
        return self.is_valid_add(arg)


class Plotter(Aggregator, BaseProcessor):
    """
    This class loads derived quantities and plot them
    """

    solve_self_dep = False

    # Axes information
    _ax_nb = {"x": 0, "y": 1, "z": 2}  # Number of each axes
    _axes_h = {"x": "y", "y": "x", "z": "x"}  # Associated horizontal axe
    _axes_v = {"x": "z", "y": "z", "z": "y"}  # Associated vertical axe
    _ax_title = {"x": r"$x$ [code]", "y": r"$y$ [code]", "z": r"$z$ [code]"}

    G = 1.0  # Gravitational constant

    label_convert = {
        "turb_rms": "$f_{rms}$",
        "beta": "$\\beta$",
        "dens0": "$n_0$",
        "sfr_avg_window": "window",
        "comp_frac": "$\\zeta$",
    }

    value_convert = {
        "sfr_avg_window": lambda x: "${:g}$ Myr".format(80 * x),
        "comp_frac": lambda x: "${:g}$".format(1 - x),
    }

    def __init__(
        self,
        path,
        in_runs=None,
        in_nums=None,
        path_out=None,
        pp_params=None,
        selector=None,
        tag=None,
        **kwargs
    ):

        super(Plotter, self).__init__(path, path_out, pp_params, tag)

        # Select runs
        if selector is None:
            selector = RunSelector(path, in_runs, in_nums, self.pp_params, **kwargs)

        # Save infos
        self.path = path
        self.runs = selector.runs
        self.nums = selector.nums

        # Get comparator object
        self.comp = Comparator(
            path, self.runs, self.nums, path_out, self.pp_params, selector=selector
        )

        # Get postprocesor objets for each run
        self.pp_runs = self.comp.pp_runs

        # Define log prefix
        self.log_id = "[plot {}] ".format(self.pp_params.out.tag)

        # Define rules
        self.def_rules()

    def _not_self_dep(self, name, dep, dep_arg, overwrite, **kwargs):
        if dep in self.comp.rules:
            done = self.comp.process(dep, dep_arg, overwrite, overwrite)
            self.just_done.extend(done)
        else:
            super(Plotter, self)._not_self_dep(name, dep, dep_arg, overwrite, **kwargs)

    def _process_rule(self, name, rule, arg, overwrite=False, **kwargs):
        if not arg is None:
            name_full = name + "_" + str(arg)
        else:
            name_full = name

        if rule.is_valid(arg):
            if rule.kind == "classic":
                for run in self.runs:
                    for i, num in enumerate(self.nums[run]):
                        plot_filename = self._find_filename(name_full, run, num)
                        save = tables.open_file(self.pp_runs[run][num].filename)
                        try:
                            self._plot_rule(
                                rule,
                                save,
                                arg,
                                plot_filename,
                                overwrite,
                                run=run,
                                **kwargs
                            )
                        finally:
                            save.close()
            else:
                if rule.kind == "series" and len(self.runs) == 1:
                    run = self.runs[0]
                    plot_filename = self._find_filename(name_full, run)
                else:
                    plot_filename = self._find_filename(name_full)
                save = tables.open_file(self.comp.filename, "r")
                try:
                    self._plot_rule(
                        rule,
                        save,
                        arg,
                        plot_filename,
                        overwrite,
                        open_figure=not self.pp_params.out.interactive,
                        **kwargs
                    )
                finally:
                    save.close()
        else:
            self._log("{} is not valid in this context".format(name_full), "ERROR")

    def _plot_rule(
        self, rule, save, arg, plot_filename, overwrite, open_figure=True, **kwargs
    ):
        if overwrite or not os.path.exists(plot_filename):
            if open_figure:
                P.figure()
            rule.plot(save, arg, **kwargs)
            P.tight_layout(pad=1)
            if not self.pp_params.out.interactive:
                P.savefig(plot_filename)
                P.close()
                self._log("{} plotted".format(plot_filename), "SUCCESS")
            else:
                self._log(
                    "{} plotted".format(os.path.basename(plot_filename)), "SUCCESS"
                )
        else:
            self._log("Plot {} is already done, skipping...".format(plot_filename))

    def _find_filename(self, name_full, run=None, num=None):
        if not self.pp_params.out.tag == "":
            tag_name = "_" + self.pp_params.out.tag
        else:
            tag_name = ""

        if not run is None and not num is None:
            return (
                self.path_out
                + "/"
                + run
                + "/"
                + name_full
                + tag_name
                + "_"
                + format(num, "05")
                + self.pp_params.plot.out_ext
            )
        elif not run is None:
            return (
                self.path_out
                + "/"
                + run
                + "/"
                + name_full
                + tag_name
                + self.pp_params.plot.out_ext
            )
        else:
            return (
                self.path_out + "/" + name_full + tag_name + self.pp_params.plot.out_ext
            )

    def _label_run(self, run, node, label, nml_key):
        def get_label_nml(nml_key):
            prop_name = os.path.basename(nml_key)
            if prop_name in self.label_convert:
                prop_label = self.label_convert[prop_name]
            else:
                prop_label = prop_name
            prop_value = self.comp.get_nml(nml_key, run)
            if prop_name in self.value_convert:
                prop_value_str = self.value_convert[prop_name](prop_value)
            else:
                prop_value_str = "${:.6g}$".format(prop_value)
            return r"{} = {}".format(prop_label, prop_value_str)

        if nml_key is None and label is None:
            label_run = r"{}".format(self.save.root._v_attrs.attrs[node.name].label)
        elif not nml_key is None:
            if not type(nml_key) == list:
                nml_key = [nml_key]
            label_run = ", ".join(map(get_label_nml, nml_key))

            if not label is None:
                label_run = label + " (" + label_run + ")"
        else:
            label_run = label
        return label_run

    def _ax_label_unit(self, node, label, unit, unit_coeff):
        if label is None:
            if "label" in node._v_attrs:
                label = node._v_attrs.label
            elif node._v_name in self.label_convert:
                label = self.label_convert[node._v_name]
            elif not node._v_title == "":
                label = node._v_title
            else:
                label = node._v_name

        if "unit" in node._v_attrs:
            unit_old = node._v_attrs.unit
        else:
            unit_old = cst.none

        if unit is None:
            unit = unit_old

        if not unit_coeff == 1:
            base = unit
            unit = unit_coeff * unit
            label = label + unit_str(unit, base=base)
        else:
            label = label + unit_str(unit)

        return label, unit_old, unit

    def _plot_map(
        self,
        name,
        ax_los,
        run,
        label=None,
        unit=None,
        unit_coeff=1.0,
        overlays=[],
        title=None,
        nml_key=None,
        put_time=True,
        cmap="plasma",
        norm="log",
        autoscale=True,
        **kwargs
    ):

        ax_h = self._axes_h[ax_los]
        ax_v = self._axes_v[ax_los]
        im_extent = self.save.root.maps._v_attrs.im_extent

        node = self.save.get_node("/maps/{}_{}".format(name, ax_los))
        dmap = node.read()

        label, unit_old, unit = self._ax_label_unit(node, label, unit, unit_coeff)

        dmap = dmap * unit_old.express(unit)

        if norm == "log":
            norm = mpl.colors.LogNorm()
        elif norm == "linear":
            norm = mpl.colors.NoNorm()

        if autoscale and not norm is None:
            norm.autoscale(dmap)

        im = P.imshow(
            dmap, extent=im_extent, origin="lower", norm=norm, cmap=cmap, **kwargs
        )

        P.locator_params(axis=ax_h, nbins=self.pp_params.plot.ntick)
        P.locator_params(axis=ax_v, nbins=self.pp_params.plot.ntick)

        P.xlabel(self._ax_title[ax_h])
        P.ylabel(self._ax_title[ax_v])

        cbar = P.colorbar(im)

        if not label is None:
            cbar.set_label(label)

        title = self._label_run(run, node, title, nml_key)

        if put_time:
            time = self.save.root._v_attrs.time * self.comp.info["unit_time"]
            time_str = "time = {:.6g} Myr".format(time.express(cst.Myr))
            if len(title) > 0:
                title = title + " | " + time_str
            else:
                title = time_str

        P.title(title)

        for plot_overlay in overlays:
            plot_overlay(ax_los)

    def _overlay_levels(self, ax_los):
        map_level = self.save.get_node("/maps/{}_{}".format("levels", ax_los)).read()
        # Computing linewidths
        levels_ar = np.arange(np.min(map_level), np.max(map_level) + 1)
        lw = np.ones(levels_ar.size) * 2
        lvl_th = 8  # Level threeshold for reducing linewidths
        lw[levels_ar >= lvl_th] = lw[levels_ar >= lvl_th] ** (
            lvl_th - levels_ar[levels_ar >= lvl_th]
        )
        lw[levels_ar < lvl_th] = 1.0

        cont = P.contour(
            map_level,
            extent=self.save.root.maps._v_attrs.im_extent,
            origin="lower",
            colors="grey",
            linewidths=lw,
            levels=levels_ar,
        )
        cont.levels = cont.levels + 1

        P.clabel(cont, cont.levels[cont.levels < 11], inline=1, fontsize=8.0, fmt="%1d")

    def _overlay_speed(self, ax_los, unit=cst.km_s, unit_coeff=1.0):
        ax_h = self._axes_h[ax_los]
        ax_v = self._axes_v[ax_los]
        dmap_vh_node = self.save.get_node("/maps/speed_h_{}".format(ax_los))
        dmap_vh = dmap_vh_node.read()
        dmap_vv = self.save.get_node("/maps/speed_v_{}".format(ax_los)).read()

        vel_red = self.pp_params.plot.vel_red
        radius = self.save.root.maps._v_attrs.radius
        center = self.save.root.maps._v_attrs.center
        lbox = self.save.root._v_attrs.lbox

        map_vh_red = dmap_vh[::vel_red, ::vel_red]  # take only a subset of velocities
        map_vv_red = dmap_vv[::vel_red, ::vel_red]
        nh = map_vh_red.shape[0]
        nv = map_vv_red.shape[1]
        vec_h = (
            np.arange(nh) * 2.0 / nh * radius - radius + center[0] + radius / nh
        ) * lbox
        vec_v = (
            np.arange(nv) * 2.0 / nv * radius - radius + center[1] + radius / nv
        ) * lbox
        hh, vv = np.meshgrid(vec_h, vec_v)
        norm_v = np.sqrt(map_vh_red ** 2 + map_vv_red ** 2)
        max_v = np.max(norm_v)
        min_v = np.min(norm_v)

        Q = P.quiver(hh, vv, map_vh_red, map_vv_red, units="width", color="grey")
        label, unit_old, unit = self._ax_label_unit(dmap_vh_node, "", unit, unit_coeff)

        key_v = (max_v + min_v) / 2.0
        P.quiverkey(
            Q,
            0.6,
            0.98,
            key_v,
            r"${:g}$".format(key_v) + label,
            labelpos="E",
            coordinates="figure",
        )

    def _plot_radial(self, name, label=None, xlog=False, ylog=False):

        radial_bins = self.save.get_node("/radial/radial_bins_" + ax_los).read()
        bin_centers = 0.5 * (radial_bins[1:] + radial_bins[:-1])
        mean_bin = self.save.get_node("/radial/{}_{}".format(name, ax_los)).read()

        P.grid()
        P.xlabel(r"$r$")

        if xlog:
            P.xscale("log")
        if ylog:
            P.yscale("log")
        P.plot(bin_centers, mean_bin)

        if not label is None:
            P.ylabel(label)

    def _plot_hist(self, name, ax_los="z", label=None, ylog=False):

        pdf = self.save.get_node("/hist/" + name + "_" + ax_los)
        values, centers = pdf.read()
        width = centers[1] - centers[0]
        P.bar(centers, values, width, log=ylog)
        P.grid()
        if not label is None:
            P.xlabel(label)

        if "/hist/fit_" + name + "_" + ax_los in self.save:
            slope = pdf.attrs.slope
            origin = pdf.attrs.origin
            P.plot(
                centers,
                10 ** (slope * centers + origin),
                "--",
                linewidth=2,
                color="orange",
            )

        P.ylim([None, 1.0])

    def _plot(
        self,
        name_x,
        name_y,
        xlabel=None,
        ylabel=None,
        label=None,
        xunit=None,
        yunit=None,
        xunit_coeff=1.0,
        yunit_coeff=1.0,
        linearfit=False,
        smooth=0,
        nml_key=None,
        runs=None,
        **kwargs
    ):

        node_x = self.save.get_node(name_x)
        node_y = self.save.get_node(name_y)

        xlabel, xunit_old, xunit = self._ax_label_unit(
            node_x, xlabel, xunit, xunit_coeff
        )
        ylabel, yunit_old, yunit = self._ax_label_unit(
            node_y, ylabel, yunit, yunit_coeff
        )

        P.xlabel(xlabel)
        P.ylabel(ylabel)
        P.grid()

        if node_y._v_attrs.CLASS == "ARRAY":
            x = node_x.read() * xunit_old.express(xunit)
            y = node_y.read() * yunit_old.express(yunit)
            if smooth > 0:
                y = gaussian_filter1d(y, sigma=smooth)
            yerr = None
            P.plot(x, y, "*", **kwargs)
        elif "mean" in node_y:
            x = node_x.read() * xunit_old.express(xunit)
            y = node_y.mean.read() * yunit_old.express(yunit)
            if smooth > 0:
                y = gaussian_filter1d(y, sigma=smooth)
            yerr = node_y.std.read() * yunit_old.express(yunit)
            P.errorbar(x, y, yerr=yerr, fmt="*", **kwargs)
        else:
            yerr = None
            if runs is None:
                runs = self.runs
            for run in runs:
                x_run, y_run = node_x[run], node_y[run]
                x = x_run.read() * xunit_old.express(xunit)
                y = y_run.read() * yunit_old.express(yunit)
                if smooth > 0:
                    y = gaussian_filter1d(y, sigma=smooth)
                label_run = self._label_run(run, y_run, label, nml_key)
                P.plot(x, y, label=label_run, **kwargs)
                P.legend()

        if linearfit:
            _overlay_linearfit(x, y, yerr)

    def _overlay_linearfit(x, y, yerr=None):
        if yerr is None:
            (a, b, rho, _, stderr) = linregress(x, y)
        else:
            c = polyfit(x, y, 1, w=[1.0 / ty for ty in yerr], full=False)
            b, a = c[0], c[1]

        P.plot(x, a * y + b, "--", linewidth=1.5)

    def overlay_kennicutt(self, n0, step):
        P.grid(False)
        ylim = P.ylim()
        (tmin, tmax) = P.xlim()
        tmax = tmax + 20
        ymax = P.ylim()[1]
        ssfr_sun = 2.5e-9
        ssfr_ken = ssfr_sun * n0 ** 1.4

        coeff = ssfr_ken * 1e6 * (self.comp.info["unit_length"].express(cst.pc)) ** 2
        for i in np.arange(tmin, max(tmax, tmin + ymax / coeff), step):
            t = np.linspace(0, tmax, 1000)
            P.plot(t + i, t * coeff, ls="--", lw=0.9, color="grey")
            P.plot(t + tmin, (t + i - tmin) * coeff, ls="--", lw=0.9, color="grey")
        P.xlim(tmin, tmax)
        P.ylim(ylim)

    def def_rules(self):
        self.rules = {
            "coldens": PlotRule(
                self,
                partial(self._plot_map, "coldens", label=r"$\Sigma$", unit=cst.coldens),
                "Column density",
                dependencies=["coldens"],
            ),
            "rho": PlotRule(
                self,
                partial(self._plot_map, "rho", label=r"$\rho$", unit=cst.Msun_pc3),
                "Density slice",
                dependencies=["rho"],
            ),
            "coldens_l": PlotRule(
                self,
                partial(
                    self._plot_map,
                    "coldens",
                    label=r"$\Sigma$",
                    unit=cst.coldens,
                    overlays=[self._overlay_levels],
                ),
                "Column density",
                dependencies=["coldens", "levels"],
            ),
            "rho_v": PlotRule(
                self,
                partial(
                    self._plot_map,
                    "rho",
                    label=r"$\rho$",
                    unit=cst.Msun_pc3,
                    overlays=[self._overlay_speed],
                ),
                "Density slice",
                dependencies=["rho", "speed_h", "speed_v"],
            ),
            "jeans_ratio": PlotRule(
                self,
                partial(
                    self._plot_map,
                    "jeans_ratio",
                    vmin=0.1,
                    vmax=100,
                    cmap="RdBu_r",
                    overlays=[self._overlay_levels],
                ),
                "Jeans' lenght divided by the max resolution",
                dependencies=["jeans_ratio", "levels"],
            ),
            "Q": PlotRule(
                self,
                partial(
                    self._plot_map,
                    "rho",
                    label=r"$Q$",
                    vmin=0.01,
                    vmax=100,
                    cmap="RdBu_r",
                ),
                "Toomre Q parameter for a Keplerian disk",
                dependencies=["Q"],
            ),
        }

        averageables = ["coldens", "rho", "T", "Q"]
        for name in averageables:
            self.rules["rad_" + name] = PlotRule(
                self,
                partial(
                    self._plot_radial,
                    "rad_avg_" + name,
                    label=name,
                    xlog=True,
                    ylog=True,
                ),
                "Azimuthal average of {}".format(name),
                dependencies=["radial_bins", "rad_avg_" + name],
            )

            self.rules["fluct_" + name] = PlotRule(
                self,
                partial(
                    self._plot_map,
                    "fluct_" + name,
                    vmin=0.01,
                    vmax=100,
                    cmap="RdBu_r",
                    label="{}/avg({})".format(name, name),
                ),
                "Fluctuation of {}".format(name),
                dependencies=["fluct_" + name],
            )
            self.rules["pdf_" + name] = PlotRule(
                self,
                partial(
                    self._plot_hist,
                    "pdf_" + name,
                    ylog=True,
                    label="{}/avg({})".format(name, name),
                ),
                "Probability density function of {} fluctuations".format(name),
                dependencies=["pdf_" + name],
            )

        self.rules.update(
            {
                "kappa_beta": PlotRule(
                    self,
                    partial(
                        self._plot,
                        "/comp/beta",
                        "/comp/avg_pdf_slope_coldens",
                        linearfit=True,
                    ),
                    kind="comp",
                    dependencies=["beta", "avg_pdf_slope_coldens"],
                ),
                "sink_mass": PlotRule(
                    self,
                    partial(
                        self._plot,
                        "/series/sinks_from_log/time",
                        "/series/sinks_from_log/mass_sink",
                        xunit=cst.Myr,
                        yunit=cst.Msun,
                    ),
                    kind="series",
                    dependencies=["sinks_from_log"],
                ),
                "assfr": PlotRule(
                    self,
                    partial(
                        self._plot,
                        "/series/sfr_from_log/time",
                        "/series/sfr_from_log/sfr",
                        ylabel="Averaged surfacic SFR",
                        xunit=cst.Myr,
                        yunit=cst.ssfr,
                    ),
                    kind="series",
                    dependencies=["sfr_from_log"],
                ),
                "issfr": PlotRule(
                    self,
                    partial(
                        self._plot,
                        "/series/sinks_from_log/time",
                        "/series/sinks_from_log/issfr",
                        ylabel="Surfacic SFR",
                        xunit=cst.Myr,
                        yunit=cst.ssfr,
                    ),
                    kind="series",
                    dependencies=["issfr"],
                ),
                "turb_rms": PlotRule(
                    self,
                    partial(
                        self._plot,
                        "/series/rms_from_log/time",
                        "/series/rms_from_log/turb_rms",
                        xunit=cst.Myr,
                    ),
                    kind="series",
                    dependencies=["rms_from_log"],
                ),
                "sigma": PlotRule(
                    self,
                    partial(
                        self._plot,
                        "/series/time",
                        "/series/time_sigma",
                        ylabel="$\\sigma$",
                        xunit=cst.Myr,
                        yunit=cst.km_s,
                    ),
                    kind="comp",
                    dependencies=["time_sigma"],
                ),
                "plot": PlotRule(
                    self, lambda arg, **kwargs: self._plot(*arg, **kwargs), kind="comp"
                ),
            }
        )


class InteractiveGUI:
    """
    This is a matplotlib interactive session to restrain analysis to a specific area
    """

    def onbuttonrelease(self, event):
        """Deal with click events"""
        button = ["left", "middle", "right"]
        toolbar = P.get_current_fig_manager().toolbar
        if toolbar.mode == "zoom rect" and event.inaxes == self.ax_col:
            print("zooming ")
            xlim = self.ax_col.get_xlim()
            ylim = self.ax_col.get_ylim()
            self.reset_mask()
        elif self.add_mask and event.inaxes == self.ax_col:
            self.plot_side()
            P.draw()

    def onbuttonpress(self, event):
        """Deal with click events"""
        button = ["left", "middle", "right"]
        toolbar = P.get_current_fig_manager().toolbar
        if toolbar.mode != "":
            print(
                "You clicked on something, but toolbar is in mode {:s}.".format(
                    toolbar.mode
                )
            )
        print(self.add_mask)
        if self.add_mask and toolbar.mode == "" and event.inaxes == self.ax_col:
            ix, iy = event.xdata, event.ydata
            print("Add patch {}, {}".format(ix, iy))
            xlim = self.ax_col.get_xlim()
            ylim = self.ax_col.get_ylim()
            radius = 0.05 * min(abs(xlim[1] - xlim[0]), abs(ylim[1] - ylim[0]))
            circle = mpatches.Circle(
                [ix, iy], radius, color="black", alpha=0.1, ec="none"
            )
            self.circles.append(circle)
            self.ax_col.add_artist(circle)
            self.ax_col.draw_artist(circle)
            self.patch_mask = self.patch_mask | (
                (self.xx - ix) ** 2 + (self.yy - iy) ** 2 < radius ** 2
            )
            # self.plot_side()

    def onkeypress(self, event):
        """whenever a key is pressed"""
        if not event.inaxes:
            return
        if event.key == "t":
            self.add_mask = not self.add_mask
            print("Add mode is {}".format(self.add_mask))
        elif event.key == "r":
            self.reset_mask()

    def plot_side(self):
        if self.add_mask:
            mask = (self.patch_mask & self.mask).flatten()
        else:
            mask = self.mask.flatten()
        self.ax_gamma.clear()
        P.sca(self.ax_gamma)
        plot_dcsdrho(self.fluct_maps, mask, tag=self.tag)

        self.ax_pdf.clear()
        P.sca(self.ax_pdf)
        sigma_pdf(self.fluct_maps, mask, tag=self.tag, nb_bin_hist=self.args.pdf_nb_bin)

    def reset_mask(self):
        xlim = self.ax_col.get_xlim()
        ylim = self.ax_col.get_ylim()
        self.mask = (
            (self.xx >= xlim[0])
            & (self.xx <= xlim[1])
            & (self.yy >= ylim[0])
            & (self.yy <= ylim[1])
        )
        self.patch_mask = np.full(self.mask.shape, False)
        for circle in self.circles:
            circle.remove()
        self.circles = []
        self.plot_side()
        P.draw()

    def __init__(self, path, run, num, path_out=None, pp_params=default_params()):
        """
        Interactive plotting

        """
        self.add_mask = False
        self.circles = []
        self.tag = tag

        # Get plotter object
        self.plot = Plotter(path, [run], [num], path_out, pp_params)

        im_extent = maps_disk["im_extent"]

        fig = P.figure()
        self.ax_col = P.subplot(1, 2, 1)
        coldens = maps_disk["coldens_z"]
        im = self.ax_col.imshow(
            coldens, extent=im_extent, origin="lower", norm=mpl.colors.LogNorm()
        )
        if set_lim:
            im.set_clim(0.01, 100)
        self.ax_col.set_xlabel(r"$x$")
        self.ax_col.set_ylabel(r"$y$")

        self.xx, self.yy, self.fluct_maps = disk_pdf(
            path,
            num,
            maps_disk,
            tag=self.tag,
            force=True,
            put_title=False,
            interactive=True,
        )
        coord_flat = zip(self.xx.flatten(), self.yy.flatten())

        self.ax_gamma = P.subplot(2, 2, 2)
        self.ax_pdf = P.subplot(2, 2, 4)

        xlim = self.ax_col.get_xlim()
        ylim = self.ax_col.get_ylim()
        self.mask = (
            (self.xx >= xlim[0])
            & (self.xx <= xlim[1])
            & (self.yy >= ylim[0])
            & (self.yy <= ylim[1])
        )
        self.patch_mask = np.full(self.mask.shape, False)

        self.plot_side()

        fig.canvas.mpl_connect("button_release_event", self.onbuttonrelease)
        fig.canvas.mpl_connect("button_press_event", self.onbuttonpress)
        fig.canvas.mpl_connect("key_press_event", self.onkeypress)

        P.tight_layout()
        P.show()