Inheritance diagram for filt::LArG4ExtCounterFilter:

Classes
struct	CounterSetPair

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

virtual	~LArG4ExtCounterFilter ()

virtual bool	filter (art::Event &e)

void	reconfigure (fhicl::ParameterSet const &pset)

void	beginJob ()

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

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

std::string	workerType () const

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

	Filter (fhicl::ParameterSet const &)

	Filter (Filter const &)=delete

	Filter (Filter &&)=delete

Filter &	operator= (Filter const &)=delete

Filter &	operator= (Filter &&)=delete

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 &)

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::Modifier
	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

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
bool	IsInterestingParticle (const art::Ptr< simb::MCParticle > particle)

bool	UsesCounterSetPair (const CounterSetPair &CSP, const std::set< unsigned int > &usedCounterIDs)

bool	UsesCounterSet (const std::vector< unsigned int > &counterIDs, const std::set< unsigned int > &usedCounterIDs)

Private Attributes
std::vector< CounterSetPair >	fCounterSetPairs

bool	fUseEWCounterPair

bool	fUseNupSdownCounterPair

bool	fUseNdownSupCounterPair

std::vector< int >	fInterestingPDGs

double	fParticleMinEnergy

double	fParticleMaxEnergy

Additional Inherited Members
Public Types inherited from art::EDFilter
using	ModuleType = EDFilter

using	WorkerType = WorkerT< EDFilter >

Public Types inherited from art::detail::Filter
template<typename UserConfig >
using	Table = Modifier::Table< UserConfig >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Static Public Attributes inherited from art::detail::Filter
static constexpr bool	Pass {true}

static constexpr bool	Fail {false}

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 18 of file LArG4ExtCounterFilter_module.cc.

Constructor & Destructor Documentation

filt::LArG4ExtCounterFilter::LArG4ExtCounterFilter ( fhicl::ParameterSet const & pset )

explicit

virtual filt::LArG4ExtCounterFilter::~LArG4ExtCounterFilter ( )

inlinevirtual

Definition at line 21 of file LArG4ExtCounterFilter_module.cc.

21 {};

Member Function Documentation

void filt::LArG4ExtCounterFilter::beginJob ( )

virtual

Reimplemented from art::EDFilter.

Definition at line 126 of file LArG4ExtCounterFilter_module.cc.

                                        {
 
     //Need to get the counter information.  By doing this at the start of the job, rather than per event, the code assumes the geomtry is not going to change between events
     art::ServiceHandle<geo::Geometry> geom;
     //Create the pairwise counter sets
     CounterSetPair EWCounterSetPair;
     CounterSetPair NupSdownCounterSetPair;
     CounterSetPair NdownSupCounterSetPair;
     //A stupid way of storing the IDs of the counters, this REALLY needs changing
     //The code loops through all of the counters in the geomtry, and if the number matches a particular counter number e.g. one of the east counters, store it in the correct, pairwise set
     for (unsigned int i = 0; i < geom->NAuxDets(); i++){
       //The WE counter pairs
       if (i >=6 && i <= 15) EWCounterSetPair.setA.push_back(i);
       else if (i >= 28 && i <=37) EWCounterSetPair.setB.push_back(i);
       //The N (up) S (down) counter pairs
       else if (i >= 22 && i <= 27) NupSdownCounterSetPair.setA.push_back(i);
       else if (i <= 5) NupSdownCounterSetPair.setB.push_back(i);
       //The N (down) S (up) counter pairs
       else if (i >= 16 && i <= 21) NdownSupCounterSetPair.setA.push_back(i);
       else if (i >= 38 && i <= 43) NdownSupCounterSetPair.setB.push_back(i);
     }
 
     //Enable/disable the counter set pairs
     EWCounterSetPair.IsRequested = fUseEWCounterPair;
     NupSdownCounterSetPair.IsRequested = fUseNupSdownCounterPair;
     NdownSupCounterSetPair.IsRequested = fUseNdownSupCounterPair;
 
     //Store them onto the vector of counter set pairs
     fCounterSetPairs.push_back(EWCounterSetPair);
     fCounterSetPairs.push_back(NupSdownCounterSetPair);
     fCounterSetPairs.push_back(NdownSupCounterSetPair);
 
 
     for (unsigned int i = 0; i < fCounterSetPairs.size(); i++){
       std::cout<<"Counter set pair: "<<i<<std::endl;
       std::cout<<"--setA size: " << fCounterSetPairs[i].setA.size() << std::endl;
       std::cout<<"--setB size: " << fCounterSetPairs[i].setB.size() << std::endl;
 
     }
   }

bool filt::LArG4ExtCounterFilter::filter ( art::Event & e )

virtual

Implements art::EDFilter.

Definition at line 73 of file LArG4ExtCounterFilter_module.cc.

                                                 {
 
     art::ServiceHandle<geo::Geometry> geom;
 
 
     //Get the vector of particles
     auto particles = e.getHandle<std::vector<simb::MCParticle> >("largeant");
     //Loop through the particles
     for (unsigned int part_i = 0; part_i < particles->size(); part_i++){
       //Get the particle
       const art::Ptr<simb::MCParticle> particle(particles,part_i);
       //Check if the particle is initially worth considering
       if (IsInterestingParticle(particle)){
         //OK so the particle matches the criteria we need.  Now we need to get the IDs of all external counters it passes through
         //To do this, get the trajectory points and find which counter (if any) said points are contained in
         //Use a set to store the counter IDs the particle passes through
         std::set<unsigned int> usedExtCounterIDs;
         //Now get the trajcectory points
         unsigned int npts = particle->NumberTrajectoryPoints();
         //Loop over those points
         for (unsigned int pt = 0; pt < npts; pt++){
           //Get the position at the point
           TLorentzVector pos4 = particle->Position(pt);
           //The function which checks whether a position is contained in a counter requires a double[3].  So convert the position to that format
           double pos[3];
           pos[0] = pos4.X();
           pos[1] = pos4.Y();
           pos[2] = pos4.Z();
           //If the position is not contained in a counter, the function throws an exception.  We don't want to end the process when this happens
           try{
             //std::cout<<"AuxDetID: " << geom->FindAuxDetAtPosition(pos) << "  pdg: " << particle->PdgCode() << std::endl;
             unsigned int counterID = geom->FindAuxDetAtPosition(pos);
             usedExtCounterIDs.insert(counterID);
           }
           catch(...){};
         }
         std::cout<<"NCounters (any) passed through: " << usedExtCounterIDs.size() << std::endl;
         //We now have a list (set) of the counter IDs which the particles passed through.  Now compare this list with the information stored in the CounterSetPairs
         for (unsigned int csp_i = 0; csp_i < fCounterSetPairs.size(); csp_i++){
           //Only bother comparing the information if a particlar counter set pair has been requested
           if (!fCounterSetPairs[csp_i].IsRequested) continue;
           if (UsesCounterSetPair(fCounterSetPairs[csp_i],usedExtCounterIDs)){
             std::cout<<"SELECTED EVENT"<<std::endl;
             return true;
           }
         }
       }
     }
 
     //Assume that the event is not worth saving
     return false;
   }

bool filt::LArG4ExtCounterFilter::IsInterestingParticle ( const art::Ptr< simb::MCParticle > particle )

private

Definition at line 167 of file LArG4ExtCounterFilter_module.cc.

                                                                                         {
     //Loop over the list of requested PDGs.  See if that matches the particle under consideration
     for (unsigned int i = 0; i < fInterestingPDGs.size(); i++){
       //Check if the particle under consideration has a requested PDG
       if (particle->PdgCode() == fInterestingPDGs[i]){
         //Got a requested PDG,  now check that the energy matches the requested range
         TLorentzVector mom4 = particle->Momentum();
         if (mom4.T() > fParticleMinEnergy && mom4.T() < fParticleMaxEnergy){
           //std::cout<<"FOUND INTERESTING PARTICLE"<<std::endl;
           return true;
         }
       }
     }
     return false;
   }

void filt::LArG4ExtCounterFilter::reconfigure ( fhicl::ParameterSet const & pset )

Definition at line 55 of file LArG4ExtCounterFilter_module.cc.

                                                                       {
     fUseEWCounterPair = pset.get<bool>("UseEWCounterPair",1);
     std::cout<<"Use EW counter pair: " << fUseEWCounterPair<<std::endl;
     fUseNupSdownCounterPair = pset.get<bool>("UseNupSdownCounterPair",1);
     std::cout<<"Use N (up) S (down) counter pair: " << fUseNupSdownCounterPair << std::endl;
     fUseNdownSupCounterPair = pset.get<bool>("UseNdownSupCounterPair",1);
     std::cout<<"Use N (down) S (up) counter pair: " << fUseNdownSupCounterPair << std::endl;
     fInterestingPDGs = pset.get<std::vector<int> >("InterestingPDGs");
     std::cout<<"NInteresting PDGs: " << fInterestingPDGs.size() << std::endl;
     for (unsigned int i = 0; i < fInterestingPDGs.size(); i++){
       std::cout<<"-- PDG: " << fInterestingPDGs[i] << std::endl; 
     }
     fParticleMinEnergy = pset.get<double>("ParticleMinEnergy",0);
     std::cout<<"Particle min energy: " << fParticleMinEnergy << std::endl;
     fParticleMaxEnergy = pset.get<double>("ParticleMaxEnergy",999999999);
     std::cout<<"Particle max energy: " << fParticleMaxEnergy << std::endl;
   }

bool filt::LArG4ExtCounterFilter::UsesCounterSet	(	const std::vector< unsigned int > &	counterIDs,
		const std::set< unsigned int > &	usedCounterIDs
	)

private

Definition at line 195 of file LArG4ExtCounterFilter_module.cc.

                                                                                                                                  {
     //Iterate over the used counter IDs and compare them with every counter ID in the vector.  If a match is found, this means the particle of interest passed through one of the counters in the vector
     for (std::set<unsigned int>::iterator setIt = userCounterIDs.begin(); setIt != userCounterIDs.end(); setIt++){
       unsigned int usedCounterID = (*setIt);
       //Now loop through the IDs in the vector
       for (unsigned int i = 0; i < counterIDs.size(); i++){
         //Compare the elements.  If there is a match, return true
         if (usedCounterID == counterIDs[i]){
           std::cout<<"Counter ID match"<<std::endl;
           return true;
         }
       }
     }
 
     //None of the used counters matched the counters in the set
     return false;
   }

bool filt::LArG4ExtCounterFilter::UsesCounterSetPair	(	const CounterSetPair &	CSP,
		const std::set< unsigned int > &	usedCounterIDs
	)

private

Definition at line 183 of file LArG4ExtCounterFilter_module.cc.

                                                                                                                      {
 
     bool usesSetA = UsesCounterSet(CSP.setA,usedCounterIDs);
     bool usesSetB = UsesCounterSet(CSP.setB,usedCounterIDs);
     if (usesSetA && usesSetB){
       std::cout<<"USES BOTH SETS OF COUNTERS"<<std::endl;
       return true;
     }
 
     return false;
   }