Cheetah - SKA - PSS - Prototype Time Domain Search Pipeline
TimeFrequencyTest.cu
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 #include "cheetah/data/cuda/test/TimeFrequencyTest.h"
25 #include "cheetah/data/TimeFrequency.h"
26 #include "cheetah/data/FrequencyTime.h"
27 #include "panda/Copy.h"
28 #include <random>
29 
30 namespace ska {
31 namespace cheetah {
32 namespace data {
33 namespace cuda {
34 namespace test {
35 
36 template <typename T>
37 TimeFrequencyTest<T>::TimeFrequencyTest()
38  : ::testing::Test()
39 {
40 }
41 
42 template <typename T>
43 TimeFrequencyTest<T>::~TimeFrequencyTest()
44 {
45 }
46 
47 template <typename T>
48 void TimeFrequencyTest<T>::SetUp()
49 {
50 }
51 
52 template <typename T>
53 void TimeFrequencyTest<T>::TearDown()
54 {
55 }
56 
57 template <class Arch, typename NumericalRepT, typename OtherNumericalRepT>
58 class DataTypes
59 {
60  public:
61  typedef Arch Architecture;
62  typedef NumericalRepT FirstType;
63  typedef NumericalRepT SecondType;
64 };
65 
66 typedef ::testing::Types<DataTypes<Cuda, uint8_t, uint8_t>,
67  DataTypes<Cuda, uint8_t, uint16_t>,
68  DataTypes<Cuda, uint8_t, float>,
69  DataTypes<Cuda, uint16_t, uint8_t>,
70  DataTypes<Cuda, uint16_t, uint16_t>,
71  DataTypes<Cuda, uint16_t, float>,
72  DataTypes<Cuda, float, uint8_t>,
73  DataTypes<Cuda, float, uint16_t>,
74  DataTypes<Cuda, float, float>,
75  DataTypes<Cpu, uint8_t, uint8_t>,
76  DataTypes<Cpu, uint8_t, uint16_t>,
77  DataTypes<Cpu, uint8_t, float>,
78  DataTypes<Cpu, uint16_t, uint8_t>,
79  DataTypes<Cpu, uint16_t, uint16_t>,
80  DataTypes<Cpu, uint16_t, float>,
81  DataTypes<Cpu, float, uint8_t>,
82  DataTypes<Cpu, float, uint16_t>,
83  DataTypes<Cpu, float, float>> TimeFrequencyTypes;
84 
85 TYPED_TEST_CASE(TimeFrequencyTest, TimeFrequencyTypes);
86 
87 TYPED_TEST(TimeFrequencyTest, test_copy)
88 {
89  typedef typename TypeParam::Architecture Arch;
90  typedef typename TypeParam::FirstType NumericalRep;
91  typedef typename TypeParam::SecondType OtherNumericalRep;
92 
93  typedef TimeFrequency<Cpu, NumericalRep> TfDataType;
94 
95  std::random_device rd;
96  std::mt19937 mt(rd());
97  std::uniform_int_distribution<int> nspectra(8, 1024);
98  std::uniform_int_distribution<int> nchans(8, 32);
99 
100  data::DimensionSize<data::Time> number_of_spectra(nspectra(mt));
101  data::DimensionSize<data::Frequency> number_of_channels(nchans(mt));
102 
103  TfDataType tf_host_data(number_of_spectra, number_of_channels);
104 
105  srand((unsigned) time(0));
106  std::generate(tf_host_data.begin(), tf_host_data.end(), [&]() { return (rand()%255); });
107 
108  auto f1 = typename data::TimeFrequency<Cpu, NumericalRep>::FrequencyType(100.0 * boost::units::si::hertz);
109  auto f2 = typename data::TimeFrequency<Cpu, NumericalRep>::FrequencyType(200.0 * boost::units::si::hertz);
110  typename utils::ModifiedJulianClock::time_point epoch(utils::julian_day(50000.0));
111  auto delta = (f2 - f1)/ (double)(number_of_channels-1);
112 
113  tf_host_data.set_channel_frequencies_const_width( f1, delta);
114  tf_host_data.start_time(epoch);
115 
116  TimeFrequency<Arch, NumericalRep> input_data(tf_host_data);
117  TimeFrequency<Cuda, OtherNumericalRep> output_data(input_data);
118  TimeFrequency<Cpu, OtherNumericalRep> output_data_copy(output_data);
119  TimeFrequency<Cpu, NumericalRep> input_data_copy(tf_host_data);
120 
121  for(unsigned i=0; i < input_data_copy.number_of_spectra(); ++i)
122  {
123  // iterate over channels
124  typename TimeFrequency<Cpu, NumericalRep>::Spectra input_spectrum = input_data_copy.spectrum(i);
125  auto input_channel_it = input_spectrum.begin();
126  typename TimeFrequency<Cpu,OtherNumericalRep>::Spectra output_spectrum = output_data_copy.spectrum(i);
127  auto output_channel_it = output_spectrum.begin();
128  while(input_channel_it != input_spectrum.end())
129  {
130  ASSERT_EQ(*input_channel_it, *output_channel_it);
131  ++input_channel_it;
132  ++output_channel_it;
133  }
134  }
135 }
136 
137 
138 TYPED_TEST(TimeFrequencyTest, test_cornerturn)
139 {
140  typedef typename TypeParam::Architecture Arch;
141  typedef typename TypeParam::FirstType NumericalRep;
142  typedef typename TypeParam::SecondType OtherNumericalRep;
143  typedef FrequencyTime<Cpu, NumericalRep> FtDataType;
144 
145  std::random_device rd;
146  std::mt19937 mt(rd());
147  std::uniform_int_distribution<int> nspectra(8, 1024);
148  std::uniform_int_distribution<int> nchans(8, 32);
149 
150  data::DimensionSize<data::Time> number_of_spectra(nspectra(mt));
151  data::DimensionSize<data::Frequency> number_of_channels(nchans(mt));
152 
153  FtDataType tf_host_data(number_of_spectra, number_of_channels);
154  srand((unsigned) time(0));
155  std::generate(tf_host_data.begin(), tf_host_data.end(), [&]() { return (rand()%255); });
156 
157  auto f1 = typename data::TimeFrequency<Cpu, NumericalRep>::FrequencyType(100.0 * boost::units::si::hertz);
158  auto f2 = typename data::TimeFrequency<Cpu, NumericalRep>::FrequencyType(200.0 * boost::units::si::hertz);
159  typename utils::ModifiedJulianClock::time_point epoch(utils::julian_day(50000.0));
160  auto delta = (f2 - f1)/ (double)(number_of_channels-1);
161 
162  tf_host_data.set_channel_frequencies_const_width( f1, delta);
163  tf_host_data.start_time(epoch);
164 
165  FrequencyTime<Arch, NumericalRep> input_data(tf_host_data);
166  TimeFrequency<Cuda, OtherNumericalRep> output_data(input_data);
167  TimeFrequency<Cpu, OtherNumericalRep> output_data_copy(output_data);
168  TimeFrequency<Cpu, NumericalRep> input_data_copy(input_data);
169 
170  for(unsigned i=0; i < input_data_copy.number_of_spectra(); ++i)
171  {
172  // iterate over channels
173  typename TimeFrequency<Cpu, NumericalRep>::Spectra input_spectrum = input_data_copy.spectrum(i);
174  auto input_channel_it = input_spectrum.begin();
175  typename TimeFrequency<Cpu,OtherNumericalRep>::Spectra output_spectrum = output_data_copy.spectrum(i);
176  auto output_channel_it = output_spectrum.begin();
177  while(input_channel_it != input_spectrum.end())
178  {
179  ASSERT_EQ(*input_channel_it, *output_channel_it);
180  ++input_channel_it;
181  ++output_channel_it;
182  }
183  }
184 }
185 
186 } // namespace test
187 } // namespace cuda
188 } // namespace data
189 } // namespace cheetah
190 } // namespace ska
Some limits and constants for FLDO.
Definition: Brdz.h:35
BaseT::Spectra Spectra
Iterator class for accessing each time sample.