docs: def check_load(grid, mode):
      """ Checks for over-loading of branches and transformers for MV or LV grid.
  
      Parameters
      ----------
      grid : GridDing0
          Grid identifier.
      mode : str
          Kind of grid ('MV' or 'LV').
  
      Returns
      -------
      :obj:`dict`
          Dict of critical branches with max. relative overloading, and the 
          following format::
          
              {
              branch_1: rel_overloading_1, 
              ..., 
              branch_n: rel_overloading_n
              }
          
      :any:`list` of :obj:`GridDing0`
          List of critical transformers with the following format::
          
          [trafo_1, ..., trafo_m]
  
      Notes
      -----
          Lines'/cables' max. capacity (load case and feed-in case) are taken from [#]_.
          
  
      References
      ----------
      .. [#] dena VNS
      
      See Also
      --------
      ding0.flexopt.reinforce_measures.reinforce_branches_current :
      ding0.flexopt.reinforce_measures.reinforce_branches_voltage :
      
      """
  
      crit_branches = {}
      crit_stations = []
  
      if mode == 'MV':
          # load load factors (conditions) for cables, lines and trafos for load- and feedin case
  
          # load_factor_mv_trans_lc_normal = float(cfg_ding0.get('assumptions',
          #                                                      'load_factor_mv_trans_lc_normal'))
          load_factor_mv_line_lc_normal = float(cfg_ding0.get('assumptions',
                                                               'load_factor_mv_line_lc_normal'))
          load_factor_mv_cable_lc_normal = float(cfg_ding0.get('assumptions',
                                                               'load_factor_mv_cable_lc_normal'))
          #load_factor_mv_trans_fc_normal = float(cfg_ding0.get('assumptions',
          #                                                     'load_factor_mv_trans_fc_normal'))
          load_factor_mv_line_fc_normal = float(cfg_ding0.get('assumptions',
                                                               'load_factor_mv_line_fc_normal'))
          load_factor_mv_cable_fc_normal = float(cfg_ding0.get('assumptions',
                                                               'load_factor_mv_cable_fc_normal'))
  
          mw2kw = 1e3
          kw2mw = 1e-3
  
          # STEP 1: check branches' loads
          for branch in grid.graph_edges():
              s_max_th = 3**0.5 * branch['branch'].type['U_n'] * branch['branch'].type['I_max_th']
  
              if branch['branch'].kind == 'line':
                  s_max_th_lcfc = [s_max_th * load_factor_mv_line_lc_normal,
                                   s_max_th * load_factor_mv_line_fc_normal]
              elif branch['branch'].kind == 'cable':
                  s_max_th_lcfc = [s_max_th * load_factor_mv_cable_lc_normal,
                                   s_max_th * load_factor_mv_cable_fc_normal]
              else:
                  raise ValueError('Branch kind is invalid!')
  
              # check loads only for non-aggregated Load Areas (aggregated ones are skipped raising except)
              try:
                  # check if s_res exceeds allowed values for laod and feedin case
                  # CAUTION: The order of values is fix! (1. load case, 2. feedin case)
                  if any([s_res * mw2kw > _ for s_res, _ in zip(branch['branch'].s_res, s_max_th_lcfc)]):
                      # save max. relative overloading
                      crit_branches[branch] = max(branch['branch'].s_res) * mw2kw / s_max_th
              except:
                  pass
  
          # STEP 2: check HV-MV station's load
  
          # NOTE: HV-MV station reinforcement is not required for status-quo
          # scenario since HV-MV trafos already sufficient for load+generation
          # case as done in MVStationDing0.choose_transformers()
  
          # OLD snippet:
          # cum_peak_load = grid.grid_district.peak_load
          # cum_peak_generation = grid.station().peak_generation(mode='MVLV')
          #
          # # reinforcement necessary only if generation > load
          # if cum_peak_generation > cum_peak_load:
          #     grid.station().choose_transformers
          #
          # cum_trafo_capacity = sum((_.s_max_a for _ in grid.station().transformers()))
          #
          # max_trafo = max((_.s_max_a for _ in grid.station().transformers()))
          #
          # # determine number and size of required transformers
          # kw2mw = 1e-3
          # residual_apparent_power = cum_generation_sum * kw2mw - \
          #                           cum_trafo_capacity
  
      elif mode == 'LV':
          raise NotImplementedError
  
      if crit_branches:
          logger.info('==> {} branches have load issues.'.format(
              len(crit_branches)))
      if crit_stations:
          logger.info('==> {} stations have load issues.'.format(
              len(crit_stations)))
  
      return crit_branches, crit_stations