Add test files

Author: AdamRJensen

twoaxistracking/tests/test_layout.py

@@ -1,4 +1,4 @@
-from twoaxistracking import layout
+from twoaxistracking import layout, twoaxistrackerfield
 from shapely import geometry
 import numpy as np
 import pytest
@@ -8,132 +8,144 @@
 def rectangular_geometry():
     collector_geometry = geometry.box(-2, -1, 2, 1)
     total_collector_area = collector_geometry.area
-    l_min = layout._calculate_l_min(collector_geometry)
-    return collector_geometry, total_collector_area, l_min
+    min_tracker_spacing = layout._calculate_min_tracker_spacing(collector_geometry)
+    return collector_geometry, total_collector_area, min_tracker_spacing
 
 
 @pytest.fixture
 def square_field_layout():
     # Corresponds to GCR 0.125 with the rectangular_geometry
-    X = np.array([-8.,  0.,  8., -8.,  8., -8.,  0.,  8.])
-    Y = np.array([-8., -8., -8.,  0.,  0.,  8.,  8.,  8.])
+    X = np.array([-8, 0, 8, -8, 8, -8, 0, 8])
+    Y = np.array([-8, -8, -8, 0, 0, 8, 8, 8])
     tracker_distance = (X**2 + Y**2)**0.5
-    relative_azimuth = np.array([225., 180., 135., 270.,  90., 315.,   0.,  45.])
+    relative_azimuth = np.array([225, 180, 135, 270, 90, 315, 0, 45])
     Z = np.zeros(8)
     relative_slope = np.zeros(8)
     return X, Y, Z, tracker_distance, relative_azimuth, relative_slope
 
 
-def test_l_min_rectangle(rectangular_geometry):
-    # Test calculation of L_min for a rectangular collector
-    l_min = layout._calculate_l_min(rectangular_geometry[0])
-    assert l_min == np.sqrt(4**2+2**2)
+def test_min_tracker_spacing_rectangle(rectangular_geometry):
+    # Test calculation of min_tracker_spacing for a rectangular collector
+    min_tracker_spacing = layout._calculate_min_tracker_spacing(rectangular_geometry[0])
+    assert min_tracker_spacing == np.sqrt(4**2+2**2)
 
 
-def test_l_min_circle():
-    # Test calculation of L_min for a circular collector with radius 1
+def test_min_tracker_spacing_circle():
+    # Test calculation of min_tracker_spacing for a circular collector with radius 1
     collector_geometry = geometry.Point(0, 0).buffer(1)
-    l_min = layout._calculate_l_min(collector_geometry)
-    assert l_min == 2
+    min_tracker_spacing = layout._calculate_min_tracker_spacing(collector_geometry)
+    assert min_tracker_spacing == 2
 
 
-def test_l_min_circle_offcenter():
-    # Test calculation of L_min for a circular collector with radius 1 rotating
+def test_min_tracker_spacing_circle_offcenter():
+    # Test calculation of min_tracker_spacing for a circular collector with radius 1 rotating
     # off-center around the point (0, 1)
     collector_geometry = geometry.Point(0, 1).buffer(1)
-    l_min = layout._calculate_l_min(collector_geometry)
-    assert l_min == 4
+    min_tracker_spacing = layout._calculate_min_tracker_spacing(collector_geometry)
+    assert min_tracker_spacing == 4
 
 
-def test_l_min_polygon():
-    # Test calculation of L_min for a polygon
+def test_min_tracker_spacingpolygon():
+    # Test calculation of min_tracker_spacing for a polygon
     collector_geometry = geometry.Polygon([(-1, -1), (3, 2), (4, 4), (1, 2), (-1, -1)])
-    l_min = layout._calculate_l_min(collector_geometry)
-    assert l_min == 2 * np.sqrt(4**2 + 4**2)
+    min_tracker_spacing = layout._calculate_min_tracker_spacing(collector_geometry)
+    assert min_tracker_spacing == 2 * np.sqrt(4**2 + 4**2)
 
 
-def test_square_layout_generation(rectangular_geometry):
-    # Test square field layout defined using tje built-in layout types
-    collector_geometry, total_collector_area, L_min = rectangular_geometry
+def test_square_layout_generation(rectangular_geometry, square_field_layout):
+    # Test that a square field layout is returned correctly
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
+    X_exp, Y_exp, Z_exp, tracker_distance_exp, relative_azimuth_exp, relative_slope_exp = \
+        square_field_layout
 
     X, Y, Z, tracker_distance, relative_azimuth, relative_slope = \
         layout.generate_field_layout(
-            gcr=0.25, total_collector_area=total_collector_area, L_min=L_min,
-            neighbor_order=1, layout_type='square',
-            slope_azimuth=0, slope_tilt=0, plot=False)
-    assert np.isclose(X, np.array([-5.65685425, 0, 5.65685425, -5.65685425,
-                                   5.65685425, -5.65685425, 0, 5.65685425])
-                      ).all()
+            gcr=0.125,
+            total_collector_area=total_collector_area,
+            min_tracker_spacing=min_tracker_spacing,
+            neighbor_order=1,
+            aspect_ratio=1,
+            offset=0,
+            rotation=0)
+    assert (X == X_exp).all()
+    assert (Y == Y_exp).all()
+    assert (Z == Z_exp).all()
+    assert (tracker_distance_exp == tracker_distance_exp).all()
+    assert (relative_azimuth == relative_azimuth_exp).all()
+    assert (relative_slope == relative_slope_exp).all()
 
 
 def test_layout_generation_value_error(rectangular_geometry):
     # Test if value errors are correctly raised
-    collector_geometry, total_collector_area, L_min = rectangular_geometry
-
-    # Test if ValueError is raised when an incorrect layout_type is specified
-    with pytest.raises(ValueError, match="layout type specified was not recognized"):
-        _ = layout.generate_field_layout(
-            gcr=0.25, total_collector_area=total_collector_area, L_min=L_min,
-            neighbor_order=1, layout_type='this_is_not_a_layout_type')
-
-    # Test if ValueError is raised if too few layout parameters are specified
-    with pytest.raises(ValueError, match="no layout type has not been selected"):
-        _ = layout.generate_field_layout(
-            gcr=0.25, total_collector_area=total_collector_area, L_min=L_min,
-            neighbor_order=1, rotation=0)
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
 
     # Test if ValueError is raised if offset is out of range
     with pytest.raises(ValueError, match="offset is outside the valid range"):
         _ = layout.generate_field_layout(
-            gcr=0.25, total_collector_area=total_collector_area, L_min=L_min,
-            neighbor_order=1, rotation=0, offset=1.1, aspect_ratio=1)
+            gcr=0.25, total_collector_area=total_collector_area,
+            min_tracker_spacing=min_tracker_spacing, neighbor_order=1,
+            aspect_ratio=1, offset=1.1, rotation=0)
 
     # Test if ValueError is raised if aspect ratio is too low
     with pytest.raises(ValueError, match="Aspect ratio is too low"):
         _ = layout.generate_field_layout(
-            gcr=0.25, total_collector_area=total_collector_area, L_min=L_min,
-            neighbor_order=1, rotation=0, offset=0, aspect_ratio=0.6)
+            gcr=0.25, total_collector_area=total_collector_area,
+            min_tracker_spacing=min_tracker_spacing, neighbor_order=1,
+            aspect_ratio=0.6, offset=0, rotation=0)
 
     # Test if ValueError is raised if aspect ratio is too high
     with pytest.raises(ValueError, match="Aspect ratio is too high"):
         _ = layout.generate_field_layout(
-            gcr=0.25, total_collector_area=total_collector_area, L_min=L_min,
-            neighbor_order=1, rotation=0, offset=0, aspect_ratio=5)
+            gcr=0.25, total_collector_area=total_collector_area,
+            min_tracker_spacing=min_tracker_spacing, neighbor_order=1,
+            aspect_ratio=5, offset=0, rotation=0)
 
-    # Test if ValueError is raised if rotation is outside valid range
+    # Test if ValueError is raised if rotation is greater than 180 degrees
     with pytest.raises(ValueError, match="rotation is outside the valid range"):
         _ = layout.generate_field_layout(
-            gcr=0.25, total_collector_area=total_collector_area, L_min=L_min,
-            neighbor_order=1, rotation=190, offset=0, aspect_ratio=1.2)
+            gcr=0.25, total_collector_area=total_collector_area,
+            min_tracker_spacing=min_tracker_spacing, neighbor_order=1,
+            aspect_ratio=1.2, offset=0, rotation=190)
 
-    # Test if ValueError is raised if L_min is outside valid range
+    # Test if ValueError is raised if rotation is less than 0
+    with pytest.raises(ValueError, match="rotation is outside the valid range"):
+        _ = layout.generate_field_layout(
+            gcr=0.5, total_collector_area=total_collector_area,
+            min_tracker_spacing=min_tracker_spacing, neighbor_order=1,
+            aspect_ratio=1, offset=0, rotation=-1)
+
+    # Test if ValueError is raised if min_tracker_spacing is outside valid range
     with pytest.raises(ValueError, match="Lmin is not physically possible"):
         _ = layout.generate_field_layout(
-            gcr=0.25, total_collector_area=total_collector_area, L_min=1,
-            neighbor_order=1, rotation=90, offset=0, aspect_ratio=1.2)
+            gcr=0.25, total_collector_area=total_collector_area,
+            min_tracker_spacing=1, neighbor_order=1, aspect_ratio=1.2,
+            offset=0, rotation=90)
 
-    # Test if ValueError is raised if rotation is outside valid range
+    # Test if ValueError is raised if maximum ground cover ratio is exceeded
     with pytest.raises(ValueError, match="Maximum ground cover ratio exceded"):
         _ = layout.generate_field_layout(
-            gcr=0.5, total_collector_area=total_collector_area, L_min=L_min,
-            neighbor_order=1, rotation=0, offset=0, aspect_ratio=1)
+            gcr=0.5, total_collector_area=total_collector_area,
+            min_tracker_spacing=min_tracker_spacing, neighbor_order=1,
+            aspect_ratio=1, offset=0, rotation=0)
 
 
-def test_square_field_layout(rectangular_geometry, square_field_layout):
-    # Test that a square field layout is returned correctly
-    collector_geometry, total_collector_area, L_min = rectangular_geometry
-    X_exp, Y_exp, Z_exp, tracker_distance_exp, relative_azimuth_exp, relative_slope_exp = \
-        square_field_layout
+def test_field_slope():
+    assert True
 
+
+def test_neighbor_order(rectangular_geometry):
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
     X, Y, Z, tracker_distance, relative_azimuth, relative_slope = \
         layout.generate_field_layout(
             gcr=0.125,
             total_collector_area=total_collector_area,
-            L_min=L_min,
-            neighbor_order=1,
-            layout_type='square')
+            min_tracker_spacing=min_tracker_spacing,
+            neighbor_order=3,
+            aspect_ratio=1,
+            offset=0,
+            rotation=0)
+    assert len(X) == (7*7-1)
 
-# Test custom layout
 # Test slope
 # Test neighbor order
 

twoaxistracking/tests/test_plotting.py

@@ -0,0 +1,52 @@
+import matplotlib.pyplot as plt
+from twoaxistracking import plotting, layout, twoaxistrackerfield
+from shapely import geometry
+import numpy as np
+import pytest
+
+
+def assert_isinstance(obj, klass):
+    assert isinstance(obj, klass), f'got {type(obj)}, expected {klass}'
+
+
+def test_field_layout_plot():
+    X = np.array([-8, 0, 8, -8, 8, -8, 0, 8])
+    Y = np.array([-8, -8, -8, 0, 0, 8, 8, 8])
+    Z = np.array([0.1237, 0.0619, 0, 0.0619, -0.0619, 0, -0.0619, -0.1237])
+    L_min = 4.4721
+    result = plotting._plot_field_layout(X, Y, Z, L_min)
+    assert_isinstance(result, plt.Figure)
+    plt.close('all')
+
+
+@pytest.fixture
+def rectangular_geometry():
+    collector_geometry = geometry.box(-2, -1, 2, 1)
+    total_collector_area = collector_geometry.area
+    min_tracker_spacing = layout._calculate_min_tracker_spacing(collector_geometry)
+    return collector_geometry, total_collector_area, min_tracker_spacing
+
+
+def test_shading_plot(rectangular_geometry):
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
+    result = plotting._plot_shading(collector_geometry, collector_geometry,
+                                    collector_geometry, min_tracker_spacing)
+    assert_isinstance(result, plt.Figure)
+    plt.close('all')
+
+
+def test_plotting_of_field_layout(rectangular_geometry):
+    # Test if plot_field_layout returns a figure object
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
+    field = twoaxistrackerfield.TwoAxisTrackerField(
+        total_collector_geometry=collector_geometry,
+        active_collector_geometry=collector_geometry,
+        neighbor_order=1,
+        gcr=0.25,
+        aspect_ratio=1,
+        offset=0.45,
+        rotation=30,
+    )
+    result = field.plot_field_layout()
+    assert_isinstance(result, plt.Figure)
+    plt.close('all')

twoaxistracking/tests/test_shading.py

@@ -0,0 +1,125 @@
+from twoaxistracking import shading, layout
+from shapely import geometry
+import numpy as np
+import pytest
+
+
+@pytest.fixture
+def rectangular_geometry():
+    collector_geometry = geometry.box(-2, -1, 2, 1)
+    total_collector_area = collector_geometry.area
+    min_tracker_spacing = layout._calculate_min_tracker_spacing(collector_geometry)
+    return collector_geometry, total_collector_area, min_tracker_spacing
+
+
+@pytest.fixture
+def square_field_layout():
+    # Corresponds to GCR 0.125 with the rectangular_geometry
+    X = np.array([-8, 0, 8, -8, 8, -8, 0, 8])
+    Y = np.array([-8, -8, -8, 0, 0, 8, 8, 8])
+    tracker_distance = (X**2 + Y**2)**0.5
+    relative_azimuth = np.array([225, 180, 135, 270, 90, 315, 0, 45])
+    Z = np.zeros(8)
+    relative_slope = np.zeros(8)
+    return X, Y, Z, tracker_distance, relative_azimuth, relative_slope
+
+
+def test_shading(rectangular_geometry, square_field_layout):
+    # Test shading when geometries completly overlap
+    # Also plots the geometry (ensures no errors occurs)
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
+    X, Y, Z, tracker_distance, relative_azimuth, relative_slope = \
+        square_field_layout
+    shaded_fraction = shading.shaded_fraction(
+        solar_elevation=3,
+        solar_azimuth=120,
+        total_collector_geometry=collector_geometry,
+        active_collector_geometry=collector_geometry,
+        min_tracker_spacing=min_tracker_spacing,
+        tracker_distance=tracker_distance,
+        relative_azimuth=relative_azimuth,
+        relative_slope=relative_slope,
+        slope_azimuth=0,
+        slope_tilt=0,
+        plot=True)
+    assert np.isclose(shaded_fraction, 0.191324)
+
+
+def test_shading_zero_solar_elevation(rectangular_geometry, square_field_layout):
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
+    X, Y, Z, tracker_distance, relative_azimuth, relative_slope = \
+        square_field_layout
+    # Test shading when geometries completly overlap
+    shaded_fraction = shading.shaded_fraction(
+        solar_elevation=0,
+        solar_azimuth=180,
+        total_collector_geometry=collector_geometry,
+        active_collector_geometry=collector_geometry,
+        min_tracker_spacing=min_tracker_spacing,
+        tracker_distance=tracker_distance,
+        relative_azimuth=relative_azimuth,
+        relative_slope=relative_slope,
+        slope_azimuth=0,
+        slope_tilt=0,
+        plot=False)
+    assert shaded_fraction == 1
+
+
+def test_no_shading(rectangular_geometry, square_field_layout):
+    # Test shading calculation when there is no shading (high solar elevation)
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
+    X, Y, Z, tracker_distance, relative_azimuth, relative_slope = \
+        square_field_layout
+    shaded_fraction = shading.shaded_fraction(
+        solar_elevation=45,
+        solar_azimuth=180,
+        total_collector_geometry=collector_geometry,
+        active_collector_geometry=collector_geometry,
+        min_tracker_spacing=min_tracker_spacing,
+        tracker_distance=tracker_distance,
+        relative_azimuth=relative_azimuth,
+        relative_slope=relative_slope,
+        slope_azimuth=0,
+        slope_tilt=0,
+        plot=False)
+    assert shaded_fraction == 0
+
+
+def test_shading_below_horizon(rectangular_geometry, square_field_layout):
+    # Test shading calculation when sun is below the horizon (elevation<0)
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
+    X, Y, Z, tracker_distance, relative_azimuth, relative_slope = \
+        square_field_layout
+    shaded_fraction = shading.shaded_fraction(
+        solar_elevation=-5.1,
+        solar_azimuth=180,
+        total_collector_geometry=collector_geometry,
+        active_collector_geometry=collector_geometry,
+        min_tracker_spacing=min_tracker_spacing,
+        tracker_distance=tracker_distance,
+        relative_azimuth=relative_azimuth,
+        relative_slope=relative_slope,
+        slope_azimuth=0,
+        slope_tilt=0,
+        plot=False)
+    assert np.isnan(shaded_fraction)
+
+
+def test_shading_below_hill_horizon(rectangular_geometry, square_field_layout):
+    # Test shading calculation when there is no shading (high solar elevation)
+    collector_geometry, total_collector_area, min_tracker_spacing = rectangular_geometry
+    X, Y, Z, tracker_distance, relative_azimuth, relative_slope = \
+        square_field_layout
+    shaded_fraction = shading.shaded_fraction(
+        solar_elevation=9,
+        solar_azimuth=180,
+        total_collector_geometry=collector_geometry,
+        active_collector_geometry=collector_geometry,
+        min_tracker_spacing=min_tracker_spacing,
+        tracker_distance=tracker_distance,
+        relative_azimuth=relative_azimuth,
+        relative_slope=relative_slope,
+        slope_azimuth=0,
+        slope_tilt=10,
+        plot=False)
+    assert shaded_fraction == 1