Merge branch 'MoreTests' into 'master'

More tests

See merge request !19

.coveragerc

+[run]
+omit = */Colonel/*
\ No newline at end of file

.gitlab-ci.yml

@@ -8,7 +8,7 @@ test_topfarm:  # name the job what we like
   stage:  # build, test, deploy defined by default [2]
     test
   script:
-  - cd tests; py.test --cov-report term-missing:skip-covered --cov=topfarm
+  - cd tests; py.test
   tags:  # only runners with this tag can do the job [3]
   - python
 

tests/test_constraint/test_PolygonBoundaryComp.py

+import unittest
+
+import numpy as np
+from topfarm.cost_models.dummy import DummyCost, DummyCostPlotComp
+from topfarm import TopFarm
+from topfarm.constraint_components.boundary_component import PolygonBoundaryComp
+
+
+class TestPolygonBoundaryComp(unittest.TestCase):
+
+    def testPolygon(self):
+        boundary = [(0, 0), (1, 1), (2, 0), (2, 2), (0, 2)]
+        pbc = PolygonBoundaryComp(boundary, 1)
+        np.testing.assert_array_equal(pbc.vertices, [[0, 0],
+                                                     [1, 1],
+                                                     [2, 0],
+                                                     [2, 2],
+                                                     [0, 2]])
+
+    def testPolygon_StartEqEnd(self):
+        boundary = [(0, 0), (1, 1), (2, 0), (2, 2), (0, 2), (0, 0)]
+        pbc = PolygonBoundaryComp(boundary, 1)
+        np.testing.assert_array_equal(pbc.vertices, [[0, 0],
+                                                     [1, 1],
+                                                     [2, 0],
+                                                     [2, 2],
+                                                     [0, 2]])
+
+    def testPolygon_Clockwise(self):
+        boundary = [(0, 0), (0, 2), (2, 2), (2, 0), (1, 1)]
+        pbc = PolygonBoundaryComp(boundary, 1)
+        np.testing.assert_array_equal(pbc.vertices, [[0, 0],
+                                                     [1, 1],
+                                                     [2, 0],
+                                                     [2, 2],
+                                                     [0, 2]])
+
+    def testPolygon_StartEqEndClockwise(self):
+        boundary = [(0, 0), (0, 2), (2, 2), (2, 0), (1, 1), (0, 0)]
+        pbc = PolygonBoundaryComp(boundary, 1)
+        np.testing.assert_array_equal(pbc.vertices, [[0, 0],
+                                                     [1, 1],
+                                                     [2, 0],
+                                                     [2, 2],
+                                                     [0, 2]])
+
+    def check(self, boundary, points, distances):
+        pbc = PolygonBoundaryComp(boundary, 1)
+        d, dx, dy = pbc.calc_distance_and_gradients(points[:, 0], points[:, 1])
+        np.testing.assert_array_almost_equal(d, distances)
+        eps = 1e-7
+        d1, _, _ = pbc.calc_distance_and_gradients(points[:, 0] + eps, points[:, 1])
+        np.testing.assert_array_almost_equal((d1 - d) / eps, dx)
+        d2, _, _ = pbc.calc_distance_and_gradients(points[:, 0], points[:, 1] + eps)
+        np.testing.assert_array_almost_equal((d2 - d) / eps, dy)
+
+    def test_calc_distance_edge(self):
+        boundary = np.array([(0, 0), (1, 0), (2, 1), (0, 2), (0, 0)])
+        points = np.array([(0.5, .2), (1, .5), (.5, 1.5), (.2, 1)])
+        self.check(boundary, points, [0.2, np.sqrt(2 * .25**2), .5 * np.sin(np.arctan(.5)), 0.2])
+
+    def test_calc_distance_edge_outside(self):
+        boundary = np.array([(0, 0), (1, 0), (2, 1), (0, 2), (0, 0)])
+        points = np.array([(0.5, -.2), (1.5, 0), (.5, 2), (-.2, 1)])
+        self.check(boundary, points, [-0.2, -np.sqrt(2 * .25**2), -.5 * np.sin(np.arctan(.5)), -0.2])
+
+    def test_calc_distance_point_vertical(self):
+        boundary = np.array([(0, 0), (1, 1), (2, 0), (2, 2), (0, 2), (0, 0)])
+        points = np.array([(.8, 1), (.8, 1.2), (1, 1.2), (1.1, 1.2), (1.2, 1.2), (1.2, 1)])
+        self.check(boundary, points, [np.sqrt(.2**2 / 2), np.sqrt(2 * .2**2), .2,
+                                      np.sqrt(.1**2 + .2**2), np.sqrt(2 * .2**2), np.sqrt(.2**2 / 2)])
+
+    def test_calc_distance_point_vertical_outside(self):
+        boundary = np.array([(0, 0), (1, 1), (2, 0), (0, 0)])
+        points = np.array([(.8, 1), (.8, 1.2), (1, 1.2), (1.1, 1.2), (1.2, 1.2), (1.2, 1)])
+
+        self.check(boundary, points, [-np.sqrt(.2**2 / 2), -np.sqrt(2 * .2**2), -.2,
+                                      -np.sqrt(.1**2 + .2**2), -np.sqrt(2 * .2**2), -np.sqrt(.2**2 / 2)])
+
+    def test_calc_distance_point_horizontal(self):
+        boundary = np.array([(0, 0), (2, 0), (1, 1), (2, 2), (0, 2), (0, 0)])
+        points = np.array([(1, .8), (.8, .8), (.8, 1), (.8, 1.1), (.8, 1.2), (1, 1.2)])
+        self.check(boundary, points, [np.sqrt(.2**2 / 2), np.sqrt(2 * .2**2), .2,
+                                      np.sqrt(.1**2 + .2**2), np.sqrt(2 * .2**2), np.sqrt(.2**2 / 2)])
+
+    def testPolygon_Line(self):
+        boundary = [(0, 0), (0, 2)]
+        self.assertRaisesRegex(AssertionError, "Area must be non-zero", PolygonBoundaryComp, boundary, 1)
+
+    def test_calc_distance_U_shape(self):
+        boundary = np.array([(0, 0), (3, 0), (3, 2), (2, 2), (2, 1), (1, 1), (1, 2), (0, 2)])
+        points = np.array([(-.1, 1.5), (.1, 1.5), (.9, 1.5), (1.1, 1.5), (1.5, 1.5), (1.9, 1.5), (2.1, 1.5), (2.9, 1.5), (3.1, 1.5)])
+        self.check(boundary, points, [-.1, .1, .1, -.1, -.5, -.1, .1, .1, -.1])
+
+    def test_calc_distance_V_shape(self):
+        boundary = np.array([(0, 0), (1, 2), (2, 0), (2, 2), (1, 4), (0, 2)])
+        points = np.array([(.8, 2), (.8, 2.2), (1, 2.2), (1.2, 2.2), (1.2, 2), (.8, 4), (.8, 4.2), (1, 4.2), (1.2, 4.2), (1.2, 4)])
+        v1 = np.sqrt(.2**2 * 4 / 5)
+        v2 = np.sqrt(2 * .2**2)
+        self.check(boundary, points, [v1, v2, .2, v2, v1, -v1, -v2, -.2, -v2, -v1])
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testName']
+    unittest.main()

tests/test_constraint/test_boundary.py

+import unittest
+
+import numpy as np
+from topfarm.cost_models.dummy import DummyCost, DummyCostPlotComp
+from topfarm import TopFarm
+
+
+class TestBoundary(unittest.TestCase):
+
+    def testSquare(self):
+        optimal = [(0, 0)]
+        boundary = [(0, 0), (1, 3)]
+        tf = TopFarm(optimal, DummyCost(optimal), 2, boundary=boundary, boundary_type='square')
+        np.testing.assert_array_equal(tf.boundary, [[-1, 0],
+                                                    [2, 0],
+                                                    [2, 3],
+                                                    [-1, 3],
+                                                    [-1, 0]])
+
+    def testRectangle(self):
+        optimal = [(0, 0)]
+        boundary = [(0, 0), (1, 3)]
+        tf = TopFarm(optimal, DummyCost(optimal), 2, boundary=boundary, boundary_type='rectangle')
+        np.testing.assert_array_equal(tf.boundary, [[0, 0],
+                                                    [1, 0],
+                                                    [1, 3],
+                                                    [0, 3],
+                                                    [0, 0]])
+
+    def testConvexHull(self):
+        optimal = [(0, 0)]
+        boundary = [(0, 0), (1, 1), (2, 0), (2, 2), (0, 2)]
+        tf = TopFarm(optimal, DummyCost(optimal), 2, boundary=boundary, boundary_type='convex_hull')
+        np.testing.assert_array_equal(tf.boundary, [[0, 0],
+                                                    [2, 0],
+                                                    [2, 2],
+                                                    [0, 2],
+                                                    [0, 0]])
+
+    def testNotImplemented(self):
+        optimal = [(0, 0)]
+        boundary = [(0, 0), (1, 1), (2, 0), (2, 2), (0, 2)]
+        self.assertRaisesRegex(NotImplementedError, "Boundary type 'Something' is not implemented", TopFarm, optimal, DummyCost(optimal), 2, boundary=boundary, boundary_type='Something')
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testName']
+    unittest.main()

tests/test_constraint/test_boundary_polygon.py

+import unittest
+
+import numpy as np
+from topfarm.cost_models.dummy import DummyCost, DummyCostPlotComp
+from topfarm import TopFarm
+from topfarm.constraint_components.boundary_component import PolygonBoundaryComp
+from topfarm.plotting import NoPlot, PlotComp
+
+
+class TestBoundaryPolygon(unittest.TestCase):
+
+    def testPolygon(self):
+        optimal = [(0, 0)]
+        boundary = [(0, 0), (1, 1), (2, 0), (2, 2), (0, 2)]
+        tf = TopFarm(optimal, DummyCost(optimal), 2, boundary=boundary, boundary_type='polygon')
+        np.testing.assert_array_equal(tf.boundary, [[0, 0],
+                                                    [1, 1],
+                                                    [2, 0],
+                                                    [2, 2],
+                                                    [0, 2],
+                                                    [0, 0]])
+
+    def testPolygonConcave(self):
+        optimal = [(1.5, 1.3), (4, 1)]
+        boundary = [(0, 0), (5, 0), (5, 2), (3, 2), (3, 1), (2, 1), (2, 2), (0, 2), (0, 0)]
+        plot_comp = NoPlot()  # DummyCostPlotComp(optimal)
+        initial = [(-0, .1), (4, 1.5)][::-1]
+        tf = TopFarm(initial, DummyCost(optimal), 0, boundary=boundary, boundary_type='polygon', plot_comp=plot_comp)
+        tf.evaluate()
+        tf.optimize()
+        np.testing.assert_array_almost_equal(tf.turbine_positions, optimal, 4)
+        plot_comp.show()
+
+    def testPolygonTwoRegionsStartInWrong(self):
+        optimal = [(1, 1), (4, 1)]
+        boundary = [(0, 0), (5, 0), (5, 2), (3, 2), (3, 0), (2, 0), (2, 2), (0, 2), (0, 0)]
+        plot_comp = NoPlot()  # DummyCostPlotComp(optimal, delay=.1)
+        initial = [(3.5, 1.5), (2, 1)]
+        tf = TopFarm(initial, DummyCost(optimal), 0, boundary=boundary, boundary_type='polygon', plot_comp=plot_comp)
+        tf.evaluate()
+        tf.optimize()
+        plot_comp.show()
+        np.testing.assert_array_almost_equal(tf.turbine_positions, optimal, 4)
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testName']
+    unittest.main()

tests/test_costmodel_utils/test_aep_calculator.py

+'''
+Created on 17. maj 2018
+
+@author: mmpe
+'''
+import unittest
+
+import numpy as np
+from topfarm.cost_models.utils.wind_resource import WindResource
+from tests.test_files import testfilepath
+from topfarm.cost_models.fused_wake_wrappers import FusedWakeGCLWakeModel
+from topfarm.cost_models.utils.aep_calculator import AEPCalculator
+
+
+class TestAEPCalculator(unittest.TestCase):
+
+    def test_AEPCalculator(self):
+        f = [1,0,0,0]
+        A = [9.176929,10,10,10]
+        k = [2.392578,2,2,2]
+        wr = WindResource(np.array(f), A, k, ti=np.zeros_like(f) + .1)
+        wf_3tb = testfilepath + "wind_farms/3tb.yml"
+        wm = FusedWakeGCLWakeModel(wf_3tb)
+        aep_calc = AEPCalculator(wr, wm)
+
+        self.assertAlmostEqual(aep_calc(np.array([[-1600, 0, 1600], [0, 0, 0]]).T), 22.3178800761)
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testName']
+    unittest.main()

tests/test_costmodel_utils/test_cost_model_wrappers.py

+'''
+Created on 17. maj 2018
+
+@author: mmpe
+'''
+import unittest
+import numpy as np
+from topfarm.cost_models.dummy import DummyCost
+from topfarm.cost_models.cost_model_wrappers import CostModelComponent,\
+    AEPCostModelComponent
+from topfarm import TopFarm
+
+
+class TestCostModelWrappers(unittest.TestCase):
+    def setUp(self):
+        unittest.TestCase.setUp(self)
+        self.boundary = [(0, 0), (6, 0), (6, -10), (0, -10)]  # turbine boundaries
+        self.initial = [[6, 0], [6, -8], [1, 1], [-1, -8]]  # initial turbine layouts
+        self.optimal_with_constraints = np.array([[2.5, -3], [6, -7], [4.5, -3], [3, -7]])  # optimal turbine layout
+        self.min_spacing = 2  # min distance between turbines
+        self.optimal = np.array([[3, -3], [7, -7], [4, -3], [3, -7]])  # desired turbine layouts
+
+    def cost(self, pos):
+        x, y = pos.T
+        opt_x, opt_y = self.optimal.T
+        return np.sum((x - opt_x)**2 + (y - opt_y)**2)
+
+    def aep_cost(self, pos):
+        x, y = pos.T
+        opt_x, opt_y = self.optimal.T
+        return -np.sum((x - opt_x)**2 + (y - opt_y)**2)
+
+    def gradients(self, pos):
+        x, y = pos.T
+        return (2 * x - 2 * self.optimal[:, 0]), (2 * y - 2 * self.optimal[:, 1])
+
+    def aep_gradients(self, pos):
+        x, y = pos.T
+        return -(2 * x - 2 * self.optimal[:, 0]), -(2 * y - 2 * self.optimal[:, 1])
+
+    def testCostModelComponent(self):
+        tf = TopFarm(self.initial, CostModelComponent(4, self.cost, self.gradients), self.min_spacing, boundary=self.boundary)
+        tf.optimize()
+        np.testing.assert_array_almost_equal(tf.turbine_positions, self.optimal_with_constraints, 5)
+
+    def testCostModelComponent_no_gradients(self):
+        tf = TopFarm(self.initial, CostModelComponent(4, self.cost), self.min_spacing, boundary=self.boundary)
+        tf.optimize()
+        np.testing.assert_array_almost_equal(tf.turbine_positions, self.optimal_with_constraints, 5)
+
+    def testAEPCostModelComponent(self):
+        tf = TopFarm(self.initial, AEPCostModelComponent(4, self.aep_cost, self.aep_gradients), self.min_spacing, boundary=self.boundary)
+        tf.optimize()
+        np.testing.assert_array_almost_equal(tf.turbine_positions, self.optimal_with_constraints, 5)
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testName']
+    unittest.main()

tests/test_costmodel_utils/test_wind_resource.py

+'''
+Created on 17. maj 2018
+
+@author: mmpe
+'''
+import unittest
+import numpy as np
+from topfarm.cost_models.utils.wind_resource import WindResource
+
+
+class TestWindResource(unittest.TestCase):
+
+    def test_WindResource(self):
+        f = [0.035972, 0.039487, 0.051674, 0.070002, 0.083645, 0.064348, 0.086432, 0.117705, 0.151576, 0.147379, 0.10012, 0.05166]
+        A = [9.176929, 9.782334, 9.531809, 9.909545, 10.04269, 9.593921, 9.584007, 10.51499, 11.39895, 11.68746, 11.63732, 10.08803]
+        k = [2.392578, 2.447266, 2.412109, 2.591797, 2.755859, 2.595703, 2.583984, 2.548828, 2.470703, 2.607422, 2.626953, 2.326172]
+        ti = np.zeros_like(f) + .1
+        wr = WindResource(f, A, k, ti)
+
+        wdir, ws, ti, weight = wr([0], [0], [4, 5])
+        np.testing.assert_array_almost_equal(weight, np.array([[0.071381703], [0.088361194]]) * 0.035972 * (12 / 360))
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testWindResource']
+    unittest.main()

tests/test_files/fuga_files/hornsrev2.lib

+wrf_HRI  173  183    0 0.0004 <coordinates>7.83191,55.48940,0.0</coordinates>
+  
+1  1 12
+ 
+0.000 0.030 0.100 0.400 1.500
+  
+70.0
+  
+3.597152 3.948682 5.167395 7.000154 8.364547 6.43485 8.643194 11.77051 15.15757 14.73792 10.01205 5.165975
+  
+9.176929  9.782334 9.531809 9.909545 10.04269 9.593921 9.584007 10.51499 11.39895 11.68746 11.63732 10.08803
+ 
+2.392578 2.447266 2.412109 2.591797 2.755859 2.595703 2.583984 2.548828 2.470703 2.607422 2.626953 2.326172
+  
\ No newline at end of file

tests/test_files/wind_farms/3tb.yml

+layout:
+  - name: WT01
+    row: 1
+    position: [0, 160]
+    turbine_type: V80
+  - name: WT02
+    row: 2
+    position: [0, 0]
+    turbine_type: V80
+  - name: WT03
+    row: 3
+    position: [0, -160]
+    turbine_type: V80
+
+metmasts:
+  - name: M2
+    position: [423412, 6153342] # <- wrong location!! please find the right one and make a pull request
+  - name: M6
+    position: [431255, 6149504]
+  - name: M7
+    position: [435252, 6149494]
+
+plant_data:
+  utm:
+    code: 32
+    letter: U
+  name: Horns Rev
+  owner: DONG Energy, Vattenfall
+
+turbine_types:
+  # Sources:
+  # [1] https://windbench.net/system/files/hornsrev_v80_0.pdf
+  # [2] http://www.thewindpower.net/turbine_en_30_vestas_2000.php
+  # [3] http://en.wind-turbine-models.com/turbines/668-vestas-v-80-offshore
+  # [4] WAsP wind turbine library (distributed as part of the WAsP software)
+  - name: V80
+    hub_height: 70.0          # [1]
+    rotor_diameter: 80.0      # [1]
+    rated_power: 2000.0       # [1]
+    cut_in_wind_speed: 4.0    # [1]
+    cut_out_wind_speed: 25.0  # [1]
+    rated_wind_speed: 16.0    # [1]
+    wind_class: IEC Ia (DIBt III) # [2]
+    air_density: 1.225        # guess
+    gear_box:
+      speed_number: 3
+      ratio: 1:100,5 # [2]
+      type: spur/planetary # [3]
+    nacelle: # [2]
+      weight: 68000.0 # kg     [2], 69000.0 kg according to [3]
+    rotor: # [2, 3]
+      weight: 37000.0 # kg     [2]
+      tip_speed: 80.0 # m/s    [3]
+      min_speed: 9 # rd/min [2]
+      max_speed: 19 # rd/min [2]
+      manufacturer: Vestas
+    hub:
+      weight: 18000 # kg [3]
+    tower: # [2]
+      weight: 198000.0 #kg [2], max 148000.0 kg according to [3]
+      material: steel
+      manufacturer: Welcon
+    control: # [1]
+      type: Active Pitch, Variable Speed
+    generator: # [2]
+      type: ASYNC
+      number: 1
+      max_output_speed: 1909 #rounds/minute
+      output_voltage: 690 #V
+      grid_frequency: 50/60 # Hz
+    power_curve: # [1]
+      - [3.0,   0.0]
+      - [4.0,   66.6]
+      - [5.0,   154.0]
+      - [6.0,   282.0]
+      - [7.0,   460.0]
+      - [8.0,   696.0]
+      - [9.0,   996.0]
+      - [10.0,  1341.0]
+      - [11.0,  1661.0]
+      - [12.0,  1866.0]
+      - [13.0,  1958.0]
+      - [14.0,  1988.0]
+      - [15.0,  1997.0]
+      - [16.0,  1999.0]
+      - [17.0,  2000.0]
+      - [18.0,  2000.0]
+      - [19.0,  2000.0]
+      - [20.0,  2000.0]
+      - [21.0,  2000.0]
+      - [22.0,  2000.0]
+      - [23.0,  2000.0]
+      - [24.0,  2000.0]
+      - [25.0,  2000.0]
+    c_t_curve:
+      - [3.0,  0.00]
+      - [4.0,  0.818]
+      - [5.0,  0.806]
+      - [6.0,  0.804]
+      - [7.0,  0.805]
+      - [8.0,  0.806]
+      - [9.0,  0.807]
+      - [10.0, 0.793]
+      - [11.0, 0.739]
+      - [12.0, 0.709]
+      - [13.0, 0.409]
+      - [14.0, 0.314]
+      - [15.0, 0.249]
+      - [16.0, 0.202]
+      - [17.0, 0.167]
+      - [18.0, 0.140]
+      - [19.0, 0.119]
+      - [20.0, 0.102]
+      - [21.0, 0.088]
+      - [22.0, 0.077]
+      - [23.0, 0.067]
+      - [24.0, 0.060]
+      - [25.0, 0.053]
+    c_t_idle: 0.053 # [4]
+    blade:
+      geometry: # [1]
+        # [radius [m], c [m], twist [deg],   airfoil   ]
+        - [2.563,      2.004,   9.50,      'Cylinder 1']
+        - [4.389,      2.523,   9.50,      'Cylinder 1']
+        - [6.216,      3.015,   9.50,      'FFA W3-301']
+        - [8.042,      3.278,   9.50,      'FFA W3-301']
+        - [9.868,      3.309,   9.50,      'FFA W3-301']
+        - [11.694,     3.195,   9.50,      'FFA W3-301']
+        - [13.520,     3.039,   9.22,      'FFA W3-241']
+        - [15.346,     2.863,   7.81,      'FFA W3-211']
+        - [17.173,     2.687,   6.40,      'FFA W3-211']
+        - [18.999,     2.511,   5.11,      'FFA W3-211']
+        - [20.825,     2.334,   3.83,      'FFA W3-211']
+        - [22.651,     2.158,   2.61,      'NACA 63-221']
+        - [24.477,     1.982,   1.48,      'NACA 63-221']
+        - [26.304,     1.806,   0.42,      'NACA 63-221']
+        - [28.130,     1.630,   0.49,      'NACA 63-221']
+        - [29.956,     1.454,   1.23,      'NACA 63-218']
+        - [31.782,     1.278,   1.79,      'NACA 63-218']
+        - [33.608,     1.102,   2.24,      'NACA 63-218']
+        - [35.435,     0.926,   2.61,      'NACA 63-218']
+        - [37.261,     0.749,   2.84,      'NACA 63-218']
+        - [39.087,     0.573,   2.97,      'NACA 63-218']
\ No newline at end of file

tests/test_fuga/test_lib_reader.py

@@ -3,12 +3,11 @@ Created on 25. apr. 2018
 
 @author: mmpe
 '''
-import os
 import unittest
-from topfarm.cost_models.fuga.lib_reader import read_lib
 import numpy as np
-from topfarm.cost_models.fuga import py_fuga
 from tests.test_files import testfilepath
+from topfarm.cost_models.fuga import py_fuga, lib_reader
+from topfarm.cost_models.fuga.lib_reader import read_lib
 
 
 class Test(unittest.TestCase):

tests/test_fuga/test_pyfuga.py

@@ -14,7 +14,7 @@ from topfarm.cost_models.fuga.pascal_dll import PascalDLL
 from topfarm.cost_models.fuga.py_fuga import PyFuga
 import os
 from topfarm.cost_models.fuga import py_fuga
-import sys
+from topfarm import TopFarm
 
 
 fuga_path = os.path.abspath(os.path.dirname(py_fuga.__file__)) + '/Colonel/'
@@ -38,10 +38,10 @@ class Test(unittest.TestCase):
 
     def lib_missing(self):
         lib_path = os.path.dirname(py_fuga.__file__) + "/Colonel/FugaLib/FugaLib.%s" % ('so', 'dll')[os.name == 'nt']
-        
+
         if os.path.isfile(lib_path) is False:
             pytest.xfail("Fugalib missing")
-            raise Warning("Fugalib '%s' not found\n"%lib_path)
+            raise Warning("Fugalib '%s' not found\n" % lib_path)
         return False
 
     def get_fuga(self, tb_x=[423974, 424033], tb_y=[6151447, 6150889]):
@@ -97,6 +97,23 @@ class Test(unittest.TestCase):
                                                                                                           [0.000000e+00, 0.000000e+00]])
         pyFuga.cleanup()
 
+    def testAEP_topfarm(self):
+        if self.lib_missing():
+            return
+        pyFuga = self.get_fuga()
+        init_pos = [[0, 0], [200, 0]]
+        tf = TopFarm(init_pos, pyFuga.get_TopFarm_cost_component(), 160, init_pos, boundary_type='square')
+        tf.evaluate()
+        np.testing.assert_array_almost_equal(tf.get_cost(), -14.866138)
+
+    def test_pyfuga_cmd(self):
+        if self.lib_missing():
+            return
+        pyFuga = PyFuga()
+        pyFuga.execute(r'echo "ColonelInit"')
+        self.assertEqual(pyFuga.log.strip().split("\n")[-1], 'ColonelInit')
+
+
 #     def test_parallel(self):
 #         from multiprocessing import Pool
 #

tests/test_fusedwake_models/test_gcl.py

+import os
+import unittest
+
+import numpy as np
+from topfarm.cost_models.fused_wake_wrappers import FusedWakeGCLWakeModel
+from topfarm.cost_models.utils.aep_calculator import AEPCalculator
+from topfarm.cost_models.utils.wind_resource import WindResource
+from tests.test_files import tfp
+from topfarm._topfarm import TopFarm
+
+
+class TestFusedWakeModels(unittest.TestCase):  # unittest version
+
+    def test_GCL(self):
+        # f, A, k = read_lib(fuga_path + 'LUT/Farms/Horns Rev 1\hornsrev_north_only_pm45.lib')
+        f = [1.0, 0.0, 0.0, 0.0]
+        A = [9.176929, 9.782334, 9.531809, 9.909545]
+        k = [2.392578, 2.447266, 2.412109, 2.591797]
+
+        wr = WindResource(f, A, k, ti=np.zeros_like(f) + .1)
+        wm = FusedWakeGCLWakeModel(tfp + "wind_farms/3tb.yml")
+        aep_calc = AEPCalculator(wr, wm)
+        init_pos = wm.windFarm.pos.T
+        self.assertEqual(aep_calc(init_pos), 19.85973533524627)
+        self.assertEqual(aep_calc(np.array([[-500, 0, 500], [0, 0, 0]]).T), 22.31788007605505)
+
+    def test_GCL_Topfarm(self):
+        # f, A, k = read_lib(fuga_path + 'LUT/Farms/Horns Rev 1\hornsrev_north_only_pm45.lib')
+        f = [1.0, 0.0, 0.0, 0.0]
+        A = [9.176929, 9.782334, 9.531809, 9.909545]
+        k = [2.392578, 2.447266, 2.412109, 2.591797]
+
+        wr = WindResource(f, A, k, ti=np.zeros_like(f) + .1)
+        wm = FusedWakeGCLWakeModel(tfp + "wind_farms/3tb.yml")
+        aep_calc = AEPCalculator(wr, wm)
+        init_pos = wm.windFarm.pos.T
+        tf = TopFarm(init_pos, aep_calc.get_TopFarm_cost_component(), 160, init_pos, boundary_type='square')
+        tf.evaluate()
+        self.assertEqual(tf.get_cost(), -19.85973533524627)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_topfarm.py

+'''
+Created on 17. maj 2018
+
+@author: mmpe
+'''
+from topfarm import TopFarm
+import unittest
+
+import numpy as np
+from topfarm.cost_models.dummy import DummyCost
+from topfarm.cost_models.cost_model_wrappers import CostModelComponent
+
+
+class TestTopFarm(unittest.TestCase):
+    def setUp(self):
+        unittest.TestCase.setUp(self)
+        self.boundary = [(0, 0), (6, 0), (6, -10), (0, -10)]  # turbine boundaries
+        self.initial = [[6, 0], [6, -8], [1, 1], [-1, -8]]  # initial turbine layouts
+        self.optimal_with_constraints = np.array([[2.5, -3], [6, -7], [4.5, -3], [3, -7]])  # optimal turbine layout
+        self.min_spacing = 2  # min distance between turbines
+        self.optimal = np.array([[3, -3], [7, -7], [4, -3], [3, -7]])  # desired turbine layouts
+
+    def cost(self, pos):
+        x, y = pos.T
+        opt_x, opt_y = self.optimal.T
+        return np.sum((x - opt_x)**2 + (y - opt_y)**2)
+
+    def gradients(self, pos):
+        x, y = pos.T
+        return (2 * x - 2 * self.optimal[:, 0]), (2 * y - 2 * self.optimal[:, 1])
+
+    def wrong_gradients(self, pos):
+        x, y = pos.T
+        return (2 * x - 2 * self.optimal[:, 0] + 1), (2 * y - 2 * self.optimal[:, 1])
+
+    def testTopFarm_default_plotcomp(self):
+        tf = TopFarm(self.initial, CostModelComponent(4, self.cost, self.gradients), self.min_spacing, boundary=self.boundary, plot_comp='default')
+
+    def testTopFarm_check_gradients(self):
+        tf = TopFarm(self.initial, CostModelComponent(4, self.cost, self.gradients), self.min_spacing, boundary=self.boundary)
+        tf.check(True)
+
+        tf = TopFarm(self.initial, CostModelComponent(4, self.cost, self.wrong_gradients), self.min_spacing, boundary=self.boundary)
+        self.assertRaisesRegex(Warning, "Mismatch between finite difference derivative of 'cost' wrt. 'turbineX' and derivative computed in 'cost_comp' is", tf.check)
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testName']
+    unittest.main()

tests/test_try_me.py

+'''
+Created on 17. maj 2018
+
+@author: mmpe
+'''
+import unittest
+import topfarm
+import pkgutil
+import importlib
+import inspect
+import ast
+import warnings
+from topfarm.cost_models.fuga import lib_reader
+import mock
+import pytest
+import os
+
+
+class TestTryMe(unittest.TestCase):
+
+    
+    def test_try_me(self):
+        if os.name == 'posix' and "DISPLAY" not in os.environ:
+            pytest.xfail("No display")
+        package = topfarm
+        for _, modname, _ in pkgutil.walk_packages(package.__path__, package.__name__ + '.'):
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                m = importlib.import_module(modname)
+            if 'try_me' in dir(m):
+                print("Checking %s.try_me" % modname)
+                with mock.patch.object(m, "__name__", "__main__"):
+                    getattr(m, 'try_me')()
+
+
+if __name__ == "__main__":
+    #import sys;sys.argv = ['', 'Test.testName']
+    unittest.main()

tests/test_with_dummy.py

 """Tests for TOPFARM
 """
+import os
+from topfarm import TopFarm
+import unittest
 import warnings
+
+import pytest
+
 import numpy as np
-from topfarm.topfarm import TopFarm
-from topfarm.cost_models.dummy import DummyCost
-import unittest
+from topfarm.cost_models.dummy import DummyCost, DummyCostPlotComp
 
 
 class Test(unittest.TestCase):  # unittest version
@@ -40,6 +44,18 @@ class Test(unittest.TestCase):  # unittest version
         self.assertLess(tb_pos[1][0], 6 + tol)  # check within border
         np.testing.assert_array_almost_equal(tb_pos, optimal, dec_prec)
 
+    def testDummyCostPlotComp(self):
+        if os.name == 'posix' and "DISPLAY" not in os.environ:
+            pytest.xfail("No display")
+        
+        desired = [[3, -3], [7, -7], [4, -3], [3, -7]]
+        tf = TopFarm(turbines=[[6, 0], [6, -8], [1, 1], [-1, -8]],
+                     cost_comp=DummyCost(desired),
+                     min_spacing=2,
+                     boundary=[(0, 0), (6, 0), (6, -10), (0, -10)],
+                     plot_comp = DummyCostPlotComp(desired))
+        tf.evaluate()
+
 
 if __name__ == "__main__":
     unittest.main()

topfarm/__init__.py

+from ._topfarm import *
\ No newline at end of file