def plot_sensitivity(self, config_nr=None, sens_data=None,
                         mag_only=False, absv=False,
                         **kwargs):
        """Create a nice looking plot of the sensitivity distribution for the
        given configuration nr. Configs start at 1!

        Parameters
        ----------
        config_nr : int, optional
            The configuration number (starting with 0) to compute the
            sensitivity for.
        sens_data : Nx2 numpy.ndarray, optional
            If provided, use this data as sensitivity data (do not compute
            anything)
        mag_only : bool, optional
            Plot only the magnitude sensitivities
        absv : bool, optional
            If true, plot absolute values of sensitivity

        Returns
        -------
        fig
        ax

        Examples
        --------

        .. plot::

            import crtomo.debug
            import crtomo
            grid = crtomo.debug.get_grid(key=20)
            td = crtomo.tdMan(grid=grid)
            td.configs.add_to_configs([1, 5, 9, 13])
            cid_mag, cid_pha = td.add_homogeneous_model(25, 0)
            td.register_forward_model(cid_mag, cid_pha)
            td.model(sensitivities=True)
            fig, axes = td.plot_sensitivity(0)
            fig.tight_layout()
            fig.savefig('sens_plot.pdf', bboch_inches='tight')

        """

        def _rescale_sensitivity(sens_data):
            norm_value = np.abs(sens_data).max()
            sens_normed = sens_data / norm_value

            indices_gt_zero = sens_data > 1e-5
            indices_lt_zero = sens_data < -1e-5

            # map all values greater than zero to the range [0.5, 1]
            x = np.log10(sens_normed[indices_gt_zero])
            # log_norm_factor = np.abs(x).max()
            log_norm_factor = -5
            y1 = 1 - x / (2 * log_norm_factor)

            # map all values smaller than zero to the range [0, 0.5]
            x = np.log10(np.abs(sens_normed[indices_lt_zero]))
            y = x / (2 * log_norm_factor)

            y2 = np.abs(y)

            # reassign values
            sens_data[:] = 0.5
            sens_data[indices_gt_zero] = y1
            sens_data[indices_lt_zero] = y2
            return sens_data

        assert config_nr is not None or sens_data is not None
        assert not (config_nr is not None and sens_data is not None)

        if config_nr is not None:
            cids = self.assignments['sensitivities'][config_nr]

            sens_mag = self.parman.parsets[cids[0]]
            sens_pha = self.parman.parsets[cids[1]]
        else:
            sens_mag = sens_data[:, 0]
            sens_pha = sens_data[:, 1]

        if absv:
            sens_mag = np.log10(np.abs(sens_mag) / np.abs(sens_mag).max())
            sens_pha = np.log10(np.abs(sens_pha) / np.abs(sens_pha).max())
            cbmin = sens_mag.min()
            cbmax = sens_mag.max()
        else:
            _rescale_sensitivity(sens_mag)
            _rescale_sensitivity(sens_pha)
            cbmin = 0
            cbmax = 1

        cmap_jet = matplotlib.cm.get_cmap('jet')
        colors = [cmap_jet(i) for i in np.arange(0, 1.1, 0.1)]
        cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
            'jetn9', colors, N=9)
        over = kwargs.get('over', 'orange')
        under = kwargs.get('under', 'cyan')
        bad = kwargs.get('bad', 'white')
        cmap.set_over(over)
        cmap.set_under(under)
        cmap.set_bad(bad)
        if mag_only:
            Nx = 1
        else:
            Nx = 2

        fig, axes = plt.subplots(1, Nx, figsize=(15 / 2.54, 12 / 2.54))
        axes = np.atleast_1d(axes)
        # magnitude
        ax = axes[0]
        cid = self.parman.add_data(sens_mag)
        fig, ax, cnorm, cmap, cb, sM = self.plot.plot_elements_to_ax(
            cid=cid,
            ax=ax,
            plot_colorbar=True,
            # cmap_name='seismic',
            cmap_name='jet_r',
            cbsegments=18,
            cbmin=cbmin,
            cbmax=cbmax,
            bad='white',
            # cbmin=-cblim,
            # cbmax=cblim,
            # converter=converter_pm_log10,
            # norm = colors.SymLogNorm(
            #     linthresh=0.03,
            #     linscale=0.03,
            #     vmin=-1.0,
            #     vmax=1.0
            # ),
            # xmin=-0.25,
            # xmax=10,
            # zmin=-2,
        )
        if not absv:
            cb.set_ticks([0, 0.25, 0.5, 0.75, 1])
            cb.set_ticklabels([
                '-1',
                r'$-10^{-2.5}$',
                '0',
                r'$10^{-2.5}$',
                '1',
            ])

        # self.plot.plot_elements_to_ax(
        #     cid=cids[0],
        #     ax=ax,
        # )

        if not mag_only:
            cid = self.parman.add_data(sens_pha)
            # plot phase
            ax = axes[1]
            fig, ax, cnorm, cmap, cb, sM = self.plot.plot_elements_to_ax(
                cid=cid,
                ax=ax,
                plot_colorbar=True,
                # cmap_name='seismic',
                cmap_name='jet_r',
                cbsegments=18,
                cbmin=cbmin,
                cbmax=cbmax,
                bad='white',
            )
            if not absv:
                cb.set_ticks([0, 0.25, 0.5, 0.75, 1])
                cb.set_ticklabels([
                    '-1',
                    r'$-10^{-2.5}$',
                    '0',
                    r'$10^{-2.5}$',
                    '1',
                ])

        fig.tight_layout()

        return fig, axes