Debian Codegraph @

temporal/t.rast.accumulate/testsuite/test_accumulation.py

raw
1 """Test t.rast.accumulate
2
3 (C) 2014 by the GRASS Development Team
4 This program is free software under the GNU General Public
5 License (>=v2). Read the file COPYING that comes with GRASS
6 for details.
7
8 @author Soeren Gebbert
9 """
10
11 import datetime
12
13 import grass.temporal as tgis
14 from grass.gunittest.case import TestCase
15
16
17 class TestAccumulate(TestCase):
18 @classmethod
19 def setUpClass(cls):
20 """Initiate the temporal GIS and set the region"""
21 tgis.init(True) # Raise on error instead of exit(1)
22 cls.use_temp_region()
23 cls.runModule("g.region", s=0, n=80, w=0, e=120, b=0, t=50, res=10, res3=10)
24
25 cls.runModule("r.mapcalc", expression="a_1 = 5", overwrite=True)
26 cls.runModule("r.mapcalc", expression="a_2 = 10", overwrite=True)
27 cls.runModule("r.mapcalc", expression="a_3 = 20", overwrite=True)
28 cls.runModule("r.mapcalc", expression="a_4 = 35", overwrite=True)
29 cls.runModule("r.mapcalc", expression="a_5 = 20", overwrite=True)
30 cls.runModule("r.mapcalc", expression="a_6 = 10", overwrite=True)
31 cls.runModule("r.mapcalc", expression="a_7 = 5", overwrite=True)
32
33 cls.runModule("r.mapcalc", expression="lower = 10", overwrite=True)
34 cls.runModule("r.mapcalc", expression="upper = 30", overwrite=True)
35
36 cls.runModule(
37 "t.create",
38 type="strds",
39 temporaltype="absolute",
40 output="A",
41 title="A test",
42 description="A test",
43 overwrite=True,
44 )
45 cls.runModule(
46 "t.register",
47 flags="i",
48 type="raster",
49 input="A",
50 maps="a_1,a_2,a_3,a_4,a_5,a_6,a_7",
51 start="2001-01-01",
52 increment="1 day",
53 overwrite=True,
54 )
55
56 cls.runModule(
57 "t.create",
58 type="strds",
59 temporaltype="absolute",
60 output="Lower",
61 title="Lower",
62 description="Lower",
63 overwrite=True,
64 )
65 cls.runModule(
66 "t.register",
67 type="raster",
68 input="Lower",
69 maps="lower",
70 start="2001-01-01",
71 end="2001-01-10",
72 overwrite=True,
73 )
74
75 cls.runModule(
76 "t.create",
77 type="strds",
78 temporaltype="absolute",
79 output="Upper",
80 title="Upper",
81 description="Upper",
82 overwrite=True,
83 )
84 cls.runModule(
85 "t.register",
86 type="raster",
87 input="Upper",
88 maps="upper",
89 start="2001-01-01",
90 end="2001-01-10",
91 overwrite=True,
92 )
93
94 @classmethod
95 def tearDownClass(cls):
96 """Remove the temporary region"""
97 cls.runModule("t.remove", flags="df", type="strds", inputs="A,Lower,Upper")
98 cls.del_temp_region()
99
100 def tearDown(self):
101 """Remove generated data"""
102 self.runModule("t.remove", flags="df", type="strds", inputs="B")
103
104 def test_1(self):
105 self.assertModule(
106 "t.rast.accumulate",
107 input="A",
108 output="B",
109 limits=[0, 40],
110 method="gdd",
111 start="2001-01-01",
112 cycle="7 days",
113 basename="b",
114 overwrite=True,
115 verbose=True,
116 )
117
118 D = tgis.open_old_stds("B", type="strds")
119
120 self.assertEqual(D.metadata.get_number_of_maps(), 7)
121 self.assertEqual(D.metadata.get_min_min(), 5)
122 self.assertEqual(D.metadata.get_max_max(), 105)
123 start, end = D.get_absolute_time()
124 self.assertEqual(start, datetime.datetime(2001, 1, 1))
125 self.assertEqual(end, datetime.datetime(2001, 1, 8))
126 self.assertEqual(D.check_temporal_topology(), True)
127 self.assertEqual(D.get_granularity(), "1 day")
128
129 def test_2(self):
130 self.assertModule(
131 "t.rast.accumulate",
132 input="A",
133 output="B",
134 limits=[10, 40],
135 method="gdd",
136 start="2001-01-01",
137 cycle="7 days",
138 basename="b",
139 overwrite=True,
140 verbose=True,
141 )
142
143 D = tgis.open_old_stds("B", type="strds")
144
145 self.assertEqual(D.metadata.get_number_of_maps(), 7)
146 self.assertEqual(D.metadata.get_min_min(), 0.0)
147 self.assertEqual(D.metadata.get_max_max(), 45.0)
148 start, end = D.get_absolute_time()
149 self.assertEqual(start, datetime.datetime(2001, 1, 1))
150 self.assertEqual(end, datetime.datetime(2001, 1, 8))
151 self.assertEqual(D.check_temporal_topology(), True)
152 self.assertEqual(D.get_granularity(), "1 day")
153
154 def test_3(self):
155 self.assertModule(
156 "t.rast.accumulate",
157 input="A",
158 output="B",
159 limits=[10, 30],
160 method="bedd",
161 start="2001-01-01",
162 cycle="7 days",
163 basename="b",
164 overwrite=True,
165 verbose=True,
166 )
167
168 D = tgis.open_old_stds("B", type="strds")
169
170 self.assertEqual(D.metadata.get_number_of_maps(), 7)
171 self.assertEqual(D.metadata.get_min_min(), 0.0)
172 self.assertEqual(D.metadata.get_max_max(), 40.0)
173 start, end = D.get_absolute_time()
174 self.assertEqual(start, datetime.datetime(2001, 1, 1))
175 self.assertEqual(end, datetime.datetime(2001, 1, 8))
176 self.assertEqual(D.check_temporal_topology(), True)
177 self.assertEqual(D.get_granularity(), "1 day")
178
179 def test_3_a(self):
180 self.assertModule(
181 "t.rast.accumulate",
182 input="A",
183 output="B",
184 lower="Lower",
185 upper="Upper",
186 limits=[0, 40],
187 method="bedd",
188 start="2001-01-01",
189 cycle="7 days",
190 basename="b",
191 overwrite=True,
192 verbose=True,
193 )
194
195 D = tgis.open_old_stds("B", type="strds")
196
197 self.assertEqual(D.metadata.get_number_of_maps(), 7)
198 self.assertEqual(D.metadata.get_min_min(), 0.0)
199 self.assertEqual(D.metadata.get_max_max(), 40.0)
200 start, end = D.get_absolute_time()
201 self.assertEqual(start, datetime.datetime(2001, 1, 1))
202 self.assertEqual(end, datetime.datetime(2001, 1, 8))
203 self.assertEqual(D.check_temporal_topology(), True)
204 self.assertEqual(D.get_granularity(), "1 day")
205
206 def test_4(self):
207 self.assertModule(
208 "t.rast.accumulate",
209 input="A",
210 output="B",
211 limits=[10, 30],
212 method="bedd",
213 start="2001-01-01",
214 cycle="7 days",
215 basename="b",
216 granularity="2 days",
217 overwrite=True,
218 verbose=True,
219 )
220
221 D = tgis.open_old_stds("B", type="strds")
222
223 self.assertEqual(D.metadata.get_number_of_maps(), 4)
224 self.assertEqual(D.metadata.get_min_min(), 0.0)
225 self.assertEqual(D.metadata.get_max_max(), 22.5)
226 start, end = D.get_absolute_time()
227 self.assertEqual(start, datetime.datetime(2001, 1, 1))
228 self.assertEqual(end, datetime.datetime(2001, 1, 9))
229 self.assertEqual(D.check_temporal_topology(), True)
230 self.assertEqual(D.get_granularity(), "2 days")
231
232 def test_4_a(self):
233 self.assertModule(
234 "t.rast.accumulate",
235 input="A",
236 output="B",
237 lower="Lower",
238 upper="Upper",
239 limits=[0, 40],
240 method="bedd",
241 start="2001-01-01",
242 cycle="7 days",
243 basename="b",
244 granularity="2 days",
245 overwrite=True,
246 verbose=True,
247 )
248
249 D = tgis.open_old_stds("B", type="strds")
250
251 self.assertEqual(D.metadata.get_number_of_maps(), 4)
252 self.assertEqual(D.metadata.get_min_min(), 0.0)
253 self.assertEqual(D.metadata.get_max_max(), 22.5)
254 start, end = D.get_absolute_time()
255 self.assertEqual(start, datetime.datetime(2001, 1, 1))
256 self.assertEqual(end, datetime.datetime(2001, 1, 9))
257 self.assertEqual(D.check_temporal_topology(), True)
258 self.assertEqual(D.get_granularity(), "2 days")
259
260 def test_5(self):
261 self.assertModule(
262 "t.rast.accumulate",
263 input="A",
264 output="B",
265 limits=[0, 40],
266 method="gdd",
267 start="2001-01-01",
268 cycle="7 days",
269 basename="b",
270 stop="2001-01-05",
271 overwrite=True,
272 verbose=True,
273 )
274
275 D = tgis.open_old_stds("B", type="strds")
276
277 self.assertEqual(D.metadata.get_number_of_maps(), 4)
278 self.assertEqual(D.metadata.get_min_min(), 5)
279 self.assertEqual(D.metadata.get_max_max(), 70)
280 start, end = D.get_absolute_time()
281 self.assertEqual(start, datetime.datetime(2001, 1, 1))
282 self.assertEqual(end, datetime.datetime(2001, 1, 5))
283 self.assertEqual(D.check_temporal_topology(), True)
284 self.assertEqual(D.get_granularity(), "1 day")
285
286 def test_count_suffix(self):
287 self.assertModule(
288 "t.rast.accumulate",
289 input="A",
290 output="B",
291 limits=[0, 40],
292 method="gdd",
293 start="2001-01-01",
294 cycle="7 days",
295 basename="b",
296 stop="2001-01-05",
297 suffix="num",
298 overwrite=True,
299 verbose=True,
300 )
301 self.assertRasterExists("b_00001")
302 self.assertRasterDoesNotExist("b_2001_01_07")
303
304 def test_count3_suffix(self):
305 self.assertModule(
306 "t.rast.accumulate",
307 input="A",
308 output="B",
309 limits=[0, 40],
310 method="gdd",
311 start="2001-01-01",
312 cycle="7 days",
313 basename="b",
314 stop="2001-01-05",
315 suffix="num%03",
316 overwrite=True,
317 verbose=True,
318 )
319 self.assertRasterExists("b_001")
320 self.assertRasterDoesNotExist("b_2001_01_07")
321
322 def test_time_suffix(self):
323 self.assertModule(
324 "t.rast.accumulate",
325 input="A",
326 output="B",
327 limits=[0, 40],
328 method="gdd",
329 start="2001-01-01",
330 cycle="7 days",
331 basename="b",
332 stop="2001-01-05",
333 suffix="time",
334 overwrite=True,
335 verbose=True,
336 )
337 self.assertRasterExists("b_2001_01_01T00_00_00")
338
339
340 if __name__ == "__main__":
341 from grass.gunittest.main import test
342
343 test()