TotallyCheatTracker_module.cc

Go to the documentation of this file.

// LArSoft libraries
#include "larexamples/Algorithms/TotallyCheatTracks/TotallyCheatTrackingAlg.h"
#include "larexamples/Algorithms/TotallyCheatTracks/CheatTrackData/CheatTrack.h"
#include "lardataobj/RecoBase/Trajectory.h"
#include "nusimdata/SimulationBase/MCParticle.h"

// framework libraries
#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h" // art::ValidHandle<>
#include "art/Persistency/Common/PtrMaker.h"
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Utilities/InputTag.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/Table.h"

// C/C++ standard libraries
#include <vector>
#include <memory> // std::make_unique()


namespace lar {
  namespace example {
  
    class TotallyCheatTracker: public art::EDProducer {
      
        public:
      
      struct Config {
        
        using Name    = fhicl::Name;
        using Comment = fhicl::Comment;
        
        fhicl::Atom<art::InputTag> particles {
          Name("particles"),
          Comment("the data product of simulated particles to be processed"),
          "largeant" // default
          };
        
        fhicl::Atom<double> minLength {
          Name("minLength"),
          Comment("minimum length of particle trajectory [cm]"),
          1.0 // default
          };
        
        fhicl::Atom<double> minEnergy {
          Name("minEnergy"),
          Comment("minimum energy of particle [GeV]"),
          1.0 // default
          };
        
        fhicl::Table<lar::example::TotallyCheatTrackingAlg::Config> algoConfig {
          Name("algoConfig"),
          Comment("configuration of TotallyCheatTrackingAlg algorithm"),
          lar::example::TotallyCheatTrackingAlg::Config{} // default
          };
        
      }; // Config
      
      using Parameters = art::EDProducer::Table<Config>;
      
      explicit TotallyCheatTracker(Parameters const& config);
      
      
      virtual void produce(art::Event& event) override;
      
      
      bool acceptParticle(simb::MCParticle const& particle) const;
      
      
        private:
      art::InputTag particleTag; 
      
      double minLength; 
      double minEnergy; 
      
      lar::example::TotallyCheatTrackingAlg trackMaker;
      
      
    }; // class TotallyCheatTracker
    
  } // namespace example
} // namespace lar



//------------------------------------------------------------------------------
//--- TotallyCheatTracker
//--- 
lar::example::TotallyCheatTracker::TotallyCheatTracker
  (Parameters const& config)
  : particleTag(config().particles())
  , minLength(config().minLength())
  , minEnergy(config().minEnergy())
  , trackMaker(config().algoConfig())
{
  
  consumes<std::vector<simb::MCParticle>>(particleTag);
  
  produces<std::vector<lar::example::CheatTrack>>();
  produces<art::Assns<lar::example::CheatTrack, simb::MCParticle>>();
  
} // lar::example::TotallyCheatTracker::TotallyCheatTracker()


//------------------------------------------------------------------------------
void lar::example::TotallyCheatTracker::produce(art::Event& event) {
  
  //
  // read the input
  //
  auto particleHandle
    = event.getValidHandle<std::vector<simb::MCParticle>>(particleTag);
  auto const& particles = *particleHandle;
  
  //
  // prepare the output structures
  //
  auto tracks = std::make_unique<std::vector<lar::example::CheatTrack>>();
  auto trackToPart =
    std::make_unique<art::Assns<lar::example::CheatTrack, simb::MCParticle>>();
  
  art::PtrMaker<simb::MCParticle> makePartPtr(event, particleHandle.id());
  art::PtrMaker<lar::example::CheatTrack> makeTrackPtr(event, *this);
  
  
  //
  // set up the algorithm
  //
  trackMaker.setup();
  
  //
  // run the algorithm
  //
  for (std::size_t iParticle = 0U; iParticle < particles.size(); ++iParticle) {
    simb::MCParticle const& particle = particles[iParticle];
    
    //
    // apply filters
    //
    if (!acceptParticle(particle)) continue;
    
    //
    // run the algorithm
    //
    tracks->push_back(trackMaker.makeTrack(particle));
    
    //
    // create the association
    //
    auto const iTrack = tracks->size() - 1;
    art::Ptr<lar::example::CheatTrack> const trackPtr = makeTrackPtr(iTrack);
    art::Ptr<simb::MCParticle> const partPtr = makePartPtr(iParticle);
    trackToPart->addSingle(trackPtr, partPtr);
    
  } // for
  
  //
  // store the data products into the event (and print a short summary)
  //
  mf::LogInfo("TotallyCheatTracker")
    << "Reconstructed " << tracks->size() << " tracks out of "
    << particleHandle->size() << " particles from '"
    << particleTag.encode() << "'";
  
  event.put(std::move(tracks));
  event.put(std::move(trackToPart));
  
} // lar::example::TotallyCheatTracker::produce()


//------------------------------------------------------------------------------
bool lar::example::TotallyCheatTracker::acceptParticle
  (simb::MCParticle const& particle) const
{
  // skip empty particle
  if (particle.NumberTrajectoryPoints() == 0) return false;
  
  // energy at the first point
  if (particle.E() < minEnergy) return false;
  
  // path length
  if (particle.Trajectory().TotalLength() < minLength) return false;
  
  // good enough!
  return true;
  
} // lar::example::TotallyCheatTracker::acceptParticle()

//------------------------------------------------------------------------------
DEFINE_ART_MODULE(lar::example::TotallyCheatTracker)


//------------------------------------------------------------------------------