Inheritance diagram for microboone::CosmicRemovalAna:

Public Types
enum	hit_origin_t { hit_origin_Unknown = -1, hit_origin_Cosmic = 0, hit_origin_NonCosmic = 1 }

Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >

using	ModuleType = EDAnalyzer

Public Member Functions
	CosmicRemovalAna (fhicl::ParameterSet const &pset)

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

void	beginJob ()

Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDAnalyzer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept

	Analyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	Analyzer (Table< Config > const &config)

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

Public Member Functions inherited from art::Observer
	~Observer () noexcept

	Observer (Observer const &)=delete

	Observer (Observer &&)=delete

Observer &	operator= (Observer const &)=delete

Observer &	operator= (Observer &&)=delete

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

void	fillDescriptions (ModuleDescription const &)

fhicl::ParameterSetID	selectorConfig () const

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
void	InitEventTree (int run_number, int event_number)

void	FillMCInfo (art::Event const &e, std::vector< recob::Hit > const &hitlist, std::vector< hit_origin_t > &hitOrigins, std::vector< sim::MCHitCollection > const &mchitCollectionVector, std::map< int, const simb::MCTruth * > const &trackIDToTruthMap)

void	FillTrackInfo (size_t const &hit_iter, hit_origin_t const &origin, float const &charge, std::vector< size_t > const &track_indices_this_hit, std::vector< std::vector< const anab::CosmicTag * >> const &tags_per_cluster, std::vector< bool > &hitsAccounted_per_tag, std::vector< bool > &hitsAllTags)

void	FillClusterInfo (size_t const &hit_iter, hit_origin_t const &origin, float const &charge, std::vector< size_t > const &cluster_indices_this_hit, std::vector< std::vector< const anab::CosmicTag * >> const &tags_per_cluster, std::vector< bool > &hitsAccounted_per_tag, std::vector< bool > &hitsAllTags)

void	FillAllTagsInfo (recob::Hit const &hit, hit_origin_t const &origin)

Private Attributes
unsigned int	nCosmicTags

TTree *	tEventTree

std::string	fHitsModuleLabel

std::string	fMCModuleLabel

std::string	fMCHitsModuleLabel

std::string	fClusterModuleLabel

std::string	fTrackModuleLabel

float	fHitCompareCut

std::vector< std::string >	fCosmicTagAssocLabel

std::vector< float >	fCosmicScoreThresholds

std::vector< float >	cTaggedCharge_Cosmic

std::vector< float >	cTaggedCharge_NonCosmic

std::vector< int >	cTaggedHits_Cosmic

std::vector< int >	cTaggedHits_NonCosmic

Additional Inherited Members
Protected Member Functions inherited from art::Observer
std::string const &	processName () const

bool	wantAllEvents () const noexcept

bool	wantEvent (ScheduleID id, Event const &e) const

Handle< TriggerResults >	getTriggerResults (Event const &e) const

	Observer (fhicl::ParameterSet const &config)

	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 40 of file CosmicRemovalAna_module.cc.

Member Enumeration Documentation

enum microboone::CosmicRemovalAna::hit_origin_t

Enumerator
hit_origin_Unknown
hit_origin_Cosmic
hit_origin_NonCosmic

Definition at line 49 of file CosmicRemovalAna_module.cc.

49 { hit_origin_Unknown = -1, hit_origin_Cosmic = 0, hit_origin_NonCosmic = 1 };

microboone::CosmicRemovalAna::hit_origin_Cosmic

Definition: CosmicRemovalAna_module.cc:49

microboone::CosmicRemovalAna::hit_origin_NonCosmic

Definition: CosmicRemovalAna_module.cc:49

microboone::CosmicRemovalAna::hit_origin_Unknown

Definition: CosmicRemovalAna_module.cc:49

Constructor & Destructor Documentation

microboone::CosmicRemovalAna::CosmicRemovalAna ( fhicl::ParameterSet const & pset )

explicit

Definition at line 159 of file CosmicRemovalAna_module.cc.

   : EDAnalyzer(pset)
   , fHitsModuleLabel(pset.get<std::string>("HitsModuleLabel"))
   , fMCModuleLabel(pset.get<std::string>("MCModuleLabel"))
   , fMCHitsModuleLabel(pset.get<std::string>("MCHitsModuleLabel"))
   , fClusterModuleLabel(pset.get<std::string>("ClusterModuleLabel"))
   , fTrackModuleLabel(pset.get<std::string>("TrackModuleLabel"))
   , fHitCompareCut(pset.get<float>("HitCompareCut"))
   , fCosmicTagAssocLabel(pset.get<std::vector<std::string>>("CosmicTagAssocLabel"))
   , fCosmicScoreThresholds(pset.get<std::vector<float>>("CosmicScoreThresholds"))
 {}

Member Function Documentation

void microboone::CosmicRemovalAna::analyze ( const art::Event & evt )

read access to event

Definition at line 209 of file CosmicRemovalAna_module.cc.

 {
 
   InitEventTree(evt.run(), evt.event());
 
   // ##################################################################
   // ### Grabbing ALL HITS in the event to monitor the backtracking ###
   // ##################################################################
   art::Handle<std::vector<recob::Hit>> hitListHandle;
   evt.getByLabel(fHitsModuleLabel, hitListHandle);
   std::vector<recob::Hit> const& hitVector(*hitListHandle);
 
   std::vector<hit_origin_t> hitOrigins(hitVector.size());
 
   //get mcHitCollection
   art::Handle<std::vector<sim::MCHitCollection>> mchitListHandle;
   evt.getByLabel(fMCHitsModuleLabel, mchitListHandle);
   std::vector<sim::MCHitCollection> const& mchitcolVector(*mchitListHandle);
 
   //get mcparticles out of the event
   art::Handle<std::vector<simb::MCParticle>> mcParticleHandle;
   evt.getByLabel(fMCModuleLabel, mcParticleHandle);
   std::vector<simb::MCParticle> const& mcParticleVector(*mcParticleHandle);
 
   //get associations of mc particles to mc truth
   art::Handle<art::Assns<simb::MCParticle, simb::MCTruth>> assnMCParticleTruthHandle;
   evt.getByLabel(fMCModuleLabel, assnMCParticleTruthHandle);
 
   std::vector<const simb::MCTruth*> particle_to_truth =
     util::GetAssociatedVectorOneP(assnMCParticleTruthHandle, mcParticleHandle);
 
   //make trackId to MCTruth map
   std::map<int, const simb::MCTruth*> trackIDToTruthMap;
   for (size_t p_iter = 0; p_iter < mcParticleVector.size(); p_iter++)
     trackIDToTruthMap[mcParticleVector[p_iter].TrackId()] = particle_to_truth[p_iter];
 
   FillMCInfo(evt, hitVector, hitOrigins, mchitcolVector, trackIDToTruthMap);
 
   art::Handle<std::vector<recob::Track>> trackListHandle;
   evt.getByLabel(fTrackModuleLabel, trackListHandle);
   std::vector<recob::Track> const& trackVector(*trackListHandle);
 
   art::Handle<std::vector<recob::Cluster>> clusterListHandle;
   evt.getByLabel(fClusterModuleLabel, clusterListHandle);
   std::vector<recob::Cluster> const& clusterVector(*clusterListHandle);
 
   art::Handle<art::Assns<recob::Hit, recob::Track>> assnHitTrackHandle;
   evt.getByLabel(fTrackModuleLabel, assnHitTrackHandle);
   std::vector<std::vector<size_t>> track_indices_per_hit =
     util::GetAssociatedVectorManyI(assnHitTrackHandle, hitListHandle);
 
   art::Handle<art::Assns<recob::Hit, recob::Cluster>> assnHitClusterHandle;
   evt.getByLabel(fClusterModuleLabel, assnHitClusterHandle);
   std::vector<std::vector<size_t>> cluster_indices_per_hit =
     util::GetAssociatedVectorManyI(assnHitClusterHandle, hitListHandle);
 
   std::vector<art::Handle<std::vector<anab::CosmicTag>>> cosmicTagHandlesVector(
     fCosmicTagAssocLabel.size());
   std::vector<art::Handle<art::Assns<recob::Track, anab::CosmicTag>>> assnTrackTagHandlesVector(
     fCosmicTagAssocLabel.size());
   std::vector<std::vector<const anab::CosmicTag*>> tags_per_track(
     trackVector.size(), std::vector<const anab::CosmicTag*>(fCosmicTagAssocLabel.size()));
   std::vector<art::Handle<art::Assns<recob::Cluster, anab::CosmicTag>>> assnClusterTagHandlesVector(
     fCosmicTagAssocLabel.size());
   std::vector<std::vector<const anab::CosmicTag*>> tags_per_cluster(
     clusterVector.size(), std::vector<const anab::CosmicTag*>(fCosmicTagAssocLabel.size()));
 
   for (size_t label_i = 0; label_i < fCosmicTagAssocLabel.size(); label_i++) {
     try {
       evt.getByLabel(fCosmicTagAssocLabel[label_i], cosmicTagHandlesVector[label_i]);
     }
     catch (...) {
       continue;
     }
     try {
       evt.getByLabel(fCosmicTagAssocLabel[label_i], assnTrackTagHandlesVector[label_i]);
       for (auto const& pair : *assnTrackTagHandlesVector[label_i])
         tags_per_track.at(pair.first.key())[label_i] = &(*(pair.second));
     }
     catch (...) {
     }
     try {
       evt.getByLabel(fCosmicTagAssocLabel[label_i], assnClusterTagHandlesVector[label_i]);
       for (auto const& pair : *assnClusterTagHandlesVector[label_i])
         tags_per_cluster.at(pair.first.key())[label_i] = &(*(pair.second));
     }
     catch (...) {
     }
   }
 
   std::vector<std::vector<bool>> hitsAccounted(
     hitVector.size(), std::vector<bool>(fCosmicTagAssocLabel.size(), false));
   std::vector<bool> hitsAllTags(hitVector.size(), false);
 
   for (size_t hit_iter = 0; hit_iter < hitVector.size(); hit_iter++) {
 
     float charge = hitVector[hit_iter].Integral();
     hit_origin_t origin = hitOrigins[hit_iter];
 
     if (track_indices_per_hit[hit_iter].size() != 0)
       FillTrackInfo(hit_iter,
                     origin,
                     charge,
                     track_indices_per_hit[hit_iter],
                     tags_per_track,
                     hitsAccounted[hit_iter],
                     hitsAllTags);
 
     if (cluster_indices_per_hit[hit_iter].size() != 0)
       FillClusterInfo(hit_iter,
                       origin,
                       charge,
                       cluster_indices_per_hit[hit_iter],
                       tags_per_cluster,
                       hitsAccounted[hit_iter],
                       hitsAllTags);
 
     if (hitsAllTags[hit_iter]) FillAllTagsInfo(hitVector[hit_iter], origin);
 
   } //end loop over all the hits
 
   tEventTree->Fill();
 }

void microboone::CosmicRemovalAna::beginJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 176 of file CosmicRemovalAna_module.cc.

 {
 
   //static cEventProperties_t cEventVals;
 
   nCosmicTags = fCosmicTagAssocLabel.size();
   cTaggedCharge_Cosmic.resize(nCosmicTags);
   cTaggedCharge_NonCosmic.resize(nCosmicTags);
   cTaggedHits_Cosmic.resize(nCosmicTags);
   cTaggedHits_NonCosmic.resize(nCosmicTags);
 
   art::ServiceHandle<art::TFileService const> tfs;
   tEventTree = (TTree*)tfs->make<TTree>("CosmicEventTree", "CosmicEventTree");
 
   tEventTree->Branch(
     "event",
     &cEventVals,
     "runNumber/I:eventNumber/I:nHitsTotal_Unknown/I:nHitsTotal_Cosmic/I:nHitsTotal_NonCosmic/"
     "I:qTotal_Unknown/F:qTotal_Cosmic/F:qTotal_NonCosmic/F:nHitsTrack/I:nHitsTrack_Cosmic/"
     "I:nHitsTrack_NonCosmic/I:qTrack/F:qTrack_Cosmic/F:qTrack_NonCosmic/F:nHitsCluster/"
     "I:nHitsCluster_Cosmic/I:nHitsCluster_NonCosmic/I:qCluster/F:qCluster_Cosmic/"
     "F:qCluster_NonCosmic/F:TotalTaggedCharge_Cosmic/F:TotalTaggedCharge_NonCosmic/"
     "F:TotalTaggedHits_Cosmic/I:TotalTaggedHits_NonCosmic/I");
   tEventTree->Branch("TaggedCharge_Cosmic", &cTaggedCharge_Cosmic);
   tEventTree->Branch("TaggedCharge_NonCosmic", &cTaggedCharge_NonCosmic);
   tEventTree->Branch("TaggedHits_Cosmic", &cTaggedHits_Cosmic);
   tEventTree->Branch("TaggedHits_NonCosmic", &cTaggedHits_NonCosmic);
 }

void microboone::CosmicRemovalAna::FillAllTagsInfo	(	recob::Hit const &	hit,
		hit_origin_t const &	origin
	)

private

Definition at line 540 of file CosmicRemovalAna_module.cc.

 {
   if (origin == hit_origin_Cosmic) {
     cEventVals.TotalTaggedCharge_Cosmic += hit.Integral();
     cEventVals.TotalTaggedHits_Cosmic++;
   }
   else if (origin == hit_origin_NonCosmic) {
     cEventVals.TotalTaggedCharge_NonCosmic += hit.Integral();
     cEventVals.TotalTaggedHits_NonCosmic++;
   }
 }

void microboone::CosmicRemovalAna::FillClusterInfo	(	size_t const &	hit_iter,
		hit_origin_t const &	origin,
		float const &	charge,
		std::vector< size_t > const &	cluster_indices_this_hit,
		std::vector< std::vector< const anab::CosmicTag * >> const &	tags_per_cluster,
		std::vector< bool > &	hitsAccounted_per_tag,
		std::vector< bool > &	hitsAllTags
	)

private

Definition at line 491 of file CosmicRemovalAna_module.cc.

 {
 
   cEventVals.nHitsCluster++;
   cEventVals.qCluster += charge;
 
   if (origin == hit_origin_Cosmic) {
     cEventVals.nHitsCluster_Cosmic++;
     cEventVals.qCluster_Cosmic += charge;
   }
   else if (origin == hit_origin_NonCosmic) {
     cEventVals.nHitsCluster_NonCosmic++;
     cEventVals.qCluster_NonCosmic += charge;
   }
 
   for (unsigned int nCT = 0; nCT < fCosmicTagAssocLabel.size();
        nCT++) { //<---This loops over the vector of cosmicTags in stored in the event
     if (hitsAccounted_per_tag[nCT]) continue;
 
     for (auto const& cluster_index : cluster_indices_this_hit) {
       if (!tags_per_cluster[cluster_index][nCT]) continue;
       const anab::CosmicTag* currentTag(tags_per_cluster[cluster_index][nCT]);
       if (currentTag->CosmicScore() > fCosmicScoreThresholds[nCT]) {
 
         hitsAccounted_per_tag[nCT] = true;
         hitsAllTags[hit_iter] = true;
         if (origin == hit_origin_Cosmic) {
           cTaggedHits_Cosmic[nCT]++;
           cTaggedCharge_Cosmic[nCT] += charge;
         }
         else if (origin == hit_origin_NonCosmic) {
           cTaggedHits_NonCosmic[nCT]++;
           cTaggedCharge_NonCosmic[nCT] += charge;
         }
       }
     }
   }
 
 } //end FillClusterInfo

void microboone::CosmicRemovalAna::FillMCInfo	(	art::Event const &	e,
		std::vector< recob::Hit > const &	hitlist,
		std::vector< hit_origin_t > &	hitOrigins,
		std::vector< sim::MCHitCollection > const &	mchitCollectionVector,
		std::map< int, const simb::MCTruth * > const &	trackIDToTruthMap
	)

private

Definition at line 381 of file CosmicRemovalAna_module.cc.

 {
   auto const clock_data =
     art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e);
 
   for (size_t itr = 0; itr < hitlist.size(); itr++) {
 
     recob::Hit const& this_hit = hitlist[itr];
 
     std::vector<int> trackIDs;
     std::vector<double> energy;
 
     for (auto const& mchit : mchitCollectionVector[this_hit.Channel()]) {
       if (std::abs(clock_data.TPCTDC2Tick(mchit.PeakTime()) - this_hit.PeakTime()) <
           fHitCompareCut) {
         trackIDs.push_back(mchit.PartTrackId());
         energy.push_back(mchit.PartEnergy());
       }
     }
 
     if (trackIDs.size() == 0) {
       hitOrigins[itr] = hit_origin_Unknown;
       cEventVals.nHitsTotal_Unknown++;
       cEventVals.qTotal_Unknown += this_hit.Integral();
       continue;
     }
 
     float cosmic_energy = 0;
     float non_cosmic_energy = 0;
 
     for (size_t iter = 0; iter < trackIDs.size(); iter++) {
       auto map_element = trackIdToTruthMap.find(std::abs(trackIDs[iter]));
       if (map_element == trackIdToTruthMap.end()) continue;
       int origin = map_element->second->Origin();
       if (origin == simb::kBeamNeutrino)
         non_cosmic_energy += energy[iter];
       else
         cosmic_energy += energy[iter];
     }
 
     if (non_cosmic_energy > cosmic_energy) {
       hitOrigins[itr] = hit_origin_NonCosmic;
       cEventVals.nHitsTotal_NonCosmic++;
       cEventVals.qTotal_NonCosmic += this_hit.Integral();
     }
     else {
       hitOrigins[itr] = hit_origin_Cosmic;
       cEventVals.nHitsTotal_Cosmic++;
       cEventVals.qTotal_Cosmic += this_hit.Integral();
     }
   }
 
 } //end FillMCInfo

void microboone::CosmicRemovalAna::FillTrackInfo	(	size_t const &	hit_iter,
		hit_origin_t const &	origin,
		float const &	charge,
		std::vector< size_t > const &	track_indices_this_hit,
		std::vector< std::vector< const anab::CosmicTag * >> const &	tags_per_cluster,
		std::vector< bool > &	hitsAccounted_per_tag,
		std::vector< bool > &	hitsAllTags
	)

private

Definition at line 442 of file CosmicRemovalAna_module.cc.

 {
 
   cEventVals.nHitsTrack++;
   cEventVals.qTrack += charge;
 
   if (origin == hit_origin_Cosmic) {
     cEventVals.nHitsTrack_Cosmic++;
     cEventVals.qTrack_Cosmic += charge;
   }
   else if (origin == hit_origin_NonCosmic) {
     cEventVals.nHitsTrack_NonCosmic++;
     cEventVals.qTrack_NonCosmic += charge;
   }
 
   for (unsigned int nCT = 0; nCT < fCosmicTagAssocLabel.size();
        nCT++) { //<---This loops over the vector of cosmicTags in stored in the event
     if (hitsAccounted_per_tag[nCT]) continue;
 
     for (auto const& track_index : track_indices_this_hit) {
       if (!tags_per_track[track_index][nCT]) continue;
       const anab::CosmicTag* currentTag(tags_per_track[track_index][nCT]);
       if (currentTag->CosmicScore() > fCosmicScoreThresholds[nCT]) {
 
         hitsAccounted_per_tag[nCT] = true;
         hitsAllTags[hit_iter] = true;
         if (origin == hit_origin_Cosmic) {
           cTaggedHits_Cosmic[nCT]++;
           cTaggedCharge_Cosmic[nCT] += charge;
         }
         else if (origin == hit_origin_NonCosmic) {
           cTaggedHits_NonCosmic[nCT]++;
           cTaggedCharge_NonCosmic[nCT] += charge;
         }
       }
     }
   }
 
 } //end FillTrackInfo

void microboone::CosmicRemovalAna::InitEventTree	(	int	run_number,
		int	event_number
	)

private

Definition at line 335 of file CosmicRemovalAna_module.cc.

 {
 
   cEventVals.runNumber = run_number;     //evt.run();
   cEventVals.eventNumber = event_number; //evt.event();
 
   cEventVals.nHitsTotal_Unknown = 0;
   cEventVals.nHitsTotal_Cosmic = 0;
   cEventVals.nHitsTotal_NonCosmic = 0;
 
   cEventVals.qTotal_Unknown = 0;
   cEventVals.qTotal_Cosmic = 0;
   cEventVals.qTotal_NonCosmic = 0;
 
   cEventVals.nHitsTrack = 0;
   cEventVals.nHitsTrack_Cosmic = 0;
   cEventVals.nHitsTrack_NonCosmic = 0;
 
   cEventVals.qTrack = 0;
   cEventVals.qTrack_Cosmic = 0;
   cEventVals.qTrack_NonCosmic = 0;
 
   cEventVals.nHitsCluster = 0;
   cEventVals.nHitsCluster_Cosmic = 0;
   cEventVals.nHitsCluster_NonCosmic = 0;
 
   cEventVals.qCluster = 0;
   cEventVals.qCluster_Cosmic = 0;
   cEventVals.qCluster_NonCosmic = 0;
 
   cEventVals.TotalTaggedCharge_Cosmic = 0.;
   cEventVals.TotalTaggedCharge_NonCosmic = 0.;
   cEventVals.TotalTaggedHits_Cosmic = 0;
   cEventVals.TotalTaggedHits_NonCosmic = 0;
 
   for (size_t iter = 0; iter < fCosmicTagAssocLabel.size(); iter++) {
     cTaggedHits_Cosmic.at(iter) = 0;
     cTaggedCharge_Cosmic.at(iter) = 0;
     cTaggedHits_NonCosmic.at(iter) = 0;
     cTaggedCharge_NonCosmic.at(iter) = 0;
   }
 }

Member Data Documentation

std::vector<float> microboone::CosmicRemovalAna::cTaggedCharge_Cosmic

private

Definition at line 92 of file CosmicRemovalAna_module.cc.

std::vector<float> microboone::CosmicRemovalAna::cTaggedCharge_NonCosmic

private

Definition at line 93 of file CosmicRemovalAna_module.cc.

std::vector<int> microboone::CosmicRemovalAna::cTaggedHits_Cosmic

private

Definition at line 94 of file CosmicRemovalAna_module.cc.

std::vector<int> microboone::CosmicRemovalAna::cTaggedHits_NonCosmic

private

Definition at line 95 of file CosmicRemovalAna_module.cc.

std::string microboone::CosmicRemovalAna::fClusterModuleLabel

private

Definition at line 60 of file CosmicRemovalAna_module.cc.

std::vector<float> microboone::CosmicRemovalAna::fCosmicScoreThresholds

private

Definition at line 64 of file CosmicRemovalAna_module.cc.

std::vector<std::string> microboone::CosmicRemovalAna::fCosmicTagAssocLabel

private

Definition at line 63 of file CosmicRemovalAna_module.cc.

float microboone::CosmicRemovalAna::fHitCompareCut

private

Definition at line 62 of file CosmicRemovalAna_module.cc.

std::string microboone::CosmicRemovalAna::fHitsModuleLabel

private

Definition at line 57 of file CosmicRemovalAna_module.cc.

std::string microboone::CosmicRemovalAna::fMCHitsModuleLabel

private

Definition at line 59 of file CosmicRemovalAna_module.cc.

std::string microboone::CosmicRemovalAna::fMCModuleLabel

private

Definition at line 58 of file CosmicRemovalAna_module.cc.

std::string microboone::CosmicRemovalAna::fTrackModuleLabel

private

Definition at line 61 of file CosmicRemovalAna_module.cc.

unsigned int microboone::CosmicRemovalAna::nCosmicTags

private

Definition at line 52 of file CosmicRemovalAna_module.cc.

TTree* microboone::CosmicRemovalAna::tEventTree

private

Definition at line 55 of file CosmicRemovalAna_module.cc.

The documentation for this class was generated from the following file:

larana/larana/CosmicRemoval/CosmicRemovalAna_module.cc

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation