Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1from builtins import zip 

2import numpy as np 

3import numpy.ma as ma 

4import matplotlib 

5matplotlib.use("Agg") 

6import healpy as hp 

7import unittest 

8import lsst.sims.maf.slicers as slicers 

9import lsst.utils.tests 

10 

11 

12class TestSlicers(unittest.TestCase): 

13 

14 def setUp(self): 

15 self.filenames = [] 

16 self.baseslicer = slicers.BaseSlicer() 

17 

18 def test_healpixSlicer_obj(self): 

19 rng = np.random.RandomState(8121) 

20 nside = 32 

21 slicer = slicers.HealpixSlicer(nside=nside) 

22 metricValues = rng.rand(hp.nside2npix(nside)).astype('object') 

23 metricValues = ma.MaskedArray(data=metricValues, 

24 mask=np.where(metricValues < .1, True, False), 

25 fill_value=slicer.badval) 

26 with lsst.utils.tests.getTempFilePath('.npz') as filename: 

27 metadata = 'testdata' 

28 slicer.writeData(filename, metricValues, metadata=metadata) 

29 metricValuesBack, slicerBack, header = self.baseslicer.readData(filename) 

30 np.testing.assert_almost_equal(metricValuesBack, metricValues) 

31 assert(slicer == slicerBack) 

32 assert(metadata == header['metadata']) 

33 attr2check = ['nside', 'nslice', 'columnsNeeded', 'lonCol', 'latCol'] 

34 for att in attr2check: 

35 assert(getattr(slicer, att) == getattr(slicerBack, att)) 

36 

37 def test_healpixSlicer_floats(self): 

38 rng = np.random.RandomState(71231) 

39 nside = 32 

40 slicer = slicers.HealpixSlicer(nside=nside) 

41 metricValues = rng.rand(hp.nside2npix(nside)) 

42 with lsst.utils.tests.getTempFilePath('.npz') as filename: 

43 slicer.writeData(filename, metricValues, metadata='testdata') 

44 metricValuesBack, slicerBack, header = self.baseslicer.readData(filename) 

45 np.testing.assert_almost_equal(metricValuesBack, metricValues) 

46 assert(slicer == slicerBack) 

47 attr2check = ['nside', 'nslice', 'columnsNeeded', 'lonCol', 'latCol'] 

48 for att in attr2check: 

49 assert(getattr(slicer, att) == getattr(slicerBack, att)) 

50 

51 def test_healpixSlicer_masked(self): 

52 rng = np.random.RandomState(712551) 

53 nside = 32 

54 slicer = slicers.HealpixSlicer(nside=nside) 

55 metricValues = rng.rand(hp.nside2npix(nside)) 

56 metricValues = ma.MaskedArray(data=metricValues, 

57 mask=np.where(metricValues < .1, True, False), 

58 fill_value=slicer.badval) 

59 with lsst.utils.tests.getTempFilePath('.npz') as filename: 

60 slicer.writeData(filename, metricValues, metadata='testdata') 

61 metricValuesBack, slicerBack, header = self.baseslicer.readData(filename) 

62 np.testing.assert_almost_equal(metricValuesBack, metricValues) 

63 assert(slicer == slicerBack) 

64 attr2check = ['nside', 'nslice', 'columnsNeeded', 'lonCol', 'latCol'] 

65 for att in attr2check: 

66 assert(getattr(slicer, att) == getattr(slicerBack, att)) 

67 

68 def test_oneDSlicer(self): 

69 rng = np.random.RandomState(71111) 

70 slicer = slicers.OneDSlicer(sliceColName='testdata') 

71 dataValues = np.zeros(10000, dtype=[('testdata', 'float')]) 

72 dataValues['testdata'] = rng.rand(10000) 

73 slicer.setupSlicer(dataValues) 

74 with lsst.utils.tests.getTempFilePath('.npz') as filename: 

75 slicer.writeData(filename, dataValues[:100]) 

76 dataBack, slicerBack, header = self.baseslicer.readData(filename) 

77 assert(slicer == slicerBack) 

78 # np.testing.assert_almost_equal(dataBack,dataValues[:100]) 

79 attr2check = ['nslice', 'columnsNeeded'] 

80 for att in attr2check: 

81 if type(getattr(slicer, att)).__module__ == 'numpy': 

82 np.testing.assert_almost_equal(getattr(slicer, att), getattr(slicerBack, att)) 

83 else: 

84 assert(getattr(slicer, att) == getattr(slicerBack, att)) 

85 

86 def test_opsimFieldSlicer(self): 

87 rng = np.random.RandomState(7442) 

88 slicer = slicers.OpsimFieldSlicer() 

89 names = ['fieldRA', 'fieldDec', 'fieldId'] 

90 dt = ['float', 'float', 'int'] 

91 metricValues = rng.rand(100) 

92 fieldData = np.zeros(100, dtype=list(zip(names, dt))) 

93 fieldData['fieldRA'] = rng.rand(100) 

94 fieldData['fieldDec'] = rng.rand(100) 

95 fieldData['fieldId'] = np.arange(100) 

96 names = ['data1', 'data2', 'fieldId'] 

97 simData = np.zeros(100, dtype=list(zip(names, dt))) 

98 simData['data1'] = rng.rand(100) 

99 simData['fieldId'] = np.arange(100) 

100 slicer.setupSlicer(simData, fieldData) 

101 with lsst.utils.tests.getTempFilePath('.npz') as filename: 

102 slicer.writeData(filename, metricValues) 

103 metricBack, slicerBack, header = self.baseslicer.readData(filename) 

104 assert(slicer == slicerBack) 

105 np.testing.assert_almost_equal(metricBack, metricValues) 

106 attr2check = ['nslice', 'columnsNeeded', 'lonCol', 'latCol', 'simDataFieldIdColName'] 

107 for att in attr2check: 

108 if type(getattr(slicer, att)).__name__ == 'dict': 

109 for key in getattr(slicer, att): 

110 np.testing.assert_almost_equal(getattr(slicer, att)[key], 

111 getattr(slicerBack, att)[key]) 

112 else: 

113 assert(getattr(slicer, att) == getattr(slicerBack, att)) 

114 

115 def test_unislicer(self): 

116 rng = np.random.RandomState(34229) 

117 slicer = slicers.UniSlicer() 

118 data = np.zeros(1, dtype=[('testdata', 'float')]) 

119 data[:] = rng.rand(1) 

120 slicer.setupSlicer(data) 

121 with lsst.utils.tests.getTempFilePath('.npz') as filename: 

122 metricValue = np.array([25.]) 

123 slicer.writeData(filename, metricValue) 

124 dataBack, slicerBack, header = self.baseslicer.readData(filename) 

125 assert(slicer == slicerBack) 

126 np.testing.assert_almost_equal(dataBack, metricValue) 

127 attr2check = ['nslice', 'columnsNeeded'] 

128 for att in attr2check: 

129 assert(getattr(slicer, att) == getattr(slicerBack, att)) 

130 

131 def test_complex(self): 

132 # Test case where there is a complex metric 

133 rng = np.random.RandomState(5442) 

134 nside = 8 

135 slicer = slicers.HealpixSlicer(nside=nside) 

136 data = np.zeros(slicer.nslice, dtype='object') 

137 for i, ack in enumerate(data): 

138 n_el = rng.rand(1)*4 # up to 4 elements 

139 data[i] = np.arange(n_el) 

140 with lsst.utils.tests.getTempFilePath('.npz') as filename: 

141 slicer.writeData(filename, data) 

142 dataBack, slicerBack, header = self.baseslicer.readData(filename) 

143 assert(slicer == slicerBack) 

144 # This is a crazy slow loop! 

145 for i, ack in enumerate(data): 

146 np.testing.assert_almost_equal(dataBack[i], data[i]) 

147 

148 def test_nDSlicer(self): 

149 rng = np.random.RandomState(621) 

150 colnames = ['test1', 'test2', 'test3'] 

151 data = [] 

152 for c in colnames: 

153 data.append(rng.rand(1000)) 

154 dv = np.core.records.fromarrays(data, names=colnames) 

155 slicer = slicers.NDSlicer(colnames, binsList=10) 

156 slicer.setupSlicer(dv) 

157 with lsst.utils.tests.getTempFilePath('.npz') as filename: 

158 metricdata = np.zeros(slicer.nslice, dtype='float') 

159 for i, s in enumerate(slicer): 

160 metricdata[i] = i 

161 slicer.writeData(filename, metricdata) 

162 dataBack, slicerBack, header = self.baseslicer.readData(filename) 

163 assert(slicer == slicerBack) 

164 np.testing.assert_almost_equal(dataBack, metricdata) 

165 

166 

167class TestMemory(lsst.utils.tests.MemoryTestCase): 

168 pass 

169 

170 

171def setup_module(module): 

172 lsst.utils.tests.init() 

173 

174 

175if __name__ == "__main__": 175 ↛ 176line 175 didn't jump to line 176, because the condition on line 175 was never true

176 lsst.utils.tests.init() 

177 unittest.main()