Cheetah - SKA - PSS - Prototype Time Domain Search Pipeline
LastUnflagged.cpp
1 #include "cheetah/rfim/policy/LastUnflagged.h"
2 #include <algorithm>
3 
4 
5 namespace ska {
6 namespace cheetah {
7 namespace rfim {
8 
9 template<typename TimeFrequencyType>
10 LastUnflagged<TimeFrequencyType>::LastUnflagged()
11  : _replacement_sample(8)
12  , _sample_index(_replacement_sample.size(), 0)
13  , _read_index(_sample_index)
14 {
15 }
16 
17 template<typename TimeFrequencyType>
18 LastUnflagged<TimeFrequencyType>::~LastUnflagged()
19 {
20 }
21 
22 template<typename TimeFrequencyType>
23 typename LastUnflagged<TimeFrequencyType>::Adapter LastUnflagged<TimeFrequencyType>::adapter(TimeFrequencyType& data)
24 {
25  if(_replacement_sample[_read_index].size() != data.template dimension<data::Frequency>())
26  {
27  _replacement_sample[_read_index].resize(data.template dimension<data::Frequency>());
28  }
29  return Adapter(*this, data);
30 }
31 
32 template<typename TimeFrequencyType>
33 void LastUnflagged<TimeFrequencyType>::set_good_sample(Spectrum const& sample)
34 {
35  unsigned index = ++_sample_index;
36  std::copy(sample.begin(), sample.end(), _replacement_sample[index].begin());
37  if(_read_index < index) { _read_index = index; }
38 }
39 
40 template<typename TimeFrequencyType>
41 void LastUnflagged<TimeFrequencyType>::set_good_sample(NumericalRep const& sample_start, std::size_t size)
42 {
43  unsigned index = ++_sample_index;
44  auto& replacement = _replacement_sample[index];
45  replacement.resize(size);
46  std::copy(&sample_start, &sample_start + size, replacement.begin());
47  if(_read_index < index) { _read_index = index; }
48 }
49 
50 template<typename TimeFrequencyType>
51 typename LastUnflagged<TimeFrequencyType>::SampleType& LastUnflagged<TimeFrequencyType>::last_good_spectrum()
52 {
53  return _replacement_sample[_read_index];
54 }
55 
56 template<typename TimeFrequencyType>
57 LastUnflaggedAdapter<TimeFrequencyType>::LastUnflaggedAdapter(LastUnflagged<TimeFrequencyType>& parent, TimeFrequencyType& data)
58  : _parent(parent)
59  , _data(&data)
60  , _replacement_sample(parent.last_good_spectrum())
61  , _last_good_spectrum(&*(_replacement_sample.begin()))
62 {
63 }
64 
65 template<typename TimeFrequencyType>
66 LastUnflaggedAdapter<TimeFrequencyType>::~LastUnflaggedAdapter()
67 {
68  _parent.set_good_sample(*_last_good_spectrum, _data->template dimension<data::Frequency>());
69 }
70 
71 template<typename TimeFrequencyType>
72 void LastUnflaggedAdapter<TimeFrequencyType>::data()
73 {
74 }
75 
76 template<typename TimeFrequencyType>
77 inline void LastUnflaggedAdapter<TimeFrequencyType>::mark_bad(NumericalRep const& data, data::DimensionIndex<data::Frequency> channel_number)
78 {
79  const_cast<NumericalRep&>(data) = *(_last_good_spectrum + channel_number);
80 }
81 
82 template<typename TimeFrequencyType>
83 inline void LastUnflaggedAdapter<TimeFrequencyType>::mark_good(NumericalRep const& data, data::DimensionIndex<data::Frequency> channel_number)
84 {
85  _replacement_sample[channel_number] = data;
86 }
87 
88 template<typename TimeFrequencyType>
89 template<typename SliceT>
90 typename std::enable_if<pss::astrotypes::is_slice<SliceT>::value, void>::type
91 LastUnflaggedAdapter<TimeFrequencyType>::mark_good(SliceT const& slice)
92 {
93  std::copy(slice.begin(), slice.end(), _replacement_sample.begin() + slice.template span<data::Frequency>().start());
94 }
95 
96 template<typename TimeFrequencyType>
97 template<typename SliceType>
98 typename std::enable_if<pss::astrotypes::is_slice<SliceType>::value && std::remove_reference<SliceType>::type::rank != 1, void>::type
99 LastUnflaggedAdapter<TimeFrequencyType>::mark_bad(SliceType const& slice)
100 {
101  auto& writable_slice = pss::astrotypes::multiarray::cast_to_non_const_slice(const_cast<SliceType&>(slice));
102  const NumericalRep* ptr = _last_good_spectrum + static_cast<std::size_t>(writable_slice.template span<data::Frequency>().start());
103  const NumericalRep* end_ptr = _last_good_spectrum + static_cast<std::size_t>(writable_slice.template dimension<data::Frequency>());
104  for(data::DimensionIndex<data::Time> spectrum_num(0); spectrum_num < slice.template dimension<data::Time>(); ++spectrum_num)
105  {
106  std::copy(ptr, end_ptr, &*writable_slice[spectrum_num].begin());
107  }
108 }
109 
110 template<typename TimeFrequencyType>
111 template<typename SliceType>
112 typename std::enable_if<pss::astrotypes::is_slice<SliceType>::value && std::remove_reference<SliceType>::type::rank == 1, void>::type
113 LastUnflaggedAdapter<TimeFrequencyType>::mark_bad(SliceType const& slice)
114 {
115  auto& writable_slice = pss::astrotypes::multiarray::cast_to_non_const_slice(const_cast<SliceType&>(slice));
116  const NumericalRep* ptr = _last_good_spectrum + static_cast<std::size_t>(writable_slice.template span<data::Frequency>().start());
117  const NumericalRep* end_ptr = _last_good_spectrum + static_cast<std::size_t>(writable_slice.template dimension<data::Frequency>());
118  std::copy(ptr, end_ptr, &*writable_slice.begin());
119 }
120 
121 template<typename TimeFrequencyType>
122 void LastUnflaggedAdapter<TimeFrequencyType>::mark_bad(ConstChannel const& channel)
123 {
124  this->mark_bad( pss::astrotypes::multiarray::cast_to_non_const_slice(const_cast<ConstChannel&>(channel)));
125 }
126 
127 template<typename TimeFrequencyType>
128 void LastUnflaggedAdapter<TimeFrequencyType>::mark_bad(Channel const& channel)
129 {
130  Channel& writable_channel = const_cast<Channel&>(channel);
131  auto const& channel_value = _last_good_spectrum[channel.template span<data::Frequency>().start()];
132  std::fill(writable_channel.begin(), writable_channel.end(), channel_value);
133 }
134 
135 template<typename TimeFrequencyType>
136 void LastUnflaggedAdapter<TimeFrequencyType>::mark_bad(data::DimensionIndex<data::Frequency> channel_number)
137 {
138  auto const max = _data->template dimension<data::Time>();
139  for(data::DimensionIndex<data::Time> spectrum_num(0); spectrum_num < max; ++spectrum_num)
140  {
141  // replace each spectrum in the channel with the corresponding value of the last good spectrum
142  _data[spectrum_num] = *(_last_good_spectrum + static_cast<std::size_t>(channel_number));
143  }
144 }
145 
146 
147 } // namespace rfim
148 } // namespace cheetah
149 } // namespace ska
Some limits and constants for FLDO.
Definition: Brdz.h:35