← Back to branch summary

~ubuntu-branches/ubuntu/vivid/grass/vivid-proposed

« back to all changes in this revision

Viewing changes to temporal/t.rast.aggregate/testsuite/test_aggregation_absolute.py

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-02-20 23:12:08 UTC
  • mfrom: (8.2.6 experimental)
  • Revision ID: package-import@ubuntu.com-20150220231208-1u6qvqm84v430b10
Tags: 7.0.0-1~exp1
* New upstream release.
* Update python-ctypes-ternary.patch to use if/else instead of and/or.
* Drop check4dev patch, rely on upstream check.
* Add build dependency on libpq-dev to grass-dev for libpq-fe.h.
* Drop patches applied upstream, refresh remaining patches.
* Update symlinks for images switched from jpg to png.

Show diffs side-by-side

added added

removed removed

Lines of Context:
temporal/t.rast.aggregate/testsuite/test_aggregation_absolute.py
 
1
"""Test t.rast.aggregation
 
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
:authors: Soeren Gebbert
 
9
"""
 
10
import os
 
11
import grass.pygrass.modules as pymod
 
12
import grass.temporal as tgis
 
13
from grass.gunittest.case import TestCase
 
14
from grass.gunittest.gmodules import SimpleModule
 
15
 
 
16
class TestAggregationAbsolute(TestCase):
 
17
 
 
18
    @classmethod
 
19
    def setUpClass(cls):
 
20
        """Initiate the temporal GIS and set the region
 
21
        """
 
22
        os.putenv("GRASS_OVERWRITE",  "1")
 
23
        tgis.init()
 
24
        cls.use_temp_region()
 
25
        cls.runModule("g.region",  s=0,  n=80,  w=0,  e=120,  b=0,  
 
26
                      t=50,  res=10,  res3=10)
 
27
        cls.runModule("r.mapcalc", expression="a1 = 100",  overwrite=True)
 
28
        cls.runModule("r.mapcalc", expression="a2 = 200",  overwrite=True)
 
29
        cls.runModule("r.mapcalc", expression="a3 = 300",  overwrite=True)
 
30
        cls.runModule("r.mapcalc", expression="a4 = 400",  overwrite=True)
 
31
        cls.runModule("r.mapcalc", expression="a5 = 500",  overwrite=True)
 
32
        cls.runModule("r.mapcalc", expression="a6 = 600",  overwrite=True)
 
33
        cls.runModule("r.mapcalc", expression="a7 = null()",  overwrite=True)
 
34
 
 
35
        cls.runModule("t.create",  type="strds",  temporaltype="absolute",  
 
36
                                    output="A",  title="A test",  
 
37
                                    description="A test",  overwrite=True)
 
38
 
 
39
        cls.runModule("t.register", flags="i",  type="raster",  input="A",  
 
40
                                     maps="a1,a2,a3,a4,a5,a6,a7",
 
41
                                     start="2001-01-15 12:05:45", 
 
42
                                     increment="14 days",  
 
43
                                     overwrite=True)
 
44
    @classmethod
 
45
    def tearDownClass(cls):
 
46
        """Remove the temporary region
 
47
        """
 
48
        cls.del_temp_region()        
 
49
        cls.runModule("t.remove", flags="rf", type="strds", inputs="A")
 
50
 
 
51
    def tearDown(self):
 
52
        """Remove generated data"""    
 
53
        self.runModule("t.remove", flags="rf", type="strds", inputs="B")
 
54
        
 
55
    def test_disaggregation(self):
 
56
        """Disaggregation with empty maps"""
 
57
        self.assertModule("t.rast.aggregate", input="A", output="B",
 
58
                          basename="b", granularity="2 days", 
 
59
                          method="average",
 
60
                          sampling=["overlaps","overlapped","during"], 
 
61
                          nprocs=2, flags="n")
 
62
 
 
63
        tinfo_string="""start_time=2001-01-15 00:00:00
 
64
                        end_time=2001-04-25 00:00:00
 
65
                        granularity=2 days
 
66
                        aggregation_type=average
 
67
                        number_of_maps=50
 
68
                        map_time=interval
 
69
                        min_min=100.0
 
70
                        min_max=600.0
 
71
                        max_min=100.0
 
72
                        max_max=600.0"""
 
73
 
 
74
        info = SimpleModule("t.info", flags="g", input="B")
 
75
        #info.run()
 
76
        #print info.outputs.stdout
 
77
        self.assertModuleKeyValue(module=info, reference=tinfo_string, 
 
78
                                  precision=2, sep="=")
 
79
 
 
80
    def test_aggregation_1month(self):
 
81
        """Aggregation one month"""
 
82
        self.assertModule("t.rast.aggregate", input="A", output="B",
 
83
                          basename="b", granularity="1 months",
 
84
                          method="maximum", sampling=["contains"], 
 
85
                          nprocs=3, flags="s")
 
86
 
 
87
        tinfo_string="""start_time=2001-01-01 00:00:00
 
88
                        end_time=2001-04-01 00:00:00
 
89
                        granularity=1 month
 
90
                        map_time=interval
 
91
                        aggregation_type=maximum
 
92
                        number_of_maps=3
 
93
                        min_min=100.0
 
94
                        min_max=500.0
 
95
                        max_min=100.0
 
96
                        max_max=500.0"""
 
97
 
 
98
        info = SimpleModule("t.info", flags="g", input="B")
 
99
        #info.run()
 
100
        #print info.outputs.stdout
 
101
        self.assertModuleKeyValue(module=info, reference=tinfo_string, 
 
102
                                  precision=2, sep="=")
 
103
 
 
104
        # Check the map names are correct
 
105
        lister = SimpleModule("t.rast.list", input="B", columns="name", 
 
106
                              flags="s")
 
107
        self.runModule(lister)
 
108
        #print lister.outputs.stdout
 
109
        maps="b_2001_01" + os.linesep + "b_2001_02" + os.linesep + \
 
110
             "b_2001_03" + os.linesep
 
111
        self.assertEqual(maps, lister.outputs.stdout)
 
112
        
 
113
    def test_aggregation_2months(self):
 
114
        """Aggregation two month"""
 
115
        self.assertModule("t.rast.aggregate", input="A", output="B",
 
116
                          basename="b", granularity="2 months",
 
117
                          method="minimum", sampling=["contains"], 
 
118
                          nprocs=4, offset=10)
 
119
 
 
120
        tinfo_string="""start_time=2001-01-01 00:00:00
 
121
                        end_time=2001-05-01 00:00:00
 
122
                        granularity=2 months
 
123
                        map_time=interval
 
124
                        aggregation_type=minimum
 
125
                        number_of_maps=2
 
126
                        min_min=100.0
 
127
                        min_max=500.0
 
128
                        max_min=100.0
 
129
                        max_max=500.0"""
 
130
 
 
131
        info = SimpleModule("t.info", flags="g", input="B")
 
132
        #info.run()
 
133
        #print info.outputs.stdout
 
134
        self.assertModuleKeyValue(module=info, reference=tinfo_string, 
 
135
                                  precision=2, sep="=")
 
136
 
 
137
        # Check the map names are correct
 
138
        lister = SimpleModule("t.rast.list", input="B", columns="name", 
 
139
                              flags="s")
 
140
        self.runModule(lister)
 
141
        #print lister.outputs.stdout
 
142
        maps="b_11" + os.linesep + "b_12" + os.linesep 
 
143
        self.assertEqual(maps, lister.outputs.stdout)
 
144
 
 
145
    def test_aggregation_3months(self):
 
146
        """Aggregation three month"""
 
147
        self.assertModule("t.rast.aggregate", input="A", output="B",
 
148
                          basename="b", granularity="3 months",
 
149
                          method="sum", sampling=["contains"], 
 
150
                          nprocs=9, offset=100)
 
151
 
 
152
        tinfo_string="""start_time=2001-01-01 00:00:00
 
153
                        end_time=2001-04-01 00:00:00
 
154
                        granularity=3 months
 
155
                        map_time=interval
 
156
                        aggregation_type=sum
 
157
                        number_of_maps=1
 
158
                        min_min=1500.0
 
159
                        min_max=1500.0
 
160
                        max_min=1500.0
 
161
                        max_max=1500.0"""
 
162
 
 
163
        info = SimpleModule("t.info", flags="g", input="B")
 
164
        #info.run()
 
165
        #print info.outputs.stdout
 
166
        self.assertModuleKeyValue(module=info, reference=tinfo_string, 
 
167
                                  precision=2, sep="=")
 
168
 
 
169
        # Check the map names are correct
 
170
        lister = SimpleModule("t.rast.list", input="B", columns="name", 
 
171
                              flags="s")
 
172
        self.runModule(lister)
 
173
        #print lister.outputs.stdout
 
174
        maps="b_101" + os.linesep 
 
175
        self.assertEqual(maps, lister.outputs.stdout)
 
176
 
 
177
if __name__ == '__main__':
 
178
    from grass.gunittest.main import test
 
179
    test()