docs: 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