Inheritance diagram for opdet::OpFlashMCTruthAna:

Public Member Functions
	OpFlashMCTruthAna (const fhicl::ParameterSet &)

void	analyze (const art::Event &)

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	fFlashInputModule

std::string	fTruthInputModule

TTree *	fAnalysisTree

TTree *	fPerEventTree

Int_t	fEventID

Int_t	fNFlashes

Int_t	fNTruths

Float_t	fFlashY

Float_t	fFlashZ

Float_t	fFlashU

Float_t	fFlashV

Float_t	fFlashT

Float_t	fFlashPE

Float_t	fFlashFastToTotal

Float_t	fFlashWidthY

Float_t	fFlashWidthZ

Float_t	fFlashWidthU

Float_t	fFlashWidthV

Float_t	fVertexX

Float_t	fVertexY

Float_t	fVertexZ

Float_t	fVertexT

Float_t	fTrueE

Int_t	fTruePDG

Float_t	fCenterX

Float_t	fCenterY

Float_t	fCenterZ

Float_t	fDistFlashCenter

Float_t	fDistFlashVertex

Float_t	fDistFlashCenterNorm

Float_t	fDistFlashVertexNorm

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 31 of file OpFlashMCTruthAna_module.cc.

Constructor & Destructor Documentation

opdet::OpFlashMCTruthAna::OpFlashMCTruthAna ( const fhicl::ParameterSet & )

Definition at line 88 of file OpFlashMCTruthAna_module.cc.

     : EDAnalyzer(pset)
   {
 
     // Indicate that the Input Module comes from .fcl
     fFlashInputModule = pset.get<std::string>("FlashInputModule");
     fTruthInputModule = pset.get<std::string>("TruthInputModule");
 
 
 
     art::ServiceHandle<art::TFileService const> tfs;
 
     fPerEventTree = tfs->make<TTree>("PerEventTree", "PerEventTree");
 
     fPerEventTree->Branch("EventID",   &fEventID,   "EventID/I");
     fPerEventTree->Branch("NFlashes",  &fNFlashes,  "NFlashes/I");
 
     fPerEventTree->Branch("VertexX",    &fVertexX,    "VertexX/F");
     fPerEventTree->Branch("VertexY",    &fVertexY,    "VertexY/F");
     fPerEventTree->Branch("VertexZ",    &fVertexZ,    "VertexZ/F");
 
     fPerEventTree->Branch("TrueE",      &fTrueE,      "TrueE/F");
     fPerEventTree->Branch("TruePDG",    &fTruePDG,    "TruePDG/I");
 
     fPerEventTree->Branch("CenterX",    &fCenterX,    "CenterX/F");
     fPerEventTree->Branch("CenterY",    &fCenterY,    "CenterY/F");
     fPerEventTree->Branch("CenterZ",    &fCenterZ,    "CenterZ/F");
 
 
 
     fAnalysisTree = tfs->make<TTree>("AnalysisTree", "AnalysisTree");
 
     fAnalysisTree->Branch("EventID",   &fEventID,   "EventID/I");
     fAnalysisTree->Branch("NFlashes",  &fNFlashes,  "NFlashes/I");
 
     fAnalysisTree->Branch("FlashY",    &fFlashY,    "FlashY/F");
     fAnalysisTree->Branch("FlashZ",    &fFlashZ,    "FlashZ/F");
     fAnalysisTree->Branch("FlashU",    &fFlashU,    "FlashU/F");
     fAnalysisTree->Branch("FlashV",    &fFlashV,    "FlashV/F");
 
     fAnalysisTree->Branch("FlashWidthY",  &fFlashWidthY,  "FlashWidthY/F");
     fAnalysisTree->Branch("FlashWidthZ",  &fFlashWidthZ,  "FlashWidthZ/F");
     fAnalysisTree->Branch("FlashWidthU",  &fFlashWidthU,  "FlashWidthU/F");
     fAnalysisTree->Branch("FlashWidthV",  &fFlashWidthV,  "FlashWidthV/F");
 
     fAnalysisTree->Branch("FlashT",    &fFlashT,    "FlashT/F");
     fAnalysisTree->Branch("FlashPE",   &fFlashPE,   "FlashPE/F");
     fAnalysisTree->Branch("FlashFastToTotal",   &fFlashFastToTotal,   "FlashFastToTotal/F");
 
     fAnalysisTree->Branch("VertexX",    &fVertexX,    "VertexX/F");
     fAnalysisTree->Branch("VertexY",    &fVertexY,    "VertexY/F");
     fAnalysisTree->Branch("VertexZ",    &fVertexZ,    "VertexZ/F");
 
     fAnalysisTree->Branch("TrueE",      &fTrueE,      "TrueE/F");
     fAnalysisTree->Branch("TruePDG",    &fTruePDG,    "TruePDG/I");
 
     fAnalysisTree->Branch("CenterX",    &fCenterX,    "CenterX/F");
     fAnalysisTree->Branch("CenterY",    &fCenterY,    "CenterY/F");
     fAnalysisTree->Branch("CenterZ",    &fCenterZ,    "CenterZ/F");
 
     fAnalysisTree->Branch("DistFlashCenter",    &fDistFlashCenter,    "DistFlashCenter/F");
     fAnalysisTree->Branch("DistFlashVertex",    &fDistFlashVertex,    "DistFlashVertex/F");
 
 
   }

Member Function Documentation

void opdet::OpFlashMCTruthAna::analyze ( const art::Event & evt )

Definition at line 155 of file OpFlashMCTruthAna_module.cc.

   {
 
     // Create a handles
     art::Handle< std::vector< recob::OpFlash > > FlashHandle;
     art::Handle< std::vector< simb::MCTruth > >  TruthHandle;
 
     // Read in data
     evt.getByLabel(fFlashInputModule, FlashHandle);
     evt.getByLabel(fTruthInputModule, TruthHandle);
 
     fEventID=evt.id().event();
 
     fNTruths  = TruthHandle->at(0).NParticles();
     fNFlashes = FlashHandle->size();
 
     std::cout<<"Size of truth collection : " << TruthHandle->size()<<std::endl;
     std::cout<<"We found " << fNTruths<<" truth particles and " << fNFlashes<<" flashes" <<std::endl;
 
 
     for(int iPart=0; iPart!=fNTruths; ++iPart)
       {
         const simb::MCParticle ThisPart = TruthHandle->at(0).GetParticle(iPart);
         fTruePDG = ThisPart.PdgCode();
         fTrueE   = ThisPart.E(0);
 
         fVertexX = ThisPart.Vx(0);
         fVertexY = ThisPart.Vy(0);
         fVertexZ = ThisPart.Vz(0);
         fVertexT = ThisPart.T(0);
 
         fCenterX = (ThisPart.Vx(0) + ThisPart.EndX())/2.;
         fCenterY = (ThisPart.Vy(0) + ThisPart.EndY())/2.;
         fCenterZ = (ThisPart.Vz(0) + ThisPart.EndZ())/2.;
 
 
         for(unsigned int i = 0; i < FlashHandle->size(); ++i)
           {
 
             // Get OpFlash
             art::Ptr< recob::OpFlash > TheFlashPtr(FlashHandle, i);
 
             fFlashT    = TheFlashPtr->Time();
             fFlashPE   = TheFlashPtr->TotalPE();
             fFlashFastToTotal   = TheFlashPtr->FastToTotal();
 
             fFlashY    = TheFlashPtr->YCenter();
             fFlashZ    = TheFlashPtr->ZCenter();
             fFlashU    = TheFlashPtr->WireCenters().at(0);
             fFlashV    = TheFlashPtr->WireCenters().at(1);
 
             fFlashWidthY  = TheFlashPtr->YWidth();
             fFlashWidthZ  = TheFlashPtr->ZWidth();
             fFlashWidthU  = TheFlashPtr->WireWidths().at(0);
             fFlashWidthV  = TheFlashPtr->WireWidths().at(1);
 
 
 
 
 
             fDistFlashCenter = pow(
                                    pow(fCenterY - fFlashY,2) +
                                    pow(fCenterZ - fFlashZ,2),
                                    0.5);
 
             fDistFlashVertex = pow(
                                    pow(fVertexY - fFlashY,2) +
                                    pow(fVertexZ - fFlashZ,2),
                                    0.5);
 
             fDistFlashCenterNorm = pow(
                                        pow((fCenterY - fFlashY)/fFlashWidthY,2) +
                                        pow((fCenterZ - fFlashZ)/fFlashWidthZ,2),
                                        0.5);
 
             fDistFlashVertexNorm = pow(
                                        pow((fVertexY - fFlashY)/fFlashWidthY,2) +
                                        pow((fVertexZ - fFlashZ)/fFlashWidthZ,2),
                                        0.5);
 
             fAnalysisTree->Fill();
 
           }
 
       }
 
     fPerEventTree->Fill();
   }