Belle II Software  release-05-02-19
HitPatternCDC.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2013 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Martin Heck *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <mdst/dataobjects/HitPatternCDC.h>
12 
13 #include<framework/logging/Logger.h>
14 
15 #include <string>
16 
17 using namespace Belle2;
18 
19 std::bitset<64> sLayerZer(static_cast<std::string>("0000000000000000000000000000000000000000000000000000000011111111"));
20 std::bitset<64> sLayerOne(static_cast<std::string>("0000000000000000000000000000000000000000000000000011111100000000"));
21 std::bitset<64> sLayerTwo(static_cast<std::string>("0000000000000000000000000000000000000000000011111100000000000000"));
22 std::bitset<64> sLayerThr(static_cast<std::string>("0000000000000000000000000000000000000011111100000000000000000000"));
23 std::bitset<64> sLayerFou(static_cast<std::string>("0000000000000000000000000000000011111100000000000000000000000000"));
24 std::bitset<64> sLayerFiv(static_cast<std::string>("0000000000000000000000000011111100000000000000000000000000000000"));
25 std::bitset<64> sLayerSix(static_cast<std::string>("0000000000000000000011111100000000000000000000000000000000000000"));
26 std::bitset<64> sLayerSev(static_cast<std::string>("0000000000000011111100000000000000000000000000000000000000000000"));
27 std::bitset<64> sLayerEig(static_cast<std::string>("0000000011111100000000000000000000000000000000000000000000000000"));
28 
29 const std::bitset<64> HitPatternCDC::s_sLayerMasks[9] = {sLayerZer, sLayerOne, sLayerTwo, sLayerThr, sLayerFou,
30  sLayerFiv, sLayerSix, sLayerSev, sLayerEig
31  };
32 
33 std::bitset<64> infoLayerCDC(static_cast<std::string>("1111111100000000000000000000000000000000000000000000000000000000"));
34 
35 const std::bitset<64> HitPatternCDC::s_infoLayerMask = infoLayerCDC;
36 
37 const std::map<unsigned short, std::pair<unsigned short, unsigned short>> HitPatternCDC::s_superLayerIndices = {
38  {0, std::make_pair(0, 7)},
39  {1, std::make_pair(8, 13)},
40  {2, std::make_pair(14, 19)},
41  {3, std::make_pair(20, 25)},
42  {4, std::make_pair(26, 31)},
43  {5, std::make_pair(32, 37)},
44  {6, std::make_pair(38, 43)},
45  {7, std::make_pair(44, 49)},
46  {8, std::make_pair(50, 55)}
47 };
48 
49 unsigned short HitPatternCDC::getNHits() const
50 {
51  // Shift the 8 MSBs to the right and return their value as integer.
52  return static_cast<unsigned short int>((m_pattern >> 56).to_ulong());
53 }
54 
55 void HitPatternCDC::setNHits(unsigned short nHits)
56 {
57  if (nHits > 256) {
58  // Maximum with 8 available bits
59  nHits = 255;
60  }
61  // Reset the 8 MSBs to zero.
63  // Set the total number of hits as the 8 MSBs
64  std::bitset<64> numberOfHits(nHits);
65  numberOfHits <<= 56;
66  // Set the 8 MSBs to the total number of hits.
67  // The 8 MSBs have to be zero, otherwise this breaks.
68  m_pattern = numberOfHits | m_pattern;
69 }
70 
71 ULong64_t HitPatternCDC::getInteger() const
72 {
73  if constexpr(sizeof(unsigned long) >= 8) {
74  return m_pattern.to_ulong();
75  } else {
76  return m_pattern.to_ullong();
77  }
78 }
79 
80 void HitPatternCDC::setLayer(const unsigned short layer)
81 {
82  B2ASSERT("Layer is out of range.", layer <= 55);
83  m_pattern.set(layer);
84 }
85 
86 void HitPatternCDC::resetLayer(const unsigned short layer)
87 {
88  B2ASSERT("Layer is out of range.", layer <= 55);
89  m_pattern.reset(layer);
90 }
91 
92 bool HitPatternCDC::hasLayer(const unsigned short layer) const
93 {
94  B2ASSERT("Layer is out of range.", layer <= 55);
95  return m_pattern[layer];
96 }
97 
99 {
100  for (unsigned int i = 0; i < m_pattern.size(); ++i) {
101  if ((m_pattern & ~s_infoLayerMask).test(i)) return i;
102  }
103  return -1;
104 }
105 
107 {
108  // m_pattern.size()-8 because the first 8 bits are not pattern
109  for (unsigned int i = m_pattern.size() - 8; i > 0; --i) {
110  // -1 because of the index couting...
111  if ((m_pattern & ~s_infoLayerMask).test(i - 1)) return i - 1;
112  }
113  return -1;
114 }
115 
116 bool HitPatternCDC::hasSLayer(const unsigned short sLayer) const
117 {
118  B2ASSERT("Super layer outof range.", sLayer <= 8);
119  return ((m_pattern & s_sLayerMasks[sLayer]).any());
120 }
121 
122 void HitPatternCDC::resetSLayer(const unsigned short sLayer)
123 {
124  B2ASSERT("Super layer outof range.", sLayer <= 8);
125  for (unsigned short int ii = 0; ii < m_pattern.size(); ++ii) {
126  if ((s_sLayerMasks[sLayer])[ii]) {resetLayer(ii);}
127  }
128 }
129 
130 std::bitset<64> HitPatternCDC::getSLayerPattern(const unsigned short sLayer)
131 {
132  return m_pattern & s_sLayerMasks[sLayer];
133 }
134 
135 unsigned short HitPatternCDC::getSLayerNHits(const unsigned short sLayer) const
136 {
137  B2ASSERT("Super layer outof range.", sLayer <= 8);
138  return static_cast<unsigned short>((m_pattern & s_sLayerMasks[sLayer]).count());
139 }
140 
141 unsigned short HitPatternCDC::getLongestContRunInSL(const unsigned short sLayer) const
142 {
143  B2ASSERT("Super layer outof range.", sLayer <= 8);
144  unsigned short max = 0;
145  unsigned short counter = 0;
146  std::pair<unsigned short, unsigned short> indices = s_superLayerIndices.at(sLayer);
147  for (unsigned short i = indices.first; i <= indices.second; ++i) {
148  counter += m_pattern[i];
149  if (m_pattern[i] == 0) {
150  if (counter > max) {
151  max = counter;
152  }
153  counter = 0;
154  }
155  }
156  return std::max(max, counter);
157 }
158 
160 {
161  return ((s_sLayerMasks[0] | s_sLayerMasks[2] | s_sLayerMasks[4] | s_sLayerMasks[6] | s_sLayerMasks[8])
162  & m_pattern).any();
163 }
164 
166 {
167  return ((s_sLayerMasks[1] | s_sLayerMasks[3] | s_sLayerMasks[5] | s_sLayerMasks[7])
168  & m_pattern).any();
169 }
170 
171 std::string HitPatternCDC::__repr__() const
172 {
173  return m_pattern.to_string();
174 }
Belle2::HitPatternCDC::m_pattern
std::bitset< 64 > m_pattern
Saves the actual pattern.
Definition: HitPatternCDC.h:168
Belle2::HitPatternCDC::getLongestContRunInSL
unsigned short getLongestContRunInSL(const unsigned short sLayer) const
Getter for longest run of consecutive layers with hits within the given Super-layer.
Definition: HitPatternCDC.cc:141
Belle2::HitPatternCDC::getFirstLayer
short getFirstLayer() const
Returns the index of the first layer with a hit.
Definition: HitPatternCDC.cc:98
Belle2::HitPatternCDC::hasSLayer
bool hasSLayer(const unsigned short sLayer) const
Getter for super-layer match.
Definition: HitPatternCDC.cc:116
Belle2::HitPatternCDC::resetSLayer
void resetSLayer(const unsigned short sLayer)
Reset complete superLayer, e.g.
Definition: HitPatternCDC.cc:122
Belle2::HitPatternCDC::s_superLayerIndices
static const std::map< unsigned short, std::pair< unsigned short, unsigned short > > s_superLayerIndices
Holds the indices for super layer access.
Definition: HitPatternCDC.h:173
Belle2::HitPatternCDC::getSLayerNHits
unsigned short getSLayerNHits(const unsigned short sLayer) const
Getter for the number of hits in one super-layer.
Definition: HitPatternCDC.cc:135
Belle2::HitPatternCDC::hasStereoLayer
bool hasStereoLayer() const
True, if at least one axial layer is true.
Definition: HitPatternCDC.cc:165
Belle2::HitPatternCDC::__repr__
std::string __repr__() const
String for printing in python.
Definition: HitPatternCDC.cc:171
Belle2::HitPatternCDC::resetLayer
void resetLayer(const unsigned short layer)
Set bit corresponding to layer to false.
Definition: HitPatternCDC.cc:86
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::HitPatternCDC::getSLayerPattern
std::bitset< 64 > getSLayerPattern(const unsigned short sLayer)
Get the bit pattern in a specific super layer.
Definition: HitPatternCDC.cc:130
Belle2::HitPatternCDC::setNHits
void setNHits(unsigned short nHits)
Sets the 8 MSBs to the total number of hits in the CDC.
Definition: HitPatternCDC.cc:55
Belle2::HitPatternCDC::setLayer
void setLayer(const unsigned short layer)
Set bit corresponding to layer to true.
Definition: HitPatternCDC.cc:80
Belle2::HitPatternCDC::getInteger
ULong64_t getInteger() const
Getter for underlying integer type.
Definition: HitPatternCDC.cc:71
Belle2::HitPatternCDC::getLastLayer
short getLastLayer() const
Returns the index of the last layer with a hit.
Definition: HitPatternCDC.cc:106
Belle2::HitPatternCDC::hasLayer
bool hasLayer(const unsigned short layer) const
Getter for single layer.
Definition: HitPatternCDC.cc:92
Belle2::HitPatternCDC::getNHits
unsigned short getNHits() const
Get the total Number of CDC hits in the fit.
Definition: HitPatternCDC.cc:49
Belle2::HitPatternCDC::s_sLayerMasks
static const std::bitset< 64 > s_sLayerMasks[9]
Masks to zero out all bits from other layers.
Definition: HitPatternCDC.h:169
Belle2::HitPatternCDC::hasAxialLayer
bool hasAxialLayer() const
True, if at least one axial layer is true.
Definition: HitPatternCDC.cc:159
Belle2::HitPatternCDC::s_infoLayerMask
static const std::bitset< 64 > s_infoLayerMask
Mask to zero out all bits from other layers.
Definition: HitPatternCDC.h:170