Belle II Software development
SVDTimeCalibrationsMonitorModule.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 <svd/modules/svdCalibration/SVDTimeCalibrationsMonitorModule.h>
10#include <vxd/geometry/GeoCache.h>
11#include <framework/datastore/StoreObjPtr.h>
12#include <framework/dataobjects/EventMetaData.h>
13
14using namespace Belle2;
15
16//-----------------------------------------------------------------
17// Register the Module
18//-----------------------------------------------------------------
19REG_MODULE(SVDTimeCalibrationsMonitor);
20
21//-----------------------------------------------------------------
22// Implementation
23//-----------------------------------------------------------------
24
25SVDTimeCalibrationsMonitorModule::SVDTimeCalibrationsMonitorModule() : Module()
26{
27 // Set module properties
28 setDescription("Module to produce a list of histograms showing the uploaded calibration constants");
29
30 // Parameter definitions
31 addParam("outputFileName", m_rootFileName, "Name of output root file.", std::string("SVDTimeCalibrationMonitor_output.root"));
32
33 addParam("timeAlgo", m_timeAlgo, "Name of the time algorithm: CoG6, CoG3, ELS3.", std::string("CoG3"));
34}
35
36void SVDTimeCalibrationsMonitorModule::beginRun()
37{
38
39 m_rootFilePtr = new TFile(m_rootFileName.c_str(), "RECREATE");
40 //tree initialization
41 m_tree = new TTree("calibTime", "RECREATE");
42 b_exp = m_tree->Branch("exp", &m_exp, "exp/i");
43 b_run = m_tree->Branch("run", &m_run, "run/i");
44 b_layer = m_tree->Branch("layer", &m_layer, "layer/i");
45 b_ladder = m_tree->Branch("ladder", &m_ladder, "ladder/i");
46 b_sensor = m_tree->Branch("sensor", &m_sensor, "sensor/i");
47 b_side = m_tree->Branch("side", &m_side, "side/i");
48 b_triggerBin = m_tree->Branch("triggerBin", &m_triggerBin, "triggerBin/i");
49 b_c0 = m_tree->Branch("c0", &m_c0, "c0/F");
50 b_c1 = m_tree->Branch("c1", &m_c1, "c1/F");
51 b_c2 = m_tree->Branch("c2", &m_c2, "c2/F");
52 b_c3 = m_tree->Branch("c3", &m_c3, "c3/F");
53
54
55 if (TString(m_timeAlgo).Contains("CoG6") && ! m_CoG6TimeCal.isValid())
56 B2WARNING("No valid SVDCoGTimeCalibrations for the requested IoV");
57
58 if (TString(m_timeAlgo).Contains("CoG3") && ! m_CoG3TimeCal.isValid())
59 B2WARNING("No valid SVD3SampleCoGTimeCalibrations for the requested IoV");
60
61
62 if (TString(m_timeAlgo).Contains("ELS3") && ! m_ELS3TimeCal.isValid())
63 B2WARNING("No valid SVD3SampleELSTimeCalibrations for the requested IoV");
64
65
66}
67
68void SVDTimeCalibrationsMonitorModule::event()
69{
70
71 StoreObjPtr<EventMetaData> meta;
72 m_run = meta->getRun();
73 m_exp = meta->getExperiment();
74
75 if (TString(m_timeAlgo).Contains("CoG6"))
76 if (!m_CoG6TimeCal.isValid())
77 return;
78
79 if (TString(m_timeAlgo).Contains("CoG3"))
80 if (!m_CoG3TimeCal.isValid())
81 return;
82
83 if (TString(m_timeAlgo).Contains("ELS3"))
84 if (!m_ELS3TimeCal.isValid())
85 return;
86
87
88 //call for a geometry instance
89 VXD::GeoCache& aGeometry = VXD::GeoCache::getInstance();
90 std::set<Belle2::VxdID> svdLayers = aGeometry.getLayers(VXD::SensorInfoBase::SVD);
91 std::set<Belle2::VxdID>::iterator itSvdLayers = svdLayers.begin();
92
93 while ((itSvdLayers != svdLayers.end()) && (itSvdLayers->getLayerNumber() != 7)) { //loop on Layers
94
95 std::set<Belle2::VxdID> svdLadders = aGeometry.getLadders(*itSvdLayers);
96 std::set<Belle2::VxdID>::iterator itSvdLadders = svdLadders.begin();
97
98 while (itSvdLadders != svdLadders.end()) { //loop on Ladders
99
100 std::set<Belle2::VxdID> svdSensors = aGeometry.getSensors(*itSvdLadders);
101 std::set<Belle2::VxdID>::iterator itSvdSensors = svdSensors.begin();
102 B2DEBUG(1, " svd sensor info " << * (svdSensors.begin()));
103
104 while (itSvdSensors != svdSensors.end()) { //loop on sensors
105 B2DEBUG(1, " svd sensor info " << *itSvdSensors);
106
107 m_layer = itSvdSensors->getLayerNumber();
108 m_ladder = itSvdSensors->getLadderNumber();
109 m_sensor = itSvdSensors->getSensorNumber();
110 Belle2::VxdID theVxdID(m_layer, m_ladder, m_sensor);
111
112 for (m_side = 0; m_side < 2; m_side++) {
113
114 for (m_triggerBin = 0; m_triggerBin < 4; m_triggerBin++) {
115
116 if (TString(m_timeAlgo).Contains("CoG6")) {
117 m_CoG6TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 0 /*raw time*/, m_triggerBin);
118 m_CoG6TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 1 /*raw time*/, m_triggerBin);
119 m_CoG6TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 2 /*raw time*/, m_triggerBin);
120 m_CoG6TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 4 /*raw time*/, m_triggerBin);
121 }
122
123 if (TString(m_timeAlgo).Contains("CoG3")) {
124 double f0 = m_CoG3TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 0 /*raw time*/, m_triggerBin);
125 double f1 = m_CoG3TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 1 /*raw time*/, m_triggerBin);
126 double f2 = m_CoG3TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 2 /*raw time*/, m_triggerBin);
127 double f4 = m_CoG3TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 4 /*raw time*/, m_triggerBin);
128
129 m_c0 = f0;
130 m_c1 = 1. / 12 * (-21 * f0 + 32 * f1 - 12 * f2 + f4);
131 m_c2 = 1. / 8 * (7 * f0 - 16 * f1 + 10 * f2 - f4);
132 m_c3 = 1. / 24 * (-3 * f0 + 8 * f1 - 6 * f2 + f4);
133
134 }
135
136 if (TString(m_timeAlgo).Contains("ELS3")) {
137 m_ELS3TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 0 /*raw time*/, m_triggerBin);
138 m_ELS3TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 1 /*raw time*/, m_triggerBin);
139 m_ELS3TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 2 /*raw time*/, m_triggerBin);
140 m_ELS3TimeCal.getCorrectedTime(theVxdID, m_side, 0 /*strip*/, 4 /*raw time*/, m_triggerBin);
141 }
142
143 m_tree->Fill();
144 }
145
146 }
147 ++itSvdSensors;
148 }
149 ++itSvdLadders;
150 }
151 ++itSvdLayers;
152 }
153
154}
155
156void SVDTimeCalibrationsMonitorModule::endRun()
157{
158 B2RESULT("******************************************");
159 B2RESULT("** UNIQUE IDs of calibration DB objects **");
160 B2RESULT("");
161 if (TString(m_timeAlgo).Contains("CoG6")) {
162 if (m_CoG6TimeCal.isValid())
163 B2RESULT(" - SVDCoGTimeCalibrations:" << m_CoG6TimeCal.getUniqueID());
164 else
165 B2WARNING("No valid SVDCoGTimeCalibrations for the requested IoV");
166 }
167
168 if (TString(m_timeAlgo).Contains("CoG3")) {
169 if (m_CoG3TimeCal.isValid())
170 B2RESULT(" - SVD3SampleCoGTimeCalibrations:" << m_CoG3TimeCal.getUniqueID());
171 else
172 B2WARNING("No valid SVD3SampleCoGTimeCalibrations for the requested IoV");
173 }
174
175 if (TString(m_timeAlgo).Contains("ELS3")) {
176 if (m_ELS3TimeCal.isValid())
177 B2RESULT(" - SVD3SampleELSTimeCalibrations:" << m_ELS3TimeCal.getUniqueID());
178 else
179 B2WARNING("No valid SVD3SampleELSTimeCalibrations for the requested IoV");
180 }
181
182 if (m_rootFilePtr != nullptr) {
183
184 m_rootFilePtr->cd();
185
186 //write the tree
187 m_tree->Write();
188
189 m_rootFilePtr->Close();
190 B2RESULT("The rootfile containing the list of histograms has been filled and closed [Time].");
191
192
193 }
194}
195
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
Belle2::Module::Module
Module()
Constructor.
Definition Module.cc:30
Belle2::SVDTimeCalibrationsMonitorModule::m_tree
TTree * m_tree
pointer at tree containing the mean and RMS of calibration constants
Definition SVDTimeCalibrationsMonitorModule.h:55
Belle2::SVDTimeCalibrationsMonitorModule::SVDTimeCalibrationsMonitorModule
SVDTimeCalibrationsMonitorModule()
Constructor: Sets the description, the properties and the parameters of the module.
Definition SVDTimeCalibrationsMonitorModule.cc:25
Belle2::SVDTimeCalibrationsMonitorModule::event
virtual void event() override
fill trees and histograms
Definition SVDTimeCalibrationsMonitorModule.cc:68
Belle2::SVDTimeCalibrationsMonitorModule::endRun
virtual void endRun() override
print the payloads uniqueID and write tree and histograms to the rootfile
Definition SVDTimeCalibrationsMonitorModule.cc:156
Belle2::SVDTimeCalibrationsMonitorModule::m_CoG3TimeCal
SVD3SampleCoGTimeCalibrations m_CoG3TimeCal
CoG3 time calibrations payload.
Definition SVDTimeCalibrationsMonitorModule.h:87
Belle2::SVDTimeCalibrationsMonitorModule::m_CoG6TimeCal
SVDCoGTimeCalibrations m_CoG6TimeCal
CoG6 time calibrations payload.
Definition SVDTimeCalibrationsMonitorModule.h:86
Belle2::SVDTimeCalibrationsMonitorModule::beginRun
virtual void beginRun() override
initialize the TTrees and check validities of payloads
Definition SVDTimeCalibrationsMonitorModule.cc:36
Belle2::SVDTimeCalibrationsMonitorModule::m_ELS3TimeCal
SVD3SampleELSTimeCalibrations m_ELS3TimeCal
ELS3 time calibrations payload.
Definition SVDTimeCalibrationsMonitorModule.h:88
Belle2::SVDTimeCalibrationsMonitorModule::m_rootFilePtr
TFile * m_rootFilePtr
pointer at root file used for storing histograms
Definition SVDTimeCalibrationsMonitorModule.h:54
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition StoreObjPtr.h:96
Belle2::VXD::GeoCache
Class to facilitate easy access to sensor information of the VXD like coordinate transformations or p...
Definition GeoCache.h:38
Belle2::VXD::GeoCache::getLayers
const std::set< Belle2::VxdID > getLayers(SensorInfoBase::SensorType sensortype=SensorInfoBase::VXD)
Return a set of all known Layers.
Definition GeoCache.cc:176
Belle2::VXD::GeoCache::getSensors
const std::set< Belle2::VxdID > & getSensors(Belle2::VxdID ladder) const
Return a set of all sensor IDs belonging to a given ladder.
Definition GeoCache.cc:204
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition GeoCache.cc:214
Belle2::VXD::GeoCache::getLadders
const std::set< Belle2::VxdID > & getLadders(Belle2::VxdID layer) const
Return a set of all ladder IDs belonging to a given layer.
Definition GeoCache.cc:193
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition VxdID.h:32
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition Module.h:559
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17