Inheritance diagram for trkf::TrackAna:

Classes
struct	MCHists

struct	RecoHists

Public Types
using	WorkerType = WorkerT< EDAnalyzer >

using	ModuleType = EDAnalyzer

Public Member Functions
	TrackAna (fhicl::ParameterSet const &pset)

virtual	~TrackAna ()

void	analyze (const art::Event &evt)

void	anaStitch (const art::Event &evt)

void	endJob ()

std::string	workerType () const

bool	modifiesEvent () const

void	registerProducts (MasterProductRegistry &, ProductDescriptions &, ModuleDescription const &)

std::string const &	processName () const

bool	wantAllEvents () const

bool	wantEvent (Event const &e)

fhicl::ParameterSetID	selectorConfig () const

art::Handle< art::TriggerResults >	getTriggerResults (Event const &e) const

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	consumes (InputTag const &it)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	consumesView (InputTag const &it)

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	mayConsume (InputTag const &it)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	mayConsumeView (InputTag const &it)

base_engine_t &	createEngine (seed_t seed)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)

seed_t	get_seed_value (fhicl::ParameterSet const &pset, char const key[]="seed", seed_t const implicit_seed=-1)

Static Public Member Functions
static cet::exempt_ptr< Consumer >	non_module_context ()

Protected Member Functions
CurrentProcessingContext const *	currentContext () const

detail::CachedProducts &	cachedProducts ()

void	validateConsumedProduct (BranchType const bt, ProductInfo const &pi)

void	prepareForJob (fhicl::ParameterSet const &pset)

void	showMissingConsumes () const

Private Member Functions
template<typename T >
std::vector< size_t >	fsort_indexes (const std::vector< T > &v)

Private Attributes
std::string	fTrackModuleLabel

std::string	fMCTrackModuleLabel

std::string	fSpacepointModuleLabel

std::string	fStitchModuleLabel

std::string	fTrkSpptAssocModuleLabel

std::string	fHitSpptAssocModuleLabel

std::string	fHitModuleLabel

int	fDump

double	fMinMCKE

double	fMinMCLen

double	fMatchColinearity

double	fMatchDisp

double	fWMatchDisp

double	fMatchLength

bool	fIgnoreSign

bool	fStitchedAnalysis

std::string	fOrigin

bool	fCheckOrigin

simb::Origin_t	fOriginValue

int	fPrintLevel

std::map< int, MCHists >	fMCHistMap

std::map< int, RecoHists >	fRecoHistMap

int	fNumEvent

Detailed Description

Definition at line 270 of file TrackAna_module.cc.

Member Typedef Documentation

using art::EDAnalyzer::ModuleType = EDAnalyzer

inherited

Definition at line 39 of file EDAnalyzer.h.

using art::EDAnalyzer::WorkerType = WorkerT<EDAnalyzer>

inherited

Definition at line 38 of file EDAnalyzer.h.

Constructor & Destructor Documentation

trkf::TrackAna::TrackAna ( fhicl::ParameterSet const & pset )

explicit

Definition at line 769 of file TrackAna_module.cc.

References fCheckOrigin, fDump, fHitModuleLabel, fHitSpptAssocModuleLabel, fMCTrackModuleLabel, fMinMCKE, fMinMCLen, fOrigin, fOriginValue, fStitchModuleLabel, fTrackModuleLabel, fTrkSpptAssocModuleLabel, simb::kBeamNeutrino, simb::kCosmicRay, simb::kSingleParticle, simb::kSuperNovaNeutrino, and simb::kUnknown.

     : EDAnalyzer(pset)
     , fTrackModuleLabel(pset.get<std::string>("TrackModuleLabel"))
     , fMCTrackModuleLabel(pset.get<std::string>("MCTrackModuleLabel"))
     , fSpacepointModuleLabel(pset.get<std::string>("SpacepointModuleLabel"))
     , fStitchModuleLabel(pset.get<std::string>("StitchModuleLabel"))
     , fTrkSpptAssocModuleLabel(pset.get<std::string>("TrkSpptAssocModuleLabel"))
     , fHitSpptAssocModuleLabel(pset.get<std::string>("HitSpptAssocModuleLabel"))
     , fHitModuleLabel(pset.get<std::string>("HitModuleLabel"))
     , fDump(pset.get<int>("Dump"))
     , fMinMCKE(pset.get<double>("MinMCKE"))
     , fMinMCLen(pset.get<double>("MinMCLen"))
     , fMatchColinearity(pset.get<double>("MatchColinearity"))
     , fMatchDisp(pset.get<double>("MatchDisp"))
     , fWMatchDisp(pset.get<double>("WMatchDisp"))
     , fMatchLength(pset.get<double>("MatchLength"))
     , fIgnoreSign(pset.get<bool>("IgnoreSign"))
     , fStitchedAnalysis(pset.get<bool>("StitchedAnalysis",false))
     , fOrigin(pset.get<std::string>("MCTrackOrigin", "Any"))
     , fPrintLevel(pset.get<int>("PrintLevel",0))
     , fNumEvent(0)
   {
     
     // Decide whether to check MCTrack origin
     fCheckOrigin = false;
     fOriginValue = simb::kUnknown;
     if(fOrigin.find("Beam") != std::string::npos) {
       fCheckOrigin = true;
       fOriginValue = simb::kBeamNeutrino;
     } else if(fOrigin.find("Cosmic") != std::string::npos) {
       fCheckOrigin = true;
       fOriginValue = simb::kCosmicRay;
     } else if(fOrigin.find("Super") != std::string::npos) {
       fCheckOrigin = true;
       fOriginValue = simb::kSuperNovaNeutrino;
     } else if(fOrigin.find("Single") != std::string::npos) {
       fCheckOrigin = true;
       fOriginValue = simb::kSingleParticle;
     }
       
     // Report.
 
     mf::LogInfo("TrackAna") 
       << "TrackAna configured with the following parameters:\n"
       << "  TrackModuleLabel = " << fTrackModuleLabel << "\n"
       << "  MCTrackModuleLabel = " << fMCTrackModuleLabel << "\n"
       << "  StitchModuleLabel = " << fStitchModuleLabel << "\n"
       << "  TrkSpptAssocModuleLabel = " << fTrkSpptAssocModuleLabel << "\n"
       << "  HitSpptAssocModuleLabel = " << fHitSpptAssocModuleLabel << "\n"
       << "  HitModuleLabel = " << fHitModuleLabel << "\n"
       << "  Dump = " << fDump << "\n"
       << "  MinMCKE = " << fMinMCKE << "\n"
       << "  MinMCLen = " << fMinMCLen
       << "  Origin = " << fOrigin<<" Origin value "<<fOriginValue;
   }

trkf::TrackAna::~TrackAna ( )

virtual

Definition at line 830 of file TrackAna_module.cc.

834 {}

Member Function Documentation

void trkf::TrackAna::analyze ( const art::Event & evt )

Definition at line 836 of file TrackAna_module.cc.

   {
     const detinfo::DetectorProperties* detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
     art::ServiceHandle<cheat::BackTrackerService> bt_serv;
     art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;
     art::ServiceHandle<geo::Geometry> geom;
 
 
     ++fNumEvent;
 
     // Optional dump stream.
 
     std::unique_ptr<mf::LogInfo> pdump;
     if(fDump > 0) {
       --fDump;
       pdump = std::unique_ptr<mf::LogInfo>(new mf::LogInfo("TrackAna"));
     }
 
     // Make sure histograms are booked.
 
     bool mc = !evt.isRealData();
 
     // Get MCTracks.
 
     art::Handle< std::vector<sim::MCTrack> > mctrackh;
     evt.getByLabel(fMCTrackModuleLabel, mctrackh);
     // pair of MCTrack and index of matched reco track
     std::vector<std::pair<const sim::MCTrack*, int>> selected_mctracks;
 
     if(mc && mctrackh.isValid()) {
 
       selected_mctracks.reserve(mctrackh->size());
 
       // Dump MCTracks.
 
       if(pdump) {
         *pdump << "MC Tracks\n"
                << "       Id   pdg           x         y         z          dx        dy        dz           p\n"
                << "-------------------------------------------------------------------------------------------\n";
       }
 
       // Loop over mc tracks, and fill histograms that depend only
       // on mc information.  Also, fill a secondary list of mc tracks
       // that pass various selection criteria.
 
       for(std::vector<sim::MCTrack>::const_iterator imctrk = mctrackh->begin();
           imctrk != mctrackh->end(); ++imctrk) {
         const sim::MCTrack& mctrk = *imctrk;
         int pdg = mctrk.PdgCode();
         if(fIgnoreSign)
           pdg = std::abs(pdg);
 
         // Ignore everything except stable charged nonshowering particles.
 
         int apdg = std::abs(pdg);
         if(apdg == 13 ||     // Muon
            apdg == 211 ||    // Charged pion
            apdg == 321 ||    // Charged kaon
            apdg == 2212) {   // (Anti)proton
 
           // check MC track origin?
           if(fCheckOrigin && mctrk.Origin() != fOriginValue) continue;
     
           // Apply minimum energy cut.
 
           if(mctrk.Start().E() >= mctrk.Start().Momentum().Mag() + 1000.*fMinMCKE) {
 
             // Calculate the x offset due to nonzero mc particle time.
 
             double mctime = mctrk.Start().T();                      // nsec
             double mcdx = mctime * 1.e-3 * detprop->DriftVelocity();  // cm
 
             // Calculate the length of this mc particle inside the fiducial volume.
 
             TVector3 mcstart;
             TVector3 mcend;
             TVector3 mcstartmom;
             TVector3 mcendmom;
             double plen = length(mctrk, mcdx, mcstart, mcend, mcstartmom, mcendmom);
 
             // Apply minimum fiducial length cut.  Always reject particles that have
             // zero length in the tpc regardless of the configured cut.
 
             if(plen > 0. && plen > fMinMCLen) {
 
               // This is a good mc particle (capable of making a track).
 
               selected_mctracks.push_back(std::make_pair(&mctrk, -1));
 
               // Dump MC particle information here.
 
               if(pdump) {
                 double pstart = mcstartmom.Mag();
                 double pend = mcendmom.Mag();
                 *pdump << "\nOffset"
                        << std::setw(3) << mctrk.TrackID()
                        << std::setw(6) << mctrk.PdgCode()
                        << "  " 
                        << std::fixed << std::setprecision(2) 
                        << std::setw(10) << mcdx
                        << "\nStart " 
                        << std::setw(3) << mctrk.TrackID()
                        << std::setw(6) << mctrk.PdgCode()
                        << "  " 
                        << std::fixed << std::setprecision(2) 
                        << std::setw(10) << mcstart[0]
                        << std::setw(10) << mcstart[1]
                        << std::setw(10) << mcstart[2];
                 if(pstart > 0.) {
                   *pdump << "  "
                          << std::fixed << std::setprecision(3) 
                          << std::setw(10) << mcstartmom[0]/pstart
                          << std::setw(10) << mcstartmom[1]/pstart
                          << std::setw(10) << mcstartmom[2]/pstart;
                 }
                 else
                   *pdump << std::setw(32) << " ";
                 *pdump << std::setw(12) << std::fixed << std::setprecision(3) << pstart;
                 *pdump << "\nEnd   " 
                        << std::setw(3) << mctrk.TrackID()
                        << std::setw(6) << mctrk.PdgCode()
                        << "  " 
                        << std::fixed << std::setprecision(2)
                        << std::setw(10) << mcend[0]
                        << std::setw(10) << mcend[1]
                        << std::setw(10) << mcend[2];
                 if(pend > 0.01) {
                   *pdump << "  " 
                          << std::fixed << std::setprecision(3) 
                          << std::setw(10) << mcendmom[0]/pend
                          << std::setw(10) << mcendmom[1]/pend
                          << std::setw(10) << mcendmom[2]/pend;
                 }
                 else
                   *pdump << std::setw(32)<< " ";
                 *pdump << std::setw(12) << std::fixed << std::setprecision(3) << pend 
                        << "\nLength: " << plen << "\n";
               }
 
               // Fill histograms.
 
               if(fMCHistMap.count(pdg) == 0) {
                 std::ostringstream ostr;
                 ostr << "MC" << (fIgnoreSign ? "All" : (pdg > 0 ? "Pos" : "Neg")) << std::abs(pdg);
                 fMCHistMap[pdg] = MCHists(ostr.str());
               }
               const MCHists& mchists = fMCHistMap[pdg];
 
               double mctheta_xz = std::atan2(mcstartmom.X(), mcstartmom.Z());
               double mctheta_yz = std::atan2(mcstartmom.Y(), mcstartmom.Z());
               double mcmom = mcstartmom.Mag();
               double mcmass = 0.001 * mctrk.Start().Momentum().Mag();
               double mcke = mcmom*mcmom / (std::sqrt(mcmom*mcmom + mcmass*mcmass) + mcmass);
 
               mchists.fHmcstartx->Fill(mcstart.X());
               mchists.fHmcstarty->Fill(mcstart.Y());
               mchists.fHmcstartz->Fill(mcstart.Z());
               mchists.fHmcendx->Fill(mcend.X());
               mchists.fHmcendy->Fill(mcend.Y());
               mchists.fHmcendz->Fill(mcend.Z());
               mchists.fHmctheta->Fill(mcstartmom.Theta());
               mchists.fHmcphi->Fill(mcstartmom.Phi());
               mchists.fHmctheta_xz->Fill(mctheta_xz);
               mchists.fHmctheta_yz->Fill(mctheta_yz);
               mchists.fHmcmom->Fill(mcmom);
               mchists.fHmcmoml->Fill(mcmom);
               mchists.fHmcke->Fill(mcke);
               mchists.fHmckel->Fill(mcke);
               mchists.fHmclen->Fill(plen);
               mchists.fHmclens->Fill(plen);
             }
           }
         }
       }
     } //mc
 
         
     // Get tracks and spacepoints and hits
     art::Handle< std::vector<recob::Track> > trackh;
     art::Handle< std::vector< art::PtrVector < recob::Track > > > trackvh;
     art::Handle< std::vector<recob::Hit> > hith;
 
     evt.getByLabel(fTrackModuleLabel, trackh);
     evt.getByLabel(fStitchModuleLabel,trackvh);
     evt.getByLabel(fHitModuleLabel, hith);
 
     // Extract all hits into a vector of art::Ptrs (the format used by back tracker).
 
     std::vector<art::Ptr<recob::Hit> > allhits;
     if(hith.isValid()) {
       allhits.reserve(hith->size());
       for(unsigned int i=0; i<hith->size(); ++i) {
         allhits.emplace_back(hith, i);
       }
     }
 
     // Construct FindManyP object to be used for finding track-hit associations.
 
     art::FindManyP<recob::Hit> tkhit_find(trackh, evt, fTrackModuleLabel);
 
     // This new top part of TrackAna between two long lines of ************s
     // is particular to analyzing Stitched Tracks.
     // *******************************************************************//
 
     if (trackvh.isValid() && fStitchedAnalysis) 
       {
         mf::LogDebug("TrackAna") 
           << "TrackAna read "  << trackvh->size()
           << "  vectors of Stitched PtrVectorsof tracks.";
         anaStitch(evt);
       }
 
     if(trackh.isValid()) {
 
       if(pdump) {
         *pdump << "\nReconstructed Tracks\n"
                << "       Id  MCid           x         y         z          dx        dy        dz           p\n"
                << "-------------------------------------------------------------------------------------------\n";
       }
 
       // Loop over tracks.
       
       int ntrack = trackh->size();
       for(int i = 0; i < ntrack; ++i) {
         art::Ptr<recob::Track> ptrack(trackh, i);
         const recob::Track& track = *ptrack;
 
         // Extract hits associated with this track.
 
         std::vector<art::Ptr<recob::Hit> > trackhits;
         tkhit_find.get(i, trackhits);
 
         // Calculate the x offset due to nonzero reconstructed time.
 
         //double recotime = track.Time() * detprop->SamplingRate();       // nsec
 //      double recotime = 0.;
 //      double trackdx = recotime * 1.e-3 * detprop->DriftVelocity();  // cm
   double trackdx = 0;
 
         // Fill histograms involving reco tracks only.
         
         int ntraj = track.NumberTrajectoryPoints();
         if(ntraj > 0) {
           TVector3 pos = track.Vertex<TVector3>();
           TVector3 dir = track.VertexDirection<TVector3>();
           TVector3 end = track.End<TVector3>();
           pos[0] += trackdx;
           end[0] += trackdx;
           
           double dpos = bdist(pos);
           double dend = bdist(end);
           double tlen = length(track);
           double theta_xz = std::atan2(dir.X(), dir.Z());
           double theta_yz = std::atan2(dir.Y(), dir.Z());
           
           if(fRecoHistMap.count(0) == 0)
             fRecoHistMap[0] = RecoHists("Reco");
           const RecoHists& rhists = fRecoHistMap[0];
           
           rhists.fHstartx->Fill(pos.X());
           rhists.fHstarty->Fill(pos.Y());
           rhists.fHstartz->Fill(pos.Z());
           rhists.fHstartd->Fill(dpos);
           rhists.fHendx->Fill(end.X());
           rhists.fHendy->Fill(end.Y());
           rhists.fHendz->Fill(end.Z());
           rhists.fHendd->Fill(dend);
           rhists.fHtheta->Fill(dir.Theta());
           rhists.fHphi->Fill(dir.Phi());
           rhists.fHtheta_xz->Fill(theta_xz);
           rhists.fHtheta_yz->Fill(theta_yz);
           
           double mom = 0.;
           if(track.HasMomentum())
             mom = track.VertexMomentum();
           rhists.fHmom->Fill(mom);
           rhists.fHmoml->Fill(mom);
           rhists.fHlen->Fill(tlen);
           rhists.fHlens->Fill(tlen);
 
           // Id of matching mc particle.
 
           int mcid = -1;
 
           // Loop over direction.  
 
           for(int swap=0; swap<2; ++swap) {
 
             // Analyze reversed tracks only if start momentum = end momentum.
 
             if(swap != 0 && track.HasMomentum() &&
                std::abs(track.VertexMomentum() - track.EndMomentum()) > 1.e-3)
               continue;
 
             // Calculate the global-to-local rotation matrix.
 
             int start_point = (swap == 0 ? 0 : ntraj-1);
             TMatrixD rot = track.GlobalToLocalRotationAtPoint<TMatrixD>(start_point);
 
             // Update track data for reversed case.
 
             if(swap != 0) {
               rot(1, 0) = -rot(1, 0);
               rot(2, 0) = -rot(2, 0);
               rot(1, 1) = -rot(1, 1);
               rot(2, 1) = -rot(2, 1);
               rot(1, 2) = -rot(1, 2);
               rot(2, 2) = -rot(2, 2);
 
               pos = track.End<TVector3>();
               dir = -track.EndDirection<TVector3>();
               end = track.Vertex<TVector3>();
               pos[0] += trackdx;
               end[0] += trackdx;
           
               dpos = bdist(pos);
               dend = bdist(end);
               theta_xz = std::atan2(dir.X(), dir.Z());
               theta_yz = std::atan2(dir.Y(), dir.Z());
 
               if(track.HasMomentum()) mom = track.EndMomentum();
             }
           
             // Get covariance matrix.
 
             const auto& cov = (swap == 0 ? track.VertexCovariance() : track.EndCovariance());
             
             // Loop over track-like mc particles.
 
       for(unsigned int imc = 0; imc < selected_mctracks.size(); ++imc) {
         const sim::MCTrack& mctrk = *selected_mctracks[imc].first;
               int pdg = mctrk.PdgCode();
               if(fIgnoreSign) pdg = std::abs(pdg);
               auto iMCHistMap = fMCHistMap.find(pdg);
               if (iMCHistMap == fMCHistMap.end())
                 throw cet::exception("TrackAna") << "no particle with ID=" << pdg << "\n";
               const MCHists& mchists = iMCHistMap->second;
 
               // Calculate the x offset due to nonzero mc particle time.
 
               double mctime = mctrk.Start().T();                                 // nsec
               double mcdx = mctime * 1.e-3 * detprop->DriftVelocity();   // cm
 
               // Calculate the points where this mc particle enters and leaves the
               // fiducial volume, and the length in the fiducial volume.
 
               TVector3 mcstart;
               TVector3 mcend;
               TVector3 mcstartmom;
               TVector3 mcendmom;
               double plen = length(mctrk, mcdx, mcstart, mcend, mcstartmom, mcendmom);
 
               // Get the displacement of this mc particle in the global coordinate system.
 
               TVector3 mcpos = mcstart - pos;
             
               // Rotate the momentum and position to the
               // track-local coordinate system.
 
               TVector3 mcmoml = rot * mcstartmom;
               TVector3 mcposl = rot * mcpos;
 
               double colinearity = mcmoml.Z() / mcmoml.Mag();
             
               double u = mcposl.X();
               double v = mcposl.Y();
               double w = mcposl.Z();
             
               double pu = mcmoml.X();
               double pv = mcmoml.Y();
               double pw = mcmoml.Z();
 
               double dudw = pu / pw;
               double dvdw = pv / pw;
 
               double u0 = u - w * dudw;
               double v0 = v - w * dvdw;
               double uv0 = std::sqrt(u0*u0 + v0*v0);
 
               mchists.fHduvcosth->Fill(colinearity, uv0);
         
               if(std::abs(uv0) < fMatchDisp) {
 
                 // Fill slope matching histograms.
 
                 mchists.fHmcdudw->Fill(dudw);
                 mchists.fHmcdvdw->Fill(dvdw);
                 mchists.fHdudwpull->Fill(dudw / std::sqrt(cov(2,2)));
                 mchists.fHdvdwpull->Fill(dvdw / std::sqrt(cov(3,3)));
               }
               mchists.fHcosth->Fill(colinearity);
               if(colinearity > fMatchColinearity) {
 
                 // Fill displacement matching histograms.
 
                 mchists.fHmcu->Fill(u0);
                 mchists.fHmcv->Fill(v0);
                 mchists.fHmcw->Fill(w);
                 mchists.fHupull->Fill(u0 / std::sqrt(cov(0,0)));
                 mchists.fHvpull->Fill(v0 / std::sqrt(cov(1,1)));
               
                 if(std::abs(uv0) < fMatchDisp) {
 
                   // Fill matching histograms.
 
                   double mctheta_xz = std::atan2(mcstartmom.X(), mcstartmom.Z());
                   double mctheta_yz = std::atan2(mcstartmom.Y(), mcstartmom.Z());
                   double mcmom = mcstartmom.Mag();
                   double mcmass = 0.001 * mctrk.Start().Momentum().Mag();
                   double mcke = mcmom*mcmom / (std::sqrt(mcmom*mcmom + mcmass*mcmass) + mcmass);
 
                   mchists.fHstartdx->Fill(pos.X() - mcstart.X());
                   mchists.fHstartdy->Fill(pos.Y() - mcstart.Y());
                   mchists.fHstartdz->Fill(pos.Z() - mcstart.Z());
                   mchists.fHenddx->Fill(end.X() - mcend.X());
                   mchists.fHenddy->Fill(end.Y() - mcend.Y());
                   mchists.fHenddz->Fill(end.Z() - mcend.Z());
                   mchists.fHlvsl->Fill(plen, tlen);
                   mchists.fHdl->Fill(tlen - plen);
                   mchists.fHpvsp->Fill(mcmom, mom);
                   double dp = mom - mcmom;
                   mchists.fHdp->Fill(dp);
                   mchists.fHppull->Fill(dp / std::sqrt(cov(4,4)));
                   if(std::abs(dpos) >= 5. && std::abs(dend) >= 5.) {
                     mchists.fHpvspc->Fill(mcmom, mom);
                     mchists.fHdpc->Fill(dp);
                     mchists.fHppullc->Fill(dp / std::sqrt(cov(4,4)));
                   }
 
                   // Count this track as well-reconstructed if it is matched to an
                   // mc particle (which it is if get here), and if in addition the
                   // starting position (w) matches and the reconstructed track length
                   // is more than 0.5 of the mc particle trajectory length.
 
                   bool good = std::abs(w) <= fWMatchDisp &&
                     tlen > fMatchLength * plen;
                   if(good) {
                     mcid = mctrk.TrackID();
 
                     // Calculate and fill hit efficiency and purity.
 
                     std::set<int> tkidset;
                     tkidset.insert(mcid);
                     double hiteff = 
                       bt_serv->HitCollectionEfficiency(tkidset, trackhits, allhits, geo::k3D);
                     double hitpurity = bt_serv->HitCollectionPurity(tkidset, trackhits);
                     mchists.fHHitEff->Fill(hiteff);
                     mchists.fHHitPurity->Fill(hitpurity);
 
                     // Fill efficiency numerator histograms.
 
                     mchists.fHgstartx->Fill(mcstart.X());
                     mchists.fHgstarty->Fill(mcstart.Y());
                     mchists.fHgstartz->Fill(mcstart.Z());
                     mchists.fHgendx->Fill(mcend.X());
                     mchists.fHgendy->Fill(mcend.Y());
                     mchists.fHgendz->Fill(mcend.Z());
                     mchists.fHgtheta->Fill(mcstartmom.Theta());
                     mchists.fHgphi->Fill(mcstartmom.Phi());
                     mchists.fHgtheta_xz->Fill(mctheta_xz);
                     mchists.fHgtheta_yz->Fill(mctheta_yz);
                     mchists.fHgmom->Fill(mcmom);
                     mchists.fHgmoml->Fill(mcmom);
                     mchists.fHgke->Fill(mcke);
                     mchists.fHgkel->Fill(mcke);
                     mchists.fHglen->Fill(plen);
                     mchists.fHglens->Fill(plen);
         
         // set the match flag
         selected_mctracks[imc].second = i;
         
         if(fPrintLevel > 0) {
           const simb::MCParticle* ptkl = pi_serv->TrackIdToParticle_P(mcid);
           float KE = ptkl->E() - ptkl->Mass();
           std::string KEUnits = " GeV";
           if(mctrk.Origin() != simb::kCosmicRay) {
             // MeV for low energy particles
             KE *= 1000;
             KEUnits = " MeV";
           }
           mf::LogVerbatim("TrackAna")
           <<evt.run()<<"."<<evt.event()
           <<" Match MCTkID "<<std::setw(6)<<mctrk.TrackID()
           <<" Origin "<<mctrk.Origin()
           <<" PDG"<<std::setw(5)<<mctrk.PdgCode()
           <<" KE"<<std::setw(4)<<(int)KE<<KEUnits
           <<" RecoTrkID "<<track.ID()
           <<" hitEff "<<std::setprecision(2)<<hiteff<<" hitPur "<<hitpurity;
           int sWire, sTick, eWire, eTick;
           // this won't work for DUNE
           for(unsigned short ipl = 0; ipl < geom->Nplanes(); ++ipl) {
             sWire = geom->NearestWire(mcstart, ipl, 0, 0);
             sTick = detprop->ConvertXToTicks(mcstart[0], ipl, 0, 0);
             eWire = geom->NearestWire(mcend, ipl, 0, 0);
             eTick = detprop->ConvertXToTicks(mcend[0], ipl, 0, 0);
             mf::LogVerbatim("TrackAna")<<"   Wire:Tick in Pln "<<ipl<<" W:T "<<sWire<<":"<<sTick<<" - "<<eWire<<":"<<eTick;
           } // ipl
         } // fPrintLevel == 2
                   } // good
                 }
               }
             }
           }
 
           // Dump track information here.
 
           if(pdump) {
             TVector3 pos = track.Vertex<TVector3>();
             TVector3 dir = track.VertexDirection<TVector3>();
             TVector3 end = track.End<TVector3>();
             pos[0] += trackdx;
             end[0] += trackdx;
             TVector3 enddir = track.EndDirection<TVector3>();
             double pstart = track.VertexMomentum();
             double pend = track.EndMomentum();
             *pdump << "\nOffset"
                    << std::setw(3) << track.ID()
                    << std::setw(6) << mcid
                    << "  "
                    << std::fixed << std::setprecision(2) 
                    << std::setw(10) << trackdx
                    << "\nStart " 
                    << std::setw(3) << track.ID()
                    << std::setw(6) << mcid
                    << "  "
                    << std::fixed << std::setprecision(2) 
                    << std::setw(10) << pos[0]
                    << std::setw(10) << pos[1]
                    << std::setw(10) << pos[2];
             if(pstart > 0.) {
               *pdump << "  "
                      << std::fixed << std::setprecision(3) 
                      << std::setw(10) << dir[0]
                      << std::setw(10) << dir[1]
                      << std::setw(10) << dir[2];
             }
             else
               *pdump << std::setw(32) << " ";
             *pdump << std::setw(12) << std::fixed << std::setprecision(3) << pstart;
             *pdump << "\nEnd   " 
                    << std::setw(3) << track.ID()
                    << std::setw(6) << mcid
                    << "  "
                    << std::fixed << std::setprecision(2)
                    << std::setw(10) << end[0]
                    << std::setw(10) << end[1]
                    << std::setw(10) << end[2];
             if(pend > 0.01) {
               *pdump << "  " 
                      << std::fixed << std::setprecision(3) 
                      << std::setw(10) << enddir[0]
                      << std::setw(10) << enddir[1]
                      << std::setw(10) << enddir[2];
             }
             else 
               *pdump << std::setw(32)<< " ";
             *pdump << std::setw(12) << std::fixed << std::setprecision(3) << pend
                    << "\nLength: " << tlen << "\n";
           }
         }
       }
     }   // i
 
     // print out un-matched MC tracks
     if(fPrintLevel > 0) {
       for(unsigned int imc = 0; imc < selected_mctracks.size(); ++imc) {
         if(selected_mctracks[imc].second >= 0) continue;
         const sim::MCTrack& mctrk = *selected_mctracks[imc].first;
         const simb::MCParticle* ptkl = pi_serv->TrackIdToParticle_P(mctrk.TrackID());
         float KE = ptkl->E() - ptkl->Mass();
         std::string KEUnits = " GeV";
         if(mctrk.Origin() != simb::kCosmicRay) {
           // MeV for low energy particles
           KE *= 1000;
           KEUnits = " MeV";
         }
         // find the start/end wire:time in each plane
         TVector3 mcstart, mcend, mcstartmom, mcendmom;
         double mcdx = mctrk.Start().T() * 1.e-3 * detprop->DriftVelocity();  // cm
         double plen = length(mctrk, mcdx, mcstart, mcend, mcstartmom, mcendmom);
         mf::LogVerbatim("TrackAna")<<evt.run()<<"."<<evt.event()
           <<" NoMat MCTkID "<<std::setw(6)<<mctrk.TrackID()
           <<" Origin "<<mctrk.Origin()
           <<" PDG"<<std::setw(5)<<mctrk.PdgCode()
           <<" KE"<<std::setw(4)<<(int)KE<<KEUnits
           <<" Length "<<std::fixed<<std::setprecision(1)<<plen<<" cm";
         if(fPrintLevel > 1) {
           int sWire, sTick, eWire, eTick;
           // this won't work for DUNE
           for(unsigned short ipl = 0; ipl < geom->Nplanes(); ++ipl) {
             sWire = geom->NearestWire(mcstart, ipl, 0, 0);
             sTick = detprop->ConvertXToTicks(mcstart[0], ipl, 0, 0);
             eWire = geom->NearestWire(mcend, ipl, 0, 0);
             eTick = detprop->ConvertXToTicks(mcend[0], ipl, 0, 0);
             mf::LogVerbatim("TrackAna")<<"   Wire:Tick in Pln "<<ipl
               <<" W:T "<<sWire<<":"<<sTick<<" - "<<eWire<<":"<<eTick;
           } // ipl
         } // fPrintLevel > 1
       } // imc
     } // fPrintLevel > 0
 
   }

void trkf::TrackAna::anaStitch ( const art::Event & evt )

art::FindManyP<recob::Hit> fh(sppth, evt, fHitSpptAssocModuleLabel);

Definition at line 1444 of file TrackAna_module.cc.

Referenced by analyze().

   {
 
     art::ServiceHandle<cheat::BackTrackerService> bt_serv;
     art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;
     art::ServiceHandle<geo::Geometry> geom;
     const detinfo::DetectorProperties* detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
 
     std::map<int, std::map<int, art::PtrVector<recob::Hit>> > hitmap; // trkID, otrk, hitvec
     std::map<int, int > KEmap; // length traveled in det [cm]?, trkID want to sort by KE
     bool mc = !evt.isRealData();
     art::Handle< std::vector<recob::Track> > trackh;
     art::Handle< std::vector< recob::SpacePoint> > sppth;
     art::Handle< std::vector< art::PtrVector < recob::Track > > > trackvh;
 
     evt.getByLabel(fTrackModuleLabel, trackh);
     evt.getByLabel(fSpacepointModuleLabel, sppth);
     evt.getByLabel(fStitchModuleLabel,trackvh);
     int ntv(trackvh->size());
     
     std::vector < art::PtrVector<recob::Track> >::const_iterator cti = trackvh->begin();
     
     if(trackh.isValid()) {
       art::FindManyP<recob::SpacePoint> fswhole(trackh, evt, fTrkSpptAssocModuleLabel);
       int nsppts_assnwhole = fswhole.size();
       std::cout << "TrackAna: Number of clumps of Spacepoints from Assn for all Tracks: " << nsppts_assnwhole << std::endl;
     }
     
     if(fRecoHistMap.count(0) == 0)
       {
         fRecoHistMap[0] = RecoHists("Reco");
         std::cout << "\n" << "\t\t  TrkAna: Fresh fRecoHistMap[0] ******* \n" << std::endl;
       }
     const RecoHists& rhistsStitched = fRecoHistMap[0];
     
     std::vector < std::vector <unsigned int> >  NtrkIdsAll; 
     std::vector < double > ntvsorted;
     hitmap.clear();
     KEmap.clear();
     
     // Look at the components of the stitched tracks. Grab their sppts/hits from Assns.
     for (int o = 0; o < ntv; ++o) // o for outer
       {
 
         const art::PtrVector<recob::Track> pvtrack(*(cti++));
         //      auto it = pvtrack.begin();
         int ntrack = pvtrack.size();
         //      if (ntrack>1)   std::cout << "\t\t  TrkAna: New Stitched Track ******* " << std::endl;
         std::vector< std::vector <unsigned int> > NtrkId_Hit; // hit IDs in inner tracks
         std::vector<unsigned int> vecMode;
         art::FindManyP<recob::SpacePoint> fs( pvtrack, evt, fTrkSpptAssocModuleLabel);
 
         for(int i = 0; i < ntrack; ++i) {
 
           //const art::Ptr<recob::Track> ptrack(*(it++));
           //      const recob::Track& track = *ptrack;
           //      auto pcoll { ptrack };
           // art::FindManyP<recob::SpacePoint> fs( ptrack, evt, fTrkSpptAssocModuleLabel);
           // From gdb> ptype fs, the vector of Ptr<SpacePoint>s it appears is grabbed after fs.at(0)
           bool assns(true);
           try {
             // Got Spacepoints from this Track; now get Hits from those Spacepoints.
             //      int nsppts = ptrack->NumberTrajectoryPoints();
             
             int nsppts_assn = fs.at(i).size();  
             //      if (ntrack>1) std::cout << "\t\tTrackAna: Number of Spacepoints from Track.NumTrajPts(): " << nsppts << std::endl;
             //      if (ntrack>1)  std::cout << "\t\tTrackAna: Number of Spacepoints from Assns for this Track: " << nsppts_assn << std::endl;
 
             const auto& sppt = fs.at(i);//.at(0);
             // since we're in a try and worried about failure, we won't pull the following
             // FindManyP out of the loop.
             art::FindManyP<recob::Hit> fh( sppt, evt, fHitSpptAssocModuleLabel);
 
             // Importantly, loop on all sppts, though they don't all contribute to the track.
             // As opposed to looping on the trajectory pts, which is a lower number. 
             // Also, important, in job in whch this runs I set TrackKal3DSPS parameter MaxPass=1, 
             // cuz I don't want merely the sparse set of sppts as follows from the uncontained 
             // MS-measurement in 2nd pass.
             std::vector <unsigned int> vecNtrkIds;
             for(int is = 0; is < nsppts_assn; ++is) {
               int nhits = fh.at(is).size(); // should be 2 or 3: number of planes.
               for(int ih = 0; ih < nhits; ++ih) {
                 const auto& hit = fh.at(is).at(ih); // Our vector is after the .at(is) this time.
                 if (hit->SignalType()!=geo::kCollection) continue;
                 rhistsStitched.fHHitChg->Fill(hit->Integral());
                 rhistsStitched.fHHitWidth->Fill(2. * hit->RMS());
                 if (mc)
                   {
                     std::vector<sim::TrackIDE> tids = bt_serv->HitToTrackIDEs(hit);
                     // more here.
                     // Loop over track ids.
                     bool justOne(true); // Only take first trk that contributed to this hit
                     //    std::cout  << "\t\t  TrkAna: TrkId  tids.size() ******* " << tids.size()  <<std::endl;
                     for(std::vector<sim::TrackIDE>::const_iterator itid = tids.begin();itid != tids.end(); ++itid) {
                       int trackID = std::abs(itid->trackID);
                       hitmap[trackID][o].push_back(hit);
 
                       if (justOne) { vecNtrkIds.push_back(trackID); justOne=false; }
                       // Add hit to PtrVector corresponding to this track id.
                       rhistsStitched.fHHitTrkId->Fill(trackID); 
                       const simb::MCParticle* part = pi_serv->TrackIdToParticle_P(trackID);
                       if (!part) break;
 
                       rhistsStitched.fHHitPdg->Fill(part->PdgCode()); 
                       // This really needs to be indexed as KE deposited in volTPC, not just KE. EC, 24-July-2014.
 
                       TVector3 mcstart;
                       TVector3 mcend;
                       TVector3 mcstartmom;
                       TVector3 mcendmom;
                       double mctime = part->T();                                 // nsec
                       double mcdx = mctime * 1.e-3 * detprop->DriftVelocity();   // cm
 
                       double plen = length(*part, mcdx, mcstart, mcend, mcstartmom, mcendmom);
 
                       KEmap[(int)(1e6*plen)] = trackID; // multiple assignment but always the same, so fine.
                       //                      std::cout  << "\t\t  TrkAna: TrkId  trackID, KE [MeV] ******* " << trackID << ", " << (int)(1e3*(part->E()-part->Mass()))  <<std::endl;
                     }
 
                   } // mc
               } //  hits
 
             } //    spacepoints
 
             if (mc)
               {
                 NtrkId_Hit.push_back(vecNtrkIds);       
                 // Find the trkID mode for this i^th track
                 unsigned int ii(1);
                 int max(-12), n(1), ind(0);
                 std::sort(vecNtrkIds.begin(),vecNtrkIds.end());
                 std::vector<unsigned int> strkIds(vecNtrkIds);
                 while ( ii < vecNtrkIds.size() )
                   { 
                     if (strkIds.at(ii) != strkIds.at(ii-1)) 
                       {
                         n=1;
                       }
                     else
                       {
                         n++; 
                       }
                     if (n>max) { max = n; ind = ii;}
                     ii++;
                   }
                 // std::cout  << "\t\t  TrkAna: TrkId  ind for this track is ******* " << ind  <<std::endl;
                 unsigned int mode(sim::NoParticleId);
                 if (strkIds.begin()!=strkIds.end()) 
                   mode = strkIds.at(ind);
                 vecMode.push_back(mode);
 
                 //      if (ntrack>1)   std::cout  << "\t\t  TrkAna: TrkId mode for this component track is ******* " << mode <<std::endl;
                 if (strkIds.size()!=0)
                   rhistsStitched.fModeFrac->Fill((double)max/(double)strkIds.size());
                 else
                   rhistsStitched.fModeFrac->Fill(-1.0);
                 } // mc
 
           } // end try 
           catch (cet::exception& x)  {
             assns = false;
           }
           if (!assns) throw cet::exception("TrackAna") << "Bad Associations. \n";
 
         } // i
 
         if (mc)
           {
             // one vector per o trk, for all modes of stitched i trks
             NtrkIdsAll.push_back(vecMode); 
 
             std::unique(NtrkIdsAll.back().begin(),NtrkIdsAll.back().end());
             double sum(0.0);
             for (auto const val :  NtrkIdsAll.back())
               {
                 //              rhistsStitched.fNTrkIdTrks3->Fill(o,val%100,hitmap[val][o].size());
                 sum += hitmap[val][o].size();
               }
             ntvsorted.push_back(sum);
 
           }
 
         //      
       } // o
 
     int vtmp(0);
         // get KEmap indices by most energetic first, least last.
         for (auto it = KEmap.rbegin(); it!=KEmap.rend(); ++it) 
           {
             //      int tval = it->second; // grab trkIDs in order, since they're sorted by KE
             //      int ke = it->first; // grab trkIDs in order, since they're sorted by KE
             //      const simb::MCParticle* part = bt_serv->TrackIDToParticle(tval);
             
             //      std::cout << "TrackAnaStitch: KEmap cntr vtmp, Length ke, tval, pdg : "  << vtmp << ", " << ke <<", " << tval <<", " << part->PdgCode() << ", " << std::endl;
 
             vtmp++;
           }
 
     // get o trk indices by their hits. Most populous track first, least last.
     for (auto const o : fsort_indexes(ntvsorted))
       {
         int v(0);
         // get KEmap indices by longest trajectory first, least last.
         for (auto it = KEmap.rbegin(); it!=KEmap.rend(); ++it) 
           {
             int val = it->second; // grab trkIDs in order, since they're sorted by KE
             //      const simb::MCParticle* part = pi_serv->TrackIDToParticle(val);
             //      std::cout << "TrackAnaStitch: trk o, KEmap cntr v, KE val, pdg  hitmap[val][o].size(): "  << o <<", " << v << ", " << val <<", " << part->PdgCode() << ", " << hitmap[val][o].size() << std::endl;
             rhistsStitched.fNTrkIdTrks3->Fill(o,v,hitmap[val][o].size());
             v++;
           }
         
       }
 
     // In how many o tracks did each trkId appear? Histo it. Would like it to be precisely 1.
     // Histo it vs. particle KE.
     flattener flat(NtrkIdsAll);
     std::vector <unsigned int> &v = flat;
   //  auto const it ( std::unique(v.begin(),v.end()) ); // never use this it, perhaps.
     for (auto const val :  v)
       {
         if (val != (unsigned int)sim::NoParticleId)
           {
             const simb::MCParticle* part = pi_serv->TrackIdToParticle_P( val ); 
             double T(part->E() - 0.001*part->Mass());
             rhistsStitched.fNTrkIdTrks->Fill(std::count(v.begin(),v.end(),val));
             rhistsStitched.fNTrkIdTrks2->Fill(std::count(v.begin(),v.end(),val),T);
           }
         else
           {
             rhistsStitched.fNTrkIdTrks2->Fill(-1.0,0.0);
           }
       }
  
   }

detail::CachedProducts& art::EventObserverBase::cachedProducts ( )

inlineprotectedinherited

Definition at line 79 of file EventObserverBase.h.

References art::EventObserverBase::selectors_.

Referenced by art::EDAnalyzer::doEvent(), and art::OutputModule::doWriteEvent().

   {
     return selectors_;
   }

template<typename T , BranchType = InEvent>

ProductToken<T> art::Consumer::consumes ( InputTag const & )

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::consumes ( InputTag const & it )

inherited

Definition at line 147 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::consumesMany ( )

inherited

Definition at line 162 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::Consumer::consumesView ( InputTag const & )

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::consumesView ( InputTag const & it )

inherited

Definition at line 172 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t seed )

inherited

Definition at line 26 of file EngineCreator.cc.

References art::EngineCreator::rng().

Referenced by evgen::CosmicsGen::CosmicsGen(), rndm::NuRandomService::createEngine(), cluster::fuzzyCluster::fuzzyCluster(), cluster::HoughLineFinder::HoughLineFinder(), art::MixFilter< T >::initEngine_(), larg4::LArG4::LArG4(), evgen::LightSource::LightSource(), evgen::NeutronOsc::NeutronOsc(), evgen::NucleonDecay::NucleonDecay(), opdet::OpMCDigi::OpMCDigi(), opdet::OptDetDigitizer::OptDetDigitizer(), phot::PhotonLibraryPropagation::PhotonLibraryPropagation(), detsim::SimDriftElectrons::SimDriftElectrons(), evgen::SingleGen::SingleGen(), evgen::SNNueAr40CCGen::SNNueAr40CCGen(), ToyOneShowerGen::ToyOneShowerGen(), and trkf::Track3DKalman::Track3DKalman().

 {
   return rng()->createEngine(placeholder_schedule_id(), seed);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make
	)

inherited

Definition at line 32 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make,
		label_t const &	engine_label
	)

inherited

Definition at line 40 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make, engine_label);
 }

CurrentProcessingContext const * art::EDAnalyzer::currentContext ( ) const

protectedinherited

Definition at line 114 of file EDAnalyzer.cc.

References art::EDAnalyzer::current_context_.

Referenced by art::EDAnalyzer::workerType().

   {
     return current_context_.get();
   }

void trkf::TrackAna::endJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 1681 of file TrackAna_module.cc.

   {
     // Print summary.
 
     mf::LogInfo("TrackAna") 
       << "TrackAna statistics:\n"
       << "  Number of events = " << fNumEvent;
 
     // Fill efficiency histograms.
 
     for(std::map<int, MCHists>::const_iterator i = fMCHistMap.begin();
         i != fMCHistMap.end(); ++i) {
       const MCHists& mchists = i->second;
       effcalc(mchists.fHgstartx, mchists.fHmcstartx, mchists.fHestartx);
       effcalc(mchists.fHgstarty, mchists.fHmcstarty, mchists.fHestarty);
       effcalc(mchists.fHgstartz, mchists.fHmcstartz, mchists.fHestartz);
       effcalc(mchists.fHgendx, mchists.fHmcendx, mchists.fHeendx);
       effcalc(mchists.fHgendy, mchists.fHmcendy, mchists.fHeendy);
       effcalc(mchists.fHgendz, mchists.fHmcendz, mchists.fHeendz);
       effcalc(mchists.fHgtheta, mchists.fHmctheta, mchists.fHetheta);
       effcalc(mchists.fHgphi, mchists.fHmcphi, mchists.fHephi);
       effcalc(mchists.fHgtheta_xz, mchists.fHmctheta_xz, mchists.fHetheta_xz);
       effcalc(mchists.fHgtheta_yz, mchists.fHmctheta_yz, mchists.fHetheta_yz);
       effcalc(mchists.fHgmom, mchists.fHmcmom, mchists.fHemom);
       effcalc(mchists.fHgmoml, mchists.fHmcmoml, mchists.fHemoml);
       effcalc(mchists.fHgke, mchists.fHmcke, mchists.fHeke);
       effcalc(mchists.fHgkel, mchists.fHmckel, mchists.fHekel);
       effcalc(mchists.fHglen, mchists.fHmclen, mchists.fHelen);
       effcalc(mchists.fHglens, mchists.fHmclens, mchists.fHelens);
     }
   }

template<typename T >

std::vector< size_t > trkf::TrackAna::fsort_indexes ( const std::vector< T > & v )

private

Definition at line 1718 of file TrackAna_module.cc.

Referenced by anaStitch().

                                                                      {
   // initialize original index locations
       std::vector<size_t> idx(v.size());
       for (size_t i = 0; i != idx.size(); ++i) idx[i] = i;
             // sort indexes based on comparing values in v
       std::sort(idx.begin(), idx.end(),
                 [&v](size_t i1, size_t i2) {return v[i1] > v[i2];}); // Want most occupied trks first. was <, EC, 21-July.
       return idx;
     }

EngineCreator::seed_t EngineCreator::get_seed_value	(	fhicl::ParameterSet const &	pset,
		char const	key[] = `"seed"`,
		seed_t const	implicit_seed = `-1`
	)

inherited

Definition at line 49 of file EngineCreator.cc.

References fhicl::ParameterSet::get().

Referenced by art::MixFilter< T >::initEngine_().

 {
   auto const& explicit_seeds = pset.get<std::vector<int>>(key, {});
   return explicit_seeds.empty() ? implicit_seed : explicit_seeds.front();
 }

art::Handle<art::TriggerResults> art::EventObserverBase::getTriggerResults ( Event const & e ) const

inlineinherited

Definition at line 61 of file EventObserverBase.h.

References art::detail::CachedProducts::getOneTriggerResults(), and art::EventObserverBase::selectors_.

Referenced by art::OutputModule::doWriteEvent().

   {
     return selectors_.getOneTriggerResults(e);
   }

template<typename T , BranchType = InEvent>

ProductToken<T> art::Consumer::mayConsume ( InputTag const & )

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::mayConsume ( InputTag const & it )

inherited

Definition at line 190 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::mayConsumeMany ( )

inherited

Definition at line 205 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::Consumer::mayConsumeView ( InputTag const & )

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::mayConsumeView ( InputTag const & it )

inherited

Definition at line 215 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

bool art::EventObserverBase::modifiesEvent ( ) const

inlineinherited

Definition at line 25 of file EventObserverBase.h.

   {
     return false;
   }

cet::exempt_ptr< art::Consumer > art::Consumer::non_module_context ( )

staticinherited

Definition at line 76 of file Consumer.cc.

 {
   static Consumer invalid{InvalidTag{}};
   return &invalid;
 }

void art::Consumer::prepareForJob ( fhicl::ParameterSet const & pset )

protectedinherited

Definition at line 89 of file Consumer.cc.

References fhicl::ParameterSet::get_if_present().

Referenced by art::EDProducer::doBeginJob(), art::EDFilter::doBeginJob(), and art::EDAnalyzer::doBeginJob().

 {
   if (!moduleContext_)
     return;
 
   pset.get_if_present("errorOnMissingConsumes", requireConsumes_);
   for (auto& consumablesPerBranch : consumables_) {
     cet::sort_all(consumablesPerBranch);
   }
 }

std::string const& art::EventObserverBase::processName ( ) const

inlineinherited

Definition at line 41 of file EventObserverBase.h.

References art::EventObserverBase::process_name_.

Referenced by art::FileDumperOutput::printPrincipal(), and art::RootOutput::RootOutput().

   {
     return process_name_;
   }

void art::EventObserverBase::registerProducts	(	MasterProductRegistry &	,
		ProductDescriptions &	,
		ModuleDescription const &
	)

inlineinherited

Definition at line 33 of file EventObserverBase.h.

36 {}

fhicl::ParameterSetID art::EventObserverBase::selectorConfig ( ) const

inlineinherited

Definition at line 56 of file EventObserverBase.h.

References art::EventObserverBase::selector_config_id_.

Referenced by art::RootOutputFile::writeOne().

   {
     return selector_config_id_;
   }

void art::Consumer::showMissingConsumes ( ) const

protectedinherited

Definition at line 125 of file Consumer.cc.

Referenced by art::EDProducer::doEndJob(), art::EDFilter::doEndJob(), art::EDAnalyzer::doEndJob(), and art::RootOutput::endJob().

 {
   if (!moduleContext_)
     return;
 
   // If none of the branches have missing consumes statements, exit early.
   if (std::all_of(cbegin(missingConsumes_),
                   cend(missingConsumes_),
                   [](auto const& perBranch) { return perBranch.empty(); }))
     return;
 
   constexpr cet::HorizontalRule rule{60};
   mf::LogPrint log{"MTdiagnostics"};
   log << '\n'
       << rule('=') << '\n'
       << "The following consumes (or mayConsume) statements are missing from\n"
       << module_context(moduleDescription_) << '\n'
       << rule('-') << '\n';
 
   cet::for_all_with_index(
     missingConsumes_, [&log](std::size_t const i, auto const& perBranch) {
       for (auto const& pi : perBranch) {
         log << "  "
             << assemble_consumes_statement(static_cast<BranchType>(i), pi)
             << '\n';
       }
     });
   log << rule('=');
 }

void art::Consumer::validateConsumedProduct	(	BranchType const	bt,
		ProductInfo const &	pi
	)

protectedinherited

Definition at line 101 of file Consumer.cc.

References art::errors::ProductRegistrationFailure.

 {
   // Early exits if consumes tracking has been disabled or if the
   // consumed product is an allowed consumable.
   if (!moduleContext_)
     return;
 
   if (cet::binary_search_all(consumables_[bt], pi))
     return;
 
   if (requireConsumes_) {
     throw Exception(errors::ProductRegistrationFailure,
                     "Consumer: an error occurred during validation of a "
                     "retrieved product\n\n")
       << "The following consumes (or mayConsume) statement is missing from\n"
       << module_context(moduleDescription_) << ":\n\n"
       << "  " << assemble_consumes_statement(bt, pi) << "\n\n";
   }
 
   missingConsumes_[bt].insert(pi);
 }

bool art::EventObserverBase::wantAllEvents ( ) const

inlineinherited

Definition at line 46 of file EventObserverBase.h.

References art::EventObserverBase::wantAllEvents_.

Referenced by art::EDAnalyzer::doEvent(), art::OutputModule::doEvent(), art::OutputModule::doWriteEvent(), art::RootOutput::RootOutput(), and art::OutputWorker::wantAllEvents().

   {
     return wantAllEvents_;
   }

bool art::EventObserverBase::wantEvent ( Event const & e )

inlineinherited

Definition at line 51 of file EventObserverBase.h.

References art::EventObserverBase::selectors_, and art::detail::CachedProducts::wantEvent().

Referenced by art::EDAnalyzer::doEvent(), art::OutputModule::doEvent(), and art::OutputModule::doWriteEvent().

   {
     return selectors_.wantEvent(e);
   }

std::string art::EDAnalyzer::workerType ( ) const

inlineinherited

Definition at line 109 of file EDAnalyzer.h.

References art::EDAnalyzer::currentContext().

     {
       return "WorkerT<EDAnalyzer>";
     }

Member Data Documentation

bool trkf::TrackAna::fCheckOrigin

private

Definition at line 454 of file TrackAna_module.cc.

Referenced by analyze(), and TrackAna().

int trkf::TrackAna::fDump

private

Definition at line 443 of file TrackAna_module.cc.

Referenced by analyze(), and TrackAna().

std::string trkf::TrackAna::fHitModuleLabel

private

Definition at line 441 of file TrackAna_module.cc.

Referenced by analyze(), and TrackAna().

std::string trkf::TrackAna::fHitSpptAssocModuleLabel

private

Definition at line 440 of file TrackAna_module.cc.

Referenced by anaStitch(), and TrackAna().

bool trkf::TrackAna::fIgnoreSign

private

Definition at line 450 of file TrackAna_module.cc.

Referenced by analyze().

double trkf::TrackAna::fMatchColinearity

private

Definition at line 446 of file TrackAna_module.cc.

Referenced by analyze().

double trkf::TrackAna::fMatchDisp

private

Definition at line 447 of file TrackAna_module.cc.

Referenced by analyze().

double trkf::TrackAna::fMatchLength

private

Definition at line 449 of file TrackAna_module.cc.

Referenced by analyze().

std::map<int, MCHists> trkf::TrackAna::fMCHistMap

private

Definition at line 460 of file TrackAna_module.cc.

Referenced by analyze(), and endJob().

std::string trkf::TrackAna::fMCTrackModuleLabel

private

Definition at line 436 of file TrackAna_module.cc.

Referenced by analyze(), and TrackAna().

double trkf::TrackAna::fMinMCKE

private

Definition at line 444 of file TrackAna_module.cc.

Referenced by analyze(), and TrackAna().

double trkf::TrackAna::fMinMCLen

private

Definition at line 445 of file TrackAna_module.cc.

Referenced by analyze(), and TrackAna().

int trkf::TrackAna::fNumEvent

private

Definition at line 465 of file TrackAna_module.cc.

Referenced by analyze(), and endJob().

std::string trkf::TrackAna::fOrigin

private

Definition at line 453 of file TrackAna_module.cc.

Referenced by TrackAna().

simb::Origin_t trkf::TrackAna::fOriginValue

private

Definition at line 455 of file TrackAna_module.cc.

Referenced by analyze(), and TrackAna().

int trkf::TrackAna::fPrintLevel

private

Definition at line 456 of file TrackAna_module.cc.

Referenced by analyze().

std::map<int, RecoHists> trkf::TrackAna::fRecoHistMap

private

Definition at line 461 of file TrackAna_module.cc.

Referenced by analyze(), and anaStitch().

std::string trkf::TrackAna::fSpacepointModuleLabel

private

Definition at line 437 of file TrackAna_module.cc.

Referenced by anaStitch().

bool trkf::TrackAna::fStitchedAnalysis

private

Definition at line 451 of file TrackAna_module.cc.

Referenced by analyze().

std::string trkf::TrackAna::fStitchModuleLabel

private

Definition at line 438 of file TrackAna_module.cc.

Referenced by analyze(), anaStitch(), and TrackAna().

std::string trkf::TrackAna::fTrackModuleLabel

private

Definition at line 435 of file TrackAna_module.cc.

Referenced by analyze(), anaStitch(), and TrackAna().

std::string trkf::TrackAna::fTrkSpptAssocModuleLabel

private

Definition at line 439 of file TrackAna_module.cc.

Referenced by anaStitch(), and TrackAna().

double trkf::TrackAna::fWMatchDisp

private

Definition at line 448 of file TrackAna_module.cc.

Referenced by analyze().

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

/cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/TrackFinder/TrackAna_module.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation