MarlinTPC  1.2.0
FlagwordDefinitions.h
1 #ifndef FLAGWORDDEFINITIONS_H
2 #define FLAGWORDDEFINITIONS_H
3 
4 namespace marlintpc
5 {
6 
23  namespace pulseflag
24  {
25  int const MULTIPLE_PULSE_CANDIDATE_BIT = 1;
26  int const ANOMALOUS_SHAPE_BIT = 1 << 1;
27  int const OVERFLOW_BIN_BIT = 1 << 2;
28  int const UNDERFLOW_BIN_BIT = 1 << 3;
29  int const WAS_SPLIT_BIT = 1 << 4;
30  int const PLATEAU_CUTOFF_BIT = 1 << 5;
31 
32  inline void setMultiplePulseCandidate(int& i)
33  {
34  i |= MULTIPLE_PULSE_CANDIDATE_BIT;
35  }
36  inline void setAnomalousShape(int& j)
37  {
38  j |= ANOMALOUS_SHAPE_BIT;
39  }
40  inline void setOverflow(int& k)
41  {
42  k |= OVERFLOW_BIN_BIT;
43  }
44  inline void setUnderflow(int& m)
45  {
46  m |= UNDERFLOW_BIN_BIT;
47  }
48  inline void setSplit(int& n)
49  {
50  n |= WAS_SPLIT_BIT;
51  }
52  inline void setPlateauCutoff(int& l)
53  {
54  l |= PLATEAU_CUTOFF_BIT;
55  }
56 
57 
58  inline bool isMultiplePulseCandidate(int i)
59  {
60  return i & MULTIPLE_PULSE_CANDIDATE_BIT;
61  }
62  inline bool isAnomalousShape(int j)
63  {
64  return j & ANOMALOUS_SHAPE_BIT;
65  }
66  inline bool isOverflow(int k)
67  {
68  return k & OVERFLOW_BIN_BIT;
69  }
70  inline bool isUnderflow(int m)
71  {
72  return m & UNDERFLOW_BIN_BIT;
73  }
74  inline bool isSplit(int n)
75  {
76  return n & WAS_SPLIT_BIT;
77  }
78  inline bool isPlateauCutoff(int l)
79  {
80  return l & PLATEAU_CUTOFF_BIT;
81  }
82 
83 
84  }
85 
86 
87  namespace hitflag
88  {
89  int const CONTAINS_DEAD_CHANNEL_BIT = 1;
90  int const CONTAINS_NOISY_CHANNEL_BIT = 1 << 1;
91  int const HIT_AT_MODULE_BORDER_BIT = 1 << 2;
92  int const CONTAINS_OVERFLOW_PULSE_BIT = 1 << 3;
93  int const CONTAINS_SPLIT_PULSE_BIT = 1 << 4;
94  int const CONTAINS_ANOMALOUS_PULSE_BIT = 1 << 5;
95  int const HIT_NEXT_TO_DEAD_CHANNEL_BIT = 1 << 6;
96  int const MULTIPLE_HIT_CANDIDATE_BIT = 1 << 7;
97  int const REMOVE_FROM_TRACK_FINDING_BIT = 1 << 8;
98  int const CONTAINS_PLATEAU_CUTOFF_PULSE_BIT = 1 << 9;
99 
100  inline void setDeadChannel(int& i)
101  {
102  i |= CONTAINS_DEAD_CHANNEL_BIT;
103  }
104  inline void setNoisyChannel(int& j)
105  {
106  j |= CONTAINS_NOISY_CHANNEL_BIT;
107  }
108  inline void setAtModuleBorder(int& k)
109  {
110  k |= HIT_AT_MODULE_BORDER_BIT;
111  }
112  inline void setOverflowPulse(int& m)
113  {
114  m |= CONTAINS_OVERFLOW_PULSE_BIT;
115  }
116  inline void setSplitPulse(int& n)
117  {
118  n |= CONTAINS_SPLIT_PULSE_BIT;
119  }
120  inline void setAnomalousPulseShape(int& p)
121  {
122  p |= CONTAINS_ANOMALOUS_PULSE_BIT;
123  }
124  inline void setNextToDeadChannel(int& q)
125  {
126  q |= HIT_NEXT_TO_DEAD_CHANNEL_BIT;
127  }
128  inline void setMultipleHitCandidate(int& r)
129  {
130  r |= MULTIPLE_HIT_CANDIDATE_BIT;
131  }
132  inline void setRemoveFromTrackFinding(int& s)
133  {
134  s |= REMOVE_FROM_TRACK_FINDING_BIT;
135  }
136  inline void setPlateauCutoffPulse(int& t)
137  {
138  t |= CONTAINS_PLATEAU_CUTOFF_PULSE_BIT;
139  }
140 
141  inline bool hasDeadChannel(int i)
142  {
143  return i & CONTAINS_DEAD_CHANNEL_BIT;
144  }
145  inline bool hasNoisyChannel(int j)
146  {
147  return j & CONTAINS_NOISY_CHANNEL_BIT;
148  }
149  inline bool isAtModuleBorder(int k)
150  {
151  return k & HIT_AT_MODULE_BORDER_BIT;
152  }
153  inline bool hasOverflowPulse(int m)
154  {
155  return m & CONTAINS_OVERFLOW_PULSE_BIT;
156  }
157  inline bool hasSplitPulse(int n)
158  {
159  return n & CONTAINS_SPLIT_PULSE_BIT;
160  }
161  inline bool hasAnomalousPulseShape(int p)
162  {
163  return p & CONTAINS_ANOMALOUS_PULSE_BIT;
164  }
165  inline bool isNextToDeadChannel(int q)
166  {
167  return q & HIT_NEXT_TO_DEAD_CHANNEL_BIT;
168  }
169  inline bool isMultipleHitCandidate(int r)
170  {
171  return r & MULTIPLE_HIT_CANDIDATE_BIT;
172  }
173  inline bool isRemovedFromTrackFinding(int s)
174  {
175  return s & REMOVE_FROM_TRACK_FINDING_BIT;
176  }
177  inline bool hasPlateauCutoffPulse(int t)
178  {
179  return t & CONTAINS_PLATEAU_CUTOFF_PULSE_BIT;
180  }
181  }
182 
183  namespace trackflag
184  {
185 
186  int const HELIX_TRACKMODEL_BIT = 1 ;
187  int const STRAIGHT_LINE_TRACKMODEL_BIT = 1 << 1;
188  int const MULTIPLE_TRACK_CANDIDATE_BIT = 1 << 2;
189  int const BROKEN_LINE_FITTER_BIT = 1 << 7;
190  int const CHISQUARE_FITTER_BIT = 1 << 8;
191  int const KALMAN_FITTER_BIT = 1 << 9;
192  int const LIKELIHOOD_FITTER_BIT = 1 << 10;
193 
194  inline void setHelixTrackModel(int& i)
195  {
196  i |= HELIX_TRACKMODEL_BIT;
197  }
198  inline void setStraightLineTrackModel(int& j)
199  {
200  j |= STRAIGHT_LINE_TRACKMODEL_BIT;
201  }
202  inline void setMultipleTrackCandidate(int& j)
203  {
204  j |= MULTIPLE_TRACK_CANDIDATE_BIT;
205  }
206  inline void setBrokenLineFitter(int& j)
207  {
208  j |= BROKEN_LINE_FITTER_BIT;
209  }
210  inline void setChiSquareFitter(int& j)
211  {
212  j |= CHISQUARE_FITTER_BIT;
213  }
214  inline void setKalmanFitter(int& j)
215  {
216  j |= KALMAN_FITTER_BIT;
217  }
218  inline void setLikelihoodFitter(int& j)
219  {
220  j |= LIKELIHOOD_FITTER_BIT;
221  }
222 
223  inline bool isHelixTrackModel(int i)
224  {
225  return i & HELIX_TRACKMODEL_BIT;
226  }
227  inline bool isStraightLineTrackModel(int j)
228  {
229  return j & STRAIGHT_LINE_TRACKMODEL_BIT;
230  }
231  inline bool isMultipleTrackCandidate(int j)
232  {
233  return j & MULTIPLE_TRACK_CANDIDATE_BIT;
234  }
235  inline bool isBrokenLineFitter(int j)
236  {
237  return j & BROKEN_LINE_FITTER_BIT;
238  }
239  inline bool isChiSquareFitter(int j)
240  {
241  return j & CHISQUARE_FITTER_BIT;
242  }
243  inline bool isKalmanFitter(int j)
244  {
245  return j & KALMAN_FITTER_BIT;
246  }
247  inline bool isLikelihoodFitter(int j)
248  {
249  return j & LIKELIHOOD_FITTER_BIT;
250  }
251  }
252 }
253 
254 
255 #endif //FLAGWORDDEFINITIONS_H