All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
GammaGammaCandidateTruthFilter.cc
Go to the documentation of this file.
1 #include "GammaGammaCandidateTruthFilter.h"
2 
3 #include <UTIL/LCRelationNavigator.h>
4 #include <UTIL/PIDHandler.h>
5 
6 
7 GammaGammaCandidateTruthFilter aGammaGammaCandidateTruthFilter ;
8 
9 
10 GammaGammaCandidateTruthFilter::GammaGammaCandidateTruthFilter() : Processor("GammaGammaCandidateTruthFilter") {
11 
12  // modify processor description
13  _description = "GammaGammaCandidateTruthFilter does whatever it does ..." ;
14 
15 
16  // register steering parameters: name, description, class-variable, default value
17 
18  registerProcessorParameter( "Printing" ,
19  "Print certain messages" ,
20  _printing,
21  (int)1 ) ;
22 
23  std::string ggResonanceName = "Pi0";
24  registerProcessorParameter( "GammaGammaResonanceName" ,
25  "Particle decaying to Gamma Gamma" ,
26  _ggResonanceName,
27  ggResonanceName) ;
28 
29  registerInputCollection( LCIO::LCRELATION,
30  "MCTruth2RecoLinkCollectionName" ,
31  "true - reco relation collection" ,
32  _trueToReco,
33  std::string("MCTruthRecoLink") ) ;
34 
35 
36  registerInputCollection( LCIO::LCRELATION,
37  "Reco2MCTruthLinkCollectionName" ,
38  "reco - true relation collection" ,
39  _recoToTrue,
40  std::string("RecoMCTruthLink") ) ;
41 
42 
43  registerInputCollection( LCIO::MCPARTICLE,
44  "MCParticleCollection" ,
45  "Name of the MCParticle input collection" ,
46  _mcParticleCollectionName ,
47  std::string("MCParticle") ) ;
48 
49 
50  registerInputCollection( LCIO::RECONSTRUCTEDPARTICLE,
51  "GammaGammaCandidateCollection" ,
52  "Name of the gamma-gamma candidate input collection" ,
53  _gammaGammaParticleCollectionName ,
54  std::string("GammaGammaCandidates") ) ;
55 
56 
57  std::string outputParticleCollectionName = "TrueGammaGammaMesons";
58  registerOutputCollection( LCIO::RECONSTRUCTEDPARTICLE,
59  "OutputParticleCollectionName" ,
60  "Output Particle Collection Name " ,
61  _outputParticleCollectionName,
62  outputParticleCollectionName);
63 
64 }
65 
66 
67 void GammaGammaCandidateTruthFilter::init() {
68 
69  streamlog_out(DEBUG) << " init called "
70  << std::endl ;
71 
72  // usually a good idea to
73  printParameters() ;
74  nEvt = 0;
75 
76 // gROOT->ProcessLine("#include <vector>");
77 }
78 
79 void GammaGammaCandidateTruthFilter::processRunHeader( LCRunHeader* /*run*/) {
80 
81 }
82 
83 
84 void GammaGammaCandidateTruthFilter::processEvent( LCEvent * evt ) {
85 
86  // Make a new vector of particles
87  LCCollectionVec * recparcol = new LCCollectionVec(LCIO::RECONSTRUCTEDPARTICLE);
88  recparcol->setSubset(true);
89 
90  streamlog_out(MESSAGE) << " start processing event " << std::endl;
91 
92  int typeRequired;
93  if(_ggResonanceName=="Pi0")typeRequired = 111;
94  if(_ggResonanceName=="Eta")typeRequired = 221;
95  if(_ggResonanceName=="EtaPrime")typeRequired = 331;
96 
97 /*
98  int nMCPi0 = 0;
99  int nRecoPi0 = 0;
100 
101  streamlog_out(DEBUG) << " iterator and navigator " << std::endl;
102  LCIterator<MCParticle> mcpIt( evt, _mcParticleCollectionName ) ;
103  streamlog_out(DEBUG) << " got mcpIt with length of " << mcpIt.size() << std::endl;
104  LCRelationNavigator mc2recoNav(evt->getCollection( _trueToReco ));
105  streamlog_out(DEBUG) << " got mc2recoNav from " << mc2recoNav.getFromType() << " to " << mc2recoNav.getToType() << std::endl;
106 
107  //----------------------------------------------------------------------------------------------------------------------------
108  // loop over MCParticles
109  //----------------------------------------------------------------------------------------------------------------------------
110 
111  int index_mcp = -1; // Should be in synch with dumpevent utility
112 
113  int nMCEta = 0;
114  int nMCEtaPrime = 0;
115  double ESum_MCP = 0.0;
116 
117  int nRecoEta = 0;
118  int nRecoEtaPrime = 0;
119 
120  while( MCParticle* mcp = mcpIt.next() ) {
121 
122  if (!mcp) continue;
123  index_mcp++;
124 
125  bool keep = false;
126  const EVENT::MCParticleVec& daughters = mcp->getDaughters();
127  // keep pi0/eta/etaprime which decays to gammagamma if production vertex within 10 cm of nominal interaction point
128  if (mcp->getPDG() == 111 || mcp->getPDG() == 221 || mcp->getPDG() == 331) {
129  if (daughters.size() == 2 && daughters[0]->getPDG() == 22 && daughters[1]->getPDG() == 22){
130  double rVertexSquared = 0.0;
131  for(int i=0; i<=2; i++){
132  rVertexSquared += pow(mcp->getVertex()[i],2);
133  }
134  if(rVertexSquared < 10000.0)keep = true;
135  }
136  }
137 
138  if (keep) {
139 
140  streamlog_out(DEBUG) << " Found GammaGamma decaying parent MCParticle " << "Index = " << index_mcp << " pdgID = " << mcp->getPDG()
141  << ", genstat = " << mcp->getGeneratorStatus()
142  << ", E = " << mcp->getEnergy() << std::endl;
143  streamlog_out(DEBUG) << " Momentum = " << mcp->getMomentum()[0] << " " << mcp->getMomentum()[1] << " " << mcp->getMomentum()[2] << std::endl;
144  streamlog_out(DEBUG) << " Vertex = " << mcp->getVertex()[0] << " " << mcp->getVertex()[1] << " " << mcp->getVertex()[2] << std::endl;
145  streamlog_out(DEBUG) << " Endpoint = " << mcp->getEndpoint()[0] << " " << mcp->getEndpoint()[1] << " " << mcp->getEndpoint()[2] << std::endl;
146 
147  nMCPi0++;
148  ESum_MCP += mcp->getEnergy();
149  if(mcp->getPDG() == 221)nMCEta++;
150  if(mcp->getPDG() == 331)nMCEtaPrime++;
151 
152  gear::Vector3D v( mcp->getVertex()[0], mcp->getVertex()[1], mcp->getVertex()[2] );
153  gear::Vector3D e( mcp->getEndpoint()[0], mcp->getEndpoint()[1], mcp->getEndpoint()[2] );
154  gear::Vector3D p( mcp->getMomentum()[0], mcp->getMomentum()[1], mcp->getMomentum()[2] );
155 
156  trueE.push_back(mcp->getEnergy());
157  trueP.push_back(p.r());
158  truePt.push_back(p.trans());
159  trueTheta.push_back(p.theta());
160  truePhi.push_back(p.phi());
161  truePDG.push_back(mcp->getPDG());
162  if (mcp->getParents()[0]) {
163  trueMother.push_back(mcp->getParents()[0]->getPDG());
164  }
165  else {
166  trueMother.push_back(-1);
167  }
168 
169  int nseen = 0;
170  int nseenphoton = 0;
171  double weightsum = 0;
172 
173  for (unsigned int idaughter = 0; idaughter < daughters.size(); idaughter++) {
174 
175  MCParticle* mcd = daughters[idaughter];
176 
177  streamlog_out(DEBUG) << " Daughter MCParticle " << idaughter << " pdg ID = " << mcd->getPDG()
178  << ", genstat = " << mcd->getGeneratorStatus()
179  << ", E = " << mcd->getEnergy() << std::endl;
180  streamlog_out(DEBUG) << " Momentum = " << mcd->getMomentum()[0] << " " << mcd->getMomentum()[1] << " " << mcd->getMomentum()[2] << std::endl;
181  streamlog_out(DEBUG) << " Vertex = " << mcd->getVertex()[0] << " " << mcd->getVertex()[1] << " " << mcd->getVertex()[2] << std::endl;
182  streamlog_out(DEBUG) << " Endpoint = " << mcd->getEndpoint()[0] << " " << mcd->getEndpoint()[1] << " " << mcd->getEndpoint()[2] << std::endl;
183 
184  streamlog_out(DEBUG) << " get reco particle for daughter " << idaughter << std::endl;
185  const EVENT::LCObjectVec& recovec = mc2recoNav.getRelatedToObjects(mcd);
186  streamlog_out(DEBUG) << " recovec has length " << recovec.size() << std::endl;
187  const EVENT::FloatVec& recoweightvec = mc2recoNav.getRelatedToWeights(mcd);
188  //streamlog_out(DEBUG) << " recoweightvec has length " << recoweightvec.size() << std::endl;
189  double maxcaloweight = 0;
190  int imaxcaloweight = -1;
191  // reconstructed at all?
192  if (recovec.size() > 0) nseen++;
193  for (unsigned int irel = 0; irel < recovec.size(); irel++) {
194  ReconstructedParticle* dummy = (ReconstructedParticle*) recovec.at(irel);
195  streamlog_out(DEBUG) << " irel " << irel << ", recoweight = " << int(recoweightvec.at(irel))
196  << ", type = " << dummy->getType()
197  << ", recoweight%10000 (track) = " << int(recoweightvec.at(irel))%10000
198  << ", recoweight/10000 (calo) = " << int(recoweightvec.at(irel))/10000 << std::endl;
199  double caloweight = double((int(recoweightvec.at(irel))/10000)/1000.);
200  if (dummy->getType() == 22 && caloweight > maxcaloweight) {
201  imaxcaloweight = irel;
202  maxcaloweight = caloweight;
203  }
204  }
205 
206 
207  // do we really have a photon?
208  if (maxcaloweight > 0.1) {
209  streamlog_out(MESSAGE) << " found reco photon for mcd at imaxcaloweight = " << imaxcaloweight << " with weight = " << maxcaloweight << std::endl ;
210  nseenphoton++;
211  weightsum += maxcaloweight;
212  }
213 
214  } // loop over daughters
215 
216  isSeen.push_back(nseen);
217  isSeenAsPhotons.push_back(nseenphoton);
218  weightToPhotons.push_back(weightsum);
219 
220  } // if keep
221 
222  } // loop over MCPs
223 
224  streamlog_out(DEBUG) << " nMCGammaGammaParticles Found = " << nMCPi0
225  << " ( " << nMCPi0-nMCEta-nMCEtaPrime << " " << nMCEta << " " << nMCEtaPrime << " )" << " Esum = " << ESum_MCP << std::endl;
226 */
227 
228  streamlog_out(DEBUG) << " reco iterator and navigator " << std::endl;
229  LCIterator<ReconstructedParticle> ggpIt( evt, _gammaGammaParticleCollectionName ) ;
230  streamlog_out(DEBUG) << " got ggpIt with length of " << ggpIt.size() << std::endl;
231  LCRelationNavigator rec2mcNav(evt->getCollection( _recoToTrue ));
232  streamlog_out(DEBUG) << " got rec2mcNav from " << rec2mcNav.getFromType() << " to " << rec2mcNav.getToType() << std::endl;
233 
234  //----------------------------------------------------------------------------------------------------------------------------
235  // loop over GammaGammaParticles
236  //----------------------------------------------------------------------------------------------------------------------------
237 
238  double ESum_Reco = 0.0;
239  double ESum_Reco_Correct = 0.0;
240  double ESum_Reco_MC_Correct = 0.0;
241  double ESum_Reco_Wrong = 0.0;
242  double ESum_Reco_MC_All = 0.0;
243  double ESum_Reco_Meas = 0.0;
244 
245  int nCorrectPi0 = 0;
246  int nCorrectEta = 0;
247  int nCorrectEtaPrime = 0;
248 
249  int nRecoPi0 = 0;
250  int nRecoEta = 0;
251  int nRecoEtaPrime = 0;
252 
253  while( ReconstructedParticle* ggp = ggpIt.next() ) {
254 
255  double Egg_Meas = 0.0;
256 
257  if (!ggp) continue;
258 
259  streamlog_out(DEBUG) << " GammaGammaParticle " << nRecoPi0 << " type = " << ggp->getType() << " E = " << ggp->getEnergy()
260  << " GoodnessOfPid " << ggp->getGoodnessOfPID() << std::endl;
261  streamlog_out(DEBUG) << " Momentum = " << ggp->getMomentum()[0] << " " << ggp->getMomentum()[1] << " " << ggp->getMomentum()[2] << std::endl;
262 
263  if(ggp->getType()==111)nRecoPi0++;
264  if(ggp->getType()==221)nRecoEta++;
265  if(ggp->getType()==331)nRecoEtaPrime++;
266 
267  ESum_Reco += ggp->getEnergy(); // Fitted energy sum (regardless of whether the fit is correct
268 
269  // get photons
270  const EVENT::ReconstructedParticleVec& gammas = ggp->getParticles ();
271  int istrue = 0;
272  int pdg = 0;
273  int ntruephoton = 0;
274  int ntruemeson = 0;
275  double sumTrueE = 0;
276  double sumTrueP[3] = {0, 0, 0};
277  double sumE = 0;
278  double sumP[3] = {0, 0, 0};
279  double sumWeight = 0;
280  MCParticle* mcgps[2];
281 
282  streamlog_out(DEBUG) << " Consitituent gammas.size() " << gammas.size() << std::endl;
283 
284  for (unsigned int igamma = 0; igamma < gammas.size(); igamma++) {
285 
286  streamlog_out(DEBUG) << " Gamma RP constituent of GGP " << igamma << " type = " << gammas[igamma]->getType()
287  << " Emeas = " << gammas[igamma]->getEnergy() << std::endl;
288  streamlog_out(DEBUG) << " Momentum = " << gammas[igamma]->getMomentum()[0] << " "
289  << gammas[igamma]->getMomentum()[1] << " "
290  << gammas[igamma]->getMomentum()[2] << std::endl;
291 
292  sumE += gammas[igamma]->getEnergy();
293 
294  Egg_Meas += gammas[igamma]->getEnergy(); // Measured energy (this is zeroed for each ggp ...)
295 
296 // ESum_Reco_Meas += gammas[igamma]->getEnergy(); // Measured Energy Sum of the Photons that are fitted to GammaGammaParticles
297  for (int i = 0; i < 3; i++) sumP[i] += gammas[igamma]->getMomentum()[i];
298  streamlog_out(DEBUG) << " get mc particle for gamma " << igamma << std::endl;
299  const EVENT::LCObjectVec& truevec = rec2mcNav.getRelatedToObjects(gammas[igamma]);
300  streamlog_out(DEBUG) << " truthvec has length " << truevec.size() << std::endl;
301  const EVENT::FloatVec& truthweightvec = rec2mcNav.getRelatedToWeights(gammas[igamma]);
302  //streamlog_out(DEBUG) << " truthweightvec has length " << truthweightvec.size() << std::endl;
303  double maxcaloweight = 0;
304  int imaxcaloweight = -1;
305  double maxtrckweight = 0;
306  int imaxtrckweight = -1;
307  double maxweight = 0;
308  int imaxweight = -1;
309  MCParticle* mcg = 0;
310 
311  bool isConversion = false;
312  // catch conversions
313  if (truevec.size() == 2) {
314  MCParticle* el1 = (MCParticle*) truevec.at(0);
315  MCParticle* el2 = (MCParticle*) truevec.at(1);
316  if ((el1->getPDG() == 11 && el2->getPDG() == -11) || (el1->getPDG() == -11 && el2->getPDG() == 11)) {
317  MCParticle* mo1 = el1->getParents()[0];
318  MCParticle* mo2 = el2->getParents()[0];
319  if (mo1->getPDG() == 22 && mo1 == mo2) {
320  streamlog_out(MESSAGE) << " found conversion - using mother photon: "
321  << " true PDGs = " << el1->getPDG() << ", " << el2->getPDG()
322  << ", true parent PDG = " << mo1->getPDG() << std::endl;
323  isConversion = true;
324  maxweight = double( (int(truthweightvec.at(0))/10000 + int(truthweightvec.at(1))/10000)/1000. );
325  // conversion mother is true photon!
326  mcg = mo1;
327  }
328  }
329  }
330 
331  if (!isConversion) {
332  for (unsigned int irel = 0; irel < truevec.size(); irel++) {
333  MCParticle* dummy = (MCParticle*) truevec.at(irel);
334 
335 // calculate cosine of the angle between the Photon PFO and this related MCParticle's momentum
336  double cosg = 0.0;
337  double momentumMCSquared = 0.0;
338  for(int i=0;i<3;++i){
339  cosg += dummy->getMomentum()[i]*gammas[igamma]->getMomentum()[i];
340  momentumMCSquared += pow(dummy->getMomentum()[i],2);
341  }
342  cosg = cosg/(sqrt(momentumMCSquared)*gammas[igamma]->getEnergy());
343 
344  streamlog_out(DEBUG) << " irel " << irel << " E = " << dummy->getEnergy() << ", truew = " << int(truthweightvec.at(irel))
345  << ", true PDG = " << dummy->getPDG() << " cos(RP - MC) " << cosg
346  << ", true par. PDG = " << dummy->getParents()[0]->getPDG()
347  << ", recow%10000 (track) = " << int(truthweightvec.at(irel))%10000
348  << ", recow/10000 (calo) = " << int(truthweightvec.at(irel))/10000 << std::endl;
349  double truthcaloweight = double( (int(truthweightvec.at(irel))/10000)/1000. );
350  if (dummy->getPDG() == 22 && truthcaloweight > maxcaloweight) {
351  imaxcaloweight = irel;
352  maxcaloweight = truthcaloweight;
353  }
354  double truthtrckweight = double((int(truthweightvec.at(irel))%10000)/1000.);
355  if (dummy->getPDG() == 22 && truthtrckweight > maxtrckweight) {
356  imaxtrckweight = irel;
357  maxtrckweight = truthtrckweight;
358  }
359  } // irel loop
360  streamlog_out(DEBUG) << " found true photon at imaxcaloweight = " << imaxcaloweight << " with weight = " << maxcaloweight << std::endl ;
361  streamlog_out(DEBUG) << " found true photon at imaxtrckweight = " << imaxtrckweight << " with weight = " << maxtrckweight << std::endl ;
362 
363  maxweight = maxcaloweight;
364  imaxweight = imaxcaloweight;
365  if (maxtrckweight > maxcaloweight) {
366  maxweight = maxtrckweight;
367  imaxweight = imaxtrckweight;
368  }
369 
370  // skip if photon has too small weight
371  if (maxweight < 0.1) {
372  streamlog_out(DEBUG) << " weight of photon = " << maxweight << " is too small - don't count as correct" << std::endl ;
373  continue;
374  }
375 
376  streamlog_out(DEBUG) << " found true photon at imaxweight = " << imaxweight << " with weight = " << maxweight << std::endl ;
377  mcg = (MCParticle*) truevec.at(imaxweight);
378  } // !isConversion if clause
379 
380 
381  if (!mcg) continue;
382 
383  // found a correct photon or a conversion
384  ntruephoton++;
385 
386  sumWeight += maxweight;
387  sumTrueE += mcg->getEnergy();
388  for (int i = 0; i < 3; i++) sumTrueP[i] += mcg->getMomentum()[i];
389 
390  streamlog_out(DEBUG) << " Gamma MCParticle of GGP " << igamma
391  << " Etrue = " << mcg->getEnergy() << std::endl;
392 
393  ESum_Reco_MC_All += mcg->getEnergy();
394 
395  // get parent
396  mcgps[igamma] = mcg->getParents()[0];
397  if (!mcgps[igamma]) continue;
398  if (mcgps[igamma]->getPDG() == typeRequired ) {
399  // found photon from desired meson
400  ntruemeson++;
401  streamlog_out(MESSAGE) << "(correct) PDG of photon's parent is = " << mcgps[igamma]->getPDG() << std::endl ;
402  pdg = mcgps[igamma]->getPDG();
403  }
404  else {
405  streamlog_out(MESSAGE) << "(wrong) PDG of photon's parent is = " << mcgps[igamma]->getPDG() << std::endl ;
406  }
407  } // Loop over constituent reconstructed particles (gammas) in the GammaGammaCandidate
408 
409  streamlog_out(DEBUG) << " ntruephoton = " << ntruephoton << std::endl;
410 
411  // check if really from same mother and has correct pdgid (Note that mcgps may not be valid ... )
412 
413  if(ntruephoton==2){
414  if (mcgps[0] && mcgps[1] && mcgps[0] == mcgps[1] && mcgps[0]->getPDG() == typeRequired ) {
415  double rVertexSquared = 0.0;
416  for(int i=0; i<=2; i++){
417  rVertexSquared += pow(mcgps[0]->getVertex()[i],2);
418  }
419  if(rVertexSquared < 10000.0)istrue = 1;
420  if(istrue){
421  pdg = mcgps[0]->getPDG();
422  streamlog_out(MESSAGE) << "(fully correct) PDG of both photons parent is = " << pdg << " Etrue = " << mcgps[0]->getEnergy()
423  << " VTX squared = " << rVertexSquared << std::endl ;
424  ESum_Reco_Correct += ggp->getEnergy();
425  ESum_Reco_MC_Correct += mcgps[0]->getEnergy();
426  ESum_Reco_Meas += Egg_Meas;
427  if(pdg == 111)nCorrectPi0++;
428  if(pdg == 221)nCorrectEta++;
429  if(pdg == 331)nCorrectEtaPrime++;
430 
431 // Add this RP to the output collection
432 // ReconstructedParticle* recoPart = dynamic_cast<ReconstructedParticle*>(col->getElementAt(i));
433  recparcol->addElement(ggp);
434  }
435  else{
436  streamlog_out(MESSAGE) << "(Non-prompt associated) PDG of both photons parent is = " << pdg << " Etrue = " << mcgps[0]->getEnergy()
437  << " VTX squared = " << rVertexSquared << std::endl ;
438  }
439  }
440  else{
441  ESum_Reco_Wrong += ggp->getEnergy();
442  }
443  }
444  } // loop over GammaGammaParticles
445 
446  if(typeRequired == 111)streamlog_out(MESSAGE) << " SUMMARY 111 " << nCorrectPi0 << " "
447  << ESum_Reco_Correct << " " << ESum_Reco_MC_Correct << " " << ESum_Reco_Meas << endl;
448  if(typeRequired == 221)streamlog_out(MESSAGE) << " SUMMARY 221 " << nCorrectEta << " "
449  << ESum_Reco_Correct << " " << ESum_Reco_MC_Correct << " " << ESum_Reco_Meas << endl;
450  if(typeRequired == 331)streamlog_out(MESSAGE) << " SUMMARY 331 " << nCorrectEtaPrime << " "
451  << ESum_Reco_Correct << " " << ESum_Reco_MC_Correct << " " << ESum_Reco_Meas << endl;
452 
453 /*
454  streamlog_out(DEBUG) << " nRecoGammaGammaParticles Found = " << nRecoPi0 <<
455  " ( " << nRecoPi0-nRecoEta-nRecoEtaPrime << " " << nRecoEta << " " << nRecoEtaPrime << " ) " <<
456  " ESum Reco = " << ESum_Reco << std::endl;
457  streamlog_out(DEBUG) << " SUMMARY = " << nMCPi0 << " ESum MCP = " << ESum_MCP << " " << nRecoPi0
458  << " ESum Reco = " << ESum_Reco << " Esum_Reco_Correct = " << ESum_Reco_Correct
459  << " ESum Reco Wrong = " << ESum_Reco_Wrong
460  << " ESum_Reco_MC_Correct " << ESum_Reco_MC_Correct
461  << " ESum_Reco_Meas " << ESum_Reco_Meas <<
462  " ESum_Reco_MC_All " << ESum_Reco_MC_All << std::endl;
463 
464  streamlog_out(DEBUG) << " SUMMARY2 = " << std::setw(2) << nMCPi0 << " " << std::setw(10) << ESum_MCP << " "
465  << std::setw(2) << nMCPi0-nMCEta-nMCEtaPrime << " "
466  << std::setw(2) << nMCEta << " " << std::setw(2) << nMCEtaPrime << " "
467  << std::setw(2) << nRecoPi0 << " " << std::setw(10) << ESum_Reco << " "
468  << std::setw(2) << nRecoPi0-nRecoEta-nRecoEtaPrime << " "
469  << std::setw(2) << nRecoEta << " " << std::setw(2) << nRecoEtaPrime << " "
470  << std::setw(2) << nCorrectPi0 << " "
471  << std::setw(2) << nCorrectEta << " " << std::setw(2) << nCorrectEtaPrime << " "
472  << std::setw(10) << ESum_Reco_Correct << " " << std::setw(10) << ESum_Reco_Wrong << " "
473  << std::setw(10) << ESum_Reco_MC_Correct << " "
474  << std::setw(10) << ESum_Reco_Meas << " "
475  << std::setw(10) << ESum_Reco_MC_All << std::endl;
476 */
477 
478  nEvt++;
479 
480  // Add new collection to event
481  evt->addCollection( recparcol , _outputParticleCollectionName.c_str() );
482 
483  cout << "======================================== event " << nEvt << std::endl ;
484 
485 }
486 
487 
488 void GammaGammaCandidateTruthFilter::check( LCEvent * /*evt*/ ) {
489 
490 }
491 
492 
493 void GammaGammaCandidateTruthFilter::end(){
494 
495 }
496 
497 
498 
GammaGammaCandidateTruthFilter::processEvent
virtual void processEvent(LCEvent *evt)
Called for every event - the working horse.
Definition: GammaGammaCandidateTruthFilter.cc:84
aGammaGammaCandidateTruthFilter
GammaGammaCandidateTruthFilter aGammaGammaCandidateTruthFilter
Definition: GammaGammaCandidateTruthFilter.cc:7
GammaGammaCandidateTruthFilter::init
virtual void init()
Called at the begin of the job before anything is read.
Definition: GammaGammaCandidateTruthFilter.cc:67
GammaGammaCandidateTruthFilter::processRunHeader
virtual void processRunHeader(LCRunHeader *run)
Called for every run.
Definition: GammaGammaCandidateTruthFilter.cc:79
GammaGammaCandidateTruthFilter::end
virtual void end()
Called after data processing for clean up.
Definition: GammaGammaCandidateTruthFilter.cc:493
GammaGammaCandidateTruthFilter
GammaGammaCandidateTruthFilter processor Checks which GammaGammaCandidates are correct author: Graham...
Definition: GammaGammaCandidateTruthFilter.h:33
sistrip::LCCollectionVec
std::vector< LCCollection * > LCCollectionVec
Definition: SiStripClus.h:55