Belle II Software  release-05-01-25
TOPCalModuleAlignment.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2019 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Umberto Tamponi (tamponi@to.infn.it), Marko Staric *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <top/dbobjects/TOPCalModuleAlignment.h>
12 #include <framework/logging/Logger.h>
13 
14 using namespace std;
15 
16 namespace Belle2 {
22  void TOPCalModuleAlignment::setAlpha(int moduleID, double alpha, double errAlpha)
23  {
24  unsigned module = moduleID - 1;
25  if (module >= c_numModules) {
26  B2ERROR("Invalid module number, constant not set (" << ClassName() << ")");
27  return;
28  }
29  m_alpha[module] = alpha;
30  m_errAlpha[module] = errAlpha;
31  }
32 
33  void TOPCalModuleAlignment::setBeta(int moduleID, double beta, double errBeta)
34  {
35  unsigned module = moduleID - 1;
36  if (module >= c_numModules) {
37  B2ERROR("Invalid module number, constant not set (" << ClassName() << ")");
38  return;
39  }
40  m_beta[module] = beta;
41  m_errBeta[module] = errBeta;
42  }
43 
44  void TOPCalModuleAlignment::setGamma(int moduleID, double gamma, double errGamma)
45  {
46  unsigned module = moduleID - 1;
47  if (module >= c_numModules) {
48  B2ERROR("Invalid module number, constant not set (" << ClassName() << ")");
49  return;
50  }
51  m_gamma[module] = gamma;
52  m_errGamma[module] = errGamma;
53  }
54 
55  void TOPCalModuleAlignment::setX(int moduleID, double x, double errX)
56  {
57  unsigned module = moduleID - 1;
58  if (module >= c_numModules) {
59  B2ERROR("Invalid module number, constant not set (" << ClassName() << ")");
60  return;
61  }
62  m_x[module] = x;
63  m_errX[module] = errX;
64  }
65 
66  void TOPCalModuleAlignment::setY(int moduleID, double y, double errY)
67  {
68  unsigned module = moduleID - 1;
69  if (module >= c_numModules) {
70  B2ERROR("Invalid module number, constant not set (" << ClassName() << ")");
71  return;
72  }
73  m_y[module] = y;
74  m_errY[module] = errY;
75  }
76 
77  void TOPCalModuleAlignment::setZ(int moduleID, double z, double errZ)
78  {
79  unsigned module = moduleID - 1;
80  if (module >= c_numModules) {
81  B2ERROR("Invalid module number, constant not set (" << ClassName() << ")");
82  return;
83  }
84  m_z[module] = z;
85  m_errZ[module] = errZ;
86  }
87 
88  void TOPCalModuleAlignment::setCalibrated(int moduleID)
89  {
90  unsigned module = moduleID - 1;
91  if (module >= c_numModules) {
92  B2ERROR("Invalid module number, status not set (" << ClassName() << ")");
93  return;
94  }
95  m_status[module] = c_Calibrated;
96  }
97 
98  void TOPCalModuleAlignment::setUnusable(int moduleID)
99  {
100  unsigned module = moduleID - 1;
101  if (module >= c_numModules) {
102  B2ERROR("Invalid module number, status not set (" << ClassName() << ")");
103  return;
104  }
105  m_status[module] = c_Unusable;
106  }
107 
108  double TOPCalModuleAlignment::getAlpha(int moduleID) const
109  {
110  unsigned module = moduleID - 1;
111  if (module >= c_numModules) {
112  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
113  return 0;
114  }
115  return m_alpha[module];
116  }
117 
118  double TOPCalModuleAlignment::getBeta(int moduleID) const
119  {
120  unsigned module = moduleID - 1;
121  if (module >= c_numModules) {
122  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
123  return 0;
124  }
125  return m_beta[module];
126  }
127 
128  double TOPCalModuleAlignment::getGamma(int moduleID) const
129  {
130  unsigned module = moduleID - 1;
131  if (module >= c_numModules) {
132  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
133  return 0;
134  }
135  return m_gamma[module];
136  }
137 
138  double TOPCalModuleAlignment::getX(int moduleID) const
139  {
140  unsigned module = moduleID - 1;
141  if (module >= c_numModules) {
142  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
143  return 0;
144  }
145  return m_x[module];
146  }
147 
148  double TOPCalModuleAlignment::getY(int moduleID) const
149  {
150  unsigned module = moduleID - 1;
151  if (module >= c_numModules) {
152  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
153  return 0;
154  }
155  return m_y[module];
156  }
157 
158  double TOPCalModuleAlignment::getZ(int moduleID) const
159  {
160  unsigned module = moduleID - 1;
161  if (module >= c_numModules) {
162  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
163  return 0;
164  }
165  return m_z[module];
166  }
167 
168  double TOPCalModuleAlignment::getAlphaErr(int moduleID) const
169  {
170  unsigned module = moduleID - 1;
171  if (module >= c_numModules) {
172  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
173  return 0;
174  }
175  return m_errAlpha[module];
176  }
177 
178  double TOPCalModuleAlignment::getBetaErr(int moduleID) const
179  {
180  unsigned module = moduleID - 1;
181  if (module >= c_numModules) {
182  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
183  return 0;
184  }
185  return m_errBeta[module];
186  }
187 
188  double TOPCalModuleAlignment::getGammaErr(int moduleID) const
189  {
190  unsigned module = moduleID - 1;
191  if (module >= c_numModules) {
192  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
193  return 0;
194  }
195  return m_errGamma[module];
196  }
197 
198  double TOPCalModuleAlignment::getXErr(int moduleID) const
199  {
200  unsigned module = moduleID - 1;
201  if (module >= c_numModules) {
202  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
203  return 0;
204  }
205  return m_errX[module];
206  }
207 
208  double TOPCalModuleAlignment::getYErr(int moduleID) const
209  {
210  unsigned module = moduleID - 1;
211  if (module >= c_numModules) {
212  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
213  return 0;
214  }
215  return m_errY[module];
216  }
217 
218  double TOPCalModuleAlignment::getZErr(int moduleID) const
219  {
220  unsigned module = moduleID - 1;
221  if (module >= c_numModules) {
222  B2WARNING("Invalid module number, returning 0 (" << ClassName() << ")");
223  return 0;
224  }
225  return m_errZ[module];
226  }
227 
228  bool TOPCalModuleAlignment::isCalibrated(int moduleID) const
229  {
230  unsigned module = moduleID - 1;
231  if (module >= c_numModules) return false ;
232  return m_status[module] == c_Calibrated;
233  }
234 
235  bool TOPCalModuleAlignment::isDefault(int moduleID) const
236  {
237  unsigned module = moduleID - 1;
238  if (module >= c_numModules) return false ;
239  return m_status[module] == c_Default;
240  }
241 
242  bool TOPCalModuleAlignment::isUnusable(int moduleID) const
243  {
244  unsigned module = moduleID - 1;
245  if (module >= c_numModules) return false ;
246  return m_status[module] == c_Unusable;
247  }
248 
249  bool TOPCalModuleAlignment::areAllCalibrated() const
250  {
251  for (int i = 0; i < c_numModules; i++) {
252  if (m_status[i] != c_Calibrated) return false;
253  }
254  return true;
255  }
256 
257  bool TOPCalModuleAlignment::areAllPrecise(double spatialPrecision,
258  double angularPrecision) const
259  {
260  for (int i = 0; i < c_numModules; i++) {
261  if (m_errAlpha[i] > angularPrecision) return false;
262  if (m_errBeta[i] > angularPrecision) return false;
263  if (m_errGamma[i] > angularPrecision) return false;
264  if (m_errX[i] > spatialPrecision) return false;
265  if (m_errY[i] > spatialPrecision) return false;
266  if (m_errZ[i] > spatialPrecision) return false;
267  }
268  return true;
269  }
270 
272 } // namespace Belle2
273 
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19