Belle II Software  release-05-01-25
GlobalParam.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2015 Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Tadeas Bilka *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <alignment/GlobalParam.h>
12 
13 #include <alignment/Hierarchy.h>
14 #include <cdc/dbobjects/CDCLayerAlignment.h>
15 #include <framework/database/Database.h>
16 #include <framework/geometry/B2Vector3.h>
17 #include <framework/logging/Logger.h>
18 #include <vxd/geometry/GeoCache.h>
19 
20 #include <map>
21 #include <string>
22 #include <vector>
23 
24 namespace Belle2 {
29  namespace alignment {
30  //std::tuple<BeamSpot, VXDAlignment, CDCAlignment, CDCLayerAlignment, CDCTimeWalks, CDCTimeZeros, CDCXtRelations, BKLMAlignment, EKLMAlignment> dbvector = {};
31 
33  template <>
34  unsigned short GlobalParamSet<BeamSpot>::getGlobalUniqueID() const { return 1; }
37  template <>
38  double GlobalParamSet<BeamSpot>::getGlobalParam(unsigned short element, unsigned short param)
39  {
40  this->ensureConstructed();
41  if (element != 0 or param > 3) {
42  B2ERROR("Invalid global BeamSpot parameter id");
43  return 0;
44  }
45 
46  if (auto bp = dynamic_cast<BeamSpot*>(this->getDBObj()))
47  return bp->getIPPosition()[param - 1];
48 
49  B2ERROR("Could not get value for BeamSpot");
50  return 0.;
51  }
53  template <>
54  void GlobalParamSet<BeamSpot>::setGlobalParam(double value, unsigned short element, unsigned short param)
55  {
56  this->ensureConstructed();
57  if (element != 0 or param > 3) {
58  B2ERROR("Invalid global BeamSpot id");
59  return;
60  }
61  if (auto bp = dynamic_cast<BeamSpot*>(this->getDBObj())) {
62  B2Vector3D vertex = bp->getIPPosition();
63  vertex[param - 1] = value;
64  bp->setIP(vertex, bp->getIPPositionCovMatrix());
65  } else {
66  B2ERROR("Could not set value for BeamSpot");
67  }
68 
69  }
71  template <>
72  std::vector<std::pair<unsigned short, unsigned short>> GlobalParamSet<BeamSpot>::listGlobalParams()
73  {
74  return {{0, 1}, {0, 2}, {0, 3}};
75  }
76 
77 
78  GlobalParamVector::GlobalParamVector(const std::vector< std::string >& components) : m_components(components) {}
79 
80  void GlobalParamVector::updateGlobalParam(double difference, short unsigned int uniqueID, short unsigned int element,
81  short unsigned int param)
82  {
83  // TODO: niw can be replaced by other fcn updateGlobalParam of GlobalParamSetAccess
84  auto prev = getGlobalParam(uniqueID, element, param);
85  setGlobalParam(prev + difference, uniqueID, element, param);
86  }
87  void GlobalParamVector::setGlobalParam(double value, short unsigned int uniqueID, short unsigned int element,
88  short unsigned int param)
89  {
90  auto dbObj = m_vector.find(uniqueID);
91  if (dbObj != m_vector.end()) {
92  dbObj->second->setGlobalParam(value, element, param);
93  } else {
94  B2WARNING("Did not found DB object with unique id " << uniqueID << " in global vector. Cannot set value for element " << element <<
95  " and parameter " << param);
96  }
97  }
98  double GlobalParamVector::getGlobalParam(short unsigned int uniqueID, short unsigned int element, short unsigned int param)
99  {
100  auto dbObj = m_vector.find(uniqueID);
101  if (dbObj != m_vector.end()) {
102  return dbObj->second->getGlobalParam(element, param);
103  } else {
104  B2WARNING("Did not found DB object with unique id " << uniqueID << " in global vector. Cannot get value for element " << element <<
105  " and parameter " << param << ". Returning 0.");
106  return 0.;
107  }
108  }
109  std::vector< std::tuple< short unsigned int, short unsigned int, short unsigned int > > GlobalParamVector::listGlobalParams()
110  {
111  std::vector<std::tuple<unsigned short, unsigned short, unsigned short>> params;
112  for (auto& uID_DBObj : m_vector) {
113  for (auto element_param : uID_DBObj.second->listGlobalParams()) {
114  params.push_back({uID_DBObj.first, element_param.first, element_param.second});
115  }
116  }
117  return params;
118  }
119  std::vector< TObject* > GlobalParamVector::releaseObjects(bool onlyConstructed)
120  {
121  std::vector<TObject*> result;
122  for (auto& uID_DBObj : m_vector) {
123  if (onlyConstructed and not uID_DBObj.second->isConstructed())
124  continue;
125 
126  result.push_back({uID_DBObj.second->releaseObject()});
127  }
128  return result;
129  }
130  void GlobalParamVector::loadFromDB()
131  {
132  for (auto& uID_DBObj : m_vector) {
133  uID_DBObj.second->loadFromDBObjPtr();
134  }
135  }
136  void GlobalParamVector::loadFromDB(const EventMetaData& event)
137  {
138  for (auto& uID_DBObj : m_vector) {
139  uID_DBObj.second->loadFromDB(event);
140  }
141  }
142  void GlobalParamVector::postHierarchyChanged(GlobalDerivativesHierarchy& hierarchy)
143  {
144  for (auto interface : m_subDetectorInterfacesVector) {
145  interface->setupAlignmentHierarchy(hierarchy);
146  }
147 
148  }
149  void GlobalParamVector::construct()
150  {
151  for (auto& uID_DBObj : m_vector) {
152  if (not uID_DBObj.second->isConstructed()) uID_DBObj.second->construct();
153  }
154  }
155  void GlobalParamVector::postReadFromResult(
156  std::vector< std::tuple< short unsigned int, short unsigned int, short unsigned int, double > >& result)
157  {
158  for (auto interface : m_subDetectorInterfacesVector) {
159  interface->readFromResult(result, *this);
160  }
161  }
162 
163  VXDGlobalParamInterface::E_VXDHierarchyType VXDGlobalParamInterface::s_hierarchyType =
164  VXDGlobalParamInterface::E_VXDHierarchyType::c_Full;
165  bool VXDGlobalParamInterface::s_enablePXD = true;
166  bool VXDGlobalParamInterface::s_enableSVD = true;
167 
168  void VXDGlobalParamInterface::setupAlignmentHierarchy(GlobalDerivativesHierarchy& hierarchy)
169  {
170  try {
171  auto& rigidBodyHierarchy = dynamic_cast<RigidBodyHierarchy&>(hierarchy);
172  auto& geo = VXD::GeoCache::getInstance();
173  // Set-up hierarchy
174  DBObjPtr<VXDAlignment> vxdAlignments;
175  if (s_hierarchyType == c_None) {
176  // Nothing to be done
177  return;
178 
179  } else if (s_hierarchyType == c_Flat) {
180  for (auto& sensor : geo.getListOfSensors()) {
181  //TODO: Don't we have better way to distinguish PXD and SVD?
182  // For PXD
183  if (sensor.getLayerNumber() <= 2 and !s_enablePXD)
184  continue;
185  // SVD layer > 2
186  if (sensor.getLayerNumber() > 2 and !s_enableSVD)
187  continue;
188 
189  rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(sensor, VxdID(0, 0, 0, 1),
190  geo.get(sensor).getTransformation(true));
191  }
192  } else if (s_hierarchyType == c_HalfShells) {
202  for (auto& halfShellPlacement : geo.getHalfShellPlacements()) {
203  // For PXD
204  if (halfShellPlacement.first.getLayerNumber() <= 2 and !s_enablePXD)
205  continue;
206  // for SVD - layer > 2
207  if (halfShellPlacement.first.getLayerNumber() > 2 and !s_enableSVD)
208  continue;
209 
210  TGeoHMatrix trafoHalfShell = halfShellPlacement.second;
211  trafoHalfShell *= geo.getTGeoFromRigidBodyParams(
212  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dU),
213  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dV),
214  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dW),
215  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dAlpha),
216  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dBeta),
217  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dGamma)
218  );
219  rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, alignment::EmptyGlobalParamSet>(halfShellPlacement.first, 0, trafoHalfShell);
220 
221  for (auto& ladderPlacement : geo.getLadderPlacements(halfShellPlacement.first)) {
222  // Updated trafo
223  TGeoHMatrix trafoLadder = ladderPlacement.second;
224  trafoLadder *= geo.getTGeoFromRigidBodyParams(
225  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dU),
226  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dV),
227  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dW),
228  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dAlpha),
229  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dBeta),
230  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dGamma)
231  );
232  // Do not insert ladder, but insert sensor directly into half-shells bellow, with the additional transformation from ladder
233  //rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(ladderPlacement.first, halfShellPlacement.first, trafoLadder);
234 
235  for (auto& sensorPlacement : geo.getSensorPlacements(ladderPlacement.first)) {
236  // Updated trafo
237  TGeoHMatrix trafoSensor = sensorPlacement.second;
238  trafoSensor *= geo.getTGeoFromRigidBodyParams(
239  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dU),
240  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dV),
241  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dW),
242  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dAlpha),
243  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dBeta),
244  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dGamma)
245  );
246  rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(sensorPlacement.first, halfShellPlacement.first,
247  trafoLadder * trafoSensor);
248 
249 
250  }
251  }
252  }
253  } else if (s_hierarchyType == c_Full) {
265  for (auto& halfShellPlacement : geo.getHalfShellPlacements()) {
266  // For PXD
267  if (halfShellPlacement.first.getLayerNumber() <= 2 and !s_enablePXD)
268  continue;
269  // for SVD - layer > 2
270  if (halfShellPlacement.first.getLayerNumber() > 2 and !s_enableSVD)
271  continue;
272 
273  TGeoHMatrix trafoHalfShell = halfShellPlacement.second;
274  trafoHalfShell *= geo.getTGeoFromRigidBodyParams(
275  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dU),
276  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dV),
277  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dW),
278  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dAlpha),
279  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dBeta),
280  vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dGamma)
281  );
282  rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, alignment::EmptyGlobalParamSet>(halfShellPlacement.first, 0, trafoHalfShell);
283 
284  for (auto& ladderPlacement : geo.getLadderPlacements(halfShellPlacement.first)) {
285  // Updated trafo
286  TGeoHMatrix trafoLadder = ladderPlacement.second;
287  trafoLadder *= geo.getTGeoFromRigidBodyParams(
288  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dU),
289  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dV),
290  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dW),
291  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dAlpha),
292  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dBeta),
293  vxdAlignments->get(ladderPlacement.first, VXDAlignment::dGamma)
294  );
295  rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(ladderPlacement.first, halfShellPlacement.first, trafoLadder);
296 
297  for (auto& sensorPlacement : geo.getSensorPlacements(ladderPlacement.first)) {
298  // Updated trafo
299  TGeoHMatrix trafoSensor = sensorPlacement.second;
300  trafoSensor *= geo.getTGeoFromRigidBodyParams(
301  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dU),
302  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dV),
303  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dW),
304  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dAlpha),
305  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dBeta),
306  vxdAlignments->get(sensorPlacement.first, VXDAlignment::dGamma)
307  );
308  rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(sensorPlacement.first, ladderPlacement.first, trafoSensor);
309 
310 
311  }
312  }
313  }
314  }
315  } catch (const std::bad_cast& e) {
316  // Bad cast
317  }
318  }
319 
320  }
322 }
Belle2::alignment::GlobalParamSet::setGlobalParam
virtual void setGlobalParam(double value, unsigned short element, unsigned short param) override final
Set global parameter of the DB object by its element and parameter number.
Definition: GlobalParam.h:216
Belle2::alignment::GlobalParamSet::getGlobalUniqueID
virtual unsigned short getGlobalUniqueID() const override final
The DB object unique id in global calibration.
Definition: GlobalParam.h:211
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
Belle2::alignment::GlobalParamSet::getGlobalParam
virtual double getGlobalParam(unsigned short element, unsigned short param) override final
Get global parameter of the DB object by its element and parameter number Note this is not const,...
Definition: GlobalParam.h:214
Belle2::alignment::GlobalDerivativesHierarchy
Class for alignment/calibration parameter hierarchy & constraints.
Definition: Hierarchy.h:51
Belle2::BeamSpot
This class contains the beam spot position and size modeled as a gaussian distribution in space.
Definition: BeamSpot.h:32
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:31
Belle2::B2Vector3< double >
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::alignment::RigidBodyHierarchy
6D Hierarchy of rigid bodies
Definition: Hierarchy.h:154
Belle2::alignment::GlobalParamSet::listGlobalParams
virtual std::vector< std::pair< unsigned short, unsigned short > > listGlobalParams() override final
List global parameters in this DB object.
Definition: GlobalParam.h:218
Belle2::alignment::GlobalParamVector::GlobalParamVector
GlobalParamVector(const std::vector< std::string > &components={})
Constructor.
Definition: GlobalParam.cc:86
Belle2::alignment::VXDGlobalParamInterface::E_VXDHierarchyType
E_VXDHierarchyType
Type of VXD hierarchy.
Definition: GlobalParam.h:85
Belle2::VXDAlignment
VXD alignment (and maybe some calibration) parameters.
Definition: VXDAlignment.h:29