24 #include "cheetah/data/test/SpCclTest.h" 25 #include "cheetah/data/SpCcl.h" 26 #include "cheetah/data/SpCandidate.h" 27 #include "cheetah/data/DedispersionMeasure.h" 28 #include "cheetah/data/Units.h" 29 #include "cheetah/data/TimeFrequency.h" 30 #include "panda/Architecture.h" 39 SpCclTest::SpCclTest() : ::testing::Test()
43 SpCclTest::~SpCclTest()
47 void SpCclTest::SetUp()
51 void SpCclTest::TearDown()
58 TEST_F(SpCclTest, test_tf_blocks)
60 typedef typename SpCcl<uint8_t>::TimeFrequencyType TimeFrequencyType;
63 typename SpCcl<uint8_t>::BlocksType blocks;
65 std::shared_ptr<TimeFrequencyType> b1(
new TimeFrequencyType(data::DimensionSize<data::Time>(1000), data::DimensionSize<data::Frequency>(10)));
66 std::shared_ptr<TimeFrequencyType> b2(
new TimeFrequencyType(data::DimensionSize<data::Time>(100), data::DimensionSize<data::Frequency>(10)));
67 blocks.emplace_back(b1);
68 blocks.emplace_back(b2);
72 SpCcl<uint8_t> cand_list(blocks);
75 auto const& blocks_ref = cand_list.tf_blocks();
77 ASSERT_EQ(blocks_ref.size(), std::size_t(2));
78 ASSERT_EQ(blocks_ref[0]->number_of_spectra(), std::size_t(1000));
79 ASSERT_EQ(blocks_ref[1]->number_of_spectra(), std::size_t(100));
82 TEST_F(SpCclTest, test_candidate_vector_behaviour)
85 typedef SpCandidate<Cpu, float> SpCandidateType;
86 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFrequencyType;
91 SpCcl<uint8_t> cand_list;
93 ASSERT_EQ(cand_list.tf_blocks().size(),std::size_t(0));
96 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
98 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
100 SpCandidateType::MsecTimeType tstart(2.0 * boost::units::si::seconds);
104 for (idx=0; idx<10; ++idx)
106 SpCandidateType candidate(dm, tstart, width, sigma, idx);
107 cand_list.push_back(candidate);
111 ASSERT_EQ(cand_list.size(), std::size_t(10));
113 for (idx=0; idx<10; ++idx)
115 auto const& cand = cand_list[idx];
116 ASSERT_EQ(cand.dm(), dm);
117 ASSERT_EQ(cand.tstart(), tstart);
118 ASSERT_EQ(cand.width(), width);
119 ASSERT_EQ(cand.sigma(), sigma);
120 ASSERT_EQ(cand.ident(), idx);
123 SpCcl<uint8_t> cand_list2;
125 for (idx=0; idx<10; ++idx)
127 SpCandidateType candidate(dm, tstart, width, sigma, idx);
128 cand_list2.emplace_back(std::move(candidate));
132 ASSERT_EQ(cand_list.size(), std::size_t(10));
134 for (idx=0; idx<10; ++idx)
136 auto const& cand = cand_list2[idx];
137 ASSERT_EQ(cand.dm(), dm);
138 ASSERT_EQ(cand.tstart(), tstart);
139 ASSERT_EQ(cand.width(), width);
140 ASSERT_EQ(cand.sigma(), sigma);
141 ASSERT_EQ(cand.ident(), idx);
145 TEST_F(SpCclTest, test_candidate_dm_range)
148 typedef SpCandidate<Cpu, float> SpCandidateType;
149 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFrequencyType;
154 SpCcl<uint8_t> cand_list;
156 ASSERT_EQ(cand_list.tf_blocks().size(),std::size_t(0));
159 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
161 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
163 SpCandidateType::MsecTimeType tstart(2.0 * boost::units::si::seconds);
167 for (idx=0; idx<10; ++idx)
169 SpCandidateType candidate(dm, tstart, width, sigma, idx);
170 dm += SpCandidateType::Dm(1.0 * parsecs_per_cube_cm);
171 cand_list.push_back(candidate);
174 ASSERT_EQ(cand_list.dm_range().first, SpCandidateType::Dm(12.0 * parsecs_per_cube_cm));
175 ASSERT_EQ(cand_list.dm_range().second, SpCandidateType::Dm(21.0 * parsecs_per_cube_cm));
178 cand_list.remove_if([](SpCandidateType
const& s)
180 return s.dm() == SpCandidateType::Dm(12.0 * parsecs_per_cube_cm);
182 ASSERT_EQ(cand_list.dm_range().first, SpCandidateType::Dm(13.0 * parsecs_per_cube_cm));
183 ASSERT_EQ(cand_list.dm_range().second, SpCandidateType::Dm(21.0 * parsecs_per_cube_cm));
186 cand_list.remove_if([](SpCandidateType
const& s)
188 return s.dm() == SpCandidateType::Dm(21.0 * parsecs_per_cube_cm);
190 ASSERT_EQ(cand_list.dm_range().first, SpCandidateType::Dm(13.0 * parsecs_per_cube_cm));
191 ASSERT_EQ(cand_list.dm_range().second, SpCandidateType::Dm(20.0 * parsecs_per_cube_cm));
194 cand_list.remove_if([](SpCandidateType
const& s)
196 return s.dm() == SpCandidateType::Dm(17.0 * parsecs_per_cube_cm);
198 ASSERT_EQ(cand_list.dm_range().first, SpCandidateType::Dm(13.0 * parsecs_per_cube_cm));
199 ASSERT_EQ(cand_list.dm_range().second, SpCandidateType::Dm(20.0 * parsecs_per_cube_cm));
203 TEST_F(SpCclTest, test_equalto_operator_no_data)
209 SpCcl<uint8_t> cand_list;
210 CandidateWindow window;
211 ASSERT_NO_THROW(cand_list.data_begin(window));
212 SpCcl<uint8_t>::ConstDataIterator it_begin = cand_list.data_begin(window);
213 SpCcl<uint8_t>::ConstDataIterator it_end = cand_list.data_end();
214 SpCcl<uint8_t>::ConstDataIterator it_end2 = cand_list.data_end();
216 ASSERT_TRUE(it_end == it_end2);
217 ASSERT_FALSE(it_end != it_end2);
218 ASSERT_TRUE(it_begin == it_end);
221 TEST_F(SpCclTest, test_emplace_back)
223 typedef SpCandidate<Cpu, float> SpCandidateType;
224 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
225 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
226 SpCandidateType::MsecTimeType tstart(2.0 * boost::units::si::seconds);
230 SpCcl<uint8_t> cand_list;
231 SpCandidateType candidate(dm, tstart, width, sigma);
232 cand_list.emplace_back(std::move(candidate));
233 ASSERT_EQ(cand_list.size(), 1U);
234 auto const& cand = cand_list[0];
235 ASSERT_EQ(cand.dm(), dm);
236 ASSERT_EQ(cand.tstart(), tstart);
237 ASSERT_EQ(cand.width(), width);
238 ASSERT_EQ(cand.sigma(), sigma);
241 SpCandidateType::MsecTimeType tstart2(1.0 * boost::units::si::seconds);
242 SpCandidateType candidate2(dm, tstart2, width, sigma);
243 cand_list.emplace_back(std::move(candidate2));
244 ASSERT_EQ(cand_list.size(), 2U);
245 auto const& cand0 = cand_list[0];
246 auto const& cand1 = cand_list[1];
247 ASSERT_EQ(cand0.tstart(), tstart2);
248 ASSERT_EQ(cand1.tstart(), tstart);
251 TEST_F(SpCclTest, test_emplace_back_constructor_list)
253 typedef SpCandidate<Cpu, float> SpCandidateType;
254 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
255 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
256 SpCandidateType::MsecTimeType tstart(2.0 * boost::units::si::seconds);
259 typedef typename std::remove_const<SpCcl<uint8_t>::BlocksType::value_type::element_type>::type TimeFrequencyType;
260 data::DimensionSize<data::Time> number_of_spectra(4U);
261 data::DimensionSize<data::Frequency> number_of_channels(10U);
263 auto f1 = data::TimeFrequency<Cpu, uint8_t>::FrequencyType(10.0 * boost::units::si::hertz);
264 auto f2 = data::TimeFrequency<Cpu, uint8_t>::FrequencyType(20.0 * boost::units::si::hertz);
265 auto delta = (f2 - f1)/ (
double)(number_of_channels-1);
266 boost::units::quantity<MilliSeconds, double> delay =
267 (4.15 * 1000000.0 * boost::units::si::milli * boost::units::si::seconds) * ( dm * ( (1/(f1 * f1)) - (1/(f2 * f2)) )).value();
269 std::shared_ptr<TimeFrequencyType> tf = std::make_shared<TimeFrequencyType>(number_of_spectra, number_of_channels);
270 tf->set_channel_frequencies_const_width( f2, -1.0 * delta );
272 SpCcl<uint8_t> cand_list({tf});
273 cand_list.emplace_back(dm, tstart, width, sigma);
275 ASSERT_EQ(cand_list.size(), 1U);
276 auto const& cand = cand_list[0];
277 ASSERT_EQ(cand.dm(), dm);
278 ASSERT_EQ(cand.tstart(), tstart);
279 ASSERT_DOUBLE_EQ(cand.tend().value(), (tstart + delay).value());
280 ASSERT_EQ(cand.width(), width);
281 ASSERT_EQ(cand.sigma(), sigma);
284 TEST_F(SpCclTest, test_sort_behaviour)
287 typedef SpCandidate<Cpu, float> SpCandidateType;
288 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFrequencyType;
293 SpCcl<uint8_t> cand_list;
295 SpCcl<uint8_t> cand_list2;
297 ASSERT_EQ(cand_list.tf_blocks().size(),std::size_t(0));
300 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
302 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
304 SpCandidateType::MsecTimeType tstart(2.0 * boost::units::si::seconds);
308 for (idx=0; idx<10; ++idx)
311 SpCandidateType candidate(dm, tstart, width, sigma, idx);
312 cand_list.push_back(candidate);
314 cand_list2.emplace(std::move(candidate));
316 tstart += SpCandidateType::MsecTimeType(1.0*boost::units::si::seconds);
320 ASSERT_EQ(cand_list.size(), std::size_t(10));
322 SpCandidateType::MsecTimeType ststart(2.0 * boost::units::si::seconds);
323 for (idx=0; idx<10; ++idx)
326 auto const& cand = cand_list[idx];
327 auto const& cand2 = cand_list2[idx];
328 ASSERT_EQ(cand.dm(), dm);
329 ASSERT_EQ(cand2.dm(), dm);
330 ASSERT_EQ(cand.tstart(), ststart);
331 ASSERT_EQ(cand2.tstart(), ststart);
332 ASSERT_EQ(cand.width(), width);
333 ASSERT_EQ(cand2.width(), width);
334 ASSERT_EQ(cand.sigma(), sigma);
335 ASSERT_EQ(cand2.sigma(), sigma);
336 ASSERT_EQ(cand.ident(), idx);
337 ASSERT_EQ(cand2.ident(), idx);
338 ststart += SpCandidateType::MsecTimeType(1.0*boost::units::si::seconds);
342 TEST_F(SpCclTest, test_disordered_input_sort_behaviour)
345 typedef SpCandidate<Cpu, float> SpCandidateType;
346 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFrequencyType;
347 data::DimensionSize<data::Time> number_of_spectra(4U);
348 data::DimensionSize<data::Frequency> number_of_channels(10U);
350 auto f1 = data::TimeFrequency<Cpu, uint8_t>::FrequencyType(10.0 * boost::units::si::hertz);
351 auto f2 = data::TimeFrequency<Cpu, uint8_t>::FrequencyType(20.0 * boost::units::si::hertz);
352 auto delta = (f2 - f1)/ (
double)(number_of_channels-1);
355 std::shared_ptr<data::TimeFrequency<Cpu, uint8_t>> tf = std::make_shared<data::TimeFrequency<Cpu, uint8_t>>(number_of_spectra, number_of_channels);
356 tf->set_channel_frequencies_const_width( f2, -1.0 * delta );
357 ASSERT_EQ(tf->low_high_frequencies().first, f1);
358 ASSERT_EQ(tf->low_high_frequencies().second, f2);
361 SpCcl<uint8_t> cand_list({tf});
362 ASSERT_EQ(cand_list.tf_blocks().size(),std::size_t(1));
363 ASSERT_EQ(cand_list.tf_blocks()[0]->low_high_frequencies().first, f1);
365 SpCcl<uint8_t> cand_list2({tf});
366 ASSERT_EQ(cand_list2.tf_blocks().size(),std::size_t(1));
369 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
370 boost::units::quantity<MilliSeconds, double> delay =
371 (4.15 * 1000000.0 * boost::units::si::milli * boost::units::si::seconds) * ( dm * ( (1/(f1 * f1)) - (1/(f2 * f2)) )).value();
374 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
376 SpCandidateType::MsecTimeType tstart(11.0 * boost::units::si::seconds);
380 for (std::size_t idx=0; idx<10; ++idx)
383 SpCandidateType candidate(dm, tstart, width, sigma, idx);
384 cand_list.push_back_calculate_duration(candidate);
385 cand_list2.emplace_calculate_duration(std::move(candidate));
386 tstart -= SpCandidateType::MsecTimeType(1.0*boost::units::si::seconds);
390 ASSERT_EQ(cand_list.size(), std::size_t(10));
392 SpCandidateType::MsecTimeType ststart(2.0 * boost::units::si::seconds);
393 for (std::size_t idx=0; idx<10; ++idx)
396 auto const& cand = cand_list[idx];
397 auto const& cand2 = cand_list2[idx];
398 ASSERT_EQ(cand.dm(), dm);
399 ASSERT_EQ(cand2.dm(), dm);
400 ASSERT_EQ(cand.tstart(), ststart);
401 ASSERT_DOUBLE_EQ(cand.tend().value(), (ststart + delay).value());
402 ASSERT_EQ(cand2.tstart(), ststart);
403 ASSERT_DOUBLE_EQ(cand2.tend().value(), (ststart + delay).value());
404 ASSERT_EQ(cand.width(), width);
405 ASSERT_EQ(cand2.width(), width);
406 ASSERT_EQ(cand.sigma(), sigma);
407 ASSERT_EQ(cand2.sigma(), sigma);
408 ASSERT_EQ(cand.ident(), 9-idx);
409 ASSERT_EQ(cand2.ident(), 9-idx);
410 ststart += SpCandidateType::MsecTimeType(1.0*boost::units::si::seconds);
415 TEST_F(SpCclTest, test_candidates_extraction)
417 typedef SpCandidate<Cpu, float> SpCandidateType;
418 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFreqType;
419 TimeFrequency<Cpu, uint8_t> tf1(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(1024));
420 TimeFrequency<Cpu, uint8_t> tf2(data::DimensionSize<data::Time>(200),data::DimensionSize<data::Frequency>(1024));
421 TimeFrequency<Cpu, uint8_t> tf3(data::DimensionSize<data::Time>(300),data::DimensionSize<data::Frequency>(1024));
423 tf1.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
424 tf2.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
425 tf3.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
427 SpCcl<uint8_t>::BlocksType tf_v;
429 std::fill(tf1.begin(),tf1.end(),0);
430 std::fill(tf2.begin(),tf2.end(),1);
431 std::fill(tf3.begin(),tf3.end(),2);
433 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf1));
434 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf2));
435 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf3));
438 SpCcl<uint8_t> cand_list(tf_v);
441 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
443 SpCandidateType::MsecTimeType width(1 * boost::units::si::milli * boost::units::si::seconds);
445 SpCandidateType::MsecTimeType tstart(5.0 * boost::units::si::seconds);
449 SpCandidateType::MsecTimeType tend(2000 * boost::units::si::milli * boost::units::si::seconds);
451 for (std::uint32_t idx=0; idx<30; ++idx)
453 SpCandidateType candidate(dm, tstart, width, sigma, idx);
454 candidate.duration_end(tend);
455 cand_list.push_back(candidate);
456 tstart += SpCandidateType::MsecTimeType(10*boost::units::si::seconds);
461 CandidateWindow window( 1000 * data::milliseconds, 1000 * data::milliseconds);
465 SpCcl<uint8_t>::ConstDataIterator it_begin = cand_list.data_begin( window );
466 SpCcl<uint8_t>::ConstDataIterator it_end = cand_list.data_end();
469 while(it_begin != it_end)
472 auto slice = *it_begin;
473 auto start_time = it_begin.start_time();
474 ASSERT_EQ(static_cast<std::size_t>(slice.size<data::Frequency>()),tf1.number_of_channels());
475 ASSERT_EQ(static_cast<std::size_t>(slice.size<data::Time>()), 4);
476 double ts = (pss::astrotypes::units::duration_cast<boost::units::quantity<MilliSeconds, double>>(start_time - tf1.start_time())).value();
477 double cts = (cand_list[count].tstart() - window.ms_before()).value();
478 ASSERT_DOUBLE_EQ(ts, cts);
479 ASSERT_NO_THROW(++it_begin);
483 ASSERT_EQ(count,cand_list.size());
486 TEST_F(SpCclTest, test_candidate_extraction_begin_range)
493 typedef SpCandidate<Cpu, float> SpCandidateType;
494 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFreqType;
495 TimeFrequency<Cpu, uint8_t> tf1(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(1024));
497 tf1.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1*boost::units::si::seconds));
500 SpCcl<uint8_t>::BlocksType tf_v;
503 std::generate(tf1.begin(),tf1.end(),[&](){
return ++n;});
505 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf1));
507 SpCcl<uint8_t> cand_list(tf_v);
510 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
512 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
514 SpCandidateType::MsecTimeType tstart3(0.1 * boost::units::si::seconds);
516 SpCandidateType::MsecTimeType tend(2000 * boost::units::si::milli * boost::units::si::seconds);
520 SpCandidateType candidate3(dm,tstart3,width,sigma, 3);
521 candidate3.duration_end(tend);
522 cand_list.push_back(candidate3);
524 CandidateWindow window(150 * data::milliseconds,150 * data::milliseconds);
526 SpCcl<uint8_t>::ConstDataIterator it_begin = cand_list.data_begin(window);
527 SpCcl<uint8_t>::ConstDataIterator it_end = cand_list.data_end();
530 auto tf_it = tf1.begin();
531 auto sl_it = (*it_begin).begin();
534 for (uint32_t ii=0; ii < 5120 ; ++ii )
536 ASSERT_EQ(*sl_it,*tf_it);
542 while(it_begin != it_end)
544 ASSERT_NO_THROW(++it_begin);
548 ASSERT_EQ(count,cand_list.size());
551 TEST_F(SpCclTest, test_candidate_extraction_end_range)
558 typedef SpCandidate<Cpu, float> SpCandidateType;
559 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFreqType;
560 TimeFrequency<Cpu, uint8_t> tf1(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(1024));
562 tf1.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1*boost::units::si::seconds));
565 SpCcl<uint8_t>::BlocksType tf_v;
567 std::fill(tf1.begin(),tf1.end(),0);
569 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf1));
571 SpCcl<uint8_t> cand_list(tf_v);
574 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
576 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
578 SpCandidateType::MsecTimeType tstart(99.9 * boost::units::si::seconds);
580 SpCandidateType::MsecTimeType tend(2000 * boost::units::si::milli * boost::units::si::seconds);
582 SpCandidateType candidate(dm, tstart, width, sigma, 1);
583 candidate.duration_end(tend);
584 cand_list.push_back(candidate);
586 CandidateWindow window(2000 * data::milliseconds,2000 * data::milliseconds);
588 SpCcl<uint8_t>::ConstDataIterator it_begin = cand_list.data_begin(window);
589 SpCcl<uint8_t>::ConstDataIterator it_end = cand_list.data_end();
591 auto tf_it = tf1.end();
592 tf_it = tf_it - 2048;
593 auto sl_it = (*it_begin).begin();
595 for (uint32_t ii=0; ii < 2048; ++ii )
597 ASSERT_EQ(*sl_it,*tf_it);
602 while(it_begin != it_end)
604 ASSERT_NO_THROW(++it_begin);
608 ASSERT_EQ(count,cand_list.size());
611 TEST_F(SpCclTest, test_candidate_extraction_overlap)
618 typedef SpCandidate<Cpu, float> SpCandidateType;
619 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFreqType;
620 TimeFrequency<Cpu, uint8_t> tf1(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(1024));
622 tf1.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1*boost::units::si::seconds));
625 SpCcl<uint8_t>::BlocksType tf_v;
627 std::fill(tf1.begin(),tf1.end(),0);
629 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf1));
631 SpCcl<uint8_t> cand_list(tf_v);
634 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
636 SpCandidateType::MsecTimeType width(0.001 * boost::units::si::seconds);
638 SpCandidateType::MsecTimeType tstart(30 * boost::units::si::seconds);
639 SpCandidateType::MsecTimeType tstart2(29 * boost::units::si::seconds);
640 SpCandidateType::MsecTimeType tstart3(31 * boost::units::si::seconds);
642 SpCandidateType::MsecTimeType tend(2000 * boost::units::si::milli * boost::units::si::seconds);
645 SpCandidateType candidate(dm, tstart, width, sigma, 1);
646 SpCandidateType candidate2(dm,tstart2,width,sigma, 2);
647 SpCandidateType candidate3(dm,tstart3,width,sigma, 3);
648 candidate.duration_end(tend);
649 candidate2.duration_end(tend);
650 candidate3.duration_end(tend);
651 cand_list.push_back(candidate);
652 cand_list.push_back(candidate2);
653 cand_list.push_back(candidate3);
655 CandidateWindow window(1000 * data::milliseconds,1000 * data::milliseconds);
657 SpCcl<uint8_t>::ConstDataIterator it_begin = cand_list.data_begin(window);
658 SpCcl<uint8_t>::ConstDataIterator it_end = cand_list.data_end();
661 while(it_begin != it_end)
663 ASSERT_NO_THROW(++it_begin);
666 ASSERT_EQ(count,cand_list.size()-2);
670 TEST_F(SpCclTest, test_candidate_spanning_multiple_blocks)
676 typedef SpCandidate<Cpu, float> SpCandidateType;
677 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFreqType;
678 TimeFrequency<Cpu, uint8_t> tf1(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(16));
679 TimeFrequency<Cpu, uint8_t> tf2(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(16));
680 TimeFrequency<Cpu, uint8_t> tf3(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(16));
682 tf1.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
683 tf2.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
684 tf3.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
686 SpCcl<uint8_t>::BlocksType tf_v;
688 std::fill(tf1.begin(),tf1.end(),0);
689 std::fill(tf2.begin(),tf2.end(),1);
690 std::fill(tf3.begin(),tf3.end(),2);
692 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf1));
693 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf2));
694 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf3));
697 SpCcl<uint8_t> cand_list(tf_v);
700 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
702 SpCandidateType::MsecTimeType width(1 * boost::units::si::milli * boost::units::si::seconds);
704 SpCandidateType::MsecTimeType tstart(5 * boost::units::si::seconds);
708 SpCandidateType::MsecTimeType tend(2000 * boost::units::si::milli * boost::units::si::seconds);
712 SpCandidateType candidate(dm, tstart, width, sigma, 1);
713 candidate.duration_end(tend);
714 cand_list.push_back(candidate);
716 CandidateWindow window(2000 * data::milliseconds,200000 * data::milliseconds);
718 SpCcl<uint8_t>::ConstDataIterator it_begin = cand_list.data_begin(window);
719 SpCcl<uint8_t>::ConstDataIterator it_end = cand_list.data_end();
722 auto tf_it = tf1.begin();
724 auto sl_it1 = (*it_begin).begin();
725 for (uint32_t ii=0; ii < 1552; ++ii)
727 ASSERT_EQ(*sl_it1,*tf_it);
732 auto sl_it2 = (*it_begin).begin();
733 auto tf_it2 = tf2.begin();
734 for (uint32_t ii=0; ii < 1600; ++ii)
736 ASSERT_EQ(*sl_it2,*tf_it2);
741 auto sl_it3 = (*it_begin).begin();
742 auto tf_it3 = tf3.begin();
743 for (uint32_t ii=0 ; ii < 112; ++ii)
745 ASSERT_EQ(*sl_it3,*tf_it3);
750 ASSERT_NO_THROW(++it_begin);
754 TEST_F(SpCclTest, test_candidate_start_beyond_end)
760 typedef SpCandidate<Cpu, float> SpCandidateType;
761 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFreqType;
762 TimeFrequency<Cpu, uint8_t> tf1(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(16));
764 tf1.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
766 SpCcl<uint8_t>::BlocksType tf_v;
768 std::fill(tf1.begin(),tf1.end(),0);
770 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf1));
773 SpCcl<uint8_t> cand_list(tf_v);
776 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
778 SpCandidateType::MsecTimeType width(1 * boost::units::si::milli * boost::units::si::seconds);
780 SpCandidateType::MsecTimeType tstart(105 * boost::units::si::seconds);
784 SpCandidateType::MsecTimeType tend(2000 * boost::units::si::milli * boost::units::si::seconds);
788 SpCandidateType candidate(dm, tstart, width, sigma, 1);
789 candidate.duration_end(tend);
790 cand_list.push_back(candidate);
792 CandidateWindow window(2000 * data::milliseconds,2000 * data::milliseconds);
798 ASSERT_ANY_THROW(cand_list.data_begin(window));
802 TEST_F(SpCclTest, test_no_candidates)
808 SpCcl<uint8_t> cand_list;
809 CandidateWindow window;
810 ASSERT_NO_THROW(cand_list.data_begin(window));
811 SpCcl<uint8_t>::ConstDataIterator it_begin = cand_list.data_begin(window);
812 SpCcl<uint8_t>::ConstDataIterator it_end = cand_list.data_end();
813 while (it_begin != it_end)
815 ASSERT_NO_THROW(++it_begin);
820 TEST_F(SpCclTest, test_offset_time)
822 typedef SpCcl<uint8_t> SpCclType;
823 typedef SpCclType::BlocksType BlocksType;
824 typedef BlocksType::value_type::element_type TimeFrequencyType;
826 TimeFrequencyType::TimeType sample_interval(64 * boost::units::si::milli * boost::units::si::seconds);
829 typename std::remove_const<TimeFrequencyType>::type tf1(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(16));
830 tf1.sample_interval(sample_interval);
831 tf_v.push_back(std::make_shared<TimeFrequencyType>(tf1));
833 for(data::DimensionIndex<data::Time> offset(0); offset < tf1.number_of_spectra(); ++offset) {
834 SpCclType cand_list(tf_v, offset);
835 ASSERT_DOUBLE_EQ(pss::astrotypes::units::duration_cast<TimeFrequencyType::TimeType>(cand_list.offset_time()).value(), (offset * sample_interval).value());
839 TEST_F(SpCclTest, test_candidate_start_multiple_blocks_behind)
845 typedef SpCandidate<Cpu, float> SpCandidateType;
846 typedef SpCcl<uint8_t>::BlocksType::value_type::element_type TimeFreqType;
847 TimeFrequency<Cpu, uint8_t> tf1(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(16));
848 TimeFrequency<Cpu, uint8_t> tf2(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(16));
849 TimeFrequency<Cpu, uint8_t> tf3(data::DimensionSize<data::Time>(100),data::DimensionSize<data::Frequency>(16));
851 tf1.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
852 tf2.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
853 tf3.sample_interval(data::TimeFrequency<Cpu, uint8_t>::TimeType(1000 * boost::units::si::milli * boost::units::si::seconds));
855 SpCcl<uint8_t>::BlocksType tf_v;
857 std::fill(tf1.begin(),tf1.end(),0);
858 std::fill(tf2.begin(),tf2.end(),1);
859 std::fill(tf3.begin(),tf3.end(),2);
861 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf1));
862 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf2));
863 tf_v.push_back(std::make_shared<TimeFrequency<Cpu, uint8_t>>(tf3));
866 SpCcl<uint8_t> cand_list(tf_v);
869 typename SpCandidateType::Dm dm(12.0 * parsecs_per_cube_cm);
871 SpCandidateType::MsecTimeType width(1 * boost::units::si::milli * boost::units::si::seconds);
873 SpCandidateType::MsecTimeType tstart(250 * boost::units::si::seconds);
877 SpCandidateType::MsecTimeType tend(2000 * boost::units::si::milli * boost::units::si::seconds);
881 SpCandidateType candidate(dm, tstart, width, sigma, 1);
882 candidate.duration_end(tend);
883 cand_list.push_back(candidate);
885 CandidateWindow window(200000 * data::milliseconds,10000 * data::milliseconds);
887 SpCcl<uint8_t>::ConstDataIterator it_begin = cand_list.data_begin(window);
888 SpCcl<uint8_t>::ConstDataIterator it_end = cand_list.data_end();
891 auto tf_it = tf1.begin();
893 auto sl_it1 = (*it_begin).begin();
894 for (uint32_t ii=0; ii < 800; ++ii)
896 ASSERT_EQ(*sl_it1,*tf_it);
901 auto sl_it2 = (*it_begin).begin();
902 auto tf_it2 = tf2.begin();
903 for (uint32_t ii=0; ii < 1600; ++ii)
905 ASSERT_EQ(*sl_it2,*tf_it2);
910 auto sl_it3 = (*it_begin).begin();
911 auto tf_it3 = tf3.begin();
912 for (uint32_t ii=0 ; ii < 992; ++ii)
914 ASSERT_EQ(*sl_it3,*tf_it3);
919 ASSERT_NO_THROW(++it_begin);
Some limits and constants for FLDO.