Belle II Software development
GlobalParam.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <alignment/GlobalParam.h>
10
11#include <alignment/Hierarchy.h>
12#include <framework/geometry/B2Vector3.h>
13#include <framework/logging/Logger.h>
14#include <vxd/geometry/GeoCache.h>
15
16#include <map>
17#include <string>
18#include <vector>
19
20namespace Belle2 {
25 namespace alignment {
26 //std::tuple<BeamSpot, VXDAlignment, CDCAlignment, CDCLayerAlignment, CDCTimeWalks, CDCTimeZeros, CDCXtRelations, BKLMAlignment, EKLMAlignment> dbvector = {};
27
29 template <>
30 unsigned short GlobalParamSet<BeamSpot>::getGlobalUniqueID() const { return 1; }
33 template <>
34 double GlobalParamSet<BeamSpot>::getGlobalParam(unsigned short element, unsigned short param)
35 {
36 this->ensureConstructed();
37 if (element != 0 or param > 3) {
38 B2ERROR("Invalid global BeamSpot parameter id");
39 return 0;
40 }
41
42 if (auto bp = dynamic_cast<BeamSpot*>(this->getDBObj()))
43 return bp->getIPPosition()[param - 1];
44
45 B2ERROR("Could not get value for BeamSpot");
46 return 0.;
47 }
49 template <>
50 void GlobalParamSet<BeamSpot>::setGlobalParam(double value, unsigned short element, unsigned short param)
51 {
52 this->ensureConstructed();
53 if (element != 0 or param > 3) {
54 B2ERROR("Invalid global BeamSpot id");
55 return;
56 }
57 if (auto bp = dynamic_cast<BeamSpot*>(this->getDBObj())) {
58 B2Vector3D vertex = bp->getIPPosition();
59 vertex[param - 1] = value;
60 bp->setIP(vertex, bp->getIPPositionCovMatrix());
61 } else {
62 B2ERROR("Could not set value for BeamSpot");
63 }
64
65 }
67 template <>
68 std::vector<std::pair<unsigned short, unsigned short>> GlobalParamSet<BeamSpot>::listGlobalParams()
69 {
70 return {{0, 1}, {0, 2}, {0, 3}};
71 }
72
73
74 GlobalParamVector::GlobalParamVector(const std::vector< std::string >& components) : m_components(components) {}
75
76 void GlobalParamVector::updateGlobalParam(double difference, short unsigned int uniqueID, short unsigned int element,
77 short unsigned int param)
78 {
79 // TODO: niw can be replaced by other fcn updateGlobalParam of GlobalParamSetAccess
80 auto prev = getGlobalParam(uniqueID, element, param);
81 setGlobalParam(prev + difference, uniqueID, element, param);
82 }
83 void GlobalParamVector::setGlobalParam(double value, short unsigned int uniqueID, short unsigned int element,
84 short unsigned int param)
85 {
86 auto dbObj = m_vector.find(uniqueID);
87 if (dbObj != m_vector.end()) {
88 dbObj->second->setGlobalParam(value, element, param);
89 } else {
90 B2WARNING("Did not found DB object with unique id " << uniqueID << " in global vector. Cannot set value for element " << element <<
91 " and parameter " << param);
92 }
93 }
94 double GlobalParamVector::getGlobalParam(short unsigned int uniqueID, short unsigned int element, short unsigned int param)
95 {
96 auto dbObj = m_vector.find(uniqueID);
97 if (dbObj != m_vector.end()) {
98 return dbObj->second->getGlobalParam(element, param);
99 } else {
100 B2WARNING("Did not found DB object with unique id " << uniqueID << " in global vector. Cannot get value for element " << element <<
101 " and parameter " << param << ". Returning 0.");
102 return 0.;
103 }
104 }
105 std::vector< std::tuple< short unsigned int, short unsigned int, short unsigned int > > GlobalParamVector::listGlobalParams()
106 {
107 std::vector<std::tuple<unsigned short, unsigned short, unsigned short>> params;
108 for (auto& uID_DBObj : m_vector) {
109 for (auto element_param : uID_DBObj.second->listGlobalParams()) {
110 params.push_back({uID_DBObj.first, element_param.first, element_param.second});
111 }
112 }
113 return params;
114 }
115 std::vector< TObject* > GlobalParamVector::releaseObjects(bool onlyConstructed)
116 {
117 std::vector<TObject*> result;
118 for (auto& uID_DBObj : m_vector) {
119 if (onlyConstructed and not uID_DBObj.second->isConstructed())
120 continue;
121
122 result.push_back({uID_DBObj.second->releaseObject()});
123 }
124 return result;
125 }
127 {
128 for (auto& uID_DBObj : m_vector) {
129 uID_DBObj.second->loadFromDBObjPtr();
130 }
131 }
133 {
134 for (auto& uID_DBObj : m_vector) {
135 uID_DBObj.second->loadFromDB(event);
136 }
137 }
139 {
140 for (auto interface : m_subDetectorInterfacesVector) {
141 interface->setupAlignmentHierarchy(hierarchy);
142 }
143
144 }
146 {
147 for (auto& uID_DBObj : m_vector) {
148 if (not uID_DBObj.second->isConstructed()) uID_DBObj.second->construct();
149 }
150 }
152 std::vector< std::tuple< short unsigned int, short unsigned int, short unsigned int, double > >& results)
153 {
154 for (auto interface : m_subDetectorInterfacesVector) {
155 interface->readFromResult(results, *this);
156 }
157 }
158
160 VXDGlobalParamInterface::E_VXDHierarchyType::c_Full;
163
165 {
166 try {
167 auto& rigidBodyHierarchy = dynamic_cast<RigidBodyHierarchy&>(hierarchy);
168 auto& geo = VXD::GeoCache::getInstance();
169 // Set-up hierarchy
170 DBObjPtr<VXDAlignment> vxdAlignments;
171 if (s_hierarchyType == c_None) {
172 // Nothing to be done
173 return;
174
175 } else if (s_hierarchyType == c_Flat) {
176 for (auto& sensor : geo.getListOfSensors()) {
177 //TODO: Don't we have better way to distinguish PXD and SVD?
178 // For PXD
179 if (sensor.getLayerNumber() <= 2 and !s_enablePXD)
180 continue;
181 // SVD layer > 2
182 if (sensor.getLayerNumber() > 2 and !s_enableSVD)
183 continue;
184
185 rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(sensor, VxdID(0, 0, 0, 1),
186 geo.getSensorInfo(sensor).getTransformation(true));
187 }
188 } else if (s_hierarchyType == c_HalfShells) {
198 for (auto& halfShellPlacement : geo.getHalfShellPlacements()) {
199 // For PXD
200 if (halfShellPlacement.first.getLayerNumber() <= 2 and !s_enablePXD)
201 continue;
202 // for SVD - layer > 2
203 if (halfShellPlacement.first.getLayerNumber() > 2 and !s_enableSVD)
204 continue;
205
206 TGeoHMatrix trafoHalfShell = halfShellPlacement.second;
207 trafoHalfShell *= geo.getTGeoFromRigidBodyParams(
208 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dU),
209 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dV),
210 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dW),
211 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dAlpha),
212 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dBeta),
213 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dGamma)
214 );
215 rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, alignment::EmptyGlobalParamSet>(halfShellPlacement.first, 0, trafoHalfShell);
216
217 for (auto& ladderPlacement : geo.getLadderPlacements(halfShellPlacement.first)) {
218 // Updated trafo
219 TGeoHMatrix trafoLadder = ladderPlacement.second;
220 trafoLadder *= geo.getTGeoFromRigidBodyParams(
221 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dU),
222 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dV),
223 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dW),
224 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dAlpha),
225 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dBeta),
226 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dGamma)
227 );
228 // Do not insert ladder, but insert sensor directly into half-shells below, with the additional transformation from ladder
229 //rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(ladderPlacement.first, halfShellPlacement.first, trafoLadder);
230
231 for (auto& sensorPlacement : geo.getSensorPlacements(ladderPlacement.first)) {
232 // Updated trafo
233 TGeoHMatrix trafoSensor = sensorPlacement.second;
234 trafoSensor *= geo.getTGeoFromRigidBodyParams(
235 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dU),
236 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dV),
237 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dW),
238 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dAlpha),
239 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dBeta),
240 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dGamma)
241 );
242 rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(sensorPlacement.first, halfShellPlacement.first,
243 trafoLadder * trafoSensor);
244
245
246 }
247 }
248 }
249 } else if (s_hierarchyType == c_Full) {
261 for (auto& halfShellPlacement : geo.getHalfShellPlacements()) {
262 // For PXD
263 if (halfShellPlacement.first.getLayerNumber() <= 2 and !s_enablePXD)
264 continue;
265 // for SVD - layer > 2
266 if (halfShellPlacement.first.getLayerNumber() > 2 and !s_enableSVD)
267 continue;
268
269 TGeoHMatrix trafoHalfShell = halfShellPlacement.second;
270 trafoHalfShell *= geo.getTGeoFromRigidBodyParams(
271 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dU),
272 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dV),
273 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dW),
274 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dAlpha),
275 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dBeta),
276 vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dGamma)
277 );
278 rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, alignment::EmptyGlobalParamSet>(halfShellPlacement.first, 0, trafoHalfShell);
279
280 for (auto& ladderPlacement : geo.getLadderPlacements(halfShellPlacement.first)) {
281 // Updated trafo
282 TGeoHMatrix trafoLadder = ladderPlacement.second;
283 trafoLadder *= geo.getTGeoFromRigidBodyParams(
284 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dU),
285 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dV),
286 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dW),
287 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dAlpha),
288 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dBeta),
289 vxdAlignments->get(ladderPlacement.first, VXDAlignment::dGamma)
290 );
291 rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(ladderPlacement.first, halfShellPlacement.first, trafoLadder);
292
293 for (auto& sensorPlacement : geo.getSensorPlacements(ladderPlacement.first)) {
294 // Updated trafo
295 TGeoHMatrix trafoSensor = sensorPlacement.second;
296 trafoSensor *= geo.getTGeoFromRigidBodyParams(
297 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dU),
298 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dV),
299 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dW),
300 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dAlpha),
301 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dBeta),
302 vxdAlignments->get(sensorPlacement.first, VXDAlignment::dGamma)
303 );
304 rigidBodyHierarchy.insertTGeoTransform<VXDAlignment, VXDAlignment>(sensorPlacement.first, ladderPlacement.first, trafoSensor);
305
306
307 }
308 }
309 }
310 }
311 } catch (const std::bad_cast& e) {
312 // Bad cast
313 }
314 }
315
316 }
318}
This class contains the beam spot position and size modeled as a gaussian distribution in space.
Definition: BeamSpot.h:22
Class for accessing objects in the database.
Definition: DBObjPtr.h:21
Store event, run, and experiment numbers.
Definition: EventMetaData.h:33
VXD alignment (and maybe some calibration) parameters.
Definition: VXDAlignment.h:19
static const baseType dAlpha
Sensor/layer/ladder alignment in local alpha.
Definition: VXDAlignment.h:29
static const baseType dGamma
Sensor/layer/ladder alignment in local gamma.
Definition: VXDAlignment.h:33
static const baseType dW
Sensor/layer/ladder alignment in local w.
Definition: VXDAlignment.h:27
static const baseType dBeta
Sensor/layer/ladder alignment in local beta.
Definition: VXDAlignment.h:31
static const baseType dU
Sensor/layer/ladder alignment in local u.
Definition: VXDAlignment.h:23
static const baseType dV
Sensor/layer/ladder alignment in local v.
Definition: VXDAlignment.h:25
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:214
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Object representing no parameters.
Definition: GlobalParam.h:32
Class for alignment/calibration parameter hierarchy & constraints.
Definition: Hierarchy.h:41
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:207
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:205
virtual std::vector< std::pair< unsigned short, unsigned short > > listGlobalParams() override final
List global parameters in this DB object.
Definition: GlobalParam.h:209
virtual unsigned short getGlobalUniqueID() const override final
The DB object unique id in global calibration.
Definition: GlobalParam.h:202
std::vector< std::tuple< unsigned short, unsigned short, unsigned short > > listGlobalParams()
Create vector of all global parameters maintained by GlobalParamVector.
Definition: GlobalParam.cc:105
std::vector< TObject * > releaseObjects(bool onlyConstructed=true)
Get the vector of raw pointers to DB objects Caller takes the ownership of the objects and has to del...
Definition: GlobalParam.cc:115
GlobalParamVector(const std::vector< std::string > &components={})
Constructor.
Definition: GlobalParam.cc:74
std::map< unsigned short, std::unique_ptr< GlobalParamSetAccess > > m_vector
The vector (well, actually a map) of DB objects.
Definition: GlobalParam.h:492
std::vector< std::shared_ptr< IGlobalParamInterface > > m_subDetectorInterfacesVector
Vector of interfaces to run at specific points in the workflow.
Definition: GlobalParam.h:494
void setGlobalParam(double value, unsigned short uniqueID, unsigned short element, unsigned short param)
Set param value.
Definition: GlobalParam.cc:83
double getGlobalParam(unsigned short uniqueID, unsigned short element, unsigned short param)
Get parameter value.
Definition: GlobalParam.cc:94
void construct()
Construct all DB objects using default constructors (should be filled with zeros)
Definition: GlobalParam.cc:145
void postReadFromResult(std::vector< std::tuple< unsigned short, unsigned short, unsigned short, double > > &result)
Function calling interfaces to do post processing after reading millepede result into GlobalParamVect...
Definition: GlobalParam.cc:151
void postHierarchyChanged(GlobalDerivativesHierarchy &hierarchy)
Function calling interfaces to build alignment hierarchy after constants changed in DB.
Definition: GlobalParam.cc:138
void loadFromDB()
Load content of all objects in vector with values valid at current EventMetaData Uses DBObjPtr<DBObjT...
Definition: GlobalParam.cc:126
void updateGlobalParam(double difference, unsigned short uniqueID, unsigned short element, unsigned short param)
Add 'difference' to param value.
Definition: GlobalParam.cc:76
6D Hierarchy of rigid bodies
Definition: Hierarchy.h:144
static bool s_enablePXD
Enable PXD in hierarchy?
Definition: GlobalParam.h:85
static bool s_enableSVD
Enable SVD in hierarchy?
Definition: GlobalParam.h:87
virtual void setupAlignmentHierarchy(GlobalDerivativesHierarchy &hierarchy) override final
Very tentative function: not yet used.
Definition: GlobalParam.cc:164
E_VXDHierarchyType
Type of VXD hierarchy.
Definition: GlobalParam.h:76
static E_VXDHierarchyType s_hierarchyType
What type of hierarchy to use for VXD?
Definition: GlobalParam.h:83
Abstract base class for different kinds of events.