ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
ClusterSeg::ClusterAnalysis Class Reference

#include <ClusterAnalysis.h>

Collaboration diagram for ClusterSeg::ClusterAnalysis:

Public Member Functions

 ClusterAnalysis ()
 ClusterAnalysis (TTree &tree)
virtual ~ClusterAnalysis ()=default
std::vector< std::vector< SpacePoint > > analyse (const std::vector< Cluster * > &clust)
void analyseWrite ()

Private Member Functions

std::vector< std::vector< SpacePoint > > createTGCSeeds (const std::vector< SpacePoint > &points)
std::vector< std::vector< SpacePoint > > createRPCSeeds (const std::vector< SpacePoint > &points)
void createSeedsAllLayers (const std::vector< SpacePoint > &layer1Points, const std::vector< SpacePoint > &layer2Points, const std::vector< SpacePoint > &layer3Points, std::vector< std::vector< SpacePoint > > &seeds)
void createSeedsTwoLayers (const std::vector< SpacePoint > &layer1Points, const std::vector< SpacePoint > &layer2Points, std::vector< std::vector< SpacePoint > > &seeds)

Static Private Member Functions

static std::vector< SpacePoint > createSpacePoints (const std::vector< Cluster * > &clust)

Private Attributes

TTree * m_tree
ClusterNtuple m_ntuple {}
int m_ncalls {}
bool m_writeOut
double m_ang_cut
double m_ang2_cut
double m_dist_cut
std::unique_ptr< TH2F > m_h_miss_RZ
std::unique_ptr< TH2F > m_h_miss_XY
std::unique_ptr< TH2F > m_h_rz
std::unique_ptr< TH2F > m_h_xy
std::unique_ptr< TH2F > m_h_corr
std::unique_ptr< TH1F > m_h_phi
std::unique_ptr< TH1F > m_h_theta
std::unique_ptr< TH1F > m_h_angle
std::unique_ptr< TH1F > m_h_phi_t
std::unique_ptr< TH1F > m_h_theta_t
std::unique_ptr< TH1F > m_h_angle_t
std::unique_ptr< TH1F > m_h_phi12
std::unique_ptr< TH1F > m_h_theta12
std::unique_ptr< TH1F > m_h_angle12
std::unique_ptr< TH1F > m_h_phi_t12
std::unique_ptr< TH1F > m_h_theta_t12
std::unique_ptr< TH1F > m_h_angle_t12
std::unique_ptr< TH1F > m_h_phi13
std::unique_ptr< TH1F > m_h_theta13
std::unique_ptr< TH1F > m_h_angle13
std::unique_ptr< TH1F > m_h_phi_t13
std::unique_ptr< TH1F > m_h_theta_t13
std::unique_ptr< TH1F > m_h_angle_t13
std::unique_ptr< TH1F > m_h_phi23
std::unique_ptr< TH1F > m_h_theta23
std::unique_ptr< TH1F > m_h_angle23
std::unique_ptr< TH1F > m_h_phi_t23
std::unique_ptr< TH1F > m_h_theta_t23
std::unique_ptr< TH1F > m_h_angle_t23
std::unique_ptr< TH1F > m_h_R
std::unique_ptr< TH1F > m_h_XY
std::unique_ptr< TH1F > m_h_R_t
std::unique_ptr< TH1F > m_h_XY_t
std::unique_ptr< TH1F > m_h_sizeL1
std::unique_ptr< TH1F > m_h_sizeL2
std::unique_ptr< TH1F > m_h_sizeL3
std::unique_ptr< TH1F > m_h_sizeL1L3
std::unique_ptr< TH1F > m_h_sizeL1L2L3
std::unique_ptr< TH1F > m_h_XY121
std::unique_ptr< TH1F > m_h_XY122
std::unique_ptr< TH1F > m_h_XY121_t
std::unique_ptr< TH1F > m_h_XY122_t
std::unique_ptr< TH1F > m_h_XY131
std::unique_ptr< TH1F > m_h_XY133
std::unique_ptr< TH1F > m_h_XY131_t
std::unique_ptr< TH1F > m_h_XY133_t
std::unique_ptr< TH1F > m_h_XY232
std::unique_ptr< TH1F > m_h_XY233
std::unique_ptr< TH1F > m_h_XY232_t
std::unique_ptr< TH1F > m_h_XY233_t
std::unique_ptr< TH1F > m_h_numseeds
std::unique_ptr< TH2F > m_h_barcodes

Detailed Description

Definition at line 23 of file ClusterAnalysis.h.

Constructor & Destructor Documentation

◆ ClusterAnalysis() [1/2]

ClusterSeg::ClusterAnalysis::ClusterAnalysis ( )

Definition at line 26 of file ClusterAnalysis.cxx.

26 :
27 m_tree(nullptr),
28 m_ncalls(-1),
29 m_writeOut(false),
30 m_ang_cut(0.5),
31 m_ang2_cut(1.0),
32 m_dist_cut(100.0)
33 {
34 m_ntuple.init();
35 }

◆ ClusterAnalysis() [2/2]

ClusterSeg::ClusterAnalysis::ClusterAnalysis ( TTree & tree)

Definition at line 37 of file ClusterAnalysis.cxx.

37 :
38 m_tree(&tree),
39 m_writeOut(false),
40 m_ang_cut(0.5),
41 m_ang2_cut(1.0),
42 m_dist_cut(100.0)
43 {
44 m_ntuple.initForRead(tree);
45 }
tree
TChain * tree
Definition tile_monitor.h:30

◆ ~ClusterAnalysis()

virtual ClusterSeg::ClusterAnalysis::~ClusterAnalysis ( )
virtualdefault

Member Function Documentation

◆ analyse()

std::vector< std::vector< SpacePoint > > ClusterSeg::ClusterAnalysis::analyse ( const std::vector< Cluster * > & clust)

Definition at line 236 of file ClusterAnalysis.cxx.

236 {
237 std::vector<std::vector<SpacePoint>> sPoints;
238 std::vector<SpacePoint> thePoints = createSpacePoints(clust);
239 if(thePoints.empty()) return sPoints;
240 std::vector<std::vector<SpacePoint>> seeds = (thePoints.at(0).techIndex() == Muon::MuonStationIndex::TechnologyIndex::TGC) ?
241 createTGCSeeds(thePoints) : createRPCSeeds(thePoints);
242 return seeds;
243 }
ClusterSeg::ClusterAnalysis::createTGCSeeds
std::vector< std::vector< SpacePoint > > createTGCSeeds(const std::vector< SpacePoint > &points)
Definition ClusterAnalysis.cxx:245
ClusterSeg::ClusterAnalysis::createRPCSeeds
std::vector< std::vector< SpacePoint > > createRPCSeeds(const std::vector< SpacePoint > &points)
Definition ClusterAnalysis.cxx:291
ClusterSeg::ClusterAnalysis::createSpacePoints
static std::vector< SpacePoint > createSpacePoints(const std::vector< Cluster * > &clust)
Definition ClusterAnalysis.cxx:423

◆ analyseWrite()

void ClusterSeg::ClusterAnalysis::analyseWrite ( )

Definition at line 48 of file ClusterAnalysis.cxx.

48 {
49 MsgStream log(Athena::getMessageSvc(),"ClusterAnalysis::analyseWrite");
50 m_h_barcodes = std::make_unique<TH2F>("barcodes","",1000,0,1000,1000,0,1000);
51 m_h_barcodes->GetXaxis()->SetTitle("layer 1");
52 m_h_barcodes->GetYaxis()->SetTitle("layer 3");
53
54 m_h_corr = std::make_unique<TH2F>("phi_theta_corr","",100,0.,M_PI_2,100,0,M_PI_2);
55 m_h_corr->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
56 m_h_corr->GetYaxis()->SetTitle("|#Delta #theta| [rad]");
57 m_h_rz = std::make_unique<TH2F>("rz_spacePoints","",1000,0,12000,3000,1000,13000);
58 m_h_rz->GetXaxis()->SetTitle("Z [mm]");
59 m_h_rz->GetYaxis()->SetTitle("R [mm]");
60 m_h_xy = std::make_unique<TH2F>("xy_spacePoints","",3000,-13000,13000,3000,-13000,13000);
61 m_h_xy->GetXaxis()->SetTitle("X [mm]");
62 m_h_xy->GetYaxis()->SetTitle("Y [mm]");
63
64 m_h_miss_RZ = std::make_unique<TH2F>("rz_missing_spacePoints","",1000,12000,16000,3000,1000,13000);
65 m_h_miss_RZ->GetXaxis()->SetTitle("Z [mm]");
66 m_h_miss_RZ->GetYaxis()->SetTitle("R [mm]");
67 m_h_miss_XY = std::make_unique<TH2F>("xy_missing_spacePoints","",3000,-13000,13000,3000,-13000,13000);
68 m_h_miss_XY->GetXaxis()->SetTitle("X [mm]");
69 m_h_miss_XY->GetYaxis()->SetTitle("Y [mm]");
70
71 m_h_phi = std::make_unique<TH1F>("phi","",100,0,M_PI_2);
72 m_h_phi->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
73 m_h_phi->GetYaxis()->SetTitle("Number of Entries");
74 m_h_theta = std::make_unique<TH1F>("theta","",100,0,M_PI_2);
75 m_h_theta->GetXaxis()->SetTitle("|#Delta #theta| [rad]");
76 m_h_theta->GetYaxis()->SetTitle("Number of Entries");
77 m_h_angle = std::make_unique<TH1F>("angle","",100,0,M_PI);
78 m_h_angle->GetXaxis()->SetTitle("#theta [rad]");
79 m_h_angle->GetYaxis()->SetTitle("Number of Entries");
80
81 m_h_phi12 = std::make_unique<TH1F>("phi12","",100,0,M_PI_2);
82 m_h_phi12->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
83 m_h_phi12->GetYaxis()->SetTitle("Number of Entries");
84 m_h_theta12 = std::make_unique<TH1F>("theta12","",100,0,M_PI_2);
85 m_h_theta12->GetXaxis()->SetTitle("|#Delta #theta| [rad]");
86 m_h_theta12->GetYaxis()->SetTitle("Number of Entries");
87 m_h_angle12 = std::make_unique<TH1F>("angle12","",100,0,M_PI);
88 m_h_angle12->GetXaxis()->SetTitle("#theta [rad]");
89 m_h_angle12->GetYaxis()->SetTitle("Number of Entries");
90
91 m_h_phi13 = std::make_unique<TH1F>("phi13","",100,0,M_PI_2);
92 m_h_phi13->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
93 m_h_phi13->GetYaxis()->SetTitle("Number of Entries");
94 m_h_theta13 = std::make_unique<TH1F>("theta13","",100,0,M_PI_2);
95 m_h_theta13->GetXaxis()->SetTitle("|#Delta #theta| [rad]");
96 m_h_theta13->GetYaxis()->SetTitle("Number of Entries");
97 m_h_angle13 = std::make_unique<TH1F>("angle13","",100,0,M_PI);
98 m_h_angle13->GetXaxis()->SetTitle("#theta [rad]");
99 m_h_angle13->GetYaxis()->SetTitle("Number of Entries");
100
101 m_h_phi23 = std::make_unique<TH1F>("phi23","",100,0,M_PI_2);
102 m_h_phi23->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
103 m_h_phi23->GetYaxis()->SetTitle("Number of Entries");
104 m_h_theta23 = std::make_unique<TH1F>("theta23","",100,0,M_PI_2);
105 m_h_theta23->GetXaxis()->SetTitle("|#Delta #theta| [rad]");
106 m_h_theta23->GetYaxis()->SetTitle("Number of Entries");
107 m_h_angle23 = std::make_unique<TH1F>("angle23","",100,0,M_PI);
108 m_h_angle23->GetXaxis()->SetTitle("#theta [rad]");
109 m_h_angle23->GetYaxis()->SetTitle("Number of Entries");
110
111 m_h_R = std::make_unique<TH1F>("R","",100,0,1000);
112 m_h_R->GetXaxis()->SetTitle("|#Delta R|");
113 m_h_R->GetYaxis()->SetTitle("Number of Entries");
114 m_h_XY = std::make_unique<TH1F>("XY","",100,0,1000);
115 m_h_XY->GetXaxis()->SetTitle("|#Delta XY|");
116 m_h_XY->GetYaxis()->SetTitle("Number of Entries");
117 m_h_R_t = std::make_unique<TH1F>("R_t","",100,0,1000);
118 m_h_R_t->GetXaxis()->SetTitle("|#Delta R|");
119 m_h_R_t->GetYaxis()->SetTitle("Number of Entries");
120 m_h_XY_t = std::make_unique<TH1F>("XY_t","",100,0,1000);
121 m_h_XY_t->GetXaxis()->SetTitle("|#Delta XY|");
122 m_h_XY_t->GetYaxis()->SetTitle("Number of Entries");
123
124 m_h_numseeds = std::make_unique<TH1F>("num_seeds","",200,0,200);
125 m_h_numseeds->GetXaxis()->SetTitle("Number of Seeds");
126 m_h_numseeds->GetYaxis()->SetTitle("Number of Entries");
127
128 m_h_phi_t = std::make_unique<TH1F>("phi_t","",100,0,M_PI_2);
129 m_h_phi_t->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
130 m_h_phi_t->GetYaxis()->SetTitle("Number of Entries");
131 m_h_theta_t = std::make_unique<TH1F>("theta_t","",100,0,M_PI_2);
132 m_h_theta_t->GetXaxis()->SetTitle("|#Delta #theta| [rad]");
133 m_h_theta_t->GetYaxis()->SetTitle("Number of Entries");
134 m_h_angle_t = std::make_unique<TH1F>("angle_t","",100,0,M_PI);
135 m_h_angle_t->GetXaxis()->SetTitle("#theta [rad]");
136 m_h_angle_t->GetYaxis()->SetTitle("Number of Entries");
137
138 m_h_phi_t12 = std::make_unique<TH1F>("phi_t12","",100,0,M_PI_2);
139 m_h_phi_t12->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
140 m_h_phi_t12->GetYaxis()->SetTitle("Number of Entries");
141 m_h_theta_t12 = std::make_unique<TH1F>("theta_t12","",100,0,M_PI_2);
142 m_h_theta_t12->GetXaxis()->SetTitle("|#Delta #theta| [rad]");
143 m_h_theta_t12->GetYaxis()->SetTitle("Number of Entries");
144 m_h_angle_t12 = std::make_unique<TH1F>("angle_t12","",100,0,M_PI);
145 m_h_angle_t12->GetXaxis()->SetTitle("#theta [rad]");
146 m_h_angle_t12->GetYaxis()->SetTitle("Number of Entries");
147
148 m_h_phi_t13 = std::make_unique<TH1F>("phi_t13","",100,0,M_PI_2);
149 m_h_phi_t13->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
150 m_h_phi_t13->GetYaxis()->SetTitle("Number of Entries");
151 m_h_theta_t13 = std::make_unique<TH1F>("theta_t13","",100,0,M_PI_2);
152 m_h_theta_t13->GetXaxis()->SetTitle("|#Delta #theta| [rad]");
153 m_h_theta_t13->GetYaxis()->SetTitle("Number of Entries");
154 m_h_angle_t13 = std::make_unique<TH1F>("angle_t13","",100,0,M_PI);
155 m_h_angle_t13->GetXaxis()->SetTitle("#theta [rad]");
156 m_h_angle_t13->GetYaxis()->SetTitle("Number of Entries");
157
158 m_h_phi_t23 = std::make_unique<TH1F>("phi_t23","",100,0,M_PI_2);
159 m_h_phi_t23->GetXaxis()->SetTitle("|#Delta #phi| [rad]");
160 m_h_phi_t23->GetYaxis()->SetTitle("Number of Entries");
161 m_h_theta_t23 = std::make_unique<TH1F>("theta_t23","",100,0,M_PI_2);
162 m_h_theta_t23->GetXaxis()->SetTitle("|#Delta #theta| [rad]");
163 m_h_theta_t23->GetYaxis()->SetTitle("Number of Entries");
164 m_h_angle_t23 = std::make_unique<TH1F>("angle_t23","",100,0,M_PI);
165 m_h_angle_t23->GetXaxis()->SetTitle("#theta [rad]");
166 m_h_angle_t23->GetYaxis()->SetTitle("Number of Entries");
167
168 m_h_sizeL1 = std::make_unique<TH1F>("sizeL1","",200,0,250);
169 m_h_sizeL1->GetXaxis()->SetTitle("Size of L1 Spacepoints");
170 m_h_sizeL1->GetYaxis()->SetTitle("Number of Entries");
171 m_h_sizeL2 = std::make_unique<TH1F>("sizeL2","",200,0,250);
172 m_h_sizeL2->GetXaxis()->SetTitle("Size of L2 Spacepoints");
173 m_h_sizeL2->GetYaxis()->SetTitle("Number of Entries");
174 m_h_sizeL3 = std::make_unique<TH1F>("sizeL3","",200,0,250);
175 m_h_sizeL3->GetXaxis()->SetTitle("Size of L3 Spacepoints");
176 m_h_sizeL3->GetYaxis()->SetTitle("Number of Entries");
177
178 m_h_sizeL1L3 = std::make_unique<TH1F>("sizeL1L3","",10000,0,10000);
179 m_h_sizeL1L2L3 = std::make_unique<TH1F>("sizeL1L2L3","",20000,0,20000);
180
181 m_h_XY121 = std::make_unique<TH1F>("XY121","",100,0,100);
182 m_h_XY122 = std::make_unique<TH1F>("XY122","",100,0,100);
183 m_h_XY121_t = std::make_unique<TH1F>("XY121_t","",100,0,100);
184 m_h_XY122_t = std::make_unique<TH1F>("XY122_t","",100,0,100);
185
186 m_h_XY131 = std::make_unique<TH1F>("XY131","",100,0,100);
187 m_h_XY133 = std::make_unique<TH1F>("XY133","",100,0,100);
188 m_h_XY131_t = std::make_unique<TH1F>("XY131_t","",100,0,100);
189 m_h_XY133_t = std::make_unique<TH1F>("XY133_t","",100,0,100);
190
191 m_h_XY232 = std::make_unique<TH1F>("XY232","",100,0,100);
192 m_h_XY233 = std::make_unique<TH1F>("XY233","",100,0,100);
193 m_h_XY232_t = std::make_unique<TH1F>("XY232_t","",100,0,100);
194 m_h_XY233_t = std::make_unique<TH1F>("XY233_t","",100,0,100);
195
196 std::vector<SpacePoint> thePoints;
197
198 Long64_t nentries = m_tree->GetEntries();
199 m_ncalls = 0;
200 for( Long64_t evt=0;evt<nentries;++evt ){
201 m_tree->LoadTree(evt);
202 m_tree->GetEntry(evt);
203
204
205 if (log.level()<=MSG::DEBUG && evt % 100 == 0) log << MSG::DEBUG << "event " << evt << "/" << nentries << endmsg;
206
207 std::vector<Cluster*> clust;
208 m_ntuple.read(clust);
209
210
211 if (clust.at(0)->techIndex() == Muon::MuonStationIndex::TechnologyIndex::TGC){
212 std::sort (clust.begin(),clust.end(), sortfunctionTGC);
213 thePoints = createSpacePoints(clust);
214
215 if(thePoints.empty()) continue;
216 std::vector<std::vector<SpacePoint>> seeds = createTGCSeeds(thePoints);
217 m_h_numseeds->Fill(seeds.size());
218 } else {
219 std::sort (clust.begin(),clust.end(), sortfunctionRPC);
220 thePoints = createSpacePoints(clust);
221
222 if(thePoints.empty()) continue;
223 std::vector<std::vector<SpacePoint>> seeds = createRPCSeeds(thePoints);
224 m_h_numseeds->Fill(seeds.size());
225 }
226
227 for(auto &it: thePoints){
228 m_h_rz->Fill(fabs(it.z()),it.rCyl());
229 m_h_xy->Fill(it.x(),it.y());
230 }
231 ++m_ncalls;
232 ClusterSeg::ClusterNtuple::clean(clust);
233 }
234 }
M_PI
#define M_PI
Definition ActiveFraction.h:11
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
ClusterSeg::ClusterAnalysis::m_h_angle13
std::unique_ptr< TH1F > m_h_angle13
Definition ClusterAnalysis.h:73
ClusterSeg::ClusterAnalysis::m_h_barcodes
std::unique_ptr< TH2F > m_h_barcodes
Definition ClusterAnalysis.h:111
ClusterSeg::ClusterAnalysis::m_h_theta_t
std::unique_ptr< TH1F > m_h_theta_t
Definition ClusterAnalysis.h:61
ClusterSeg::ClusterAnalysis::m_h_phi23
std::unique_ptr< TH1F > m_h_phi23
Definition ClusterAnalysis.h:78
ClusterSeg::ClusterAnalysis::m_h_theta13
std::unique_ptr< TH1F > m_h_theta13
Definition ClusterAnalysis.h:72
ClusterSeg::ClusterAnalysis::m_h_numseeds
std::unique_ptr< TH1F > m_h_numseeds
Definition ClusterAnalysis.h:110
ClusterSeg::ClusterAnalysis::m_h_XY131
std::unique_ptr< TH1F > m_h_XY131
Definition ClusterAnalysis.h:100
ClusterSeg::ClusterAnalysis::m_h_theta
std::unique_ptr< TH1F > m_h_theta
Definition ClusterAnalysis.h:58
ClusterSeg::ClusterAnalysis::m_h_miss_RZ
std::unique_ptr< TH2F > m_h_miss_RZ
Definition ClusterAnalysis.h:52
ClusterSeg::ClusterAnalysis::m_h_XY_t
std::unique_ptr< TH1F > m_h_XY_t
Definition ClusterAnalysis.h:88
ClusterSeg::ClusterAnalysis::m_h_R
std::unique_ptr< TH1F > m_h_R
Definition ClusterAnalysis.h:85
ClusterSeg::ClusterAnalysis::m_h_XY233_t
std::unique_ptr< TH1F > m_h_XY233_t
Definition ClusterAnalysis.h:108
ClusterSeg::ClusterAnalysis::m_h_phi_t13
std::unique_ptr< TH1F > m_h_phi_t13
Definition ClusterAnalysis.h:74
ClusterSeg::ClusterAnalysis::m_h_phi_t12
std::unique_ptr< TH1F > m_h_phi_t12
Definition ClusterAnalysis.h:67
ClusterSeg::ClusterAnalysis::m_h_miss_XY
std::unique_ptr< TH2F > m_h_miss_XY
Definition ClusterAnalysis.h:53
ClusterSeg::ClusterAnalysis::m_h_XY122
std::unique_ptr< TH1F > m_h_XY122
Definition ClusterAnalysis.h:96
ClusterSeg::ClusterAnalysis::m_h_R_t
std::unique_ptr< TH1F > m_h_R_t
Definition ClusterAnalysis.h:87
ClusterSeg::ClusterAnalysis::m_h_sizeL1L2L3
std::unique_ptr< TH1F > m_h_sizeL1L2L3
Definition ClusterAnalysis.h:93
ClusterSeg::ClusterAnalysis::m_h_corr
std::unique_ptr< TH2F > m_h_corr
Definition ClusterAnalysis.h:56
ClusterSeg::ClusterAnalysis::m_h_sizeL3
std::unique_ptr< TH1F > m_h_sizeL3
Definition ClusterAnalysis.h:91
ClusterSeg::ClusterAnalysis::m_h_phi_t23
std::unique_ptr< TH1F > m_h_phi_t23
Definition ClusterAnalysis.h:81
ClusterSeg::ClusterAnalysis::m_h_angle_t
std::unique_ptr< TH1F > m_h_angle_t
Definition ClusterAnalysis.h:62
ClusterSeg::ClusterAnalysis::m_h_angle_t23
std::unique_ptr< TH1F > m_h_angle_t23
Definition ClusterAnalysis.h:83
ClusterSeg::ClusterAnalysis::m_h_sizeL1L3
std::unique_ptr< TH1F > m_h_sizeL1L3
Definition ClusterAnalysis.h:92
ClusterSeg::ClusterAnalysis::m_h_rz
std::unique_ptr< TH2F > m_h_rz
Definition ClusterAnalysis.h:54
ClusterSeg::ClusterAnalysis::m_h_theta12
std::unique_ptr< TH1F > m_h_theta12
Definition ClusterAnalysis.h:65
ClusterSeg::ClusterAnalysis::m_h_theta23
std::unique_ptr< TH1F > m_h_theta23
Definition ClusterAnalysis.h:79
ClusterSeg::ClusterAnalysis::m_h_sizeL1
std::unique_ptr< TH1F > m_h_sizeL1
Definition ClusterAnalysis.h:89
ClusterSeg::ClusterAnalysis::m_h_phi
std::unique_ptr< TH1F > m_h_phi
Definition ClusterAnalysis.h:57
ClusterSeg::ClusterAnalysis::m_h_theta_t23
std::unique_ptr< TH1F > m_h_theta_t23
Definition ClusterAnalysis.h:82
ClusterSeg::ClusterAnalysis::m_h_XY121
std::unique_ptr< TH1F > m_h_XY121
Definition ClusterAnalysis.h:95
ClusterSeg::ClusterAnalysis::m_h_sizeL2
std::unique_ptr< TH1F > m_h_sizeL2
Definition ClusterAnalysis.h:90
ClusterSeg::ClusterAnalysis::m_h_XY232
std::unique_ptr< TH1F > m_h_XY232
Definition ClusterAnalysis.h:105
ClusterSeg::ClusterAnalysis::m_h_phi_t
std::unique_ptr< TH1F > m_h_phi_t
Definition ClusterAnalysis.h:60
ClusterSeg::ClusterAnalysis::m_h_angle12
std::unique_ptr< TH1F > m_h_angle12
Definition ClusterAnalysis.h:66
ClusterSeg::ClusterAnalysis::m_h_XY121_t
std::unique_ptr< TH1F > m_h_XY121_t
Definition ClusterAnalysis.h:97
ClusterSeg::ClusterAnalysis::m_h_phi13
std::unique_ptr< TH1F > m_h_phi13
Definition ClusterAnalysis.h:71
ClusterSeg::ClusterAnalysis::m_h_XY233
std::unique_ptr< TH1F > m_h_XY233
Definition ClusterAnalysis.h:106
ClusterSeg::ClusterAnalysis::m_h_XY
std::unique_ptr< TH1F > m_h_XY
Definition ClusterAnalysis.h:86
ClusterSeg::ClusterAnalysis::m_h_theta_t12
std::unique_ptr< TH1F > m_h_theta_t12
Definition ClusterAnalysis.h:68
ClusterSeg::ClusterAnalysis::m_h_XY122_t
std::unique_ptr< TH1F > m_h_XY122_t
Definition ClusterAnalysis.h:98
ClusterSeg::ClusterAnalysis::m_h_phi12
std::unique_ptr< TH1F > m_h_phi12
Definition ClusterAnalysis.h:64
ClusterSeg::ClusterAnalysis::m_h_XY131_t
std::unique_ptr< TH1F > m_h_XY131_t
Definition ClusterAnalysis.h:102
ClusterSeg::ClusterAnalysis::m_h_theta_t13
std::unique_ptr< TH1F > m_h_theta_t13
Definition ClusterAnalysis.h:75
ClusterSeg::ClusterAnalysis::m_h_angle_t12
std::unique_ptr< TH1F > m_h_angle_t12
Definition ClusterAnalysis.h:69
ClusterSeg::ClusterAnalysis::m_h_angle23
std::unique_ptr< TH1F > m_h_angle23
Definition ClusterAnalysis.h:80
ClusterSeg::ClusterAnalysis::m_h_angle
std::unique_ptr< TH1F > m_h_angle
Definition ClusterAnalysis.h:59
ClusterSeg::ClusterAnalysis::m_h_XY133
std::unique_ptr< TH1F > m_h_XY133
Definition ClusterAnalysis.h:101
ClusterSeg::ClusterAnalysis::m_h_xy
std::unique_ptr< TH2F > m_h_xy
Definition ClusterAnalysis.h:55
ClusterSeg::ClusterAnalysis::m_h_angle_t13
std::unique_ptr< TH1F > m_h_angle_t13
Definition ClusterAnalysis.h:76
ClusterSeg::ClusterAnalysis::m_h_XY133_t
std::unique_ptr< TH1F > m_h_XY133_t
Definition ClusterAnalysis.h:103
ClusterSeg::ClusterAnalysis::m_h_XY232_t
std::unique_ptr< TH1F > m_h_XY232_t
Definition ClusterAnalysis.h:107
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition getMessageSvc.cxx:20
ClusterSeg::sortfunctionRPC
bool sortfunctionRPC(Cluster *i, Cluster *j)
Definition ClusterAnalysis.cxx:24
ClusterSeg::sortfunctionTGC
bool sortfunctionTGC(Cluster *i, Cluster *j)
Definition ClusterAnalysis.cxx:23
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition DVL_algorithms.h:554
ClusterSeg::ClusterNtuple::clean
static void clean(std::vector< Cluster * > &clusters)
Definition ClusterNtuple.cxx:117

◆ createRPCSeeds()

std::vector< std::vector< SpacePoint > > ClusterSeg::ClusterAnalysis::createRPCSeeds ( const std::vector< SpacePoint > & points)
private

Definition at line 291 of file ClusterAnalysis.cxx.

291 {
292
293 std::vector<SpacePoint> layer1Points;
294 std::vector<SpacePoint> layer2Points;
295 std::vector<std::vector<SpacePoint>> seeds;
296
297 for(const auto &it: points){
298 if (it.phiIndex() == Muon::MuonStationIndex::PhiIndex::BM1) layer1Points.push_back(it);
299 else if (it.phiIndex() == Muon::MuonStationIndex::PhiIndex::BM2) layer2Points.push_back(it);
300 }
301 if(m_writeOut){
302 int L1size = layer1Points.size();
303 int L2size = layer2Points.size();
304
305 m_h_sizeL1->Fill(L1size);
306 m_h_sizeL2->Fill(L2size);
307 }
308
309
310 if(m_writeOut && (layer1Points.empty() || layer2Points.empty())){
311 if(!layer1Points.empty()){
312 for(auto &it1: layer1Points){if(it1.isMatch()) m_h_miss_RZ->Fill(fabs(it1.z()),it1.rCyl()); m_h_miss_XY->Fill(it1.x(),it1.y());}
313 }
314 if(!layer2Points.empty()){
315 for(auto &it1: layer2Points){if(it1.isMatch()) m_h_miss_RZ->Fill(fabs(it1.z()),it1.rCyl()); m_h_miss_XY->Fill(it1.x(),it1.y());}
316 }
317 }
318
319 if(seeds.size() < 25 && !layer1Points.empty() && !layer2Points.empty()) createSeedsTwoLayers(layer1Points,layer2Points,seeds);
320
321 return seeds;
322 }
ClusterSeg::ClusterAnalysis::createSeedsTwoLayers
void createSeedsTwoLayers(const std::vector< SpacePoint > &layer1Points, const std::vector< SpacePoint > &layer2Points, std::vector< std::vector< SpacePoint > > &seeds)
Definition ClusterAnalysis.cxx:391

◆ createSeedsAllLayers()

void ClusterSeg::ClusterAnalysis::createSeedsAllLayers ( const std::vector< SpacePoint > & layer1Points,
const std::vector< SpacePoint > & layer2Points,
const std::vector< SpacePoint > & layer3Points,
std::vector< std::vector< SpacePoint > > & seeds )
private

Definition at line 325 of file ClusterAnalysis.cxx.

328 {
329
330 if(!layer1Points.empty() && !layer3Points.empty()){
331 for(const auto &it1: layer1Points){
332 for(const auto &it3: layer3Points){
333 if (TMath::Sign(1.,it1.z()) != TMath::Sign(1.,it3.z())) continue;
334 std::vector<SpacePoint> theSeed;
335 Cluster point = Cluster(it3.x()-it1.x(),it3.y()-it1.y(),it3.z()-it1.z(),false,0,0,false,0);
336 double angle = acos((point.x()*it1.x()+point.y()*it1.y()+point.z()*it1.z())/(point.rSph()*it1.rSph()));
337 if(angle > M_PI) angle = 2*M_PI - angle;
338 double dphi = fabs(point.phi()-it1.phi());
339 if(dphi > M_PI_2 && dphi < 3*M_PI_2) dphi -= M_PI;
340 if(dphi > 3*M_PI_2) dphi -= 2*M_PI;
341 double dtheta = fabs(point.theta()-it1.theta());
342 if (m_writeOut) {
343 m_h_phi->Fill(fabs(dphi));
344 m_h_theta->Fill(dtheta);
345 m_h_corr->Fill(dphi,dtheta);
346 m_h_angle->Fill(angle);
347 }
348 if(m_writeOut && it3.isMatch() && it1.isMatch() && it3.barcode() == it1.barcode() && it1.barcode() != 0 ) {
349 m_h_barcodes->Fill(it1.barcode(),it3.barcode());
350 m_h_phi_t->Fill(fabs(dphi));
351 m_h_theta_t->Fill(dtheta);
352 m_h_angle_t->Fill(angle);
353 }
354
355 if(angle < m_ang_cut) {
356 if(!layer2Points.empty()){
357 for(const auto &it2: layer2Points){
358 std::vector<SpacePoint> theSeed;
359 if (TMath::Sign(1.,it2.z()) != TMath::Sign(1.,it1.z())) continue;
360 double seedR = (it2.z()-it1.z())*tan(point.theta()) + it1.rCyl();
361 double spR = it2.rCyl();
362 double t = (it2.z() - it1.z())/point.z();
363 double seedX = it1.x() + t*point.x();
364 double seedY = it1.y() + t*point.y();
365 double XY = sqrt(pow(it2.x()-seedX,2)+pow(it2.y()-seedY,2));
366 if (m_writeOut) {
367 m_h_R->Fill(fabs(spR-seedR));
368 m_h_XY->Fill(XY);
369 }
370
371 if(m_writeOut && it1.isMatch() && it3.isMatch() && it2.isMatch() && it1.barcode() == it3.barcode() && it1.barcode() == it2.barcode() && it1.barcode() != 0) {
372 m_h_R_t->Fill(fabs(spR-seedR));
373 m_h_XY_t->Fill(XY);
374
375 }
376
377 if( XY < m_dist_cut){
378 theSeed.push_back(it1);
379 theSeed.push_back(it2);
380 theSeed.push_back(it3);
381 seeds.push_back(std::move(theSeed));
382 }
383 } //end loop of layer2points
384 }
385 } // check that seed passes IP pointing constraint
386 } //end loop over layer3points
387 } //end loop over layer1points
388 }//end if statement
389 }
angle
double angle(const GeoTrf::Vector2D &a, const GeoTrf::Vector2D &b)
Definition TRTDetectorFactory_Full.cxx:71
pow
constexpr int pow(int base, int exp) noexcept
Definition ap_fixedTest.cxx:15
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:5

◆ createSeedsTwoLayers()

void ClusterSeg::ClusterAnalysis::createSeedsTwoLayers ( const std::vector< SpacePoint > & layer1Points,
const std::vector< SpacePoint > & layer2Points,
std::vector< std::vector< SpacePoint > > & seeds )
private

Definition at line 391 of file ClusterAnalysis.cxx.

392 {
393 for(const auto &it1: layer1Points){
394 for(const auto &it3: layer2Points){
395 if (TMath::Sign(1.,it1.z()) != TMath::Sign(1.,it3.z())) continue;
396 std::vector<SpacePoint> theSeed;
397 Cluster point = Cluster(it3.x()-it1.x(),it3.y()-it1.y(),it3.z()-it1.z(),false,0,0,false,0);
398 double angle = acos((point.x()*it1.x()+point.y()*it1.y()+point.z()*it1.z())/(point.rSph()*it1.rSph()));
399 if(angle > M_PI) angle = 2*M_PI - angle;
400 double dphi = fabs(point.phi()-it1.phi());
401 if(dphi > M_PI_2 && dphi < 3*M_PI_2) dphi -= M_PI;
402 if(dphi > 3*M_PI_2) dphi -= 2*M_PI;
403 double dtheta = fabs(point.theta()-it1.theta());
404 if (m_writeOut) {
405 m_h_phi12->Fill(fabs(dphi));
406 m_h_theta12->Fill(dtheta);
407 m_h_angle12->Fill(angle);
408 }
409 if(m_writeOut && it3.isMatch() && it1.isMatch() && it3.barcode() == it1.barcode() && it1.barcode() != 0 ) {
410 m_h_phi_t12->Fill(fabs(dphi));
411 m_h_theta_t12->Fill(dtheta);
412 m_h_angle_t12->Fill(angle);
413 }
414 if (angle < m_ang2_cut){
415 theSeed.push_back(it1);
416 theSeed.push_back(it3);
417 seeds.push_back(std::move(theSeed));
418 }
419 }//layer2Points
420 } //layer1Points
421 }

◆ createSpacePoints()

std::vector< SpacePoint > ClusterSeg::ClusterAnalysis::createSpacePoints ( const std::vector< Cluster * > & clust)
staticprivate

Definition at line 423 of file ClusterAnalysis.cxx.

423 {
424
425 std::vector<std::pair<Cluster*,int>> phiClusters;
426 std::vector<std::pair<Cluster*,int>> etaClusters;
427 std::vector<SpacePoint> spacePoints;
428
429 int citer(0);
430 for(auto *it: clust){
431 if(it->isPhi()) phiClusters.emplace_back(it,citer);
432 else etaClusters.emplace_back(it,citer);
433 citer++;
434 }
435 for(auto &pit: phiClusters){
436 for(auto &eit: etaClusters){
437 bool tbool = false;
438 if (eit.first->isMatch() && pit.first->isMatch() && eit.first->barcode() == pit.first->barcode()) tbool = true;
439 if(pit.first->phiIndex() == eit.first->phiIndex() && eit.first->isSideA() == pit.first->isSideA()) {
440 SpacePoint thePoint = SpacePoint(eit.first->eta(),pit.first->phi(),eit.first->z(),eit.first->techIndex(),eit.first->phiIndex(),tbool,eit.first->barcode(),eit.second,pit.second);
441 spacePoints.push_back(thePoint);
442 }
443 }
444 }
445 return spacePoints;
446 }

◆ createTGCSeeds()

std::vector< std::vector< SpacePoint > > ClusterSeg::ClusterAnalysis::createTGCSeeds ( const std::vector< SpacePoint > & points)
private

Definition at line 245 of file ClusterAnalysis.cxx.

245 {
246
247 std::vector<SpacePoint> layer1Points;
248 std::vector<SpacePoint> layer2Points;
249 std::vector<SpacePoint> layer3Points;
250 std::vector<std::vector<SpacePoint>> seeds;
251
252 for(const auto &it: points){
253 if (it.phiIndex() == Muon::MuonStationIndex::PhiIndex::T1) layer1Points.push_back(it);
254 else if(it.phiIndex() == Muon::MuonStationIndex::PhiIndex::T2) layer2Points.push_back(it);
255 else if(it.phiIndex() == Muon::MuonStationIndex::PhiIndex::T3) layer3Points.push_back(it);
256 }
257
258 if(m_writeOut){
259 int L1size = layer1Points.size();
260 int L2size = layer2Points.size();
261 int L3size = layer3Points.size();
262
263 m_h_sizeL1->Fill(L1size);
264 m_h_sizeL2->Fill(L2size);
265 m_h_sizeL3->Fill(L3size);
266 m_h_sizeL1L3->Fill(L1size*L3size);
267 m_h_sizeL1L2L3->Fill(L1size*L2size*L3size);
268 }
269
270 if(m_writeOut && (layer1Points.empty() || layer2Points.empty() || layer3Points.empty())){
271 if(!layer1Points.empty()){
272 for(auto &it1: layer1Points){if(it1.isMatch()) m_h_miss_RZ->Fill(fabs(it1.z()),it1.rCyl()); m_h_miss_XY->Fill(it1.x(),it1.y());}
273 }
274 if(!layer2Points.empty()){
275 for(auto &it1: layer2Points){if(it1.isMatch()) m_h_miss_RZ->Fill(fabs(it1.z()),it1.rCyl()); m_h_miss_XY->Fill(it1.x(),it1.y());}
276 }
277 if(!layer3Points.empty()){
278 for(auto &it1: layer3Points){if(it1.isMatch()) m_h_miss_RZ->Fill(fabs(it1.z()),it1.rCyl()); m_h_miss_XY->Fill(it1.x(),it1.y());}
279 }
280 }
281
282 createSeedsAllLayers(layer1Points,layer2Points,layer3Points,seeds);
283 if(seeds.size() < 25){
284 if(!layer1Points.empty() && !layer2Points.empty() && layer3Points.empty()) createSeedsTwoLayers(layer1Points,layer2Points,seeds);
285 if(!layer3Points.empty() && !layer1Points.empty() && layer2Points.empty()) createSeedsTwoLayers(layer1Points,layer3Points,seeds);
286 if(!layer2Points.empty() && !layer3Points.empty() && layer1Points.empty()) createSeedsTwoLayers(layer2Points,layer3Points,seeds);
287 }
288 return seeds;
289 }
ClusterSeg::ClusterAnalysis::createSeedsAllLayers
void createSeedsAllLayers(const std::vector< SpacePoint > &layer1Points, const std::vector< SpacePoint > &layer2Points, const std::vector< SpacePoint > &layer3Points, std::vector< std::vector< SpacePoint > > &seeds)
Definition ClusterAnalysis.cxx:325

Member Data Documentation

◆ m_ang2_cut

double ClusterSeg::ClusterAnalysis::m_ang2_cut
private

Definition at line 49 of file ClusterAnalysis.h.

◆ m_ang_cut

double ClusterSeg::ClusterAnalysis::m_ang_cut
private

Definition at line 48 of file ClusterAnalysis.h.

◆ m_dist_cut

double ClusterSeg::ClusterAnalysis::m_dist_cut
private

Definition at line 50 of file ClusterAnalysis.h.

◆ m_h_angle

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_angle
private

Definition at line 59 of file ClusterAnalysis.h.

◆ m_h_angle12

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_angle12
private

Definition at line 66 of file ClusterAnalysis.h.

◆ m_h_angle13

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_angle13
private

Definition at line 73 of file ClusterAnalysis.h.

◆ m_h_angle23

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_angle23
private

Definition at line 80 of file ClusterAnalysis.h.

◆ m_h_angle_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_angle_t
private

Definition at line 62 of file ClusterAnalysis.h.

◆ m_h_angle_t12

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_angle_t12
private

Definition at line 69 of file ClusterAnalysis.h.

◆ m_h_angle_t13

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_angle_t13
private

Definition at line 76 of file ClusterAnalysis.h.

◆ m_h_angle_t23

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_angle_t23
private

Definition at line 83 of file ClusterAnalysis.h.

◆ m_h_barcodes

std::unique_ptr<TH2F> ClusterSeg::ClusterAnalysis::m_h_barcodes
private

Definition at line 111 of file ClusterAnalysis.h.

◆ m_h_corr

std::unique_ptr<TH2F> ClusterSeg::ClusterAnalysis::m_h_corr
private

Definition at line 56 of file ClusterAnalysis.h.

◆ m_h_miss_RZ

std::unique_ptr<TH2F> ClusterSeg::ClusterAnalysis::m_h_miss_RZ
private

Definition at line 52 of file ClusterAnalysis.h.

◆ m_h_miss_XY

std::unique_ptr<TH2F> ClusterSeg::ClusterAnalysis::m_h_miss_XY
private

Definition at line 53 of file ClusterAnalysis.h.

◆ m_h_numseeds

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_numseeds
private

Definition at line 110 of file ClusterAnalysis.h.

◆ m_h_phi

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_phi
private

Definition at line 57 of file ClusterAnalysis.h.

◆ m_h_phi12

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_phi12
private

Definition at line 64 of file ClusterAnalysis.h.

◆ m_h_phi13

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_phi13
private

Definition at line 71 of file ClusterAnalysis.h.

◆ m_h_phi23

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_phi23
private

Definition at line 78 of file ClusterAnalysis.h.

◆ m_h_phi_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_phi_t
private

Definition at line 60 of file ClusterAnalysis.h.

◆ m_h_phi_t12

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_phi_t12
private

Definition at line 67 of file ClusterAnalysis.h.

◆ m_h_phi_t13

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_phi_t13
private

Definition at line 74 of file ClusterAnalysis.h.

◆ m_h_phi_t23

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_phi_t23
private

Definition at line 81 of file ClusterAnalysis.h.

◆ m_h_R

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_R
private

Definition at line 85 of file ClusterAnalysis.h.

◆ m_h_R_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_R_t
private

Definition at line 87 of file ClusterAnalysis.h.

◆ m_h_rz

std::unique_ptr<TH2F> ClusterSeg::ClusterAnalysis::m_h_rz
private

Definition at line 54 of file ClusterAnalysis.h.

◆ m_h_sizeL1

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_sizeL1
private

Definition at line 89 of file ClusterAnalysis.h.

◆ m_h_sizeL1L2L3

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_sizeL1L2L3
private

Definition at line 93 of file ClusterAnalysis.h.

◆ m_h_sizeL1L3

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_sizeL1L3
private

Definition at line 92 of file ClusterAnalysis.h.

◆ m_h_sizeL2

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_sizeL2
private

Definition at line 90 of file ClusterAnalysis.h.

◆ m_h_sizeL3

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_sizeL3
private

Definition at line 91 of file ClusterAnalysis.h.

◆ m_h_theta

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_theta
private

Definition at line 58 of file ClusterAnalysis.h.

◆ m_h_theta12

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_theta12
private

Definition at line 65 of file ClusterAnalysis.h.

◆ m_h_theta13

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_theta13
private

Definition at line 72 of file ClusterAnalysis.h.

◆ m_h_theta23

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_theta23
private

Definition at line 79 of file ClusterAnalysis.h.

◆ m_h_theta_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_theta_t
private

Definition at line 61 of file ClusterAnalysis.h.

◆ m_h_theta_t12

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_theta_t12
private

Definition at line 68 of file ClusterAnalysis.h.

◆ m_h_theta_t13

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_theta_t13
private

Definition at line 75 of file ClusterAnalysis.h.

◆ m_h_theta_t23

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_theta_t23
private

Definition at line 82 of file ClusterAnalysis.h.

◆ m_h_XY

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY
private

Definition at line 86 of file ClusterAnalysis.h.

◆ m_h_xy

std::unique_ptr<TH2F> ClusterSeg::ClusterAnalysis::m_h_xy
private

Definition at line 55 of file ClusterAnalysis.h.

◆ m_h_XY121

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY121
private

Definition at line 95 of file ClusterAnalysis.h.

◆ m_h_XY121_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY121_t
private

Definition at line 97 of file ClusterAnalysis.h.

◆ m_h_XY122

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY122
private

Definition at line 96 of file ClusterAnalysis.h.

◆ m_h_XY122_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY122_t
private

Definition at line 98 of file ClusterAnalysis.h.

◆ m_h_XY131

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY131
private

Definition at line 100 of file ClusterAnalysis.h.

◆ m_h_XY131_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY131_t
private

Definition at line 102 of file ClusterAnalysis.h.

◆ m_h_XY133

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY133
private

Definition at line 101 of file ClusterAnalysis.h.

◆ m_h_XY133_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY133_t
private

Definition at line 103 of file ClusterAnalysis.h.

◆ m_h_XY232

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY232
private

Definition at line 105 of file ClusterAnalysis.h.

◆ m_h_XY232_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY232_t
private

Definition at line 107 of file ClusterAnalysis.h.

◆ m_h_XY233

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY233
private

Definition at line 106 of file ClusterAnalysis.h.

◆ m_h_XY233_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY233_t
private

Definition at line 108 of file ClusterAnalysis.h.

◆ m_h_XY_t

std::unique_ptr<TH1F> ClusterSeg::ClusterAnalysis::m_h_XY_t
private

Definition at line 88 of file ClusterAnalysis.h.

◆ m_ncalls

int ClusterSeg::ClusterAnalysis::m_ncalls {}
private

Definition at line 45 of file ClusterAnalysis.h.

45{};

◆ m_ntuple

ClusterNtuple ClusterSeg::ClusterAnalysis::m_ntuple {}
private

Definition at line 44 of file ClusterAnalysis.h.

44{};

◆ m_tree

TTree* ClusterSeg::ClusterAnalysis::m_tree
private

Definition at line 43 of file ClusterAnalysis.h.

◆ m_writeOut

bool ClusterSeg::ClusterAnalysis::m_writeOut
private

Definition at line 47 of file ClusterAnalysis.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0