def plot_account(self, row, per_capita=False, sector=None,
                     file_name=False, file_dpi=600,
                     population=None, **kwargs):
        """ Plots D_pba, D_cba, D_imp and D_exp for the specified row (account)

        Plot either the total country accounts or for a specific sector,
        depending on the 'sector' parameter.

        Per default the accounts are plotted as bar charts.
        However, any valid keyword for the pandas.DataFrame.plot
        method can be passed.

        Notes
        -----
            This looks prettier with the seaborn module
            (import seaborn before calling this method)

        Parameters
        ----------
        row : string, tuple or int
            A valid index for the row in the extension which
            should be plotted (one(!) row - no list allowed)
        per_capita : boolean, optional
            Plot the per capita accounts instead of the absolute values
            default is False
        sector: string, optional
            Plot the results for a specific sector of the IO table. If
            None is given (default), the total regional accounts are plotted.
        population : pandas.DataFrame or np.array, optional
            Vector with population per region. This must be given if
            values should be plotted per_capita for a specific sector since
            these values are calculated on the fly.
        file_name : path string, optional
            If given, saves the plot to the given filename
        file_dpi : int, optional
            Dpi for saving the figure, default 600

        **kwargs : key word arguments, optional
            This will be passed directly to the pd.DataFrame.plot method

        Returns
        -------
        Axis as given by pandas.DataFrame.plot, None in case of errors

        """
        # necessary if row is given for Multiindex without brackets
        if type(per_capita) is not bool:
            logging.error('per_capita parameter must be boolean')
            return None

        if type(row) is int:
            row = self.D_cba.ix[row].name

        name_row = (str(row).
                    replace('(', '').
                    replace(')', '').
                    replace("'", "").
                    replace('[', '').
                    replace(']', ''))
        if sector:
            graph_name = name_row + ' for sector ' + sector
        else:
            graph_name = name_row + ' total account'
        if per_capita:
            graph_name = graph_name + ' - per capita'

        graph_name = self.name + ' - ' + graph_name

        if self.unit is not None:
            try:
                # for multiindex the entry is given with header,
                # for single index just the entry
                y_label_name = (name_row +
                                ' (' +
                                str(self.unit.ix[row, 'unit'].tolist()[0]) +
                                ')')
            except:
                y_label_name = (name_row + ' (' +
                                str(self.unit.ix[row, 'unit']) + ')')
        else:
            y_label_name = name_row

        if 'kind' not in kwargs:
            kwargs['kind'] = 'bar'

        if 'colormap' not in kwargs:
            kwargs['colormap'] = 'Spectral'

        accounts = collections.OrderedDict()

        if sector:
            accounts['Footprint'] = 'D_cba'
            accounts['Territorial'] = 'D_pba'
            accounts['Imports'] = 'D_imp'
            accounts['Exports'] = 'D_exp'
        else:
            if per_capita:
                accounts['Footprint'] = 'D_cba_cap'
                accounts['Territorial'] = 'D_pba_cap'
                accounts['Imports'] = 'D_imp_cap'
                accounts['Exports'] = 'D_exp_cap'
            else:
                accounts['Footprint'] = 'D_cba_reg'
                accounts['Territorial'] = 'D_pba_reg'
                accounts['Imports'] = 'D_imp_reg'
                accounts['Exports'] = 'D_exp_reg'

        data_row = pd.DataFrame(columns=[key for key in accounts])
        for key in accounts:
            if sector:
                try:
                    _data = pd.DataFrame(
                             getattr(self, accounts[key]).xs(
                                 key=sector, axis=1, level='sector').ix[row].T)
                except (AssertionError, KeyError):
                    _data = pd.DataFrame(
                             getattr(self, accounts[key]).xs(
                                 key=sector, axis=1, level=1).ix[row].T)

                if per_capita:
                    if population is not None:
                        if type(population) is pd.DataFrame:
                            # check for right order:
                            if (population.columns.tolist() !=
                                    self.D_cba_reg.columns.tolist()):
                                logging.warning(
                                    'Population regions are inconsistent '
                                    'with IO regions')
                            population = population.values
                            population = population.reshape((-1, 1))
                            _data = _data / population
                    else:
                        logging.error('Population must be given for sector '
                                      'results per capita')
                        return
            else:
                _data = pd.DataFrame(getattr(self, accounts[key]).ix[row].T)
            _data.columns = [key]
            data_row[key] = _data[key]

        if 'title' not in kwargs:
            kwargs['title'] = graph_name

        ax = data_row.plot(**kwargs)
        plt.xlabel('Regions')
        plt.ylabel(y_label_name)
        plt.legend(loc='best')
        try:
            plt.tight_layout()
        except:
            pass

        if file_name:
            plt.savefig(file_name, dpi=file_dpi)
        return ax