15 locEventLoop->GetSingle(locParticleID);
18 vector<const DFCALGeometry*> locFCALGeometry;
19 locEventLoop->Get(locFCALGeometry);
22 vector<const DTrackFitter*>locFitters;
23 locEventLoop->Get(locFitters);
28 japp->RootWriteLock();
34 dNShowerBCAL_FCAL = GetOrCreate_Histogram<TH2I>(
"NShowerBCAL_FCAL",
"Number of non-matched showers; FCAL; BCAL", 10, 0, 10, 10, 0, 10);
35 dHistMap_FCALShowerDeltaR_P = GetOrCreate_Histogram<TH2I>(
"FCALShowerDeltaR_P",
"Unused FCAL showers #DeltaR vs momentum; momentum; #DeltaR", 120, 0., 6., 200, 0, 50);
36 dHistMap_FCALShowerDeltaR_Theta = GetOrCreate_Histogram<TH2I>(
"FCALShowerDeltaR_Theta",
"Unused FCAL showers #DeltaR vs #theta; #theta; #DeltaR", 150, 0, 15, 200, 0, 50);
37 dHistMap_FCALShowerDeltaD_P = GetOrCreate_Histogram<TH2I>(
"FCALShowerDeltaD_P",
"Unused FCAL showers #DeltaD vs momentum; momentum; #DeltaR", 120, 0., 6., 200, 0, 50);
38 dHistMap_FCALShowerDeltaD_Theta = GetOrCreate_Histogram<TH2I>(
"FCALShowerDeltaD_Theta",
"Unused FCAL showers #DeltaD vs #theta; #theta; #DeltaD", 150, 0, 15, 200, 0, 50);
39 dHistMap_FCALShowerDeltaD_DeltaT = GetOrCreate_Histogram<TH2I>(
"FCALShowerDeltaD_DeltaT",
"Unused FCAL showers #DeltaD vs #Deltat; #Deltat; #DeltaD", 200, -100., 100., 200, 0, 50);
41 dHistMap_BCALShowerDeltaPhi_DeltaZ = GetOrCreate_Histogram<TH2I>(
"BCALShowerDeltaPhi_DeltaZ",
"Unused BCAL showers #Delta#phi vs #DeltaZ; #DeltaZ; #Delta#phi", 200, -50, 50, 360, -180, 180);
42 dHistMap_BCALShowerDeltaPhi_P = GetOrCreate_Histogram<TH2I>(
"BCALShowerDeltaPhi_P",
"Unused BCAL showers #Delta#phi vs momentum; momentum; #Delta#phi", 120, 0., 6., 360, -180, 180);
43 dHistMap_BCALShowerDeltaPhi_Theta = GetOrCreate_Histogram<TH2I>(
"BCALShowerDeltaPhi_Theta",
"Unused BCAL showers #Delta#phi vs #theta; #theta; #Delta#phi", 150, 0, 150, 360, -180, 180);
44 dHistMap_BCALShowerDeltaPhi_DeltaT = GetOrCreate_Histogram<TH2I>(
"BCALShowerDeltaPhi_DeltaT",
"Unused BCAL showers #Delta#phi vs #Deltat; #Deltat; #Delta$phi", 200, -100., 100., 360, -180, 180);
45 dHistMap_BCALShowerDeltaZ_DeltaT = GetOrCreate_Histogram<TH2I>(
"BCALShowerDeltaZ_DeltaT",
"Unused FCAL showers #DeltaZ vs #Deltat; #Deltat; #DeltaZ", 200, -100., 100., 200, -50, 50);
48 h1_deltaX = GetOrCreate_Histogram<TH1I>(
"h1_deltaX",
"Fcal X - Track X", nbins,-25,25);
49 h1_deltaY = GetOrCreate_Histogram<TH1I>(
"h1_deltaY",
"Fcal Y - Track Y", nbins,-25,25);
50 h1_Efcal = GetOrCreate_Histogram<TH1I>(
"h1_Efcal",
"Hit energy", nbins,0,4);
51 h1_tfcal = GetOrCreate_Histogram<TH1I>(
"h1_tfcal",
"Hit time", 250,-25,225);
53 h1_N9 = GetOrCreate_Histogram<TH1I>(
"h1_N9",
"Hit N9", 25, 0, 25);
54 h1_E9 = GetOrCreate_Histogram<TH1I>(
"h1_E9",
"Energy E9 (GeV)", nbins, 0, 2);
55 h1_t9 = GetOrCreate_Histogram<TH1I>(
"h1_t9",
"Time t9 (ns)", 250, -25, 225);
56 h1_t9sigma = GetOrCreate_Histogram<TH1I>(
"h1_t9sigma",
"Time t9sigma",nbins,0,10);
58 h1_N1 = GetOrCreate_Histogram<TH1I>(
"h1_N1",
"Hit N1", 25, 0, 25);
59 h1_E1 = GetOrCreate_Histogram<TH1I>(
"h1_E1",
"Energy E1 (GeV)", nbins, 0, 2);
60 h1_t1 = GetOrCreate_Histogram<TH1I>(
"h1_t1",
"Time t1 (ns)", 250, -25, 225);
61 h1_t1sigma = GetOrCreate_Histogram<TH1I>(
"h1_t1sigma",
"Time t1sigma",nbins,0,10);
63 h2_YvsX9 = GetOrCreate_Histogram<TH2I>(
"h2_YvsX9",
"Hit position Y vs X, E9",240,-120,120,240,-120,120);
64 h2_dEdx9_vsp= GetOrCreate_Histogram<TH2I>(
"h2_dEdx9_vsp",
"Track dEdx9 vs p",nbins,0,4,nbins,0,10);
65 h2_E9vsp= GetOrCreate_Histogram<TH2I>(
"h2_E9vsp",
"E9 vs p",nbins,0,4,nbins,0,4);
66 h2_dEdxvsE9= GetOrCreate_Histogram<TH2I>(
"h2_dEdxvsE9",
"dEdx vs E9 energy",nbins,0,4,nbins,0,4);
67 h2_E9_vsTheta= GetOrCreate_Histogram<TH2I>(
"h2_E9_vsTheta",
"E9 vs Theta",90,0,30,nbins,0,4);
68 h2_E9_vsPhi= GetOrCreate_Histogram<TH2I>(
"h2_E9_vsPhi",
"E9 vs Phi",90,-180,180,nbins,0,4);
70 h2_YvsX1 = GetOrCreate_Histogram<TH2I>(
"h2_YvsX1",
"Hit position Y vs X, E1",240,-120,120,240,-120,120);
71 h2_dEdx1_vsp = GetOrCreate_Histogram<TH2I>(
"h2_dEdx1_vsp",
"Track dEdx1 vs p",nbins,0,4,nbins,0,10);
72 h2_E1vsp = GetOrCreate_Histogram<TH2I>(
"h2_E1vsp",
"E1 vs p",nbins,0,4,nbins,0,4);
73 h2_dEdxvsE1 = GetOrCreate_Histogram<TH2I>(
"h2_dEdxvsE1",
"dEdx vs E1 energy",nbins,0,4,nbins,0,4);
74 h2_E1_vsTheta = GetOrCreate_Histogram<TH2I>(
"h2_E1_vsTheta",
"E1 vs Theta",90,0,30,nbins,0,4);
75 h2_E1_vsPhi = GetOrCreate_Histogram<TH2I>(
"h2_E1_vsPhi",
"E1 vs Phi",90,-180,180,nbins,0,4);
76 h2_E1vsRlocal = GetOrCreate_Histogram<TH2I>(
"h2_E1vsRlocal",
"E1 vs Rtrk rel to Block center (cm)",nbins,0,5,nbins,0,4);
77 h2_YvsXcheck = GetOrCreate_Histogram<TH2I>(
"h2_E1vsRlocal",
"E1 vs Rtrk rel to Block center (cm)",nbins,0,5,nbins,0,4);
81 TString match[2] = {
"Match",
""};
82 map<int, TString> charge;
83 charge[-1] =
"Neg"; charge[+1] =
"Pos";
85 for(
int locDummy = 0; locDummy < 2; locDummy++) {
86 bool locMatch = (locDummy == 0);
88 for(
int locCharge = -1; locCharge < 2; locCharge+=2) {
89 locHistName =
"TrackNhits_Theta" + match[locDummy] + charge[locCharge];
90 locHistTitle =
"Number of hits on track vs #theta: " + match[locDummy] + charge[locCharge];
91 locHistTitle +=
"; #theta; # DOF";
92 dHistMap_TrackNhits_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 90, 0., 90., 35, 0, 35);
94 locHistName =
"TrackNhitsCDC_Theta" + match[locDummy] + charge[locCharge];
95 locHistTitle =
"Number of CDC ring hits on track vs #theta: " + match[locDummy] + charge[locCharge];
96 locHistTitle +=
"; #theta; # CDC ring hits";
97 dHistMap_TrackNhitsCDC_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 90, 0., 90., 35, 0, 35);
99 locHistName =
"TrackNhitsFDC_Theta" + match[locDummy] + charge[locCharge];
100 locHistTitle =
"Number of FDC plane hits on track vs #theta: " + match[locDummy] + charge[locCharge];
101 locHistTitle +=
"; #theta; # FDC plane hits";
102 dHistMap_TrackNhitsFDC_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 90, 0., 90., 35, 0, 35);
104 locHistName =
"TrackNhitsFDCVsCDC_Theta13_16" + match[locDummy] + charge[locCharge];
105 locHistTitle =
"Number of FDC plane hits vs CDC ring hits (13<#theta<16): " + match[locDummy] + charge[locCharge];
106 locHistTitle +=
"; # CDC ring hits; # FDC plane hits";
109 locHistName =
"TrackNhitsFDCVsCDC_Theta16_20" + match[locDummy] + charge[locCharge];
110 locHistTitle =
"Number of FDC plane hits vs CDC ring hits (16<#theta<20): " + match[locDummy] + charge[locCharge];
111 locHistTitle +=
"; # CDC ring hits; # FDC plane hits";
114 locHistName =
"TrackChiSq_Theta" + match[locDummy] + charge[locCharge];
115 locHistTitle =
"FOM for track #chi^{2} vs #theta: " + match[locDummy] + charge[locCharge];
116 locHistTitle +=
"; #theta; #chi^{2}";
117 dHistMap_TrackChiSq_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 90, 0., 90., 500, 0., 100.);
119 locHistName =
"TrackFOM_Theta" + match[locDummy] + charge[locCharge];
120 locHistTitle =
"FOM for track fit vs #theta: " + match[locDummy] + charge[locCharge];
121 locHistTitle +=
"; #theta; FOM";
122 dHistMap_TrackFOM_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 90, 0., 90., 1000, 0., 1.);
124 locHistName =
"TrackP_Theta" + match[locDummy] + charge[locCharge];
125 locHistTitle =
"P vs #theta: " + match[locDummy] + charge[locCharge];
126 locHistTitle +=
"; #theta; momentum";
127 dHistMap_TrackP_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 90, 0., 90., 120, 0., 3.);
129 locHistName =
"TrackPOCAXY" + match[locDummy] + charge[locCharge];
130 locHistTitle =
"POCA to beamline Y vs X: " + match[locDummy] + charge[locCharge];
131 locHistTitle +=
"; POCA X; POCAY";
132 dHistMap_TrackPOCAXY[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 200, -20., 20., 200, -20., 20.);
134 locHistName =
"TrackPOCAZ" + match[locDummy] + charge[locCharge];
135 locHistTitle =
"POCA to beamline Z: " + match[locDummy] + charge[locCharge];
136 locHistTitle +=
"; POCA Z";
137 dHistMap_TrackPOCAZ[locMatch][locCharge] = GetOrCreate_Histogram<TH1I>(locHistName.Data(), locHistTitle.Data(), 500, 0., 250.);
139 locHistName =
"TrackCDCHitRadius_NHits" + match[locDummy] + charge[locCharge];
140 locHistTitle =
"CDC Hit radius vs # hits: " + match[locDummy] + charge[locCharge];
141 locHistTitle +=
"; # hits; CDC Hit Radius";
144 locHistName =
"HighNDFTrackCDCHitRadius_PT" + match[locDummy] + charge[locCharge];
145 locHistTitle =
"High NDF tracks CDC Hit radius vs P_{T}: " + match[locDummy] + charge[locCharge];
146 locHistTitle +=
"; P_{T} (GeV); CDC Hit Radius";
149 locHistName =
"LowNDFTrackCDCHitRadius_PT" + match[locDummy] + charge[locCharge];
150 locHistTitle =
"Low NDF tracks CDC Hit radius vs P_{T}: " + match[locDummy] + charge[locCharge];
151 locHistTitle +=
"; P_{T} (GeV); CDC Hit Radius";
154 locHistName =
"LowNDFTrackP_VertZ" + match[locDummy] + charge[locCharge];
155 locHistTitle =
"Low NDF tracks P vs vertex Z: " + match[locDummy] + charge[locCharge];
156 locHistTitle +=
"; Vertex Z (cm); momentum";
157 dHistMap_LowNDFTrackP_VertZ[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 500, 0., 250., 120, 0., 3.);
159 locHistName =
"LowNDFTrackPT_Phi" + match[locDummy] + charge[locCharge];
160 locHistTitle =
"Low NDF tracks P_{T} vs #phi: " + match[locDummy] + charge[locCharge];
161 locHistTitle +=
"; #phi; transverse momentum";
162 dHistMap_LowNDFTrackPT_Phi[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 360., -180., 180., 120, 0., 3.);
164 locHistName =
"TrackMCHitFraction_Theta" + match[locDummy] + charge[locCharge];
165 locHistTitle =
"Track MC Hit Fraction vs #theta: " + match[locDummy] + charge[locCharge];
166 locHistTitle +=
"; #theta; MC Hit Fraction";
169 locHistName =
"TrackMCMomRes_Theta" + match[locDummy] + charge[locCharge];
170 locHistTitle =
"Track MC Momentum Resolution vs #theta: " + match[locDummy] + charge[locCharge];
171 locHistTitle +=
"; #theta; MC Momentum Resolution #Delta p/p";
172 dHistMap_TrackMCMomRes_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 90., 0., 90., 100, -0.4, 0.4);
174 locHistName =
"TrackMCThetaRes_Theta" + match[locDummy] + charge[locCharge];
175 locHistTitle =
"Track MC Theta Resolution vs #theta: " + match[locDummy] + charge[locCharge];
176 locHistTitle +=
"; #theta; MC Theta Resolution #Delta#theta (degrees)";
177 dHistMap_TrackMCThetaRes_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 90., 0., 90., 100, -5, 5);
180 vector<DetectorSystem_t> locDetectorSystems;
181 locDetectorSystems.push_back(
SYS_FCAL); locDetectorSystems.push_back(
SYS_BCAL);
182 for(
size_t loc_i = 0; loc_i < locDetectorSystems.size(); ++loc_i)
185 TString locSystemName = (locSystem ==
SYS_FCAL) ?
"FCAL" :
"BCAL";
186 double thetaMax = (locSystem ==
SYS_FCAL) ? 15. : 150.;
188 locHistName =
"ShowerEnergy_Theta" + match[locDummy] + locSystemName;
189 locHistTitle =
"Shower Energy vs #theta: " + match[locDummy] + locSystemName;
190 locHistTitle +=
";#theta; Energy";
191 dHistMap_ShowerEnergy_Theta[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 100., 0., 5.);
193 locHistName =
"ShowerPhi_Theta" + match[locDummy] + locSystemName;
194 locHistTitle =
"Shower #phi vs #theta: " + match[locDummy] + locSystemName;
195 locHistTitle +=
";#theta; #phi";
196 dHistMap_ShowerPhi_Theta[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 360., -180., 180.);
198 locHistName =
"ShowerNClusters" + match[locDummy] + locSystemName;
199 locHistTitle =
"Number of clusters in shower: " + match[locDummy] + locSystemName;
200 dHistMap_ShowerNclusters[locMatch][locSystem] = GetOrCreate_Histogram<TH1I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15);
202 locHistName =
"ShowerNHits" + match[locDummy] + locSystemName;
203 locHistTitle =
"Number of hits in shower: " + match[locDummy] + locSystemName;
204 dHistMap_ShowerNhits[locMatch][locSystem] = GetOrCreate_Histogram<TH1I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15);
206 locHistName =
"ShowerMaxEnergy_NHits" + match[locDummy] + locSystemName;
207 locHistTitle =
"E_{max}/E_{tot} vs number of hits in shower: " + match[locDummy] + locSystemName;
208 dHistMap_ShowerMaxEnergy_Nhits[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15, 500, 0., 1.);
210 locHistName =
"ShowerDeltaT_NHits" + match[locDummy] + locSystemName;
211 locHistTitle =
"t_{shower} - t_{#gamma} vs number of hits in shower: " + match[locDummy] + locSystemName;
212 dHistMap_ShowerDeltaT_Nhits[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15, 200, -100., 100.);
214 locHistName =
"ShowerDeltaT_E" + match[locDummy] + locSystemName;
215 locHistTitle =
"t_{shower} - t_{#gamma} vs shower energy: " + match[locDummy] + locSystemName;
216 dHistMap_ShowerDeltaT_E[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 100., 0., 5., 200, -100., 100.);
218 locHistName =
"ShowerE_Theta" + match[locDummy] + locSystemName;
219 locHistTitle =
"t_{shower} - t_{#gamma} vs shower #theta: " + match[locDummy] + locSystemName;
220 dHistMap_ShowerE_Theta[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 120., 0., 6.);
223 locHistName =
"ShowerNcell" + match[locDummy] + locSystemName;
224 locHistTitle =
"Number of points in shower: " + match[locDummy] + locSystemName;
225 dHistMap_BCALShowerNcell[locMatch] = GetOrCreate_Histogram<TH1I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15);
227 locHistName =
"Layer1Energy_Theta" + match[locDummy] + locSystemName;
228 locHistTitle =
"Shower Layer 1 Energy vs #theta: " + match[locDummy] + locSystemName;
229 locHistTitle +=
";#theta; Energy Layer 1";
230 dHistMap_Layer1Energy_Theta[locMatch] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 500., 0., 1.);
232 locHistName =
"Layer2Energy_Theta" + match[locDummy] + locSystemName;
233 locHistTitle =
"Shower Layer 2 Energy vs #theta: " + match[locDummy] + locSystemName;
234 locHistTitle +=
";#theta; Energy Layer 2";
235 dHistMap_Layer2Energy_Theta[locMatch] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 500., 0., 1.);
237 locHistName =
"Layer3Energy_Theta" + match[locDummy] + locSystemName;
238 locHistTitle =
"Shower Layer 3 Energy vs #theta: " + match[locDummy] + locSystemName;
239 locHistTitle +=
";#theta; Energy Layer 3";
240 dHistMap_Layer3Energy_Theta[locMatch] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 500., 0., 1.);
242 locHistName =
"Layer4Energy_Theta" + match[locDummy] + locSystemName;
243 locHistTitle =
"Shower Layer 4 Energy vs #theta: " + match[locDummy] + locSystemName;
244 locHistTitle +=
";#theta; Energy Layer 4";
245 dHistMap_Layer4Energy_Theta[locMatch] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 500., 0., 1.);
264 double locBeamPhotonTime = locBeamPhoton->time();
268 locEventLoop->GetSingle(locDetectorMatches);
271 vector<const DMCThrownMatching*> locMCThrownMatchingVector;
272 locEventLoop->Get(locMCThrownMatchingVector);
273 vector<const DMCThrown*> locMCThrowns;
274 locEventLoop->Get(locMCThrowns);
277 vector<const DChargedTrack*> locChargedTracks;
278 locEventLoop->Get(locChargedTracks);
279 vector<const DNeutralShower*> locNeutralShowers;
280 locEventLoop->Get(locNeutralShowers);
281 vector<const DFCALShower*> locFCALShowers;
282 locEventLoop->Get(locFCALShowers);
283 vector<const DBCALShower*> locBCALShowers;
284 locEventLoop->Get(locBCALShowers);
286 vector<const DChargedTrack*> locUnusedChargedTracks;
287 vector<const DNeutralShower*> locUnusedNeutralShowers;
290 for(
size_t loc_j = 0; loc_j < locChargedTracks.size(); ++loc_j) {
295 if(!locMCThrowns.empty())
296 locMCThrown = locMCThrownMatchingVector[0]->Get_MatchingMCThrown(locChargedTracks[loc_j], locMatchFOM);
299 for(
size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i) {
302 if(locChargedTrack == NULL)
continue;
304 if(locChargedTracks[loc_j]->candidateid == locChargedTrack->
candidateid) {
306 FillTrack(locEventLoop, locChargedTracks[loc_j],
true, locMCThrown);
312 locUnusedChargedTracks.push_back(locChargedTracks[loc_j]);
313 FillTrack(locEventLoop, locChargedTracks[loc_j],
false, locMCThrown);
318 for(
size_t loc_j = 0; loc_j < locBCALShowers.size(); ++loc_j) {
321 for(
size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i) {
324 if(locChargedTrack == NULL)
continue;
329 const DBCALShower *locBCALShower = locBCALShowers[loc_j];
330 DVector3 bcal_pos(locBCALShower->
x, locBCALShower->
y, locBCALShower->
z);
332 double locFlightTime = 9.9E9, locPathLength = 9.9E9;
333 vector<DTrackFitter::Extrapolation_t>extrapolations=locTrackTimeBased->extrapolations.at(
SYS_BCAL);
342 double dz = bcal_pos.z() - proj_pos.z();
343 double dphi = bcal_pos.Phi() - proj_pos.Phi();
344 while(dphi > TMath::Pi())
345 dphi -= 2*TMath::Pi();
346 while(dphi < -1.*TMath::Pi())
347 dphi += 2*TMath::Pi();
349 double locDeltaT = locBCALShowers[loc_j]->t - locBeamPhotonTime;
364 shared_ptr<const DBCALShowerMatchParams> locBCALShowerMatchParams;
367 if(locBCALShowerMatchParams->dBCALShower == locBCALShower) {
370 locNeutralShower->
dEnergy = locBCALShowers[loc_j]->E;
371 locNeutralShower->
dSpacetimeVertex.SetXYZT(locBCALShowers[loc_j]->
x, locBCALShowers[loc_j]->
y, locBCALShowers[loc_j]->z, locBCALShowers[loc_j]->t);
372 locNeutralShower->AddAssociatedObject(locBCALShowers[loc_j]);
373 double locFlightTime = locBCALShowerMatchParams->dFlightTime;
374 FillShower(locNeutralShower,
true, locBeamPhotonTime, locFlightTime);
375 delete locNeutralShower;
381 for(
size_t loc_j = 0; loc_j < locFCALShowers.size(); ++loc_j) {
384 for(
size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i) {
387 if(locChargedTrack == NULL)
continue;
392 const DFCALShower *locFCALShower = locFCALShowers[loc_j];
396 vector<DTrackFitter::Extrapolation_t>extrapolations=locTrackTimeBased->extrapolations.at(
SYS_FCAL);
397 if (extrapolations.size()==0)
continue;
398 DVector3 proj_pos=extrapolations[0].position;
400 double dd = (fcal_pos - proj_pos).Mag();
401 double dr = (fcal_pos - proj_pos).Perp();
402 double dphi = fcal_pos.Phi() - proj_pos.Phi();
403 while(dphi > TMath::Pi())
404 dphi -= 2*TMath::Pi();
405 while(dphi < -1.*TMath::Pi())
406 dphi += 2*TMath::Pi();
408 double locDeltaT = locFCALShowers[loc_j]->getTime() - locBeamPhotonTime;
423 shared_ptr<const DFCALShowerMatchParams> locFCALShowerMatchParams;
426 if(locFCALShowerMatchParams->dFCALShower == locFCALShower) {
429 locNeutralShower->
dEnergy = locFCALShowers[loc_j]->getEnergy();
430 locNeutralShower->
dSpacetimeVertex.SetVect(locFCALShowers[loc_j]->getPosition());
432 locNeutralShower->AddAssociatedObject(locFCALShowers[loc_j]);
433 double locFlightTime = locFCALShowerMatchParams->dFlightTime;
434 FillShower(locNeutralShower,
true, locBeamPhotonTime, locFlightTime);
435 delete locNeutralShower;
441 int nUnmatchedFCAL = 0;
442 int nUnmatchedBCAL = 0;
447 for(
size_t loc_j = 0; loc_j < locNeutralShowers.size(); ++loc_j) {
448 locUnusedNeutralShowers.push_back(locNeutralShowers[loc_j]);
449 double locFlightTime = locNeutralShowers[loc_j]->dSpacetimeVertex.Vect().Mag()/
SPEED_OF_LIGHT;
450 FillShower(locNeutralShowers[loc_j],
false, locBeamPhotonTime, locFlightTime);
452 if(locNeutralShowers[loc_j]->dDetectorSystem ==
SYS_FCAL) {
455 if(locNeutralShowers[loc_j]->dDetectorSystem ==
SYS_BCAL) {
477 int locCharge = locChargedTrackHypothesis->
charge();
481 double nHits = locTrackTimeBased->
Ndof + 5.;
482 double locTheta = locTrackTimeBased->momentum().Theta()*180/TMath::Pi();
484 set<int> locCDCRings;
487 set<int> locFDCPlanes;
490 double locHitFraction = locTrackTimeBased->dNumHitsMatchedToThrown/nHits;
491 double locMomentumRes = -999;
492 double locThetaRes = -999;
494 locMomentumRes = (locTrackTimeBased->momentum().Mag() - locMCThrown->
momentum().Mag())/locMCThrown->
momentum().Mag();
495 locThetaRes = (locTrackTimeBased->momentum().Theta() - locMCThrown->
momentum().Theta())*180./TMath::Pi();
506 if(locTheta>13. && locTheta<16.)
508 if(locTheta>16. && locTheta<20.)
513 dHistMap_TrackPOCAXY[locMatch][locCharge]->Fill(locTrackTimeBased->position().X(), locTrackTimeBased->position().Y());
522 for(set<int>::iterator locIterator = locFDCPlanes.begin(); locIterator != locFDCPlanes.end(); ++locIterator) {
527 if(locTrackTimeBased->momentum().Theta()*180./TMath::Pi() > 30.){
528 for(set<int>::iterator locIterator = locCDCRings.begin(); locIterator != locCDCRings.end(); ++locIterator) {
536 dHistMap_LowNDFTrackPT_Phi[locMatch][locCharge]->Fill(locTrackTimeBased->momentum().Phi()*180/TMath::Pi(), locTrackTimeBased->momentum().Perp());
542 if(!locMatch)
return;
546 DVector3 fcal_origin(0.0,0.0,zfcal);
550 double theta = locTrackTimeBased->momentum().Theta()*180./TMath::Pi();
551 double phi = locTrackTimeBased->momentum().Phi()*180./TMath::Pi();
552 double p = locTrackTimeBased->momentum().Mag();
553 double dEdx = locTrackTimeBased->dEdx()*1e6;
555 vector<const DFCALHit*> fcalhits;
556 locEventLoop->Get(fcalhits);
557 if(fcalhits.empty())
return;
559 vector<DTrackFitter::Extrapolation_t>extrapolations=locTrackTimeBased->extrapolations.at(
SYS_FCAL);
560 if (extrapolations.size()>0){
561 trkpos=extrapolations[0].position;
562 double trkposX = trkpos.X();
563 double trkposY = trkpos.Y();
583 trkrow += row_offset;
584 trkcol += col_offset;
586 for (
unsigned int j=0; j < fcalhits.size(); ++j) {
587 int row = fcalhits[j]->row;
588 int col = fcalhits[j]->column;
589 double x = fcalhits[j]->x;
590 double y = fcalhits[j]->y;
591 double Efcal = fcalhits[j]->E;
592 double tfcal= fcalhits[j]->t;
593 double intOverPeak = fcalhits[j]->intOverPeak;
596 int drow = abs(row - trkrow);
597 int dcol = abs(col - trkcol);
605 if (drow<=Delta_block && dcol<=Delta_block && (tfcal>-15 && tfcal<50) && (intOverPeak>2.5 && intOverPeak<9)) {
607 E9peak += Efcal*6/intOverPeak;
622 t9 = N9>0? t9/N9 : 0;
623 t9sigma = N9>0?
sqrt(t9sq/N9 - t9*t9): 0;
653 double Rlocal =
sqrt(dX_E1*dX_E1 + dY_E1*dY_E1);
671 double layerE[4] = {0., 0., 0., 0.};
673 double locEnergy = locNeutralShower->
dEnergy;
675 double locDeltaT = locNeutralShower->
dSpacetimeVertex.T() - locFlightTime - locBeamPhotonTime;
677 double locEnergyCluster = 0.;
678 double locMaxEnergyCluster = 0.;
684 locNeutralShower->GetSingleT(locFCALShower);
686 vector<const DFCALCluster*> locFCALClusters;
687 locFCALShower->Get(locFCALClusters);
688 nClusters = locFCALClusters.size();
691 for(
unsigned int i=0; i<locFCALClusters.size(); i++){
692 const vector<DFCALCluster::DFCALClusterHit_t> locFCALHits = locFCALClusters[i]->GetHits();
694 locEnergyCluster = locFCALClusters[i]->getEnergy();
695 locMaxEnergyCluster = locFCALClusters[i]->getEmax();
697 for(
unsigned int j=0; j<locFCALHits.size(); j++){
706 locNeutralShower->GetSingleT(locBCALShower);
717 vector<const DBCALCluster*> locBCALClusters;
718 locBCALShower->Get(locBCALClusters);
719 nClusters = locBCALClusters.size();
722 for(
unsigned int i=0; i<locBCALClusters.size(); i++){
723 vector<const DBCALPoint*> locBCALPoints;
724 locBCALClusters[i]->Get(locBCALPoints);
726 locEnergyCluster = locBCALClusters[i]->E();
727 if(locBCALPoints.size() == 1) locMaxEnergyCluster = locBCALClusters[i]->E();
729 for(
unsigned int j=0; j<locBCALPoints.size(); j++){
733 if(point->
E() > locMaxEnergyCluster)
734 locMaxEnergyCluster = point->
E();
736 layerE[point->
layer()-1] += point->
E();
747 dHistMap_ShowerPhi_Theta[locMatch][locSystem]->Fill(locPosition.Theta()*180./TMath::Pi(), locPosition.Phi()*180./TMath::Pi());
754 if(locDeltaT > -5. && locDeltaT < 5. && locSystem ==
SYS_FCAL)
756 if(locDeltaT > -5. && locDeltaT < 5. && locSystem ==
SYS_BCAL)
vector< const DKinematicData * > Get_FinalParticles_Measured(void) const
TDirectoryFile * ChangeTo_BaseDirectory(void)
TH2I * dHistMap_BCALShowerDeltaPhi_Theta
void Get_FDCPlanes(unsigned int locBitPattern, set< int > &locFDCPlanes) const
bool ExtrapolateToRadius(double R, const vector< Extrapolation_t > &extraps, DVector3 &pos, DVector3 &mom, double &t, double &s) const
void Get_CDCRings(unsigned int locBitPattern, set< int > &locCDCRings) const
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerEnergy_Theta
map< bool, map< int, TH2I * > > dHistMap_TrackNhitsFDC_Theta
map< bool, map< int, TH2I * > > dHistMap_TrackPOCAXY
map< bool, TH2I * > dHistMap_Layer4Energy_Theta
map< bool, map< int, TH2I * > > dHistMap_TrackP_Theta
map< bool, map< DetectorSystem_t, TH1I * > > dHistMap_ShowerNclusters
TH2I * dHistMap_BCALShowerDeltaZ_DeltaT
bool Perform_Action(JEventLoop *locEventLoop, const DParticleCombo *locParticleCombo)
const DFCALGeometry * dFCALGeometry
map< bool, TH2I * > dHistMap_Layer3Energy_Theta
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerDeltaT_Nhits
TH2I * dHistMap_BCALShowerDeltaPhi_DeltaZ
void Initialize(JEventLoop *locEventLoop)
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerMaxEnergy_Nhits
const DTrackTimeBased * Get_TrackTimeBased(void) const
TDirectoryFile * CreateAndChangeTo_ActionDirectory(void)
const DKinematicData * Get_InitialParticle_Measured(void) const
map< bool, TH1I * > dHistMap_BCALShowerNcell
map< bool, map< int, TH2I * > > dHistMap_TrackCDCHitRadius_Nhits
bool Get_UseKinFitResultsFlag(void) const
map< bool, map< DetectorSystem_t, TH1I * > > dHistMap_ShowerNhits
DetectorSystem_t dDetectorSystem
DLorentzVector dSpacetimeVertex
map< bool, map< int, TH2I * > > dHistMap_TrackMCThetaRes_Theta
map< bool, map< int, TH1I * > > dHistMap_TrackPOCAZ
map< bool, map< int, TH2I * > > dHistMap_LowNDFTrackCDCHitRadius_PT
TH2I * dHistMap_BCALShowerDeltaPhi_DeltaT
TH2I * dHistMap_FCALShowerDeltaD_Theta
TH2I * dHistMap_FCALShowerDeltaD_P
map< bool, map< int, TH2I * > > dHistMap_TrackMCMomRes_Theta
map< bool, map< int, TH2I * > > dHistMap_TrackNhitsCDC_Theta
bool Get_BestFCALMatchParams(const DTrackingData *locTrack, const DDetectorMatches *locDetectorMatches, shared_ptr< const DFCALShowerMatchParams > &locBestMatchParams) const
bool Get_BestBCALMatchParams(const DTrackingData *locTrack, const DDetectorMatches *locDetectorMatches, shared_ptr< const DBCALShowerMatchParams > &locBestMatchParams) const
void FillShower(const DNeutralShower *locNeutralShower, bool locMatch, double locBeamPhotonTime, double locFlightTime)
const DTrackFitter * dFitter
map< bool, map< int, TH2I * > > dHistMap_HighNDFTrackCDCHitRadius_PT
vector< const DKinematicData * > Get_FinalParticles(void) const
map< bool, map< int, TH2I * > > dHistMap_TrackNhitsFDCVsCDC_Theta16_20
map< bool, map< int, TH2I * > > dHistMap_TrackNhitsFDCVsCDC_Theta13_16
map< bool, TH2I * > dHistMap_Layer1Energy_Theta
TH2I * dHistMap_FCALShowerDeltaR_Theta
void FillTrack(JEventLoop *locEventLoop, const DChargedTrack *locChargedTrack, bool locMatch, const DMCThrown *locMCThrown)
map< bool, TH2I * > dHistMap_Layer2Energy_Theta
const DParticleID * dParticleID
map< bool, map< int, TH2I * > > dHistMap_TrackChiSq_Theta
int Ndof
Number of degrees of freedom in the fit.
double charge(void) const
map< bool, map< int, TH2I * > > dHistMap_TrackMCHitFraction_Theta
int column(int channel) const
const JObject * Get_FinalParticle_SourceObject(size_t locFinalParticleIndex) const
map< bool, map< int, TH2I * > > dHistMap_TrackNhits_Theta
const DKinematicData * Get_InitialParticle(void) const
const DVector3 & momentum(void) const
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerE_Theta
const DChargedTrackHypothesis * Get_BestFOM(void) const
TH2I * dHistMap_FCALShowerDeltaR_P
TH2I * dHistMap_FCALShowerDeltaD_DeltaT
int row(int channel) const
map< bool, map< int, TH2I * > > dHistMap_LowNDFTrackP_VertZ
const DParticleComboStep * Get_ParticleComboStep(size_t locStepIndex) const
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerPhi_Theta
DVector3 getPosition() const
map< bool, map< int, TH2I * > > dHistMap_TrackFOM_Theta
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerDeltaT_E
TH2I * dHistMap_BCALShowerDeltaPhi_P
map< bool, map< int, TH2I * > > dHistMap_LowNDFTrackPT_Phi