Inheritance diagram for sbnd::CRTDetSimAna:

Classes
struct	Config

Public Types
using	Parameters = art::EDAnalyzer::Table< Config >

Public Member Functions
	CRTDetSimAna (Parameters const &config)

virtual void	beginJob () override

virtual void	analyze (const art::Event &event) override

virtual void	endJob () override

Private Attributes
art::InputTag	fSimModuleLabel
	name of MCParticle producer in g4 More...

art::InputTag	fSimChannelModuleLabel
	name of SimChannel producer in g4 More...

art::InputTag	fCRTSimLabel
	name of CRT producer More...

bool	fVerbose
	print information about what's going on More...

double	fQPed

double	fQSlope

double	fClockSpeedCRT

std::map< std::string, TH1D * >	hADC

std::map< std::string, TH1D * >	hNpe

std::map< std::string, TH1D * >	hNpeRatio

std::map< std::string, TH1D * >	hTime

std::map< std::string, TH1D * >	hStripDist

std::map< std::string, TH1D * >	hSipmDist

std::map< std::string, TH1D * >	hEffSipmDistTotal

std::map< std::string, TH1D * >	hEffSipmDistReco

std::map< std::string, TH1D * >	hEffStripDistTotal

std::map< std::string, TH1D * >	hEffStripDistReco

std::map< std::string, TH1D * >	hEffEDepTotal

std::map< std::string, TH1D * >	hEffEDepReco

std::map< std::string, TH1D * >	hEffLengthTotal

std::map< std::string, TH1D * >	hEffLengthReco

std::map< std::string, TH2D * >	hStripDistADC

std::map< std::string, TH2D * >	hSipmDistADC

std::map< std::string, TH2D * >	hStripDistNpe

std::map< std::string, TH2D * >	hSipmDistNpe

std::map< std::string, TH2D * >	hSipmDistNpeRatio

geo::GeometryCore const *	fGeometryService

TPCGeoAlg	fTpcGeo

CRTGeoAlg	fCrtGeo

CRTBackTracker	fCrtBackTrack

Detailed Description

Definition at line 63 of file CRTDetSimAna_module.cc.

Member Typedef Documentation

using sbnd::CRTDetSimAna::Parameters = art::EDAnalyzer::Table<Config>

Definition at line 111 of file CRTDetSimAna_module.cc.

Constructor & Destructor Documentation

sbnd::CRTDetSimAna::CRTDetSimAna ( Parameters const & config )

explicit

Definition at line 172 of file CRTDetSimAna_module.cc.

     : EDAnalyzer(config)
     , fSimModuleLabel       (config().SimModuleLabel())
     , fSimChannelModuleLabel(config().SimChannelModuleLabel())
     , fCRTSimLabel          (config().CRTSimLabel())
     , fVerbose              (config().Verbose())
     , fQPed                 (config().QPed())
     , fQSlope               (config().QSlope())
     , fClockSpeedCRT        (config().ClockSpeedCRT())
     , fCrtBackTrack         (config().CrtBackTrack())
   {
     // Get a pointer to the fGeometryServiceetry service provider
     fGeometryService = lar::providerFrom<geo::Geometry>();
   }

Member Function Documentation

void sbnd::CRTDetSimAna::analyze ( const art::Event & event )

overridevirtual

Definition at line 222 of file CRTDetSimAna_module.cc.

   {
 
     // Fetch basic event info
     if(fVerbose){
       std::cout<<"============================================"<<std::endl
                <<"Run = "<<event.run()<<", SubRun = "<<event.subRun()<<", Event = "<<event.id().event()<<std::endl
                <<"============================================"<<std::endl;
     }
 
 
     //----------------------------------------------------------------------------------------------------------
     //                                          GETTING PRODUCTS
     //----------------------------------------------------------------------------------------------------------
 
     // Get g4 particles
     art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;
     auto particleHandle = event.getValidHandle<std::vector<simb::MCParticle>>(fSimModuleLabel);
 
     // Get CRT data from the event
     art::Handle< std::vector<sbnd::crt::CRTData>> crtDataHandle;
     std::vector<art::Ptr<sbnd::crt::CRTData> > crtDataList;
     if (event.getByLabel(fCRTSimLabel, crtDataHandle))
       art::fill_ptr_vector(crtDataList, crtDataHandle);
 
     art::FindManyP<sim::AuxDetIDE> findManyIdes(crtDataHandle, event, fCRTSimLabel);
 
     // Get all the auxdet IDEs from the event
     art::Handle<std::vector<sim::AuxDetSimChannel> > channels;
     event.getByLabel(fSimChannelModuleLabel, channels);
 
     //----------------------------------------------------------------------------------------------------------
     //                                          TRUTH MATCHING
     //----------------------------------------------------------------------------------------------------------
      
     std::map<int, simb::MCParticle> particles;
     // Loop over the true particles
     for (auto const& particle: (*particleHandle)){
       
       // Make map with ID
       int partID = particle.TrackId();
       particles[partID] = particle;
 
     }
 
     //----------------------------------------------------------------------------------------------------------
     //                                        CRT DATA ANALYSIS
     //----------------------------------------------------------------------------------------------------------
 
     std::map<int, std::vector<sbnd::crt::CRTData>> crtData;
     for(size_t i  = 0; i < crtDataList.size(); i++){
 
       // Truth matching
       std::vector<int> trueIDs = fCrtBackTrack.AllTrueIds(event, *crtDataList[i]);
       for(auto const& id : trueIDs){
         crtData[id].push_back(*crtDataList[i]);
       }
 
       int trueID = fCrtBackTrack.TrueIdFromTotalEnergy(event, *crtDataList[i]);
       // Only consider primary muons
       if(particles.find(trueID) == particles.end()) continue;
       if(!(std::abs(particles[trueID].PdgCode()) == 13 && particles[trueID].Mother() == 0)) continue;
 
       // Get the IDEs associated with the crtData
       std::vector<art::Ptr<sim::AuxDetIDE>> ides = findManyIdes.at(i);
       // Calculate the average position
       double x = 0, y = 0, z = 0;
       for(auto const& ide : ides){
         x += (ide->entryX + ide->exitX)/2.;
         y += (ide->entryY + ide->exitY)/2.;
         z += (ide->entryZ + ide->exitZ)/2.;
       }
       x = x/ides.size();
       y = y/ides.size();
       z = z/ides.size();
       geo::Point_t cross {x, y, z};
 
       int channel = crtDataList[i]->Channel();
       std::string stripName = fCrtGeo.ChannelToStripName(channel);
       std::string tagger = fCrtGeo.GetTaggerName(stripName);
 
       double npe = ((double)crtDataList[i]->ADC() - fQPed)/fQSlope;
 
       // Calculate distance to the sipm
       double sipmDist = fCrtGeo.DistanceBetweenSipms(cross, channel);
       hSipmDist[tagger]->Fill(sipmDist);
       hSipmDistADC[tagger]->Fill(sipmDist, crtDataList[i]->ADC());
       hSipmDistNpe[tagger]->Fill(sipmDist, npe);
 
       if(channel % 2 == 0){
         double npe1 = ((double)crtDataList[i+1]->ADC() - fQPed)/fQSlope;
         hNpeRatio[tagger]->Fill(npe/npe1);
         hSipmDistNpeRatio[tagger]->Fill(sipmDist, npe/npe1);
       }
 
       // Calculate the distance to the end
       double stripDist = std::abs(fCrtGeo.DistanceDownStrip(cross, stripName));
       hStripDist[tagger]->Fill(stripDist);
       hStripDistADC[tagger]->Fill(stripDist, crtDataList[i]->ADC());
       hStripDistNpe[tagger]->Fill(stripDist, npe);
 
       hADC[tagger]->Fill(crtDataList[i]->ADC());
       hNpe[tagger]->Fill(npe);
 
       //fTrigClock.SetTime(crtDataList[i]->T0());
       //double time = fTrigClock.Time(); // [us]
       double time = (double)(int)crtDataList[i]->T0()/fClockSpeedCRT; // [tick -> us]
       hTime[tagger]->Fill(time);
     }
 
     //----------------------------------------------------------------------------------------------------------
     //                                          EFFICIENCIES
     //----------------------------------------------------------------------------------------------------------
 
     for (auto& adsc : *channels) {
       // Get the IDEs from the Aux Det channels
       if(adsc.AuxDetSensitiveID() == UINT_MAX) {
         mf::LogWarning("CRTDetSimAna") << "AuxDetSimChannel with ID: UINT_MAX\n"
                                        << "skipping channel...";
         continue;
       }
 
       std::string stripName = fCrtGeo.GetStrip(adsc.AuxDetSensitiveID()).name;
       std::string tagger = fCrtGeo.GetTaggerName(stripName);
       std::vector<sim::AuxDetIDE> ides = adsc.AuxDetIDEs();
 
       for(auto const& ide : ides){
         geo::Point_t pos {(ide.entryX + ide.exitX)/2, 
                           (ide.entryY + ide.exitY)/2, 
                           (ide.entryZ + ide.exitZ)/2};
         int trueID = ide.trackID;
         // Calculate length in strip
         double length = std::sqrt(std::pow(ide.entryX - ide.exitX, 2)
                                   + std::pow(ide.entryY - ide.exitY, 2)
                                   + std::pow(ide.entryZ - ide.exitZ, 2));
         // Calculate distances of average point to sipms
         double sipmDistIde = fCrtGeo.DistanceBetweenSipms(pos, stripName);
         double stripDistIde = fCrtGeo.DistanceDownStrip(pos, stripName);
 
         // Only consider primary muons for efficiency
         if(particles.find(trueID) == particles.end()) continue;
         if(!(std::abs(particles[trueID].PdgCode()) == 13 && particles[trueID].Mother() == 0)) continue;
 
         // Fill total histograms
         hEffSipmDistTotal[tagger]->Fill(sipmDistIde);
         hEffStripDistTotal[tagger]->Fill(stripDistIde);
         hEffEDepTotal[tagger]->Fill(ide.energyDeposited);
         hEffLengthTotal[tagger]->Fill(length);
 
         // Get all the CRT data matched to the same true ID
         if(crtData.find(trueID) == crtData.end()) continue;
         bool match = false;
         // If there is CRT data produced on the same channel then it is matched
         for(auto const& data : crtData[trueID]){
           std::string stripNameData = fCrtGeo.ChannelToStripName(data.Channel());
           if(stripName == stripNameData) match = true;
         }
         if(!match) continue;
 
         // Fill reconstructed histograms
         hEffSipmDistReco[tagger]->Fill(sipmDistIde);
         hEffStripDistReco[tagger]->Fill(stripDistIde);
         hEffEDepReco[tagger]->Fill(ide.energyDeposited);
         hEffLengthReco[tagger]->Fill(length);
           
       }
     }
 
 
   } // CRTDetSimAna::analyze()

void sbnd::CRTDetSimAna::beginJob ( )

overridevirtual

Definition at line 187 of file CRTDetSimAna_module.cc.

   {
     // Access tfileservice to handle creating and writing histograms
     art::ServiceHandle<art::TFileService> tfs;
     for(size_t i = 0; i < fCrtGeo.NumTaggers(); i++){
       std::string tagger = fCrtGeo.GetTagger(i).name;
       hADC[tagger]          = tfs->make<TH1D>(Form("ADC_%s", tagger.c_str()),       "", 40, 0, 10000);
       hNpe[tagger]          = tfs->make<TH1D>(Form("Npe_%s", tagger.c_str()),       "", 40, 0, 300);
       hNpeRatio[tagger]     = tfs->make<TH1D>(Form("NpeRatio_%s", tagger.c_str()),  "", 40, 0, 10);
       hTime[tagger]         = tfs->make<TH1D>(Form("Time_%s", tagger.c_str()),      "", 40, -5000, 5000);
       hStripDist[tagger]    = tfs->make<TH1D>(Form("StripDist_%s", tagger.c_str()), "", 40, 0,     450);
       hSipmDist[tagger]     = tfs->make<TH1D>(Form("SipmDist_%s", tagger.c_str()),  "", 40, 0,     11.2);
 
       hEffSipmDistTotal[tagger]  = tfs->make<TH1D>(Form("EffSipmDistTotal_%s", tagger.c_str()),  "", 20, 0, 11.2);
       hEffSipmDistReco[tagger]   = tfs->make<TH1D>(Form("EffSipmDistReco_%s", tagger.c_str()),   "", 20, 0, 11.2);
       hEffStripDistTotal[tagger] = tfs->make<TH1D>(Form("EffStripDistTotal_%s", tagger.c_str()), "", 20, 0, 450);
       hEffStripDistReco[tagger]  = tfs->make<TH1D>(Form("EffStripDistReco_%s", tagger.c_str()),  "", 20, 0, 450);
       hEffEDepTotal[tagger]      = tfs->make<TH1D>(Form("EffEdepTotal_%s", tagger.c_str()),      "", 20, 0, 0.01);
       hEffEDepReco[tagger]       = tfs->make<TH1D>(Form("EffEdepReco_%s", tagger.c_str()),       "", 20, 0, 0.01);
       hEffLengthTotal[tagger]    = tfs->make<TH1D>(Form("EffLengthTotal_%s", tagger.c_str()),    "", 20, 0, 10);
       hEffLengthReco[tagger]     = tfs->make<TH1D>(Form("EffLengthReco_%s", tagger.c_str()),     "", 20, 0, 10);
 
       hStripDistADC[tagger] = tfs->make<TH2D>(Form("StripDistADC_%s", tagger.c_str()), "", 20, 0, 450,  20, 0, 10000);
       hSipmDistADC[tagger]  = tfs->make<TH2D>(Form("SipmDistADC_%s", tagger.c_str()),  "", 20, 0, 11.2, 20, 0, 10000);
       hStripDistNpe[tagger] = tfs->make<TH2D>(Form("StripDistNpe_%s", tagger.c_str()), "", 20, 0, 450,  20, 0, 300);
       hSipmDistNpe[tagger]  = tfs->make<TH2D>(Form("SipmDistNpe_%s", tagger.c_str()),  "", 20, 0, 11.2, 20, 0, 300);
       hSipmDistNpeRatio[tagger]  = tfs->make<TH2D>(Form("SipmDistNpeRatio_%s", tagger.c_str()),  "", 20, 0, 11.2, 20, 0, 10);
     }
     
 
     // Initial output
     std::cout<<"----------------- Full CRT Detector Simulation Analysis Module -------------------"<<std::endl;
 
   }// CRTDetSimAna::beginJob()

void sbnd::CRTDetSimAna::endJob ( )

overridevirtual

Definition at line 393 of file CRTDetSimAna_module.cc.

                            {
 
   } // CRTDetSimAna::endJob()

Member Data Documentation

double sbnd::CRTDetSimAna::fClockSpeedCRT

private

Definition at line 134 of file CRTDetSimAna_module.cc.

CRTBackTracker sbnd::CRTDetSimAna::fCrtBackTrack

private

Definition at line 167 of file CRTDetSimAna_module.cc.

CRTGeoAlg sbnd::CRTDetSimAna::fCrtGeo

private

Definition at line 166 of file CRTDetSimAna_module.cc.

art::InputTag sbnd::CRTDetSimAna::fCRTSimLabel

private

name of CRT producer

Definition at line 130 of file CRTDetSimAna_module.cc.

geo::GeometryCore const* sbnd::CRTDetSimAna::fGeometryService

private

Definition at line 164 of file CRTDetSimAna_module.cc.

double sbnd::CRTDetSimAna::fQPed

private

Definition at line 132 of file CRTDetSimAna_module.cc.

double sbnd::CRTDetSimAna::fQSlope

private

Definition at line 133 of file CRTDetSimAna_module.cc.

art::InputTag sbnd::CRTDetSimAna::fSimChannelModuleLabel

private

name of SimChannel producer in g4

Definition at line 129 of file CRTDetSimAna_module.cc.

art::InputTag sbnd::CRTDetSimAna::fSimModuleLabel

private

name of MCParticle producer in g4

Definition at line 128 of file CRTDetSimAna_module.cc.

TPCGeoAlg sbnd::CRTDetSimAna::fTpcGeo

private

Definition at line 165 of file CRTDetSimAna_module.cc.

bool sbnd::CRTDetSimAna::fVerbose

private

print information about what's going on

Definition at line 131 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hADC

private

Definition at line 138 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hEffEDepReco

private

Definition at line 152 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hEffEDepTotal

private

Definition at line 151 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hEffLengthReco

private

Definition at line 154 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hEffLengthTotal

private

Definition at line 153 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hEffSipmDistReco

private

Definition at line 148 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hEffSipmDistTotal

private

Definition at line 147 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hEffStripDistReco

private

Definition at line 150 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hEffStripDistTotal

private

Definition at line 149 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hNpe

private

Definition at line 139 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hNpeRatio

private

Definition at line 140 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hSipmDist

private

Definition at line 144 of file CRTDetSimAna_module.cc.

std::map<std::string, TH2D*> sbnd::CRTDetSimAna::hSipmDistADC

private

Definition at line 158 of file CRTDetSimAna_module.cc.

std::map<std::string, TH2D*> sbnd::CRTDetSimAna::hSipmDistNpe

private

Definition at line 160 of file CRTDetSimAna_module.cc.

std::map<std::string, TH2D*> sbnd::CRTDetSimAna::hSipmDistNpeRatio

private

Definition at line 161 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hStripDist

private

Definition at line 143 of file CRTDetSimAna_module.cc.

std::map<std::string, TH2D*> sbnd::CRTDetSimAna::hStripDistADC

private

Definition at line 157 of file CRTDetSimAna_module.cc.

std::map<std::string, TH2D*> sbnd::CRTDetSimAna::hStripDistNpe

private

Definition at line 159 of file CRTDetSimAna_module.cc.

std::map<std::string, TH1D*> sbnd::CRTDetSimAna::hTime

private

Definition at line 142 of file CRTDetSimAna_module.cc.

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

CRTDetSimAna_module.cc

Classes

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation