docs: def _build_lv_grid(ding0_grid, network):
      """
      Build eDisGo LV grid from Ding0 data
  
      Parameters
      ----------
      ding0_grid: ding0.MVGridDing0
          Ding0 MV grid object
  
      Returns
      -------
      list of LVGrid
          LV grids
      dict
          Dictionary containing a mapping of LV stations in Ding0 to newly
          created eDisGo LV stations. This mapping is used to use the same
          instances of LV stations in the MV grid graph.
      """
  
      lv_station_mapping = {}
      lv_grids = []
      lv_grid_mapping = {}
  
      for la in ding0_grid.grid_district._lv_load_areas:
          for lvgd in la._lv_grid_districts:
              ding0_lv_grid = lvgd.lv_grid
              if not ding0_lv_grid.grid_district.lv_load_area.is_aggregated:
  
                  # Create LV grid instance
                  lv_grid = LVGrid(
                      id=ding0_lv_grid.id_db,
                      geom=ding0_lv_grid.grid_district.geo_data,
                      grid_district={
                          'geom': ding0_lv_grid.grid_district.geo_data,
                          'population': ding0_lv_grid.grid_district.population},
                      voltage_nom=ding0_lv_grid.v_level / 1e3,
                      network=network)
  
                  station = {repr(_): _ for _ in
                             network.mv_grid.graph.nodes_by_attribute(
                                 'lv_station')}['LVStation_' + str(
                                      ding0_lv_grid._station.id_db)]
  
                  station.grid = lv_grid
                  for t in station.transformers:
                      t.grid = lv_grid
  
                  lv_grid.graph.add_node(station, type='lv_station')
                  lv_station_mapping.update({ding0_lv_grid._station: station})
  
                  # Create list of load instances and add these to grid's graph
                  loads = {_: Load(
                      id=_.id_db,
                      geom=_.geo_data,
                      grid=lv_grid,
                      consumption=_.consumption) for _ in ding0_lv_grid.loads()}
                  lv_grid.graph.add_nodes_from(loads.values(), type='load')
  
                  # Create list of generator instances and add these to grid's
                  # graph
                  generators = {_: (GeneratorFluctuating(
                      id=_.id_db,
                      geom=_.geo_data,
                      nominal_capacity=_.capacity,
                      type=_.type,
                      subtype=_.subtype,
                      grid=lv_grid,
                      weather_cell_id=_.weather_cell_id,
                      v_level=_.v_level) if _.type in ['wind', 'solar'] else
                                    Generator(
                                        id=_.id_db,
                                        geom=_.geo_data,
                                        nominal_capacity=_.capacity,
                                        type=_.type,
                                        subtype=_.subtype,
                                        grid=lv_grid,
                                        v_level=_.v_level))
                                for _ in ding0_lv_grid.generators()}
                  lv_grid.graph.add_nodes_from(generators.values(),
                                               type='generator')
  
                  # Create list of branch tee instances and add these to grid's
                  # graph
                  branch_tees = {
                      _: BranchTee(id=_.id_db,
                                   geom=_.geo_data,
                                   grid=lv_grid,
                                   in_building=_.in_building)
                      for _ in ding0_lv_grid._cable_distributors}
                  lv_grid.graph.add_nodes_from(branch_tees.values(),
                                                type='branch_tee')
  
                  # Merge node above defined above to a single dict
                  nodes = {**loads,
                           **generators,
                           **branch_tees,
                           **{ding0_lv_grid._station: station}}
  
                  edges = []
                  edges_raw = list(nx.get_edge_attributes(
                      ding0_lv_grid._graph, 'branch').items())
                  for edge in edges_raw:
                      edges.append({'adj_nodes': edge[0], 'branch': edge[1]})
  
                  # Create list of line instances and add these to grid's graph
                  lines = [(nodes[_['adj_nodes'][0]], nodes[_['adj_nodes'][1]],
                            {'line': Line(
                                id=_['branch'].id_db,
                                type=_['branch'].type,
                                length=_['branch'].length / 1e3,
                                kind=_['branch'].kind,
                                grid=lv_grid)
                            })
                           for _ in edges]
                  # convert voltage from V to kV
                  for line in lines:
                      # ToDo: remove work around once it's fixed in ding0
                      if line[2]['line'].type['U_n'] >= 400:
                          line[2]['line'].type['U_n'] = \
                              line[2]['line'].type['U_n'] / 1e3
                  lv_grid.graph.add_edges_from(lines, type='line')
  
                  # Add LV station as association to LV grid
                  lv_grid._station = station
  
                  # Add to lv grid mapping
                  lv_grid_mapping.update({lv_grid: ding0_lv_grid})
  
                  # Put all LV grid to a list of LV grids
                  lv_grids.append(lv_grid)
  
      # ToDo: don't forget to adapt lv stations creation in MV grid
      return lv_grids, lv_station_mapping, lv_grid_mapping