15 locEventLoop->GetSingle(locParticleID);
20 japp->RootWriteLock();
26 dNShowerBCAL_FCAL = GetOrCreate_Histogram<TH2I>(
"NShowerBCAL_FCAL",
"Number of non-matched showers; FCAL; BCAL", 10, 0, 10, 10, 0, 10);
30 TString match[2] = {
"Match",
""};
31 map<int, TString> charge;
32 charge[-1] =
"Neg"; charge[+1] =
"Pos";
34 for(
int locDummy = 0; locDummy < 2; locDummy++) {
35 bool locMatch = (locDummy == 0);
37 for(
int locCharge = -1; locCharge < 2; locCharge+=2) {
38 locHistName =
"TrackNhits_Theta" + match[locDummy] + charge[locCharge];
39 locHistTitle =
"Number of hits on track vs #theta: " + match[locDummy] + charge[locCharge];
40 locHistTitle +=
"; #theta; # DOF";
41 dHistMap_TrackNhits_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., 150., 50, 0, 50);
43 locHistName =
"TrackChiSq_Theta" + match[locDummy] + charge[locCharge];
44 locHistTitle =
"FOM for track #chi^{2} vs #theta: " + match[locDummy] + charge[locCharge];
45 locHistTitle +=
"; #theta; #chi^{2}";
46 dHistMap_TrackChiSq_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., 150., 500, 0., 100.);
48 locHistName =
"TrackFOM_Theta" + match[locDummy] + charge[locCharge];
49 locHistTitle =
"FOM for track fit vs #theta: " + match[locDummy] + charge[locCharge];
50 locHistTitle +=
"; #theta; FOM";
51 dHistMap_TrackFOM_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., 150., 1000, 0., 1.);
53 locHistName =
"TrackP_Theta" + match[locDummy] + charge[locCharge];
54 locHistTitle =
"P vs #theta: " + match[locDummy] + charge[locCharge];
55 locHistTitle +=
"; #theta; momentum";
56 dHistMap_TrackP_Theta[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., 150., 120, 0., 6.);
58 locHistName =
"TrackPOCAXY" + match[locDummy] + charge[locCharge];
59 locHistTitle =
"POCA to beamline Y vs X: " + match[locDummy] + charge[locCharge];
60 locHistTitle +=
"; POCA X; POCAY";
61 dHistMap_TrackPOCAXY[locMatch][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 200, -20., 20., 200, -20., 20.);
63 locHistName =
"TrackPOCAZ" + match[locDummy] + charge[locCharge];
64 locHistTitle =
"POCA to beamline Z: " + match[locDummy] + charge[locCharge];
65 locHistTitle +=
"; POCA Z";
66 dHistMap_TrackPOCAZ[locMatch][locCharge] = GetOrCreate_Histogram<TH1I>(locHistName.Data(), locHistTitle.Data(), 500, 0., 250.);
81 vector<DetectorSystem_t> locDetectorSystems;
82 locDetectorSystems.push_back(
SYS_FCAL); locDetectorSystems.push_back(
SYS_BCAL);
83 for(
size_t loc_i = 0; loc_i < locDetectorSystems.size(); ++loc_i)
86 TString locSystemName = (locSystem ==
SYS_FCAL) ?
"FCAL" :
"BCAL";
87 double thetaMax = (locSystem ==
SYS_FCAL) ? 15. : 150.;
89 locHistName =
"ShowerEnergy_Theta" + match[locDummy] + locSystemName;
90 locHistTitle =
"Shower Energy vs #theta: " + match[locDummy] + locSystemName;
91 locHistTitle +=
";#theta; Energy";
92 dHistMap_ShowerEnergy_Theta[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 100., 0., 5.);
94 locHistName =
"ShowerPhi_Theta" + match[locDummy] + locSystemName;
95 locHistTitle =
"Shower #phi vs #theta: " + match[locDummy] + locSystemName;
96 locHistTitle +=
";#theta; #phi";
97 dHistMap_ShowerPhi_Theta[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 360., -180., 180.);
99 locHistName =
"ShowerNClusters" + match[locDummy] + locSystemName;
100 locHistTitle =
"Number of clusters in shower: " + match[locDummy] + locSystemName;
101 dHistMap_ShowerNclusters[locMatch][locSystem] = GetOrCreate_Histogram<TH1I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15);
104 locHistName =
"ShowerNHits" + match[locDummy] + locSystemName;
105 locHistTitle =
"Number of hits in shower: " + match[locDummy] + locSystemName;
106 dHistMap_ShowerNhits[locMatch][locSystem] = GetOrCreate_Histogram<TH1I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15);
108 locHistName =
"ShowerMaxEnergy_NHits" + match[locDummy] + locSystemName;
109 locHistTitle =
"E_{max}/E_{tot} vs number of hits in shower: " + match[locDummy] + locSystemName;
110 dHistMap_ShowerMaxEnergy_Nhits[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15, 500, 0., 1.);
112 locHistName =
"ShowerDeltaT_NHits" + match[locDummy] + locSystemName;
113 locHistTitle =
"t_{shower} - t_{#gamma} vs number of hits in shower: " + match[locDummy] + locSystemName;
114 dHistMap_ShowerDeltaT_Nhits[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15, 200, -100., 100.);
116 locHistName =
"ShowerDeltaT_E" + match[locDummy] + locSystemName;
117 locHistTitle =
"t_{shower} - t_{#gamma} vs shower energy: " + match[locDummy] + locSystemName;
118 dHistMap_ShowerDeltaT_E[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 100., 0., 5., 200, -100., 100.);
120 locHistName =
"ShowerE_Theta" + match[locDummy] + locSystemName;
121 locHistTitle =
"t_{shower} - t_{#gamma} vs shower #theta: " + match[locDummy] + locSystemName;
122 dHistMap_ShowerE_Theta[locMatch][locSystem] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 120., 0., 6.);
125 locHistName =
"ShowerNcell" + match[locDummy] + locSystemName;
126 locHistTitle =
"Number of points in shower: " + match[locDummy] + locSystemName;
127 dHistMap_BCALShowerNcell[locMatch] = GetOrCreate_Histogram<TH1I>(locHistName.Data(), locHistTitle.Data(), 15, 0, 15);
129 locHistName =
"Layer1Energy_Theta" + match[locDummy] + locSystemName;
130 locHistTitle =
"Shower Layer 1 Energy vs #theta: " + match[locDummy] + locSystemName;
131 locHistTitle +=
";#theta; Energy Layer 1";
132 dHistMap_Layer1Energy_Theta[locMatch] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 500., 0., 1.);
134 locHistName =
"Layer2Energy_Theta" + match[locDummy] + locSystemName;
135 locHistTitle =
"Shower Layer 2 Energy vs #theta: " + match[locDummy] + locSystemName;
136 locHistTitle +=
";#theta; Energy Layer 2";
137 dHistMap_Layer2Energy_Theta[locMatch] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 500., 0., 1.);
139 locHistName =
"Layer3Energy_Theta" + match[locDummy] + locSystemName;
140 locHistTitle =
"Shower Layer 3 Energy vs #theta: " + match[locDummy] + locSystemName;
141 locHistTitle +=
";#theta; Energy Layer 3";
142 dHistMap_Layer3Energy_Theta[locMatch] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 500., 0., 1.);
144 locHistName =
"Layer4Energy_Theta" + match[locDummy] + locSystemName;
145 locHistTitle =
"Shower Layer 4 Energy vs #theta: " + match[locDummy] + locSystemName;
146 locHistTitle +=
";#theta; Energy Layer 4";
147 dHistMap_Layer4Energy_Theta[locMatch] = GetOrCreate_Histogram<TH2I>(locHistName.Data(), locHistTitle.Data(), 150, 0., thetaMax, 500., 0., 1.);
167 double locBeamPhotonTime = locBeamPhoton->time();
171 locEventLoop->GetSingle(locDetectorMatches);
174 vector<const DChargedTrack*> locChargedTracks;
175 locEventLoop->Get(locChargedTracks);
176 vector<const DNeutralShower*> locNeutralShowers;
177 locEventLoop->Get(locNeutralShowers);
180 for(
size_t loc_j = 0; loc_j < locChargedTracks.size(); ++loc_j) {
184 for(
size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i) {
185 if(locParticles[loc_i]->PID() !=
Proton)
continue;
188 if(locChargedTrack == NULL)
continue;
189 if(locChargedTracks[loc_j]->candidateid == locChargedTrack->
candidateid) {
191 FillTrack(locChargedTracks[loc_j],
true);
197 FillTrack(locChargedTracks[loc_j],
false);
201 int nUnmatchedFCAL = 0;
202 int nUnmatchedBCAL = 0;
207 for(
size_t loc_j = 0; loc_j < locNeutralShowers.size(); ++loc_j) {
211 for(
size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i) {
212 if(locParticles[loc_i]->PID() ==
Proton)
continue;
215 if(locNeutralShower == locNeutralShowers[loc_j]){
217 double locFlightTime = locNeutralShowers[loc_j]->dSpacetimeVertex.Vect().Mag()/
SPEED_OF_LIGHT;
218 FillShower(locNeutralShowers[loc_j],
true, locBeamPhotonTime, locFlightTime);
223 double locFlightTime = locNeutralShowers[loc_j]->dSpacetimeVertex.Vect().Mag()/
SPEED_OF_LIGHT;
224 FillShower(locNeutralShowers[loc_j],
false, locBeamPhotonTime, locFlightTime);
225 if(locNeutralShowers[loc_j]->dDetectorSystem ==
SYS_FCAL) nUnmatchedFCAL++;
226 if(locNeutralShowers[loc_j]->dDetectorSystem ==
SYS_BCAL) nUnmatchedBCAL++;
247 int locCharge = locChargedTrackHypothesis->
charge();
251 float nHits = locTrackTimeBased->
Ndof + 5.;
266 dHistMap_TrackChiSq_Theta[locMatch][locCharge]->Fill(locTrackTimeBased->momentum().Theta()*180/TMath::Pi(), locTrackTimeBased->chisq);
267 dHistMap_TrackFOM_Theta[locMatch][locCharge]->Fill(locTrackTimeBased->momentum().Theta()*180/TMath::Pi(), locTrackTimeBased->FOM);
268 dHistMap_TrackP_Theta[locMatch][locCharge]->Fill(locTrackTimeBased->momentum().Theta()*180/TMath::Pi(), locTrackTimeBased->momentum().Mag());
269 dHistMap_TrackPOCAXY[locMatch][locCharge]->Fill(locTrackTimeBased->position().X(), locTrackTimeBased->position().Y());
287 double layerE[4] = {0., 0., 0., 0.};
289 double locEnergy = locNeutralShower->
dEnergy;
291 double locDeltaT = locNeutralShower->
dSpacetimeVertex.T() - locFlightTime - locBeamPhotonTime;
293 double locEnergyCluster = 0.;
294 double locMaxEnergyCluster = 0.;
300 locNeutralShower->GetSingleT(locFCALShower);
302 vector<const DFCALCluster*> locFCALClusters;
303 locFCALShower->Get(locFCALClusters);
304 nClusters = locFCALClusters.size();
307 for(
unsigned int i=0; i<locFCALClusters.size(); i++){
308 const vector<DFCALCluster::DFCALClusterHit_t> locFCALHits = locFCALClusters[i]->GetHits();
310 locEnergyCluster = locFCALClusters[i]->getEnergy();
311 locMaxEnergyCluster = locFCALClusters[i]->getEmax();
313 for(
unsigned int j=0; j<locFCALHits.size(); j++){
322 locNeutralShower->GetSingleT(locBCALShower);
333 vector<const DBCALCluster*> locBCALClusters;
334 locBCALShower->Get(locBCALClusters);
335 nClusters = locBCALClusters.size();
338 for(
unsigned int i=0; i<locBCALClusters.size(); i++){
339 vector<const DBCALPoint*> locBCALPoints;
340 locBCALClusters[i]->Get(locBCALPoints);
342 locEnergyCluster = locBCALClusters[i]->E();
343 if(locBCALPoints.size() == 1) locMaxEnergyCluster = locBCALClusters[i]->E();
345 for(
unsigned int j=0; j<locBCALPoints.size(); j++){
349 if(point->
E() > locMaxEnergyCluster)
350 locMaxEnergyCluster = point->
E();
352 layerE[point->
layer()-1] += point->
E();
363 dHistMap_ShowerPhi_Theta[locMatch][locSystem]->Fill(locPosition.Theta()*180./TMath::Pi(), locPosition.Phi()*180./TMath::Pi());
370 if(locDeltaT > -5. && locDeltaT < 5. && locSystem ==
SYS_FCAL)
372 if(locDeltaT > -5. && locDeltaT < 5. && locSystem ==
SYS_BCAL)
vector< const DKinematicData * > Get_FinalParticles_Measured(void) const
TDirectoryFile * ChangeTo_BaseDirectory(void)
void FillShower(const DNeutralShower *locNeutralShower, bool locMatch, double locBeamPhotonTime, double locFlightTime)
map< bool, map< DetectorSystem_t, TH1I * > > dHistMap_ShowerNhits
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerDeltaT_Nhits
const DTrackTimeBased * Get_TrackTimeBased(void) const
TDirectoryFile * CreateAndChangeTo_ActionDirectory(void)
const DKinematicData * Get_InitialParticle_Measured(void) const
bool Get_UseKinFitResultsFlag(void) const
DetectorSystem_t dDetectorSystem
DLorentzVector dSpacetimeVertex
map< bool, map< DetectorSystem_t, TH1I * > > dHistMap_ShowerNclusters
map< bool, map< int, TH2I * > > dHistMap_TrackChiSq_Theta
map< bool, TH2I * > dHistMap_Layer1Energy_Theta
map< bool, map< int, TH1I * > > dHistMap_TrackPOCAZ
bool Perform_Action(JEventLoop *locEventLoop, const DParticleCombo *locParticleCombo)
void FillTrack(const DChargedTrack *locChargedTrack, bool locMatch)
const DParticleID * dParticleID
vector< const DKinematicData * > Get_FinalParticles(void) const
int Ndof
Number of degrees of freedom in the fit.
double charge(void) const
map< bool, map< int, TH2I * > > dHistMap_TrackFOM_Theta
const JObject * Get_FinalParticle_SourceObject(size_t locFinalParticleIndex) const
const DKinematicData * Get_InitialParticle(void) const
map< bool, TH2I * > dHistMap_Layer4Energy_Theta
map< bool, map< int, TH2I * > > dHistMap_TrackNhits_Theta
void Initialize(JEventLoop *locEventLoop)
map< bool, TH2I * > dHistMap_Layer2Energy_Theta
map< bool, map< int, TH2I * > > dHistMap_TrackP_Theta
map< bool, TH2I * > dHistMap_Layer3Energy_Theta
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerE_Theta
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerDeltaT_E
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerEnergy_Theta
map< bool, map< int, TH2I * > > dHistMap_TrackPOCAXY
const DChargedTrackHypothesis * Get_BestFOM(void) const
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerMaxEnergy_Nhits
const DParticleComboStep * Get_ParticleComboStep(size_t locStepIndex) const
map< bool, TH1I * > dHistMap_BCALShowerNcell
map< bool, map< DetectorSystem_t, TH2I * > > dHistMap_ShowerPhi_Theta