docs: def set_default_branch_type(self, debug=False):
          """ Determines default branch type according to grid district's peak load and standard equipment.
  
          Args
          ----
          debug: bool, defaults to False
              If True, information is printed during process
  
          Returns
          -------
          :pandas:`pandas.Series<series>`   
              default branch type: pandas Series object. If no appropriate type is found, return largest possible one.
          :pandas:`pandas.Series<series>`    
              default branch type max: pandas Series object. Largest available line/cable type
  
          Notes
          -----
          Parameter values for cables and lines are taken from [#]_, [#]_ and [#]_.
  
          Lines are chosen to have 60 % load relative to their nominal capacity according to [#]_.
  
          Decision on usage of overhead lines vs. cables is determined by load density of the considered region. Urban
          areas usually are equipped with underground cables whereas rural areas often have overhead lines as MV
          distribution system [#]_.
  
          References
          ----------
          .. [#] Klaus Heuck et al., "Elektrische Energieversorgung", Vieweg+Teubner, Wiesbaden, 2007
          .. [#] René Flosdorff et al., "Elektrische Energieverteilung", Vieweg+Teubner, 2005
          .. [#] Südkabel GmbH, "Einadrige VPE-isolierte Mittelspannungskabel",
              http://www.suedkabel.de/cms/upload/pdf/Garnituren/Einadrige_VPE-isolierte_Mittelspannungskabel.pdf, 2017
          .. [#] Deutsche Energie-Agentur GmbH (dena), "dena-Verteilnetzstudie. Ausbau- und Innovationsbedarf der
              Stromverteilnetze in Deutschland bis 2030.", 2012
          .. [#] Tao, X., "Automatisierte Grundsatzplanung von
              Mittelspannungsnetzen", Dissertation, RWTH Aachen, 2007
          """
  
          # decide whether cable or line is used (initially for entire grid) and set grid's attribute
          if self.v_level == 20:
              self.default_branch_kind = 'line'
          elif self.v_level == 10:
              self.default_branch_kind = 'cable'
  
          # get power factor for loads
          cos_phi_load = cfg_ding0.get('assumptions', 'cos_phi_load')
  
          # get max. count of half rings per MV grid district
          mv_half_ring_count_max = int(cfg_ding0.get('mv_routing_tech_constraints',
                                                     'mv_half_ring_count_max'))
          #mv_half_ring_count_max=20
  
          # load cable/line assumptions, file_names and parameter
          if self.default_branch_kind == 'line':
              load_factor_normal = float(cfg_ding0.get('assumptions',
                                                       'load_factor_mv_line_lc_normal'))
              branch_parameters = self.network.static_data['MV_overhead_lines']
  
              # load cables as well to use it within settlements
              branch_parameters_settle = self.network.static_data['MV_cables']
              # select types with appropriate voltage level
              branch_parameters_settle = branch_parameters_settle[branch_parameters_settle['U_n'] == self.v_level]
  
          elif self.default_branch_kind == 'cable':
              load_factor_normal = float(cfg_ding0.get('assumptions',
                                                       'load_factor_mv_cable_lc_normal'))
              branch_parameters = self.network.static_data['MV_cables']
          else:
              raise ValueError('Grid\'s default_branch_kind is invalid, could not set branch parameters.')
  
          # select appropriate branch params according to voltage level, sorted ascending by max. current
          # use <240mm2 only (ca. 420A) for initial rings and for disambiguation of agg. LA
          branch_parameters = branch_parameters[branch_parameters['U_n'] == self.v_level]
          branch_parameters = branch_parameters[branch_parameters['reinforce_only'] == 0].sort_values('I_max_th')
  
          # get largest line/cable type
          branch_type_max = branch_parameters.loc[branch_parameters['I_max_th'].idxmax()]
  
          # set aggregation flag using largest available line/cable
          self.set_nodes_aggregation_flag(branch_type_max['I_max_th'] * load_factor_normal)
  
          # calc peak current sum (= "virtual" current) of whole grid (I = S / sqrt(3) / U) excluding load areas of type
          # satellite and aggregated
          peak_current_sum = ((self.grid_district.peak_load -
                               self.grid_district.peak_load_satellites -
                               self.grid_district.peak_load_aggregated) /
                              cos_phi_load /
                              (3**0.5) / self.v_level)  # units: kVA / kV = A
  
          branch_type_settle = branch_type_settle_max = None
  
          # search the smallest possible line/cable for MV grid district in equipment datasets for all load areas
          # excluding those of type satellite and aggregated
          for idx, row in branch_parameters.iterrows():
              # calc number of required rings using peak current sum of grid district,
              # load factor and max. current of line/cable
              half_ring_count = round(peak_current_sum / (row['I_max_th'] * load_factor_normal))
  
              if debug:
                  logger.debug('=== Selection of default branch type in {} ==='.format(self))
                  logger.debug('Peak load= {} kVA'.format(self.grid_district.peak_load))
                  logger.debug('Peak current={}'.format(peak_current_sum))
                  logger.debug('I_max_th={}'.format(row['I_max_th']))
                  logger.debug('Half ring count={}'.format(half_ring_count))
  
              # if count of half rings is below or equal max. allowed count, use current branch type as default
              if half_ring_count <= mv_half_ring_count_max:
                  if self.default_branch_kind == 'line':
  
                      # take only cables that can handle at least the current of the line
                      branch_parameters_settle_filter = branch_parameters_settle[\
                                                        branch_parameters_settle['I_max_th'] - row['I_max_th'] > 0]
  
                      # get cable type with similar (but greater) I_max_th
                      # note: only grids with lines as default branch kind get cables in settlements
                      # (not required in grids with cables as default branch kind)
                      branch_type_settle = branch_parameters_settle_filter.loc[\
                                           branch_parameters_settle_filter['I_max_th'].idxmin()]
  
                  return row, branch_type_max, branch_type_settle
  
          # no equipment was found, return largest available line/cable
  
          if debug:
              logger.debug('No appropriate line/cable type could be found for '
                           '{}, declare some load areas as aggregated.'.format(self))
  
          if self.default_branch_kind == 'line':
              branch_type_settle_max = branch_parameters_settle.loc[branch_parameters_settle['I_max_th'].idxmax()]
  
          return branch_type_max, branch_type_max, branch_type_settle_max