CloseInTime_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       CloseInTime
// Module Type: analyzer
// File:        CloseInTime_module.cc
////////////////////////////////////////////////////////////////////////
// This is a very simple module to help determine cuts for the backtracker
// function CloseInTime. CloseInTime links cell hits with mc photon signals
// by determining if the hit and photon signals are in the same cell, plane,
// and reasonably close in time to eachother. This prevents one from counting
// photon signals from, for example, another hit later in time but in the 
// same cell and plane. 
//
// There are two constants to determine for each detector/timing resolution.
// The offset is approximately the mean of the histograms this module produces.
// The width is approximately the width of the distribution of the histograms.
// These constants should be looked at anytime a major change happens to our 
// timing resolution or a new detector is added.
//
// For more information, please see docdb 9092 or contact Susan Lein.
////////////////////////////////////////////////////////////////////////
#include "TH1.h"

#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Services/Optional/TFileService.h"

#include "MCCheater/BackTracker.h"
#include "Geometry/Geometry.h"
#include "NovaDAQConventions/DAQConventions.h"

namespace mcchk
{
  class CloseInTime : public art::EDAnalyzer
  {
  public:
    explicit CloseInTime(const fhicl::ParameterSet& p);
    virtual ~CloseInTime();

    virtual void analyze(const art::Event& e);
    virtual void reconfigure(fhicl::ParameterSet const & p);
    virtual void beginRun(art::Run const &r);

  private:

    std::string         fHitModuleLabel; ///< label for module making the hits
    TH1D*               fTimeDiff;       ///< histogram of the difference between the time of photon signals in the cell and a cell hit's time
    TH1D*               fTimeExtend;     ///< same as TimeDiff, but with an extend range to see the behavior of the tails
    novadaq::cnv::DetId fDetID;          ///< detector id, used to decide histogram extent

  };

//-------------------------------------------------------------------
  CloseInTime::CloseInTime(const fhicl::ParameterSet& p):
    EDAnalyzer(p),
    fTimeDiff(NULL),
    fTimeExtend(NULL)
  {
    this->reconfigure(p);
  }

//-------------------------------------------------------------------
  CloseInTime::~CloseInTime()
  {
  }

//-------------------------------------------------------------------
  void CloseInTime::analyze(const art::Event& e)
  {
    // check that this is MC, stop if it isn't
    art::ServiceHandle<cheat::BackTracker> bt;
    if(!bt->HaveTruthInfo()){
      mf::LogWarning("CloseInTime") << "attempting to run MC truth check on "
                                    << "things without truth, bail";
      return;
    }

    // get all hits in the event 
    art::Handle< std::vector<rb::CellHit> > hithdl;
    e.getByLabel(fHitModuleLabel, hithdl);

    art::PtrVector<rb::CellHit> allhits;
    for(size_t h = 0; h < hithdl->size(); ++h){
      art::Ptr<rb::CellHit> hit(hithdl, h);
      allhits.push_back(hit);
    }

    for(size_t s = 0; s < allhits.size(); ++s){
      if(bt->IsNoise(allhits[s])) continue;

      //Only look at hits with proper timing fit for FD, ND. NDOS never has good timing enabled.
      if (!(allhits[s]->GoodTiming()) && !(fDetID == novadaq::cnv::kNDOS)) continue;

      double hitTime = allhits[s]->TNS();     

      const std::vector<sim::PhotonSignal> photVec = bt->CellToPhotonSignal(allhits[s]->Plane(),allhits[s]->Cell());
     
      for(size_t j = 0; j < photVec.size(); ++j){
        double photTime = photVec[j].TimeMean();       
        fTimeDiff->Fill(photTime-hitTime);
        fTimeExtend->Fill(photTime-hitTime);
      }//End of loop over photon signals
    }//End of loop over all hits

  }// end analyze

//-------------------------------------------------------------------
  void CloseInTime::reconfigure(fhicl::ParameterSet const & p) 
  {
    fHitModuleLabel     = p.get< std::string >("HitModuleLabel"    );
  }


 //-------------------------------------------------------------------
  void CloseInTime::beginRun(art::Run const &r) 
  {
    if (!fTimeDiff){
    art::ServiceHandle<art::TFileService> tfs;
    art::ServiceHandle<geo::Geometry>  geom;
    fDetID = geom->DetId();

    if (fDetID == novadaq::cnv::kNDOS){fTimeDiff = tfs->make<TH1D>("TimeDiff",";Photon Time - Hit TNS;Hits",100, -800, 2000);}
    else {fTimeDiff = tfs->make<TH1D>("TimeDiff",";Photon Time - Hit TNS;Hits",100, -750, 750);}

    fTimeExtend = tfs->make<TH1D>("TimeExtend",";Photon Time - Hit TNS;Hits",1000, -10000, 10000); 
    }//End of loop to only define histograms once per job
  }

  DEFINE_ART_MODULE(CloseInTime)

}// end namespace mcchk