Cheetah - SKA - PSS - Prototype Time Domain Search Pipeline
FrequencyTimeTester.cpp
1 /*
2  * The MIT License (MIT)
3  *
4  * Copyright (c) 2016 The SKA organisation
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 
25 namespace ska {
26 namespace cheetah {
27 namespace data {
28 namespace test {
29 
30 
31 template <typename TestTraits>
32 FrequencyTimeTester<TestTraits>::FrequencyTimeTester()
33 {
34 }
35 
36 template <typename TestTraits>
37 FrequencyTimeTester<TestTraits>::~FrequencyTimeTester()
38 {
39 }
40 
41 template <typename TestTraits>
42 void FrequencyTimeTester<TestTraits>::SetUp()
43 {
44 }
45 
46 template <typename TestTraits>
47 void FrequencyTimeTester<TestTraits>::TearDown()
48 {
49 }
50 
51 ALGORITHM_TYPED_TEST_P(FrequencyTimeTester, test_dimensions)
52 {
53  (void) device;
54  typedef typename TypeParam::DataType DataType;
55  data::DimensionSize<data::Time> number_of_spectra(10);
56  data::DimensionSize<data::Frequency> number_of_channels(10);
57  DataType ft_1(number_of_channels, number_of_spectra);
58  DataType ft_2(number_of_spectra, number_of_channels);
59 
60  ASSERT_EQ(ft_1.number_of_channels(), number_of_channels);
61  ASSERT_EQ(ft_2.number_of_channels(), number_of_channels);
62  ASSERT_EQ(ft_1.number_of_spectra(), number_of_spectra);
63  ASSERT_EQ(ft_2.number_of_spectra(), number_of_spectra);
64 }
65 
66 ALGORITHM_TYPED_TEST_P(FrequencyTimeTester, test_samples)
67 {
68  (void) device;
69  typedef typename TypeParam::DataType DataType;
70  data::DimensionSize<data::Time> number_of_spectra(10U);
71  data::DimensionSize<data::Frequency> number_of_channels(5U);
72 
73  DataType ft(number_of_spectra, number_of_channels);
74  ASSERT_EQ(static_cast<std::size_t>(number_of_spectra), ft.number_of_spectra());
75  ASSERT_EQ(static_cast<std::size_t>(number_of_channels), ft.number_of_channels());
76 
77  for(unsigned sample_number=0; sample_number < ft.number_of_spectra(); ++sample_number) {
78  SCOPED_TRACE("sample = " + std::to_string(sample_number));
79  typename DataType::Spectra it = ft.spectrum(sample_number);
80  unsigned channel_count = 0U;
81  auto channel_it = it.begin();
82  while(channel_it != it.end()) {
83  ++channel_count;
84  ++channel_it;
85  }
86  ASSERT_EQ(static_cast<std::size_t>(number_of_channels), channel_count);
87  }
88 }
89 
90 ALGORITHM_TYPED_TEST_P(FrequencyTimeTester, test_channel_frequencies_start_end)
91 {
92  (void) device;
93  data::DimensionSize<data::Time> number_of_spectra(1U);
94  data::DimensionSize<data::Frequency> number_of_channels(0);
95  typedef typename TypeParam::DataType DataType;
96 
97  for(; number_of_channels < data::DimensionSize<data::Frequency>(5U); ++number_of_channels) {
98  DataType ft(number_of_spectra, number_of_channels);
99  auto f1 = 5.0 * boost::units::si::mega * boost::units::si::hertz;
100  auto delta = 1.0 * boost::units::si::mega * boost::units::si::hertz;
101  auto f2 = 12.0 * delta - f1;
102 
103  ft.set_channel_frequencies_const_width( f1, delta );
104  { // USe Case: first fre < sencond
105  auto generated = ft.channel_frequencies();
106  ASSERT_EQ(generated.size(), number_of_channels);
107 
108  for(std::size_t i = 0U; i < number_of_channels; ++i) {
109  auto dif = (double)i * delta;
110  ASSERT_TRUE( f1 + dif == generated[i]) << "element " << i << " dif=" << dif << " generated=" << generated[i];
111  }
112  }
113  ft.set_channel_frequencies_const_width( f2, -1.0 * delta );
114  {
115  // Use Case: first freq > sencond
116  auto generated = ft.channel_frequencies();
117  ASSERT_EQ(generated.size(), number_of_channels);
118  for(std::size_t i = 0U; i < number_of_channels; ++i) {
119  ASSERT_TRUE( f2 - (double)i * delta == generated[i]) << "element " << i;
120  }
121  }
122  }
123 }
124 
125 ALGORITHM_TYPED_TEST_P(FrequencyTimeTester, test_low_high_freq)
126 {
127  (void) device;
128  typedef typename TypeParam::DataType DataType;
129  data::DimensionSize<data::Time> number_of_spectra(4U);
130  data::DimensionSize<data::Frequency> number_of_channels(10U);
131 
132  DataType ft(number_of_spectra, number_of_channels);
133  typedef std::pair<typename DataType::FrequencyType, typename DataType::FrequencyType> ReturnType;
134 
135  // eexpect 0 values if channel_freq are not set
136  ReturnType r = ft.low_high_frequencies();
137  ASSERT_EQ(0.0, r.first.value());
138  ASSERT_EQ(0.0, r.second.value());
139 
140  auto f1 = typename DataType::FrequencyType(10.0 * boost::units::si::hertz);
141  auto f2 = typename DataType::FrequencyType(20.0 * boost::units::si::hertz);
142  auto delta = (f2 - f1)/ (double)(number_of_channels-1);
143 
144  // low to haigh channel freq ordering
145  ft.set_channel_frequencies_const_width( f1, delta );
146  ASSERT_EQ(ft.channel_frequencies().size(), number_of_channels);
147  r = ft.low_high_frequencies();
148  ASSERT_EQ(f1, r.first);
149  ASSERT_EQ(f2, r.second);
150 
151  // high to low freq ordering
152  ft.set_channel_frequencies_const_width( f2, -1.0 *delta );
153  ASSERT_EQ(ft.channel_frequencies().size(), number_of_channels);
154  r = ft.low_high_frequencies();
155  ASSERT_EQ(f1, r.first);
156  ASSERT_EQ(f2, r.second);
157 
158 }
159 
160 ALGORITHM_TYPED_TEST_P(FrequencyTimeTester, set_channel)
161 {
162  (void) device;
163  typedef typename TypeParam::DataType DataType;
164 
165  data::DimensionSize<data::Time> number_of_spectra(3U);
166  data::DimensionSize<data::Frequency> number_of_channels(5U);
167 
168  for(unsigned set_channel=0; set_channel<number_of_channels; ++set_channel)
169  {
170  SCOPED_TRACE(set_channel);
171  DataType ft(number_of_spectra, number_of_channels);
172  ASSERT_EQ(ft.number_of_channels(), number_of_channels);
173  ASSERT_EQ(ft.number_of_spectra(), number_of_spectra);
174  //std::fill(ft.begin(), ft.end(), 0.0);
175  ft.set_channel(set_channel, 1.0);
176  for(unsigned channel_num=0; channel_num<number_of_channels; ++channel_num) {
177  SCOPED_TRACE(channel_num);
178  auto channel=ft.channel(channel_num);
179  auto channel_it = channel.begin();
180  ASSERT_EQ(channel.template dimension<data::Time>(), number_of_spectra);
181  ASSERT_EQ(channel.template dimension<data::Frequency>(), DimensionSize<data::Frequency>(1));
182  unsigned sample_count=0U;
183  while(channel_it != channel.end()) {
184  ++sample_count;
185  if(channel_num != set_channel) {
186  ASSERT_EQ(0.0, *channel_it);
187  }
188  else {
189  ASSERT_EQ(1.0, *channel_it);
190  }
191  ++channel_it;
192  }
193  ASSERT_EQ(static_cast<std::size_t>(number_of_spectra), sample_count);
194  }
195  }
196 }
197 
198 ALGORITHM_TYPED_TEST_P(FrequencyTimeTester, test_start_time_offset)
199 {
200  (void) device;
201  typedef typename TypeParam::DataType DataType;
202 
203  data::DimensionSize<data::Time> number_of_spectra(100U);
204  data::DimensionSize<data::Frequency> number_of_channels(1U);
205 
206  DataType ft(number_of_spectra, number_of_channels);
207  typename utils::ModifiedJulianClock::time_point epoch(utils::julian_day(50000.0));
208  typename DataType::TimeType interval(1.0 * boost::units::si::milli * boost::units::si::seconds);
209  ft.sample_interval(interval);
210  ft.start_time(epoch);
211  epoch += std::chrono::duration<double>(ft.sample_interval().value()*std::size_t(12));
212  ASSERT_EQ(ft.start_time(12L), epoch);
213 }
214 
215 
216 ALGORITHM_TYPED_TEST_P(FrequencyTimeTester, test_transpose)
217 {
218  (void) device;
219  typedef typename TypeParam::DataType DataType;
220  typedef data::TimeFrequency<Cpu, typename DataType::NumericalRep> TfDataType;
221  typedef data::FrequencyTime<Cpu, typename DataType::NumericalRep> FtDataType;
222  data::DimensionSize<data::Time> number_of_spectra(1024U);
223  data::DimensionSize<data::Frequency> number_of_channels(512U);
224 
225  TfDataType tf(number_of_spectra, number_of_channels);
226 
227  unsigned val=0;
228  std::generate(tf.begin(), tf.end(), [&]() { return val++; });
229 
230  auto f1 = typename data::TimeFrequency<Cpu, typename DataType::NumericalRep>::FrequencyType(100.0 * boost::units::si::hertz);
231  auto f2 = typename data::TimeFrequency<Cpu, typename DataType::NumericalRep>::FrequencyType(200.0 * boost::units::si::hertz);
232  typename utils::ModifiedJulianClock::time_point epoch(utils::julian_day(50000.0));
233  auto delta = (f2 - f1)/ (double)(number_of_channels-1);
234 
235  tf.set_channel_frequencies_const_width( f1, delta);
236  tf.start_time(epoch);
237 
238  FtDataType ft(tf);
239 
240  ASSERT_EQ(tf.number_of_channels(), ft.number_of_channels());
241  ASSERT_EQ(tf.number_of_spectra(), ft.number_of_spectra());
242  ASSERT_EQ(tf.number_of_spectra(), ft.number_of_spectra());
243  ASSERT_EQ(tf.start_time(), ft.start_time());
244 
245  for(std::size_t i = 0U; i < ft.channel_frequencies().size(); ++i) {
246  ASSERT_EQ(ft.channel_frequencies()[i], ft.channel_frequencies()[i]);
247  }
248 
249  for(unsigned i=0; i < tf.number_of_spectra(); ++i)
250  {
251  // iterate over channels
252  typename TfDataType::Spectra tf_spectrum = tf.spectrum(i);
253  auto tf_channel_it = tf_spectrum.begin();
254  typename FtDataType::Spectra ft_spectrum = ft.spectrum(i);
255  auto ft_channel_it = ft_spectrum.begin();
256  while(tf_channel_it != tf_spectrum.end())
257  {
258  ASSERT_EQ(*tf_channel_it, *ft_channel_it);
259  ++tf_channel_it;
260  ++ft_channel_it;
261  }
262  }
263 
264 }
265 
266 // each test defined by ALGORITHM_TYPED_TEST_P must be added to the
267 REGISTER_TYPED_TEST_CASE_P(FrequencyTimeTester, test_dimensions, test_samples, test_channel_frequencies_start_end, test_low_high_freq, set_channel, test_start_time_offset, test_transpose);
268 
269 } // namespace test
270 } // namespace data
271 } // namespace cheetah
272 } // namespace ska
Some limits and constants for FLDO.
Definition: Brdz.h:35