docs: def select_transformers(self):
          """ Selects appropriate transformers for the HV-MV substation.
  
          The transformers are chosen according to max. of load case and feedin-case
          considering load factors.
          The HV-MV transformer with the next higher available nominal apparent power is
          chosen. If one trafo is not sufficient, multiple trafos are used. Additionally,
          in a second step an redundant trafo is installed with max. capacity of the
          selected trafos of the first step according to general planning principles for
          MV distribution grids (n-1).
  
          Parameters
          ----------
          transformers : dict
              Contains technical information of p hv/mv transformers
          **kwargs : dict
              Should contain a value behind the key 'peak_load'
  
  
          Notes
          -----
          Parametrization of transformers bases on [#]_.
          
          Potential hv-mv-transformers are chosen according to [#]_.
          
  
          References
          ----------
          .. [#] Deutsche Energie-Agentur GmbH (dena), "dena-Verteilnetzstudie.
              Ausbau- und Innovationsbedarf der Stromverteilnetze in Deutschland
              bis 2030.", 2012
          .. [#] X. Tao, "Automatisierte Grundsatzplanung von
              Mittelspannungsnetzen", Dissertation, 2006
  
          """
  
          # get power factor for loads and generators
          cos_phi_load = cfg_ding0.get('assumptions', 'cos_phi_load')
          cos_phi_feedin = cfg_ding0.get('assumptions', 'cos_phi_gen')
  
          # get trafo load factors
          load_factor_mv_trans_lc_normal = float(cfg_ding0.get('assumptions',
                                                               'load_factor_mv_trans_lc_normal'))
          load_factor_mv_trans_fc_normal = float(cfg_ding0.get('assumptions',
                                                               'load_factor_mv_trans_fc_normal'))
  
          # get equipment parameters of MV transformers
          trafo_parameters = self.grid.network.static_data['MV_trafos']
  
          # get peak load and peak generation
          cum_peak_load = self.peak_load / cos_phi_load
          cum_peak_generation = self.peak_generation(mode='MVLV') / cos_phi_feedin
  
          # check if load or generation is greater respecting corresponding load factor
          if (cum_peak_load / load_factor_mv_trans_lc_normal) > \
             (cum_peak_generation / load_factor_mv_trans_fc_normal):
              # use peak load and load factor from load case
              load_factor_mv_trans = load_factor_mv_trans_lc_normal
              residual_apparent_power = cum_peak_load
          else:
              # use peak generation and load factor for feedin case
              load_factor_mv_trans = load_factor_mv_trans_fc_normal
              residual_apparent_power = cum_peak_generation
  
          # determine number and size of required transformers
  
          # get max. trafo
          transformer_max = trafo_parameters.iloc[trafo_parameters['S_nom'].idxmax()]
  
          while residual_apparent_power > 0:
              if residual_apparent_power > load_factor_mv_trans * transformer_max['S_nom']:
                  transformer = transformer_max
              else:
                  # choose trafo
                  transformer = trafo_parameters.iloc[
                      trafo_parameters[trafo_parameters['S_nom'] * load_factor_mv_trans >
                                       residual_apparent_power]['S_nom'].idxmin()]
  
              # add transformer on determined size with according parameters
              self.add_transformer(TransformerDing0(**{'grid': self.grid,
                                                       'v_level': self.grid.v_level,
                                                       's_max_longterm': transformer['S_nom']}))
              # calc residual load
              residual_apparent_power -= (load_factor_mv_trans *
                                          transformer['S_nom'])
  
          # if no transformer was selected (no load in grid district), use smallest one
          if len(self._transformers) == 0:
              transformer = trafo_parameters.iloc[trafo_parameters['S_nom'].idxmin()]
  
              self.add_transformer(
                  TransformerDing0(grid=self.grid,
                                   v_level=self.grid.v_level,
                                   s_max_longterm=transformer['S_nom']))
  
          # add redundant transformer of the size of the largest transformer
          s_max_max = max((o.s_max_a for o in self._transformers))
          self.add_transformer(TransformerDing0(**{'grid': self.grid,
                                                   'v_level': self.grid.v_level,
                                                   's_max_longterm': s_max_max}))