Debian Codegraph @

imagery/i.eb.netrad/testsuite/test_i_eb_netrad.py

raw
1 import grass.script as gs
2 from grass.gunittest.case import TestCase
3 from grass.gunittest.main import test
4
5
6 class TestIEbNetrad(TestCase):
7 """Regression test suite for i.eb.netrad module."""
8
9 albedo = "test_albedo"
10 ndvi = "test_ndvi"
11 temperature = "test_temperature"
12 localutctime = "test_localutctime"
13 temperaturedifference2m = "test_temperaturediff2m"
14 emissivity = "test_emissivity"
15 transmissivity = "test_transmissivity"
16 dayofyear = "test_dayofyear"
17 sunzenithangle = "test_sunzenithangle"
18 output = "test_netrad_output"
19 tmp_rasters = []
20
21 @classmethod
22 def setUpClass(cls):
23 """Set up the test environment and generate input raster maps for net radiation calculation."""
24 cls.use_temp_region()
25 cls.runModule("g.region", e=10, w=0, s=0, n=10, rows=10, cols=10)
26 cls.runModule(
27 "r.mapcalc",
28 expression=f"{cls.albedo} = float(0.1 + 0.3 * (row() + col()) / 20.0)",
29 overwrite=True,
30 )
31 cls.runModule(
32 "r.mapcalc",
33 expression=f"{cls.ndvi} = float(-0.2 + 0.8 * (row() + col()) / 20.0)",
34 overwrite=True,
35 )
36 cls.runModule(
37 "r.mapcalc",
38 expression=f"{cls.temperature} = float(300.0 + 10.0 * sin((row() + col()) * 0.1))",
39 overwrite=True,
40 )
41 cls.runModule(
42 "r.mapcalc",
43 expression=f"{cls.localutctime} = float(12.0 + 1.0 * cos((row() + col()) * 0.2))",
44 overwrite=True,
45 )
46 cls.runModule(
47 "r.mapcalc",
48 expression=f"{cls.temperaturedifference2m} = float(3.0 + 2.0 * (row() % 3))",
49 overwrite=True,
50 )
51 cls.runModule(
52 "r.mapcalc",
53 expression=f"{cls.emissivity} = float(0.90 + 0.05 * (col() / 10.0))",
54 overwrite=True,
55 )
56 cls.runModule(
57 "r.mapcalc",
58 expression=f"{cls.transmissivity} = float(0.65 + 0.1 * sin((row() + col()) * 0.15))",
59 overwrite=True,
60 )
61 cls.runModule(
62 "r.mapcalc",
63 expression=f"{cls.dayofyear} = int(180 + 20 * cos((row() + col()) * 0.1))",
64 overwrite=True,
65 )
66 cls.runModule(
67 "r.mapcalc",
68 expression=f"{cls.sunzenithangle} = float(35.0 + 10.0 * sin((row() + col()) * 0.2))",
69 overwrite=True,
70 )
71 cls.tmp_rasters.extend(
72 [
73 cls.albedo,
74 cls.ndvi,
75 cls.temperature,
76 cls.localutctime,
77 cls.temperaturedifference2m,
78 cls.emissivity,
79 cls.transmissivity,
80 cls.dayofyear,
81 cls.sunzenithangle,
82 ]
83 )
84
85 @classmethod
86 def tearDownClass(cls):
87 """Remove temporary region and all generated raster maps."""
88 cls.tmp_rasters.append(cls.output)
89 cls.runModule("g.remove", flags="f", type="raster", name=cls.tmp_rasters)
90 cls.del_temp_region()
91
92 def run_netrad(self, output, **overrides):
93 """Helper function to run i.eb.netrad with optional input overrides."""
94 args = {
95 "albedo": self.albedo,
96 "ndvi": self.ndvi,
97 "temperature": self.temperature,
98 "localutctime": self.localutctime,
99 "temperaturedifference2m": self.temperaturedifference2m,
100 "emissivity": self.emissivity,
101 "transmissivity_singleway": self.transmissivity,
102 "dayofyear": self.dayofyear,
103 "sunzenithangle": self.sunzenithangle,
104 "output": output,
105 "overwrite": True,
106 }
107 args.update(overrides)
108 self.runModule("i.eb.netrad", **args)
109
110 def test_netrad_output_validity(self):
111 """Verify net radiation calculation produces expected raster with valid statistics."""
112 self.run_netrad(self.output)
113 self.assertRasterExists(self.output)
114
115 reference_stats = {
116 "min": 295.210365,
117 "max": 472.952460,
118 "mean": 384.149065,
119 "stddev": 40.098359,
120 }
121 self.assertRasterFitsUnivar(self.output, reference_stats, precision=1e-6)
122
123 def test_rn_decreases_with_higher_albedo(self):
124 """Confirm inverse relationship between albedo and net radiation."""
125 self.runModule("r.mapcalc", expression="albedo_low = 0.1", overwrite=True)
126 self.run_netrad("rn_low", albedo="albedo_low")
127 self.tmp_rasters.extend(["albedo_low", "rn_low"])
128 stats_low = gs.parse_command("r.univar", map="rn_low", format="json")
129
130 self.runModule("r.mapcalc", expression="albedo_high = 0.5", overwrite=True)
131 self.run_netrad("rn_high", albedo="albedo_high")
132 self.tmp_rasters.extend(["albedo_high", "rn_high"])
133 stats_high = gs.parse_command("r.univar", map="rn_high", format="json")
134
135 self.assertGreater(stats_low["mean"], stats_high["mean"])
136
137 def test_rn_increases_with_lower_zenith_angle(self):
138 """Validate positive correlation between solar elevation and net radiation."""
139 self.runModule("r.mapcalc", expression="zenith_low = 10.0", overwrite=True)
140 self.run_netrad("rn_low_zen", sunzenithangle="zenith_low")
141 self.tmp_rasters.extend(["zenith_low", "rn_low_zen"])
142 stats_low = gs.parse_command("r.univar", map="rn_low_zen", format="json")
143
144 self.runModule("r.mapcalc", expression="zenith_high = 70.0", overwrite=True)
145 self.run_netrad("rn_high_zen", sunzenithangle="zenith_high")
146 self.tmp_rasters.extend(["zenith_high", "rn_high_zen"])
147 stats_high = gs.parse_command("r.univar", map="rn_high_zen", format="json")
148
149 self.assertGreater(stats_low["mean"], stats_high["mean"])
150
151 def test_monotonic_gradient_trend(self):
152 """Check expected negative correlation between surface temperature and net radiation."""
153 self.runModule(
154 "r.mapcalc", expression="linear_temp = 290 + row()", overwrite=True
155 )
156 self.run_netrad("rn_grad", temperature="linear_temp")
157 self.tmp_rasters.append("linear_temp")
158 self.runModule("r.mapcalc", expression="row_index = row()", overwrite=True)
159 self.tmp_rasters.append("row_index")
160 coeffs = gs.parse_command(
161 "r.regression.line", mapx="row_index", mapy="rn_grad", flags="g"
162 )
163
164 self.assertLess(float(coeffs["b"]), -5.0)
165 self.assertLess(float(coeffs["R"]), -0.5)
166
167
168 if __name__ == "__main__":
169 test()