All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Private Member Functions | Private Attributes | List of all members
cluster::DBclusterAna Class Reference
Inheritance diagram for cluster::DBclusterAna:

Public Member Functions

 DBclusterAna (fhicl::ParameterSet const &pset)
 
virtual ~DBclusterAna ()
 

Private Member Functions

void analyze (const art::Event &evt)
 read access to event More...
 
void beginJob ()
 

Private Attributes

TH1F * fNoParticles_pdg
 
TH1F * fNoParticles_trackid
 
TH1F * fNoParticles_trackid_mother
 
TH1F * fNoParticles_trackid_per_event
 
TH1F * fNoParticles_pdg_per_event
 
TH1F * fCl_for_Muon
 
TH1F * fNoClustersInEvent
 
TH1F * fPercentNoise
 
TH1F * fno_of_clusters_per_track
 
TH1F * fPercent_lost_muon_hits
 
TH1F * fPercent_lost_electron_hits
 
TH1F * fPercent_lost_positron_hits
 
TH1F * fPercent_lost_111_hits
 
TH1F * fPercent_lost_211_hits
 
TH1F * fPercent_lost_m211_hits
 
TH1F * fPercent_lost_2212_hits
 
TH1F * fPercent_lost_2112_hits
 
TH1F * fPercent_lost_muon_energy
 
TH1F * fPercent_lost_electron_energy
 
TH1F * fPercent_lost_positron_energy
 
TH1F * fPercent_lost_111_energy
 
TH1F * fPercent_lost_211_energy
 
TH1F * fPercent_lost_m211_energy
 
TH1F * fPercent_lost_2212_energy
 
TH1F * fPercent_lost_2112_energy
 
TH1F * fEnergy
 
TH2F * fbrian_in
 
TH2F * fbrian_coll
 
std::string fDigitModuleLabel
 
std::string fHitsModuleLabel
 
std::string fLArG4ModuleLabel
 
std::string fClusterFinderModuleLabel
 
std::string fCalDataModuleLabel
 
std::string fGenieGenModuleLabel
 

Detailed Description

Definition at line 45 of file DBclusterAna_module.cc.

Constructor & Destructor Documentation

cluster::DBclusterAna::DBclusterAna ( fhicl::ParameterSet const &  pset)
explicit

Definition at line 100 of file DBclusterAna_module.cc.

101  : EDAnalyzer(pset)
102  , fDigitModuleLabel(pset.get<std::string>("DigitModuleLabel"))
103  , fHitsModuleLabel(pset.get<std::string>("HitsModuleLabel"))
104  , fLArG4ModuleLabel(pset.get<std::string>("LArGeantModuleLabel"))
105  , fClusterFinderModuleLabel(pset.get<std::string>("ClusterFinderModuleLabel"))
106  , fCalDataModuleLabel(pset.get<std::string>("CalDataModuleLabel"))
107  , fGenieGenModuleLabel(pset.get<std::string>("GenieGenModuleLabel"))
108  {}
cluster::DBclusterAna::fClusterFinderModuleLabel
std::string fClusterFinderModuleLabel
Definition: DBclusterAna_module.cc:89
cluster::DBclusterAna::~DBclusterAna ( )
virtual

Definition at line 111 of file DBclusterAna_module.cc.

111 {}

Member Function Documentation

void cluster::DBclusterAna::analyze ( const art::Event &  evt)
private

read access to event

Definition at line 268 of file DBclusterAna_module.cc.

269  {
270  std::cout << "run : " << evt.run() << std::endl;
271  std::cout << "event : " << evt.id().event() << std::endl;
272  //----------------------------------------------------------------
273 
274  /* This is basically a module for studying MC efficiency/purity. Kick out now if not MC. EC, 8-Oct-2010 */
275  if (evt.isRealData()) {
276  std::cout << "**** DBclusterAna: Bailing. Don't call this module if you're not MC. "
277  << std::endl;
278  exit(1);
279  }
280 
281  art::ServiceHandle<geo::Geometry const> geom;
282  art::ServiceHandle<cheat::BackTrackerService const> bt_serv;
283  art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;
284 
285  art::Handle<std::vector<raw::RawDigit>> rdListHandle;
286  evt.getByLabel(fDigitModuleLabel, rdListHandle);
287  art::Handle<std::vector<recob::Hit>> hitListHandle;
288  evt.getByLabel(fHitsModuleLabel, hitListHandle);
289  art::Handle<std::vector<simb::MCTruth>> mctruthListHandle;
290  evt.getByLabel(fGenieGenModuleLabel, mctruthListHandle);
291  art::Handle<std::vector<recob::Cluster>> clusterListHandle;
292  evt.getByLabel(fClusterFinderModuleLabel, clusterListHandle);
293  art::Handle<std::vector<recob::Wire>> wireListHandle;
294  evt.getByLabel(fCalDataModuleLabel, wireListHandle);
295 
296  art::FindManyP<recob::Hit> fmh(clusterListHandle, evt, fClusterFinderModuleLabel);
297 
298  //----------------------------------------------------------------
299 
300  //----------------------------------------------------------------
301 
302  art::PtrVector<raw::RawDigit> rawdigits;
303 
304  for (size_t ii = 0; ii < rdListHandle->size(); ++ii) {
305  art::Ptr<raw::RawDigit> rawdigit(rdListHandle, ii);
306  rawdigits.push_back(rawdigit);
307  }
308 
309  //get the simb::MCParticle collection from the art::Event and then use the
310  //Simulation/SimListUtils object to create a sim::ParticleList from the art::Event.
311  pi_serv->SetEveIdCalculator(new sim::EmEveIdCalculator);
312 
313  sim::ParticleList const& _particleList = pi_serv->ParticleList();
314 
315  std::vector<int> mc_trackids;
316 
317  for (auto i = _particleList.begin(); i != _particleList.end(); ++i) {
318  int trackID = (*i).first;
319  mc_trackids.push_back(trackID);
320  }
321 
322  //----------------------------------------------------------------
323  art::PtrVector<simb::MCTruth> mclist;
324  for (size_t ii = 0; ii < mctruthListHandle->size(); ++ii) {
325  art::Ptr<simb::MCTruth> mctparticle(mctruthListHandle, ii);
326  mclist.push_back(mctparticle);
327  }
328 
329  //--------------------------------------------------
330  std::vector<art::Ptr<recob::Hit>> hits_vec;
331 
332  //--------------------------------------------------
333  std::vector<art::Ptr<recob::Hit>> hits;
334  art::fill_ptr_vector(hits, hitListHandle);
335  //---------------------------------------------------
336 
337  art::PtrVector<recob::Cluster> clusters;
338  for (unsigned int ii = 0; ii < clusterListHandle->size(); ++ii) {
339  art::Ptr<recob::Cluster> clusterHolder(clusterListHandle, ii);
340  clusters.push_back(clusterHolder);
341  }
342 
343  std::cout << "in Efficiency, clusters.size()= " << clusters.size() << std::endl;
344 
345  //---------------------------------------------------------------
346  art::PtrVector<recob::Wire> wirelist;
347 
348  for (size_t ii = 0; ii < wireListHandle->size(); ++ii) {
349  art::Ptr<recob::Wire> wireHolder(wireListHandle, ii);
350 
351  wirelist.push_back(wireHolder);
352  }
353 
354  //...........................................................................
355  // How many different particles do we have in a cluster???
356  // -- I will answer that by 3 methods
357  // 1) count different TrackIDs in each cluster
358  // 2) count different TrackIDs in each cluster with the use of "Mother" to get rid of the ones that just randomly got their TrackIDs changed by Geant4
359  // 3) count different pdg codes in each cluster <--probably not very good b/c if you have 2 "different" electrons in a cluster it's going to count them as one.
360  //..........................................................................
361  // How many clusters it takes to contain a particle???
362  // take each TrackID and count in how many clusters it appears
363  //.........................................................................
364 
365  double no_of_particles_in_cluster = 0;
366  double sum_vec_trackid = 0;
367  double no_of_clusters = 0;
368  double total_no_hits_in_clusters = 0;
369  std::vector<int> vec_pdg;
370  std::vector<int> vec_trackid, vec_trackid_mother, vec_trackid_mother_en;
371  std::vector<int> all_trackids;
372  std::vector<int> ids;
373  std::vector<int>::iterator it, it2, it3, it4, it5, it6, it7, it8;
374  int no_cl_for_muon = 0;
375  int no_cl_for_electron = 0;
376  int no_cl_for_positron = 0;
377  int no_cl_for_pion_111 = 0;
378  int no_cl_for_pion_211 = 0;
379  int no_cl_for_pion_m211 = 0;
380  int no_cl_for_proton = 0;
381  double noCluster = 0;
382  double _hit_13 = 0, _hit_11 = 0, _hit_m_11 = 0, _hit_111 = 0, _hit_211 = 0, _hit_m211 = 0,
383  _hit_2212 = 0, _hit_2112 = 0;
384  double _en_13 = 0, _en_11 = 0, _en_m11 = 0, _en_111 = 0, _en_211 = 0, _en_m211 = 0,
385  _en_2212 = 0, _en_2112 = 0;
386  std::vector<double> diff_vec;
387 
388  double hit_energy = 0;
389  double total_Q_cluster_hits = 0;
390 
391  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
392  if (clusters.size() != 0 && hits.size() != 0) {
393  for (unsigned int plane = 0; plane < geom->Nplanes(); ++plane) {
394  geo::View_t view = geom->Plane(plane).View();
395  for (size_t j = 0; j < clusters.size(); ++j) {
396 
397  if (clusters[j]->View() == view) {
398 
399  std::vector<art::Ptr<recob::Hit>> _hits = fmh.at(j);
400  art::Ptr<recob::Hit> _hits_ptr;
401 
402  for (size_t p = 0; p < _hits.size(); ++p) {
403  _hits_ptr = _hits[p];
404  hits_vec.push_back(_hits_ptr);
405  total_Q_cluster_hits += _hits[p]->Integral();
406  }
407 
408  std::vector<art::Ptr<recob::Hit>>::iterator itr = hits_vec.begin();
409 
410  while (itr != hits_vec.end()) {
411  diff_vec.clear();
412 
413  hit_energy = _hits[itr - hits_vec.begin()]->Integral();
414 
415  std::vector<sim::TrackIDE> trackides = bt_serv->HitToTrackIDEs(clockData, *itr);
416  std::vector<sim::TrackIDE> eveides = bt_serv->HitToEveTrackIDEs(clockData, *itr);
417 
418  std::vector<sim::TrackIDE>::iterator idesitr = trackides.begin();
419 
420  while (idesitr != trackides.end()) {
421 
422  vec_trackid.push_back((*idesitr).trackID);
423 
424  const simb::MCParticle* particle = _particleList.at((*idesitr).trackID);
425  int pdg = particle->PdgCode();
426  if (pdg == 13 || pdg == -13) {
427  _hit_13++;
428  _en_13 += hit_energy * ((*idesitr).energyFrac);
429  }
430  idesitr++;
431  }
432 
433  itr++;
434 
435  } // loop thru hits
436 
437  it = find(vec_pdg.begin(), vec_pdg.end(), 13);
438  if (it != vec_pdg.end()) { no_cl_for_muon++; }
439 
440  it2 = find(vec_pdg.begin(), vec_pdg.end(), 11);
441  if (it2 != vec_pdg.end()) { no_cl_for_electron++; }
442 
443  it3 = find(vec_pdg.begin(), vec_pdg.end(), -11);
444  if (it3 != vec_pdg.end()) { no_cl_for_positron++; }
445 
446  it4 = find(vec_pdg.begin(), vec_pdg.end(), 111);
447  if (it4 != vec_pdg.end()) { no_cl_for_pion_111++; }
448  it6 = find(vec_pdg.begin(), vec_pdg.end(), 211);
449  if (it6 != vec_pdg.end()) { no_cl_for_pion_211++; }
450  it7 = find(vec_pdg.begin(), vec_pdg.end(), -211);
451  if (it7 != vec_pdg.end()) { no_cl_for_pion_m211++; }
452  it8 = find(vec_pdg.begin(), vec_pdg.end(), 2212);
453  if (it8 != vec_pdg.end()) { no_cl_for_proton++; }
454 
455  sort(vec_pdg.begin(), vec_pdg.end());
456  vec_pdg.erase(unique(vec_pdg.begin(), vec_pdg.end()), vec_pdg.end());
457 
458  //same for vec_trackid:
459 
460  sort(vec_trackid.begin(), vec_trackid.end());
461  vec_trackid.erase(unique(vec_trackid.begin(), vec_trackid.end()), vec_trackid.end());
462  for (unsigned int ii = 0; ii < vec_trackid.size(); ++ii) {
463  all_trackids.push_back(vec_trackid[ii]);
464  }
465 
466  //...............................................................
467  //Also Make vec_trackid_mother unique:
468 
469  sort(vec_trackid_mother.begin(), vec_trackid_mother.end());
470  vec_trackid_mother.erase(unique(vec_trackid_mother.begin(), vec_trackid_mother.end()),
471  vec_trackid_mother.end());
472 
473  // Also Make vec_trackid_mother_en unique:
474 
475  sort(vec_trackid_mother_en.begin(), vec_trackid_mother_en.end());
476  vec_trackid_mother_en.erase(
477  unique(vec_trackid_mother_en.begin(), vec_trackid_mother_en.end()),
478  vec_trackid_mother_en.end());
479 
480  //........................................................................
481 
482  // Q: How many clusters it takes to contain a certain particle?
483  for (unsigned int ii = 0; ii < mc_trackids.size(); ++ii) {
484  it5 = find(vec_trackid.begin(), vec_trackid.end(), mc_trackids[ii]);
485  if (it5 != vec_trackid.end()) {
486  ids.push_back(mc_trackids[ii]); // then make it unique
487  noCluster++;
488  }
489  }
490 
491  fNoParticles_pdg->Fill(vec_pdg.size());
492 
493  fNoParticles_trackid->Fill(vec_trackid.size());
494 
495  fNoParticles_trackid_mother->Fill(vec_trackid_mother.size());
496 
497  no_of_clusters++;
498 
499  no_of_particles_in_cluster += vec_pdg.size();
500  sum_vec_trackid += vec_trackid_mother.size();
501  total_no_hits_in_clusters += _hits.size();
502 
503  vec_pdg.clear();
504 
505  vec_trackid.clear();
506 
507  vec_trackid_mother.clear();
508 
509  vec_trackid_mother_en.clear();
510 
511  } // end if cluster is in correct view
512 
513  hits_vec.clear();
514  } // for each cluster
515 
516  sort(all_trackids.begin(), all_trackids.end());
517  all_trackids.erase(unique(all_trackids.begin(), all_trackids.end()), all_trackids.end());
518 
519  // now I have a vector(all_trackids) that only contains unique trackids
520  // go to it and search for each trackid in every cluster
521 
522  sort(ids.begin(), ids.end());
523  ids.erase(unique(ids.begin(), ids.end()), ids.end());
524  double no_of_clusters_per_track = noCluster / ids.size();
525 
526  // Filling Histograms:
527 
528  if (no_cl_for_muon != 0) { fCl_for_Muon->Fill(no_cl_for_muon); }
529 
530  fno_of_clusters_per_track->Fill(no_of_clusters_per_track);
531 
532  no_cl_for_muon = 0;
533  no_cl_for_electron = 0;
534  no_cl_for_positron = 0;
535  no_cl_for_pion_111 = 0;
536  no_cl_for_pion_211 = 0;
537  no_cl_for_pion_m211 = 0;
538  no_cl_for_proton = 0;
539  noCluster = 0;
540  ids.clear();
541 
542  } // for each plane
543  double result = no_of_particles_in_cluster / no_of_clusters;
544 
545  double no_noise_hits = hits.size() - total_no_hits_in_clusters;
546  double percent_noise = double(no_noise_hits / hits.size()) * 100;
547 
548  double no_trackid_per_cl_per_event = sum_vec_trackid / no_of_clusters;
549  fNoParticles_trackid_per_event->Fill(no_trackid_per_cl_per_event);
550  fNoParticles_pdg_per_event->Fill(result);
551  fNoClustersInEvent->Fill(clusters.size());
552 
553  fPercentNoise->Fill(percent_noise);
554 
555  //-----------------------------------------------------------------------
556  for (unsigned int i = 0; i < mclist.size(); ++i) {
557  art::Ptr<simb::MCTruth> mc(mclist[i]);
558 
559  for (int ii = 0; ii < mc->NParticles(); ++ii) {
560  simb::MCParticle part(mc->GetParticle(ii));
561  std::cout << "FROM MC TRUTH,the particle's pdg code is: " << part.PdgCode() << std::endl;
562  std::cout << "with energy= " << part.E();
563  if (abs(part.PdgCode()) == 13) { std::cout << " I have a muon!!!" << std::endl; }
564  if (abs(part.PdgCode()) == 111) { std::cout << " I have a pi zero!!!" << std::endl; }
565  }
566  }
567  }
568 
569  // Now I can load just hits (not clusters) and see how many of what kind are
570  // lost due to dbscan marking them as noise:
571 
572  // Load hits and copy most of the code from above:
573 
574  double hit_13 = 0, hit_11 = 0, hit_m_11 = 0, hit_111 = 0, hit_211 = 0, hit_m211 = 0,
575  hit_2212 = 0, hit_2112 = 0;
576  double en_13 = 0, en_11 = 0, en_m11 = 0, en_111 = 0, en_211 = 0, en_m211 = 0, en_2212 = 0,
577  en_2112 = 0;
578 
579  std::vector<art::Ptr<recob::Hit>>::iterator itr = hits.begin();
580  while (itr != hits.end()) {
581 
582  std::vector<sim::TrackIDE> trackides = bt_serv->HitToTrackIDEs(clockData, *itr);
583  std::vector<sim::TrackIDE> eveides = bt_serv->HitToEveTrackIDEs(clockData, *itr);
584 
585  std::vector<sim::TrackIDE>::iterator idesitr = trackides.begin();
586 
587  hit_energy = hits[itr - hits.begin()]->Integral();
588 
589  while (idesitr != trackides.end()) {
590 
591  const simb::MCParticle* particle = _particleList.at((*idesitr).trackID);
592 
593  int pdg = particle->PdgCode();
594  diff_vec.clear();
595 
596  if (pdg == 13 || pdg == -13) {
597  hit_13++;
598  en_13 += hit_energy * ((*idesitr).energyFrac);
599  }
600  idesitr++;
601 
602  } // trackIDs
603 
604  itr++;
605  } // hits
606 
607  if (hit_13 != 0) { fPercent_lost_muon_hits->Fill(100 - ((_hit_13 / hit_13) * 100)); }
608  if (hit_11 != 0) { fPercent_lost_electron_hits->Fill(100 - ((_hit_11 / hit_11) * 100)); }
609  if (hit_m_11 != 0) { fPercent_lost_positron_hits->Fill(100 - ((_hit_m_11 / hit_m_11) * 100)); }
610  if (hit_111 != 0) { fPercent_lost_111_hits->Fill(100 - ((_hit_111 / hit_111) * 100)); }
611 
612  if (hit_211 != 0) { fPercent_lost_211_hits->Fill(100 - ((_hit_211 / hit_211) * 100)); }
613 
614  if (hit_m211 != 0) { fPercent_lost_m211_hits->Fill(100 - ((_hit_m211 / hit_m211) * 100)); }
615  if (hit_2212 != 0) { fPercent_lost_2212_hits->Fill(100 - ((_hit_2212 / hit_2212) * 100)); }
616  if (hit_2112 != 0) { fPercent_lost_2112_hits->Fill(100 - ((_hit_2112 / hit_2112) * 100)); }
617 
618  std::cout << "****** mu E from clusters = " << _en_13 << std::endl;
619  std::cout << "****** mu E from hits = " << en_13 << std::endl;
620 
621  if (en_13 != 0) { fPercent_lost_muon_energy->Fill(100 - ((_en_13 / en_13) * 100)); }
622  if (en_11 != 0) { fPercent_lost_electron_energy->Fill(100 - ((_en_11 / en_11) * 100)); }
623  if (en_m11 != 0) { fPercent_lost_positron_energy->Fill(100 - ((_en_m11 / en_m11) * 100)); }
624  if (en_111 != 0) { fPercent_lost_111_energy->Fill(100 - ((_en_111 / en_111) * 100)); }
625  if (en_211 != 0) { fPercent_lost_211_energy->Fill(100 - ((_en_211 / en_211) * 100)); }
626  if (en_m211 != 0) { fPercent_lost_m211_energy->Fill(100 - ((_en_m211 / en_m211) * 100)); }
627  if (en_2212 != 0) { fPercent_lost_2212_energy->Fill(100 - ((_en_2212 / en_2212) * 100)); }
628  if (en_2112 != 0) { fPercent_lost_2112_energy->Fill(100 - ((_en_2112 / en_2112) * 100)); }
629  }
tca::TCEvent::event
unsigned int event
Definition: DataStructs.h:634
pdg
var pdg
Definition: selectors.fcl:14
tca::TCEvent::run
unsigned int run
Definition: DataStructs.h:635
exit
exit
Definition: generate_icarus_geometry_splitwire.pl:430
geo::View_t
enum geo::_plane_proj View_t
Enumerate the possible plane projections.
p
pdgs p
Definition: selectors.fcl:22
abs
T abs(T value)
Definition: sparse_vector_test.cc:30
tca::evt
TCEvent evt
Definition: DataStructs.cxx:8
cluster::DBclusterAna::fClusterFinderModuleLabel
std::string fClusterFinderModuleLabel
Definition: DBclusterAna_module.cc:89
cout
BEGIN_PROLOG could also be cout
Definition: messageservice.fcl:10
void cluster::DBclusterAna::beginJob ( )
private

Definition at line 114 of file DBclusterAna_module.cc.

115  {
116  // get access to the TFile service
117  art::ServiceHandle<art::TFileService const> tfs;
118 
119  fNoParticles_pdg_per_event = tfs->make<TH1F>(
120  "fNoParticles_pdg_per_event", "Average # of Particles per cluster for each event", 500, 0, 5);
121  fNoParticles_pdg = tfs->make<TH1F>(
122  "fNoParticles_pdg", "Number of Particles in a Cluster for each cluster", 500, 0, 5);
123  fNoParticles_trackid = tfs->make<TH1F>(
124  "fNoParticles_trackid", "Number of different TrackIDs in a Cluster", 300, 0, 30);
125 
126  fNoParticles_trackid_mother =
127  tfs->make<TH1F>("fNoParticles_trackid_mother",
128  "Number of different TrackIDs in a Cluster(using mother)for each cluster",
129  300,
130  0,
131  30);
132 
133  fNoParticles_trackid_per_event =
134  tfs->make<TH1F>("fNoParticles_trackid_per_event",
135  "Avg Number of different TrackIDs per Cluster per event",
136  300,
137  0,
138  30);
139  fCl_for_Muon =
140  tfs->make<TH1F>("fCl_for_Muon", "Number of Clusters for Muon per plane (pdg)", 1500, 0, 15);
141 
142  fNoClustersInEvent =
143  tfs->make<TH1F>("fNoClustersInEvent", "Number of Clusters in an Event", 50, 0, 50);
144 
145  fPercentNoise =
146  tfs->make<TH1F>("fPercentNoise", "% of hits that were marked as Noise by DBSCAN", 250, 0, 25);
147 
148  fno_of_clusters_per_track = tfs->make<TH1F>(
149  "fno_of_clusters_per_track", "Number of Clusters per TrackID per plane", 1500, 0, 15);
150 
151  fPercent_lost_muon_hits =
152  tfs->make<TH1F>("fPercent_lost_muon_hits",
153  "Number of muon hits excluded by dbscan in % (per Event)",
154  10000,
155  0,
156  100);
157  fPercent_lost_electron_hits =
158  tfs->make<TH1F>("fPercent_lost_electron_hits",
159  "Number of electron hits excluded by dbscan in % (per Event)",
160  10000,
161  0,
162  100);
163  fPercent_lost_positron_hits =
164  tfs->make<TH1F>("fPercent_lost_positron_hits",
165  "Number of positron hits excluded by dbscan in % (per Event)",
166  10000,
167  0,
168  100);
169  fPercent_lost_111_hits =
170  tfs->make<TH1F>("fPercent_lost_111_hits",
171  "Number of pion(111) hits excluded by dbscan in % (per Event)",
172  10000,
173  0,
174  100);
175  fPercent_lost_211_hits =
176  tfs->make<TH1F>("fPercent_lost_211_hits",
177  "Number of pion(211) hits excluded by dbscan in % (per Event)",
178  10000,
179  0,
180  100);
181  fPercent_lost_m211_hits =
182  tfs->make<TH1F>("fPercent_lost_m211_hits",
183  "Number of pion(-211) hits excluded by dbscan in % (per Event)",
184  10000,
185  0,
186  100);
187  fPercent_lost_2212_hits =
188  tfs->make<TH1F>("fPercent_lost_2212_hits",
189  "Number of proton hits excluded by dbscan in % (per Event)",
190  10000,
191  0,
192  100);
193  fPercent_lost_2112_hits =
194  tfs->make<TH1F>("fPercent_lost_2112_hits",
195  "Number of neutron hits excluded by dbscan in % (per Event)",
196  10000,
197  0,
198  100);
199 
200  fPercent_lost_muon_energy = tfs->make<TH1F>("fPercent_lost_muon_energy",
201  " muon energy excluded by dbscan in % (per Event)",
202  10000,
203  0,
204  100);
205  fPercent_lost_electron_energy =
206  tfs->make<TH1F>("fPercent_lost_electron_energy",
207  "electron energy excluded by dbscan in % (per Event)",
208  10000,
209  0,
210  100);
211  fPercent_lost_positron_energy =
212  tfs->make<TH1F>("fPercent_lost_positron_energy",
213  " positron energy excluded by dbscan in % (per Event)",
214  10000,
215  0,
216  100);
217  fPercent_lost_111_energy =
218  tfs->make<TH1F>("fPercent_lost_111_energy",
219  "pion(111) energy excluded by dbscan in % (per Event)",
220  10000,
221  0,
222  100);
223  fPercent_lost_211_energy =
224  tfs->make<TH1F>("fPercent_lost_211_energy",
225  "pion(211) energy excluded by dbscan in % (per Event)",
226  10000,
227  0,
228  100);
229  fPercent_lost_m211_energy =
230  tfs->make<TH1F>("fPercent_lost_m211_energy",
231  " pion(-211) energy excluded by dbscan in % (per Event)",
232  10000,
233  0,
234  100);
235  fPercent_lost_2212_energy = tfs->make<TH1F>("fPercent_lost_2212_energy",
236  "proton energy excluded by dbscan in % (per Event)",
237  10000,
238  0,
239  100);
240  fPercent_lost_2112_energy =
241  tfs->make<TH1F>("fPercent_lost_2112_energy",
242  "neutron energy excluded by dbscan in % (per Event)",
243  10000,
244  0,
245  100);
246 
247  fEnergy = tfs->make<TH1F>("fEnergy", "energy for each voxel", 100000, 0, 0.0005);
248 
249  fbrian_in = tfs->make<TH2F>("fbrian_in",
250  ";# Electrons deposited; # Electrons detected by hitfinder",
251  1000,
252  0,
253  10000000,
254  1000,
255  0,
256  10000000);
257  fbrian_coll = tfs->make<TH2F>("fbrian_coll",
258  ";# Electrons deposited; # Electrons detected by hitfinder",
259  1000,
260  0,
261  10000000,
262  1000,
263  0,
264  10000000);
265  }
tfs
art::ServiceHandle< art::TFileService > tfs
Definition: NuVertexChargeTree_module.cc:254

Member Data Documentation

TH2F* cluster::DBclusterAna::fbrian_coll
private

Definition at line 84 of file DBclusterAna_module.cc.

TH2F* cluster::DBclusterAna::fbrian_in
private

Definition at line 83 of file DBclusterAna_module.cc.

std::string cluster::DBclusterAna::fCalDataModuleLabel
private

Definition at line 90 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fCl_for_Muon
private

Definition at line 61 of file DBclusterAna_module.cc.

std::string cluster::DBclusterAna::fClusterFinderModuleLabel
private

Definition at line 89 of file DBclusterAna_module.cc.

std::string cluster::DBclusterAna::fDigitModuleLabel
private

Definition at line 86 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fEnergy
private

Definition at line 82 of file DBclusterAna_module.cc.

std::string cluster::DBclusterAna::fGenieGenModuleLabel
private

Definition at line 91 of file DBclusterAna_module.cc.

std::string cluster::DBclusterAna::fHitsModuleLabel
private

Definition at line 87 of file DBclusterAna_module.cc.

std::string cluster::DBclusterAna::fLArG4ModuleLabel
private

Definition at line 88 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fno_of_clusters_per_track
private

Definition at line 64 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fNoClustersInEvent
private

Definition at line 62 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fNoParticles_pdg
private

Definition at line 56 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fNoParticles_pdg_per_event
private

Definition at line 60 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fNoParticles_trackid
private

Definition at line 57 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fNoParticles_trackid_mother
private

Definition at line 58 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fNoParticles_trackid_per_event
private

Definition at line 59 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_111_energy
private

Definition at line 77 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_111_hits
private

Definition at line 68 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_2112_energy
private

Definition at line 81 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_2112_hits
private

Definition at line 72 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_211_energy
private

Definition at line 78 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_211_hits
private

Definition at line 69 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_2212_energy
private

Definition at line 80 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_2212_hits
private

Definition at line 71 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_electron_energy
private

Definition at line 75 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_electron_hits
private

Definition at line 66 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_m211_energy
private

Definition at line 79 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_m211_hits
private

Definition at line 70 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_muon_energy
private

Definition at line 74 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_muon_hits
private

Definition at line 65 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_positron_energy
private

Definition at line 76 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercent_lost_positron_hits
private

Definition at line 67 of file DBclusterAna_module.cc.

TH1F* cluster::DBclusterAna::fPercentNoise
private

Definition at line 63 of file DBclusterAna_module.cc.

The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.5