Inheritance diagram for opdet::OpFlashMCTruthAna:

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

void	analyze (const art::Event &)

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

Detailed Description

Definition at line 31 of file OpFlashMCTruthAna_module.cc.

Constructor & Destructor Documentation

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

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();
   }