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