Belle II Software development
PXDDQMTrackRawNtupleModule.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 <pxd/modules/pxdDQM/PXDDQMTrackRawNtupleModule.h>
10#include <mdst/dataobjects/Track.h>
11#include <tracking/dataobjects/RecoTrack.h>
12#include <tracking/dataobjects/PXDIntercept.h>
13
14#include <pxd/dataobjects/PXDRawHit.h>
15#include <pxd/dataobjects/PXDDAQStatus.h>
16
17#include <pxd/reconstruction/PXDPixelMasker.h>
18#include <framework/gearbox/Const.h>
19
20#include "TMatrixDSym.h"
21using namespace Belle2;
22
23//-----------------------------------------------------------------
24// Register the Module
25//-----------------------------------------------------------------
26REG_MODULE(PXDDQMTrackRawNtuple);
27
28//-----------------------------------------------------------------
29// Implementation
30//-----------------------------------------------------------------
31
33{
34 // Set module properties
35 setDescription("Create tuple PXD trigger studies");
36
37 // setPropertyFlags(c_ParallelProcessingCertified);// for ntuple not certified!!!
38
39 // Parameter definitions
40 addParam("ntupleName", m_ntupleName, "name of ntuple file", std::string("rawhits.root"));
41 addParam("pxdHitsName", m_pxdHitsName, "name of StoreArray with PXD raw hits", std::string(""));
42 addParam("recoTracksName", m_recoTracksName, "name of StoreArray with RecoTracks", std::string(""));
43 addParam("tracksName", m_tracksName, "name of StoreArray with Tracks", std::string(""));
44 addParam("PXDInterceptListName", m_PXDInterceptListName, "name of the list of interceptions", std::string(""));
45 addParam("useAlignment", m_useAlignment, "if true the alignment will be used", true);
46 addParam("pCut", m_pcut, "Set a cut on the track fit p-value (0=no cut)", double(1e-20));
47 addParam("minSVDHits", m_minSVDHits, "Number of SVD hits required in a track to be considered", 5u);
48 addParam("momCut", m_momCut, "Set a cut on the track momentum in GeV/c, 0 disables", double(0.3));
49 addParam("pTCut", m_pTCut, "Set a cut on the track transverse momentum (<=0 disable)", double(0.3));
50 addParam("uDist", m_uDist, "distance in ucell to intercept to accept hit", int(10));
51 addParam("vDist", m_vDist, "distance in vcell to intercept to accept hit", int(10));
52}
53
54
56{
57 auto dir = gDirectory;
58 if (m_tuple) {
59 if (m_file) { // no file -> no write to file
60 m_file->cd();
61 }
62 m_tuple->Write();
63 delete m_tuple;
64 m_tuple = nullptr;
65 }
66 if (m_file) {
67 m_file->Write();
68 m_file->Close();
69 delete m_file;
70 m_file = nullptr;
71 }
72 dir->cd();
73}
74
75
77{
78 m_file = new TFile(m_ntupleName.data(), "recreate");
79 if (m_file) m_file->cd();
80 m_tuple = new TNtuple("trackraw", "trackraw", "vxdid:u:v:p:pt:framenr:triggergate");
81
82 //register the required arrays
83 //Register as optional so validation for cases where they are not available still succeeds, but module will not do any meaningful work without them
84 m_pxdhits.isOptional(m_pxdHitsName);
86 m_tracks.isOptional(m_tracksName);
88 m_storeDAQEvtStats.isRequired();
89}
90
91
93{
94 if (!m_pxdhits.isValid()) {
95 B2INFO("PXDHits array is missing, will not do anything");
96 return;
97 }
98 if (!m_recoTracks.isValid()) {
99 B2INFO("RecoTrack array is missing, will not do anything");
100 return;
101 }
102 if (!m_tracks.isValid()) {
103 B2INFO("Track array is missing, will not do anything");
104 return;
105 }
106 if (!m_intercepts.isValid()) {
107 B2INFO("Intercept array is missing, will not do anything");
108 return;
109 }
110
111 std::map<unsigned int, int> triggergate;
112 auto evt = *m_storeDAQEvtStats;
113 for (auto& pkt : evt) {
114 for (auto& dhc : pkt) {
115 for (auto& dhe : dhc) {
116 triggergate[(unsigned int)dhe.getSensorID()] = dhe.getTriggerGate();
117 // dhe.getFirstDataGate());
118 }
119 }
120 }
121
122 for (auto& track : m_tracks) {
123 RelationVector<RecoTrack> recoTrack = track.getRelationsTo<RecoTrack>(m_recoTracksName);
124 if (!recoTrack.size()) continue;
125
126 auto a_track = recoTrack[0];
127 //If fit failed assume position pointed to is useless anyway
128 if (!a_track->wasFitSuccessful()) continue;
129
130 if (a_track->getNumberOfSVDHits() < m_minSVDHits) continue;
131
132 RelationVector<PXDIntercept> interceptList = a_track->getRelationsTo<PXDIntercept>(m_PXDInterceptListName);
133 if (!interceptList.size()) continue;
134
135 const genfit::FitStatus* fitstatus = a_track->getTrackFitStatus();
136 if (fitstatus->getPVal() < m_pcut) continue;
137
138 genfit::MeasuredStateOnPlane trackstate;
139 trackstate = a_track->getMeasuredStateOnPlaneFromFirstHit();
140 if (trackstate.getMom().Mag() < m_momCut) continue;
141 if (trackstate.getMom().Pt() < m_pTCut) continue;
142
143 const TrackFitResult* ptr2 = track.getTrackFitResultWithClosestMass(Const::pion);
144 if (!ptr2) {
145 B2ERROR("expect a track fit result for mass");
146 continue;
147 }
148
149 //loop over all PXD sensors to get the intersections
150 std::vector<VxdID> sensors = m_vxdGeometry.getListOfSensors();
151 for (auto intercept : interceptList) {
152 VxdID aVxdID = intercept.getSensorID();
153 auto& info = m_vxdGeometry.getSensorInfo(aVxdID);
154 //Search for intersections of the track with all PXD layers
155 //Traditional (aka the person before did it like this) method
156 //If there is a way to find out sensors crossed by a track directly, that would most likely be faster
157
158 double u_fit = intercept.getCoorU();
159 double v_fit = intercept.getCoorV();
160
161 int ucell_fit = info.getUCellID(u_fit); // check wie overflow!!!
162 int vcell_fit = info.getVCellID(v_fit); // Check wie overflow
163
164 //loop the hits
165 for (auto& hit : m_pxdhits) {
166 //Do not consider as different if only segment differs!
167 //As of this writing segment is never filled for hits, but just to be sure
168 VxdID hitID = hit.getSensorID();
169 if (aVxdID.getLayerNumber() != hitID.getLayerNumber() ||
170 aVxdID.getLadderNumber() != hitID.getLadderNumber() ||
171 aVxdID.getSensorNumber() != hitID.getSensorNumber()) {
172 continue;
173 }
174 //only hit on the correct sensor and direction should survive
175
176 auto u = hit.getUCellID();
177 auto v = hit.getVCellID();
178 if (abs(ucell_fit - u) < m_uDist && abs(vcell_fit - v) < m_vDist) {
179
180 float fill[7] = {float((int)aVxdID), float(u), float(v), float(trackstate.getMom().Mag()), float(trackstate.getMom().Pt()), float(hit.getFrameNr()), float(triggergate[hitID])};
181 m_tuple->Fill(fill);
182 }
183 }
184 }
185 }
186}
static const ChargedStable pion
charged pion particle
Definition Const.h:661
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
Module()
Constructor.
Definition Module.cc:30
StoreArray< PXDRawHit > m_pxdhits
store array of pxd clusters
void initialize() override final
initializes the need store arrays, trees and histograms
StoreObjPtr< PXDDAQStatus > m_storeDAQEvtStats
Input array for DAQ Status.
unsigned int m_minSVDHits
Required hits in SVD strips for tracks.
std::string m_PXDInterceptListName
intercept list name
double m_momCut
Cut on fitted track momentum.
void terminate() override final
terminate , save tuple to file if needed
void event() override final
main function which fills trees and histograms
StoreArray< Track > m_tracks
store array of tracks
std::string m_recoTracksName
name of the store array of recotracks
std::string m_pxdHitsName
name of the store array of pxd clusters
PXDDQMTrackRawNtupleModule()
Constructor: Sets the description, the properties and the parameters of the module.
StoreArray< PXDIntercept > m_intercepts
store array of PXD Intercepts
StoreArray< RecoTrack > m_recoTracks
store array of reco tracks
bool m_useAlignment
if true alignment will be used!
int m_uDist
distance in ucell to intercept to accept hit
TNtuple * m_tuple
pointer to opened tuple
int m_vDist
distance in vcell to intercept to accept hit
std::string m_tracksName
name of the store array of tracks
PXDIntercept stores the U,V coordinates and uncertainties of the intersection of a track with an PXD ...
This is the Reconstruction Event-Data Model Track.
Definition RecoTrack.h:79
Class for type safe access to objects that are referred to in relations.
size_t size() const
Get number of relations.
Values of the result of a track fit with a given particle hypothesis.
Class to uniquely identify a any structure of the PXD and SVD.
Definition VxdID.h:32
baseType getSensorNumber() const
Get the sensor id.
Definition VxdID.h:99
baseType getLadderNumber() const
Get the ladder id.
Definition VxdID.h:97
baseType getLayerNumber() const
Get the layer id.
Definition VxdID.h:95
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
Namespace to provide code needed by both Vertex Detectors, PXD and SVD, and also testbeam telescopes.
Definition GeoCache.h:33
Abstract base class for different kinds of events.