protoana::ProtoFlash Class Reference

Inheritance diagram for protoana::ProtoFlash:

Public Member Functions
	ProtoFlash (const fhicl::ParameterSet &)
virtual	~ProtoFlash ()
void	beginJob ()
void	analyze (const art::Event &)
void	ExtractTrueTimes (const std::string &moduleName, std::map< int, double > &timeMap, const art::Event &evt)
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 Attributes
std::string	fOpFlashModuleLabel
std::string	fOpHitModuleLabel
std::string	fSignalLabel
std::string	fCosmicLabel
std::string	fGeantLabel
std::string	fParticleLabel
TH1D *	hFlashToTrueTime
TH1D *	hFlashPurity
TH2D *	hPurityTimeDiff
TH1D *	hFlashToRecoTime
TH1D *	hFlashToRecoWide
TH1D *	hFlashToRecoWider
TH1D *	hFlashTimes
TH1D *	hHitTimes
TH1D *	hNFlash
TH1D *	hNHitPerFlash

Additional Inherited Members
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >
using	ModuleType = EDAnalyzer
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 47 of file ProtoFlash_module.cc.

Constructor & Destructor Documentation

protoana::ProtoFlash::ProtoFlash

(

const fhicl::ParameterSet &

)

Definition at line 97 of file ProtoFlash_module.cc.

    : EDAnalyzer(pset)
  {

    // Indicate that the Input Module comes from .fcl
    fOpFlashModuleLabel = pset.get<std::string>("OpFlashModuleLabel");
    fOpHitModuleLabel   = pset.get<std::string>("OpHitModuleLabel");
    fSignalLabel        = pset.get<std::string>("SignalLabel");
    fCosmicLabel        = pset.get<std::string>("CosmicLabel");
    fGeantLabel         = pset.get<std::string>("GeantLabel");
    fParticleLabel      = pset.get<std::string>("ParticleLabel");

    art::ServiceHandle< art::TFileService > tfs;

    // Make a few plots
    hFlashToTrueTime    = tfs->make<TH1D>("hFlashToTrueTime","",50,-5,5);
    hFlashPurity     = tfs->make<TH1D>("hFlashPurity","",50,0.499,1.001);
    hFlashToRecoTime = tfs->make<TH1D>("hFlashToRecoTime","",50,-5,5);
    hFlashToRecoWide = tfs->make<TH1D>("hFlashToRecoWide","",100,-10,10);
    hFlashToRecoWider = tfs->make<TH1D>("hFlashToRecoWider","",100,-50,50);
    hNFlash          = tfs->make<TH1D>("hNFlash","",50,0,400);
    hNHitPerFlash    = tfs->make<TH1D>("hNHitPerFlash","",50,0,100);
    hFlashTimes      = tfs->make<TH1D>("hFlashTimes","",100,-4000,4000);
    hHitTimes        = tfs->make<TH1D>("hHitTimes","",100,-4000,4000);
    hPurityTimeDiff  = tfs->make<TH2D>("hPurityTimeDiff","",25,-5,5,25,0.499,1.001);
  }

protoana::ProtoFlash::~ProtoFlash ( )

virtual

Definition at line 126 of file ProtoFlash_module.cc.

  {}

Member Function Documentation

void protoana::ProtoFlash::analyze

(

const art::Event &

evt

)

Definition at line 134 of file ProtoFlash_module.cc.

  {

    // Make sure we can use this on data and MC
    bool isMC = !(evt.isRealData());
//    isMC = false;

    // Get flashes from event
    std::vector<art::Ptr<recob::OpFlash> > flashlist;
    auto FlashHandle = evt.getHandle< std::vector< recob::OpFlash > >(fOpFlashModuleLabel);
    if (FlashHandle) {
      art::fill_ptr_vector(flashlist, FlashHandle);
      std::sort(flashlist.begin(), flashlist.end(), recob::OpFlashPtrSortByPE);
    }

    // Get assosciations between flashes and hits
    art::FindManyP< recob::OpHit > Assns(FlashHandle, evt, fOpFlashModuleLabel);

    // We want to store a map of track time to track id
    // This will later allow us to check how much of a flash comes from the best matched time
    std::map<int,double> trueTimeID;
    if(isMC){
      // Check for generator inputs - particle gun or protoDUNE beam
      if(fSignalLabel!=""){
        ExtractTrueTimes(fSignalLabel,trueTimeID,evt);
      }

      // Check for cosmic generator inputs
      if(fCosmicLabel!=""){
        ExtractTrueTimes(fCosmicLabel,trueTimeID,evt);
      }
    }

    //////////////////////////////////////
    // Access all the Flash Information //
    //////////////////////////////////////

    hNFlash->Fill(FlashHandle->size());

    // Use the clocks service to make sure to account for the offset between true times and the electronics clocks
    auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService>()->DataFor(evt);

    // Store a map of flash times
    std::map<int,double> flashMap;

    // For every OpFlash in the vector
    for(unsigned int i = 0; i < FlashHandle->size(); ++i)
    {

      // Get OpFlash and associated hits
      art::Ptr< recob::OpFlash > TheFlashPtr(FlashHandle, i);
      recob::OpFlash TheFlash = *TheFlashPtr;
      art::FindManyP< recob::OpHit > Assns(FlashHandle, evt, fOpFlashModuleLabel);
      std::vector< art::Ptr<recob::OpHit> > matchedHits = Assns.at(i);

      // Account for the time offset in the TPC
      flashMap.insert(std::make_pair(i,TheFlash.Time() - clockData.TriggerOffsetTPC()));

      hNHitPerFlash->Fill(matchedHits.size());
      hFlashTimes->Fill(TheFlash.Time());

      for(auto const h : matchedHits){
        hHitTimes->Fill(h->PeakTime());
      }

      // Truth level code
      if(isMC){
        art::ServiceHandle<cheat::PhotonBackTrackerService> pbt;
    
        // Get the best match in time, then check how much of the light comes from
        // the best matched particle      
        int bestMatch = 0;
        double bestPurity = 0;
        double minTimeDiff = 1e20;
            
        // Iterate over the map
        for(auto &m : trueTimeID){
            
          double dist = fabs(m.second - TheFlash.Time());
          if(dist < minTimeDiff){
            // Does this track give us purity > 0.5?
            std::set<int> trackIDs;
            trackIDs.emplace(m.first);
            double purity = pbt->OpHitCollectionPurity(trackIDs,matchedHits);
            if(purity < 0.5) continue;
  
            // If purity is good enough, this is a success
            minTimeDiff = dist;
            bestMatch = m.first;
            bestPurity = purity;
          }
        }
        if(minTimeDiff > 1000){
  //        std::cout << "No sensible true match to flash " << i << std::endl;
        }
  
        if(bestPurity >= 0.5) std::cout << "Best true time matched particle " << bestMatch << " has delta T = " << minTimeDiff << " and gives a purity " << bestPurity << std::endl;
  
        hFlashToTrueTime->Fill(trueTimeID[bestMatch] - TheFlash.Time());
        hPurityTimeDiff->Fill(trueTimeID[bestMatch] - TheFlash.Time(),bestPurity);
        hFlashPurity->Fill(bestPurity);
      }
    } // End loop over flashes

    // Get reconstruction information from particles with a measured T0
    // Try finding some particles
    art::ValidHandle< std::vector<recob::PFParticle> > particleHandle
          = evt.getValidHandle<std::vector<recob::PFParticle> >(fParticleLabel);

    protoana::ProtoDUNEPFParticleUtils pfpUtil;

    for (size_t p = 0; p != particleHandle->size(); ++p){

      const auto thisParticle = (*particleHandle)[p];

      // Only consider primaries so we don't include deltas etc
      if(!(thisParticle.IsPrimary())) continue;

      // Did this particle have an associated T0?
      std::vector<anab::T0> t0s = pfpUtil.GetPFParticleT0(thisParticle,evt,fParticleLabel);
      if(t0s.size() == 0) continue;

      // Pandora gives us times in ns
      double recoT0 = t0s[0].Time() / 1000.; 
   
      int bestRecoMatch = 0;
      double minRecoTimeDiff = 1e20;

      // Now loop over the flashes
      for(auto &m : flashMap){
        double dist = fabs(recoT0 - m.second); 
        if(dist < minRecoTimeDiff){
          minRecoTimeDiff = dist;
          bestRecoMatch = m.first;
        }
      } 

      std::cout << "Particle " << p << " has a TPC T0 = " << recoT0 << std::endl;

      if(minRecoTimeDiff > 100){
        std::cout << "No sensible reco match to flash " << p << std::endl;
      }
      std::cout << "Best matched flash " << bestRecoMatch << " has delta T = " << minRecoTimeDiff << std::endl;

      hFlashToRecoTime->Fill(recoT0 - flashMap[bestRecoMatch]);
      hFlashToRecoWide->Fill(recoT0 - flashMap[bestRecoMatch]);
      hFlashToRecoWider->Fill(recoT0 - flashMap[bestRecoMatch]);
    }

  }

void protoana::ProtoFlash::beginJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 130 of file ProtoFlash_module.cc.

  {}

void protoana::ProtoFlash::ExtractTrueTimes	(	const std::string &	moduleName,
		std::map< int, double > &	timeMap,
		const art::Event &	evt
	)

Definition at line 285 of file ProtoFlash_module.cc.

                                                                                                                {


    auto MCTruthsHandle = evt.getValidHandle<std::vector<simb::MCTruth> >(moduleName);
    art::Ptr<simb::MCTruth> thisMCTruth(MCTruthsHandle, 0);
    if (thisMCTruth->NParticles() == 0) {
      mf::LogError("FlashMatchAna") << "No Cosmic MCTruth Particles";
    }
    else std::cout << "MCTruth from " << moduleName  << " has " << thisMCTruth->NParticles() << " particles " << std::endl;

    // Get all the track ids associated with the cosmic events.
    art::FindManyP<simb::MCParticle> geantAssns(MCTruthsHandle,evt,fGeantLabel);

    for ( size_t i = 0; i < geantAssns.size(); i++) {
      auto parts = geantAssns.at(i);
      int counter = 0;
      for (auto part = parts.begin(); part != parts.end(); part++) {
        ++counter;
        timeMap.insert(std::make_pair((*part)->TrackId(),(*part)->T()/1000.));
      }
      std::cout << "Found " << counter << " GEANT particles associated to " << moduleName << " MCTruth " << i << std::endl;
    }

  }

Member Data Documentation

std::string protoana::ProtoFlash::fCosmicLabel

private

Definition at line 73 of file ProtoFlash_module.cc.

std::string protoana::ProtoFlash::fGeantLabel

private

Definition at line 74 of file ProtoFlash_module.cc.

std::string protoana::ProtoFlash::fOpFlashModuleLabel

private

Definition at line 70 of file ProtoFlash_module.cc.

std::string protoana::ProtoFlash::fOpHitModuleLabel

private

Definition at line 71 of file ProtoFlash_module.cc.

std::string protoana::ProtoFlash::fParticleLabel

private

Definition at line 75 of file ProtoFlash_module.cc.

std::string protoana::ProtoFlash::fSignalLabel

private

Definition at line 72 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hFlashPurity

private

Definition at line 78 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hFlashTimes

private

Definition at line 83 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hFlashToRecoTime

private

Definition at line 80 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hFlashToRecoWide

private

Definition at line 81 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hFlashToRecoWider

private

Definition at line 82 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hFlashToTrueTime

private

Definition at line 77 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hHitTimes

private

Definition at line 84 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hNFlash

private

Definition at line 85 of file ProtoFlash_module.cc.

TH1D* protoana::ProtoFlash::hNHitPerFlash

private

Definition at line 86 of file ProtoFlash_module.cc.

TH2D* protoana::ProtoFlash::hPurityTimeDiff

private

Definition at line 79 of file ProtoFlash_module.cc.

---

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

• protoduneana/protoduneana/Utilities/ProtoFlash_module.cc