docs: def mv_connect_satellites(mv_grid, graph, mode='normal', debug=False):
      """ Connect satellites (small Load Areas) to MV grid
  
      Args
      ----
      mv_grid: MVGridDing0
          MV grid instance
      graph: :networkx:`NetworkX Graph Obj< >`
          NetworkX graph object with nodes
      mode: str, defaults to 'normal'
          Specify mode how satellite `LVLoadAreaCentreDing0` are connected to the
          grid. Mode normal (default) considers for restrictions like max.
          string length, max peak load per string.
          The mode 'isolated' disregards any connection restrictions and connects
          the node `LVLoadAreaCentreDing0` to the next connection point.
          
      debug: bool, defaults to False
           If True, information is printed during process
  
      Notes
      -----
      conn_dist_weight: The satellites can be connected to line (new terminal is
      created) or to one station where the line ends, depending on the distance
      from satellite to the objects. This threshold is a length weighting to
      prefer stations instead of direct line connection to respect grid planning
      principles.
  
      Example: The distance from satellite to line is 1km, to station1 1.2km, to
      station2 2km. With conn_dist_threshold=0.75, the 'virtual' distance to
      station1 would be 1.2km * 0.75 = 0.9km, so this conn. point would be
      preferred.
  
      Returns
      -------
      :networkx:`NetworkX Graph Obj< >`
          NetworkX graph object with nodes and newly created branches
      """
  
      # conn_dist_weight: The satellites can be connected to line (new terminal is created) or to one station where the
      # line ends, depending on the distance from satellite to the objects. This threshold is a length weighting to prefer
      # stations instead of direct line connection to respect grid planning principles.
      # Example: The distance from satellite to line is 1km, to station1 1.2km, to station2 2km.
      # With conn_dist_threshold=0.75, the 'virtual' distance to station1 would be 1.2km * 0.75 = 0.9km, so this conn.
      # point would be preferred.
      conn_dist_weight = cfg_ding0.get('mv_connect', 'load_area_sat_conn_dist_weight')
  
      # conn_dist_ring_mod: Allow re-routing of ring main route if node is closer than this threshold (in m) to ring.
      conn_dist_ring_mod = cfg_ding0.get('mv_connect', 'load_area_sat_conn_dist_ring_mod')
  
      load_area_sat_buffer_radius = cfg_ding0.get('mv_connect', 'load_area_sat_buffer_radius')
      load_area_sat_buffer_radius_inc = cfg_ding0.get('mv_connect', 'load_area_sat_buffer_radius_inc')
  
      start = time.time()
  
      # WGS84 (conformal) to ETRS (equidistant) projection
      proj1 = partial(
              pyproj.transform,
              pyproj.Proj(init='epsg:4326'),  # source coordinate system
              pyproj.Proj(init='epsg:3035'))  # destination coordinate system
  
      # ETRS (equidistant) to WGS84 (conformal) projection
      proj2 = partial(
              pyproj.transform,
              pyproj.Proj(init='epsg:3035'),  # source coordinate system
              pyproj.Proj(init='epsg:4326'))  # destination coordinate system
  
      # check all nodes
      if mode == 'normal':
          #nodes = sorted(graph.nodes(), key=lambda x: repr(x))
          nodes = mv_grid.graph_isolated_nodes()
      elif mode == 'isolated':
          nodes = mv_grid.graph_isolated_nodes()
      else:
          raise ValueError('\'mode\' is invalid.')
  
      for node in nodes:
  
          # node is Load Area centre
          if isinstance(node, LVLoadAreaCentreDing0):
  
              # satellites only
              if node.lv_load_area.is_satellite:
  
                  node_shp = transform(proj1, node.geo_data)
  
                  if mode == 'normal':
                      # get branches within a the predefined radius `load_area_sat_buffer_radius`
                      branches = calc_geo_branches_in_buffer(node,
                                                             mv_grid,
                                                             load_area_sat_buffer_radius,
                                                             load_area_sat_buffer_radius_inc, proj1)
                  elif mode == 'isolated':
                      # get nodes of all MV rings
                      nodes = set()
                      [nodes.update(ring_nodes) for ring_nodes in list(mv_grid.rings_nodes(include_root_node=True))]
                      nodes = list(nodes)
                      # get branches of these nodes
                      branches = []
                      [branches.append(mv_grid.graph_branches_from_node(node_branches)) for node_branches in nodes]
                      # reformat branches
                      branches = [_ for _ in list(mv_grid.graph_edges())
                                  if (_['adj_nodes'][0] in nodes and _['adj_nodes'][1] in nodes)]
  
                  # calc distance between node and grid's lines -> find nearest line
                  conn_objects_min_stack = find_nearest_conn_objects(node_shp, branches, proj1,
                                                                     conn_dist_weight, debug,
                                                                     branches_only=False)
  
                  # iterate over object stack
                  find_connection_point(node, node_shp, graph, proj2, conn_objects_min_stack,
                                        conn_dist_ring_mod, debug)
  
      # parametrize newly created branches
      parametrize_lines(mv_grid)
  
      if debug:
          logger.debug('Elapsed time (mv_connect): {}'.format(time.time() - start))
  
      return graph