示例#1
0
def test_shadows_coords_left_right_of_cut_point():
    """Test that coords left and right of cut point are created correctly"""
    # Ground inputs
    shadow_coords = np.array(
        [[[[0], [0]], [[2], [0]]], [[[3], [0]], [[5], [0]]]], dtype=float)
    overlap = [False]

    # --- Create timeseries ground
    cut_point = TsPointCoords([2.5], [0])
    ts_ground = TsGround.from_ordered_shadows_coords(
        shadow_coords, flag_overlap=overlap, cut_point_coords=[cut_point])

    # Get left and right shadows
    shadows_left = ts_ground.shadow_coords_left_of_cut_point(0)
    shadows_right = ts_ground.shadow_coords_right_of_cut_point(0)

    # Reformat for testing
    shadows_left = [shadow.as_array for shadow in shadows_left]
    shadows_right = [shadow.as_array for shadow in shadows_right]

    expected_shadows_left = [
        shadow_coords[0], [cut_point.as_array, cut_point.as_array]
    ]
    expected_shadows_right = [[cut_point.as_array, cut_point.as_array],
                              shadow_coords[1]]

    # Test that correct
    np.testing.assert_allclose(shadows_left, expected_shadows_left)
    np.testing.assert_allclose(shadows_right, expected_shadows_right)

    # --- Case where pv rows are flat, cut point are inf
    cut_point = TsPointCoords([np.inf], [0])
    ts_ground = TsGround.from_ordered_shadows_coords(
        shadow_coords, flag_overlap=overlap, cut_point_coords=[cut_point])

    # Get right shadows
    shadows_right = ts_ground.shadow_coords_right_of_cut_point(0)

    # Test that correct
    maxi = MAX_X_GROUND
    expected_shadows_right = np.array([[[[maxi], [0.]], [[maxi], [0.]]],
                                       [[[maxi], [0.]], [[maxi], [0.]]]])
    shadows_right = [shadow.as_array for shadow in shadows_right]
    np.testing.assert_allclose(shadows_right, expected_shadows_right)

    # --- Case where pv rows are flat, cut point are - inf
    cut_point = TsPointCoords([-np.inf], [0])
    ts_ground = TsGround.from_ordered_shadows_coords(
        shadow_coords, flag_overlap=overlap, cut_point_coords=[cut_point])

    # Get left shadows
    shadows_left = ts_ground.shadow_coords_left_of_cut_point(0)

    # Test that correct
    mini = MIN_X_GROUND
    expected_shadows_left = np.array([[[[mini], [0.]], [[mini], [0.]]],
                                      [[[mini], [0.]], [[mini], [0.]]]])
    shadows_left = [shadow.as_array for shadow in shadows_left]
    np.testing.assert_allclose(shadows_left, expected_shadows_left)
示例#2
0
def test_ts_ground_overlap():

    shadow_coords = np.array([[[[0, 0], [0, 0]], [[2, 1], [0, 0]]],
                              [[[1, 2], [0, 0]], [[5, 5], [0, 0]]]])
    overlap = [True, False]

    # Test without overlap
    ts_ground = TsGround.from_ordered_shadows_coords(shadow_coords)
    np.testing.assert_allclose(ts_ground.shadow_elements[0].b2.x, [2, 1])

    # Test with overlap
    ts_ground = TsGround.from_ordered_shadows_coords(shadow_coords,
                                                     flag_overlap=overlap)
    np.testing.assert_allclose(ts_ground.shadow_elements[0].b2.x, [1, 1])
示例#3
0
def test_ts_ground_to_geometry():

    # There should be an overlap
    shadow_coords = np.array([[[[0, 0], [0, 0]], [[2, 1], [0, 0]]],
                              [[[1, 2], [0, 0]], [[5, 5], [0, 0]]]])
    overlap = [True, False]
    cut_point_coords = [TsPointCoords.from_array(np.array([[2, 2], [0, 0]]))]

    # Test with overlap
    ts_ground = TsGround.from_ordered_shadows_coords(
        shadow_coords, flag_overlap=overlap, cut_point_coords=cut_point_coords)

    # Run some checks for index 0
    pvground = ts_ground.at(0,
                            merge_if_flag_overlap=False,
                            with_cut_points=False)
    assert pvground.n_surfaces == 4
    assert pvground.list_segments[0].illum_collection.n_surfaces == 2
    assert pvground.list_segments[0].shaded_collection.n_surfaces == 2
    assert pvground.list_segments[0].shaded_collection.length == 5
    np.testing.assert_allclose(pvground.shaded_length, 5)

    # Run some checks for index 1
    pvground = ts_ground.at(1, with_cut_points=False)
    assert pvground.n_surfaces == 5
    assert pvground.list_segments[0].illum_collection.n_surfaces == 3
    assert pvground.list_segments[0].shaded_collection.n_surfaces == 2
    assert pvground.list_segments[0].shaded_collection.length == 4
    np.testing.assert_allclose(pvground.shaded_length, 4)

    # Run some checks for index 0, when merging
    pvground = ts_ground.at(0,
                            merge_if_flag_overlap=True,
                            with_cut_points=False)
    assert pvground.n_surfaces == 3
    assert pvground.list_segments[0].illum_collection.n_surfaces == 2
    assert pvground.list_segments[0].shaded_collection.n_surfaces == 1
    assert pvground.list_segments[0].shaded_collection.length == 5
    np.testing.assert_allclose(pvground.shaded_length, 5)

    # Run some checks for index 0, when merging and with cut points
    pvground = ts_ground.at(0,
                            merge_if_flag_overlap=True,
                            with_cut_points=True)
    assert pvground.n_surfaces == 4
    assert pvground.list_segments[0].illum_collection.n_surfaces == 2
    assert pvground.list_segments[0].shaded_collection.n_surfaces == 2
    assert pvground.list_segments[0].shaded_collection.length == 5
    np.testing.assert_allclose(pvground.shaded_length, 5)