Belle II Software development
TOPPhotonYieldsCollectorModule.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 <top/modules/collectors/TOPPhotonYieldsCollectorModule.h>
10#include <top/reconstruction_cpp/TOPTrack.h>
11#include <top/geometry/TOPGeometryPar.h>
12
13// framework aux
14#include <framework/gearbox/Unit.h>
15#include <framework/logging/Logger.h>
16
17// root
18#include <TH1F.h>
19#include <TH2F.h>
20#include <TProfile.h>
21
22using namespace std;
23
24namespace Belle2 {
29
30 using namespace TOP;
31
32 //-----------------------------------------------------------------
34 //-----------------------------------------------------------------
35
36 REG_MODULE(TOPPhotonYieldsCollector);
37
38 //-----------------------------------------------------------------
39 // Implementation
40 //-----------------------------------------------------------------
41
43 {
44 // set module description and processing properties
45 setDescription("A collector for photon pixel yields aimed for PMT ageing studies and for finding optically decoupled PMT's");
47
48 // module parameters
49 addParam("sample", m_sample, "sample type: one of dimuon or bhabha", std::string("dimuon"));
50 addParam("deltaEcms", m_deltaEcms, "c.m.s energy window (half size) if sample is dimuon or bhabha", 0.1);
51 addParam("dr", m_dr, "cut on POCA in r", 2.0);
52 addParam("dz", m_dz, "cut on POCA in abs(z)", 4.0);
53
54 }
55
56
58 {
59 // input collections
60 m_digits.isRequired();
61 m_tracks.isRequired();
62 m_extHits.isRequired();
63 m_recBunch.isRequired();
64 m_asicMask.isRequired();
65 m_associatedPDFs.isRequired();
66
67 // set track selector
68 if (m_sample == "dimuon" or m_sample == "bhabha") {
70 m_selector.setDeltaEcms(m_deltaEcms);
71 m_selector.setCutOnPOCA(m_dr, m_dz);
72 m_selector.setCutOnLocalZ(m_minZ, m_maxZ);
73 } else {
74 B2ERROR("Invalid sample type '" << m_sample << "'");
75 }
76
77 // create and register histograms
78
79 const int numModules = 16;
80 const int numPixels = 512;
81
82 // time stamp (average unix time and its standard deviation)
83 auto* timeStamp = new TProfile("timeStamp", "Time stamp; ; unix time", 1, 0, 1, 0, 1.0e10, "S");
84 registerObject<TProfile>("timeStamp", timeStamp);
85
86 // number of selected tracks per slot
87 auto* numTracks = new TH1F("numTracks", "Number of tracks per slot; slot number; track count", numModules, 0.5, numModules + 0.5);
88 registerObject<TH1F>("numTracks", numTracks);
89
90 // number of pixel hits in a signal time window
91 for (int slot = 1; slot <= numModules; slot++) {
92 string name = (slot < 10) ? "signalHits_0" + to_string(slot) : "signalHits_" + to_string(slot);
93 string title = "Hits in signal window for slot " + to_string(slot);
94 auto h = new TH1F(name.c_str(), title.c_str(), numPixels, 0.5, numPixels + 0.5);
95 h->SetXTitle("pixel number");
96 h->SetYTitle("hit count");
97 registerObject<TH1F>(name, h);
98 m_signalNames.push_back(name);
99 }
100
101 // number of pixel hits in a background time window
102 for (int slot = 1; slot <= numModules; slot++) {
103 string name = (slot < 10) ? "bkgHits_0" + to_string(slot) : "bkgHits_" + to_string(slot);
104 string title = "Hits in background window for slot " + to_string(slot);
105 auto h = new TH1F(name.c_str(), title.c_str(), numPixels, 0.5, numPixels + 0.5);
106 h->SetXTitle("pixel number");
107 h->SetYTitle("hit count");
108 registerObject<TH1F>(name, h);
109 m_bkgNames.push_back(name);
110 }
111
112 // active pixels
113 for (int slot = 1; slot <= numModules; slot++) {
114 string name = (slot < 10) ? "activePixels_0" + to_string(slot) : "activePixels_" + to_string(slot);
115 string title = "Active pixels for slot " + to_string(slot);
116 auto h = new TH1F(name.c_str(), title.c_str(), numPixels, 0.5, numPixels + 0.5);
117 h->SetXTitle("pixel number");
118 h->SetYTitle("track count");
119 registerObject<TH1F>(name, h);
120 m_activeNames.push_back(name);
121 }
122
123 // number of effective signal hits in pixels
124 for (int slot = 1; slot <= numModules; slot++) {
125 string name = (slot < 10) ? "effectiveSignalHits_0" + to_string(slot) : "effectiveSignalHits_" + to_string(slot);
126 string title = "Effective signal hits for slot " + to_string(slot);
127 auto h = new TH1F(name.c_str(), title.c_str(), numPixels, 0.5, numPixels + 0.5);
128 h->SetXTitle("pixel number");
129 h->SetYTitle("hit count");
130 registerObject<TH1F>(name, h);
131 m_effectiveSignalNames.push_back(name);
132 }
133
134 // number of pixel hits with low impact angle on photo cathode
135 for (int slot = 1; slot <= numModules; slot++) {
136 string name = (slot < 10) ? "alphaLow_0" + to_string(slot) : "alphaLow_" + to_string(slot);
137 string title = "Hits w/ low alpha for slot " + to_string(slot);
138 auto h = new TH1F(name.c_str(), title.c_str(), numPixels, 0.5, numPixels + 0.5);
139 h->SetXTitle("pixel number");
140 h->SetYTitle("hit count");
141 registerObject<TH1F>(name, h);
142 m_alphaLowNames.push_back(name);
143 }
144
145 // number of pixel hits with high impact angle on photo cathode
146 for (int slot = 1; slot <= numModules; slot++) {
147 string name = (slot < 10) ? "alphaHigh_0" + to_string(slot) : "alphaHigh_" + to_string(slot);
148 string title = "Hits w/ high alpha for slot " + to_string(slot);
149 auto h = new TH1F(name.c_str(), title.c_str(), numPixels, 0.5, numPixels + 0.5);
150 h->SetXTitle("pixel number");
151 h->SetYTitle("hit count");
152 registerObject<TH1F>(name, h);
153 m_alphaHighNames.push_back(name);
154 }
155
156 // pixel pulse-height distributions
157 for (int slot = 1; slot <= numModules; slot++) {
158 string name = (slot < 10) ? "pulseHeights_0" + to_string(slot) : "pulseHeights_" + to_string(slot);
159 string title = "Pulse height distributions for slot " + to_string(slot);
160 auto h = new TH2F(name.c_str(), title.c_str(), numPixels, 0.5, numPixels + 0.5, 200, 0, 2000);
161 h->SetXTitle("pixel number");
162 h->SetYTitle("pulse height");
163 registerObject<TH2F>(name, h);
164 m_pulseHeightNames.push_back(name);
165 }
166
167 // local z-distribution of tracks
168 for (int slot = 1; slot <= numModules; slot++) {
169 string name = (slot < 10) ? "muonZ_0" + to_string(slot) : "muonZ_" + to_string(slot);
170 string title = "Track z-distribution for slot " + to_string(slot);
171 auto h = new TH1F(name.c_str(), title.c_str(), 100, m_minZ, m_maxZ);
172 h->SetXTitle("local z [cm]");
173 h->SetYTitle("track count");
174 registerObject<TH1F>(name, h);
175 m_muonZNames.push_back(name);
176 }
177
178 }
179
180
182 {
183 // bunch must be reconstructed
184
185 if (not m_recBunch->isReconstructed()) return;
186
187 // loop over reconstructed tracks, make a selection and fill histograms
188
189 for (const auto& track : m_tracks) {
190 // track selection
191 TOPTrack trk(track);
192 if (not trk.isValid()) continue;
193 if (not m_selector.isSelected(trk)) continue;
194
195 // fill histograms
196 auto timeStamp = getObjectPtr<TProfile>("timeStamp");
197 timeStamp->Fill(0.5, m_eventMetaData->getTime() / 1000000000);
198
199 int slot = trk.getModuleID();
200 auto numTracks = getObjectPtr<TH1F>("numTracks");
201 numTracks->Fill(slot);
202
203 auto muonZ = getObjectPtr<TH1F>(m_muonZNames[slot - 1]);
204 muonZ->Fill(m_selector.getLocalPosition().Z());
205
206 auto signalHits = getObjectPtr<TH1F>(m_signalNames[slot - 1]);
207 auto bkgHits = getObjectPtr<TH1F>(m_bkgNames[slot - 1]);
208 auto pulseHeight = getObjectPtr<TH2F>(m_pulseHeightNames[slot - 1]);
209 for (const auto& digit : m_digits) {
210 if (digit.getModuleID() != slot) continue;
211 if (digit.getHitQuality() != TOPDigit::c_Good) continue; // junk hit or pixel masked-out
212 if (std::abs(digit.getTime()) > m_timeWindow) continue;
213 if (digit.getTime() > 0) {
214 signalHits->Fill(digit.getPixelID());
215 pulseHeight->Fill(digit.getPixelID(), digit.getPulseHeight());
216 } else {
217 bkgHits->Fill(digit.getPixelID());
218 }
219 }
220
221 auto activePixels = getObjectPtr<TH1F>(m_activeNames[slot - 1]);
222 const auto& chMapper = TOPGeometryPar::Instance()->getChannelMapper();
223 for (int pixel = 1; pixel <= activePixels->GetNbinsX(); pixel++) {
224 unsigned channel = chMapper.getChannel(pixel);
225 if (m_channelMask->isActive(slot, channel) and m_asicMask->isActive(slot, channel)) activePixels->Fill(pixel);
226 }
227
228 auto alphaLow = getObjectPtr<TH1F>(m_alphaLowNames[slot - 1]);
229 auto alphaHigh = getObjectPtr<TH1F>(m_alphaHighNames[slot - 1]);
230 auto effectiveSignalHits = getObjectPtr<TH1F>(m_effectiveSignalNames[slot - 1]);
231 for (const auto& digit : m_digits) {
232 if (digit.getModuleID() != slot) continue;
233 if (digit.getHitQuality() != TOPDigit::c_Good) continue; // junk hit or pixel masked-out
234 const auto* pdf = digit.getRelated<TOPAssociatedPDF>();
235 if (not pdf) continue;
236 const auto* peak = pdf->getSinglePeak();
237 if (not peak) continue; // hit associated with background
238 effectiveSignalHits->Fill(digit.getPixelID());
239 if (std::abs(m_selector.getLocalPosition().Z()) > m_excludedZ) {
240 double alpha = acos(std::abs(peak->kzd)) / Unit::deg;
241 if (alpha > 60) continue;
242 if (alpha < 30) alphaLow->Fill(digit.getPixelID());
243 else alphaHigh->Fill(digit.getPixelID());
244 }
245 }
246 } // loop over tracks
247
248 }
249
250
252} // end namespace Belle2
void registerObject(std::string name, T *obj)
Register object with a name, takes ownership, do not access the pointer beyond prepare()
T * getObjectPtr(std::string name)
Calls the CalibObjManager to get the requested stored collector data.
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition Module.cc:208
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition Module.h:80
Class to store analytic PDF associated with a photon.
DBObjPtr< TOPCalChannelMask > m_channelMask
masked channels
StoreObjPtr< TOPRecBunch > m_recBunch
reconstructed bunch
TOP::TrackSelector m_selector
track selection utility
std::vector< std::string > m_activeNames
histogram names for active pixels count
std::vector< std::string > m_alphaHighNames
histogram names for counting hits w/ high impact angle on photo cathode
std::vector< std::string > m_pulseHeightNames
histogram names for pulse heights
StoreObjPtr< EventMetaData > m_eventMetaData
event meta data object
std::vector< std::string > m_effectiveSignalNames
histogram names for effective signal hits in pixels
std::vector< std::string > m_muonZNames
histogram names for track z-distribution
std::vector< std::string > m_alphaLowNames
histogram names for counting hits w/ low impact angle on photo cathode
const double m_timeWindow
time window for counting photon hits (half size)
StoreArray< Track > m_tracks
collection of tracks
StoreArray< TOPAssociatedPDF > m_associatedPDFs
collection of PDF's associated to TOP digits
const double m_minZ
minimal local z of extrapolated track
const double m_excludedZ
excluded central region of extrapolated track for photon impact angle counting
const double m_maxZ
maximal local z of extrapolated track
std::vector< std::string > m_signalNames
histogram names for signal window hit counts
std::vector< std::string > m_bkgNames
histogram names for background window hit counts
StoreArray< TOPDigit > m_digits
collection of TOP digits
StoreArray< ExtHit > m_extHits
collection of extrapolated hits
StoreObjPtr< TOPAsicMask > m_asicMask
online masked Asics
const ChannelMapper & getChannelMapper() const
Returns default channel mapper (mapping of channels to pixels)
static TOPGeometryPar * Instance()
Static method to obtain the pointer to its instance.
Reconstructed track at TOP.
Definition TOPTrack.h:39
bool isValid() const
Checks if track is successfully constructed.
Definition TOPTrack.h:137
int getModuleID() const
Returns slot ID.
Definition TOPTrack.h:143
Utility for the track selection - used in various calibration modules.
static const double deg
degree to radians
Definition Unit.h:109
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
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
virtual void collect() final
Replacement for event().
virtual void prepare() final
Replacement for initialize().
Abstract base class for different kinds of events.
STL namespace.