cheat::RecoCheckAna Class Reference

Inheritance diagram for cheat::RecoCheckAna:

Public Member Functions
	RecoCheckAna (fhicl::ParameterSet const &p)

Private Member Functions
void	analyze (art::Event const &e) override
void	beginRun (art::Run const &r) override
void	CheckReco (detinfo::DetectorClocksData const &clockData, int const &colID, std::vector< art::Ptr< recob::Hit >> const &allhits, std::vector< art::Ptr< recob::Hit >> const &colHits, std::map< std::pair< int, int >, std::pair< double, double >> &g4RecoBaseIDToPurityEfficiency)
void	CheckRecoClusters (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Cluster >> const &clscol, std::vector< art::Ptr< recob::Hit >> const &allhits)
void	CheckRecoTracks (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Track >> const &tcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
void	CheckRecoShowers (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Shower >> const &scol, std::vector< art::Ptr< recob::Hit >> const &allhits)
void	CheckRecoVertices (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Vertex >> const &vtxcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
void	CheckRecoEvents (art::Event const &evt, std::string const &label, art::Handle< std::vector< recob::Event >> const &evtcol, std::vector< art::Ptr< recob::Hit >> const &allhits)
void	FillResults (detinfo::DetectorClocksData const &clockData, std::vector< art::Ptr< recob::Hit >> const &allhits)
void	FlattenMap (std::map< std::pair< int, int >, std::pair< double, double >> const &g4RecoBaseIDToPurityEfficiency, std::map< int, std::vector< std::pair< int, std::pair< double, double >>>> &g4IDToRecoBasePurityEfficiency, TH1D *purity, TH1D *efficiency, TH1D *purityEfficiency, TH2D *purityEfficiency2D)

Private Attributes
art::ServiceHandle < cheat::BackTrackerService const >	fBT
	the back tracker service More...
art::ServiceHandle < cheat::ParticleInventoryService const >	fPI
	the back tracker service More...
std::string	fHitModuleLabel
	label for module making the hits More...
std::string	fClusterModuleLabel
	label for module making the clusters More...
std::string	fShowerModuleLabel
	label for module making the showers More...
std::string	fTrackModuleLabel
	label for module making the tracks More...
std::string	fVertexModuleLabel
	label for module making the vertices More...
std::string	fEventModuleLabel
	label for module making the events More...
bool	fCheckClusters
	should we check the reconstruction of clusters? More...
bool	fCheckShowers
	should we check the reconstruction of showers? More...
bool	fCheckTracks
	should we check the reconstruction of tracks? More...
bool	fCheckVertices
	should we check the reconstruction of vertices? More...
bool	fCheckEvents
	should we check the reconstruction of events? More...
TH1D *	fClusterPurity
	histogram of cluster purity More...
TH1D *	fClusterEfficiency
	histogram of cluster efficiency More...
TH1D *	fClusterPurityEfficiency
	histogram of cluster efficiency times purity More...
TH2D *	fClusterPurityEfficiency2D
	scatter histogram of cluster purity and efficiency More...
TH1D *	fShowerPurity
	histogram of shower purity More...
TH1D *	fShowerEfficiency
	histogram of shower efficiency More...
TH1D *	fShowerPurityEfficiency
	histogram of shower efficiency times purity More...
TH2D *	fShowerPurityEfficiency2D
	scatter histogram of cluster purity and efficiency More...
TH1D *	fTrackPurity
	histogram of track purity More...
TH1D *	fTrackEfficiency
	histogram of track efficiency More...
TH1D *	fTrackPurityEfficiency
	histogram of track efficiency times purity More...
TH2D *	fTrackPurityEfficiency2D
	scatter histogram of cluster purity and efficiency More...
TH1D *	fVertexPurity
	histogram of vertex purity More...
TH1D *	fVertexEfficiency
	histogram of vertex efficiency More...
TH1D *	fVertexPurityEfficiency
	histogram of vertex efficiency times purity More...
TH1D *	fEventPurity
	histogram of event purity More...
TH1D *	fEventEfficiency
	histogram of event efficiency More...
TH1D *	fEventPurityEfficiency
	histogram of event efficiency times purity More...
std::map< std::pair< int, int > , std::pair< double, double > >	fG4ClusterIDToPurityEfficiency
std::map< std::pair< int, int > , std::pair< double, double > >	fG4ShowerIDToPurityEfficiency
std::map< std::pair< int, int > , std::pair< double, double > >	fG4TrackIDToPurityEfficiency
TTree *	fTree
	TTree to save efficiencies. More...
int	frun
	run number More...
int	fevent
	event number More...
int	ftrackid
	geant track ID More...
int	fpdg
	particle pdg code More...
double	fpmom
	particle momentum More...
double	fhiteff
	hitfinder efficiency for this particle More...
int	fnclu
	number of clusters for this particle More...
std::vector< double >	fclueff
	cluster efficiencies More...
std::vector< double >	fclupur
	cluster purities More...
std::vector< int >	fcluid
	cluster IDs More...
int	fnshw
	number of showers for this particle More...
std::vector< double >	fshweff
	shower efficiencies More...
std::vector< double >	fshwpur
	shower purities More...
std::vector< int >	fshwid
	shower IDs More...
int	fntrk
	number of tracks for this particle More...
std::vector< double >	ftrkeff
	track efficiencies More...
std::vector< double >	ftrkpur
	track purities More...
std::vector< int >	ftrkid
	track IDs More...

Detailed Description

Definition at line 50 of file RecoCheckAna_module.cc.

Constructor & Destructor Documentation

cheat::RecoCheckAna::RecoCheckAna ( fhicl::ParameterSet const &  p )

explicit

Definition at line 162 of file RecoCheckAna_module.cc.

  : EDAnalyzer(p)
  , fHitModuleLabel{p.get<std::string>("HitModuleLabel")}
  , fClusterModuleLabel{p.get<std::string>("ClusterModuleLabel")}
  , fShowerModuleLabel{p.get<std::string>("ShowerModuleLabel")}
  , fTrackModuleLabel{p.get<std::string>("TrackModuleLabel")}
  , fVertexModuleLabel{p.get<std::string>("VertexModuleLabel")}
  , fEventModuleLabel{p.get<std::string>("EventModuleLabel")}
  , fCheckClusters{p.get<bool>("CheckClusters")}
  , fCheckShowers{p.get<bool>("CheckShowers")}
  , fCheckTracks{p.get<bool>("CheckTracks")}
  , fCheckVertices{p.get<bool>("CheckVertices")}
  , fCheckEvents{p.get<bool>("CheckEvents")}
{}

Member Function Documentation

void cheat::RecoCheckAna::analyze ( art::Event const &  e )

overrideprivate

Definition at line 179 of file RecoCheckAna_module.cc.

{
  // check that this is MC, stop if it isn't
  if (e.isRealData()) {
    mf::LogWarning("RecoVetter") << "attempting to run MC truth check on "
                                 << "real data, bail";
    return;
  }

  // get all hits in the event to figure out how many there are
  art::Handle<std::vector<recob::Hit>> hithdl;
  e.getByLabel(fHitModuleLabel, hithdl);
  std::vector<art::Ptr<recob::Hit>> allhits;
  art::fill_ptr_vector(allhits, hithdl);

  // define variables to hold the reconstructed objects
  art::Handle<std::vector<recob::Cluster>> clscol;
  art::Handle<std::vector<recob::Track>> trkcol;
  art::Handle<std::vector<recob::Shower>> shwcol;
  art::Handle<std::vector<recob::Vertex>> vtxcol;
  art::Handle<std::vector<recob::Event>> evtcol;

  if (fCheckClusters) {
    e.getByLabel(fClusterModuleLabel, clscol);
    if (!clscol.failedToGet()) this->CheckRecoClusters(e, fClusterModuleLabel, clscol, allhits);
  }
  if (fCheckTracks) {
    e.getByLabel(fTrackModuleLabel, trkcol);
    if (!trkcol.failedToGet()) this->CheckRecoTracks(e, fTrackModuleLabel, trkcol, allhits);
  }
  if (fCheckShowers) {
    e.getByLabel(fShowerModuleLabel, shwcol);
    if (!shwcol.failedToGet()) this->CheckRecoShowers(e, fShowerModuleLabel, shwcol, allhits);
  }
  if (fCheckVertices) {
    e.getByLabel(fVertexModuleLabel, vtxcol);
    if (!vtxcol.failedToGet()) this->CheckRecoVertices(e, fVertexModuleLabel, vtxcol, allhits);
  }
  if (fCheckEvents) {
    e.getByLabel(fEventModuleLabel, evtcol);
    if (!evtcol.failedToGet()) this->CheckRecoEvents(e, fEventModuleLabel, evtcol, allhits);
  }

  frun = e.run();
  fevent = e.id().event();

  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e);
  this->FillResults(clockData, allhits);

  return;
}

void cheat::RecoCheckAna::beginRun ( art::Run const &  r )

overrideprivate

Definition at line 233 of file RecoCheckAna_module.cc.

{
  art::ServiceHandle<art::TFileService const> tfs;

  if (fCheckEvents) {
    fEventPurity = tfs->make<TH1D>("eventPurity", ";Purity;Events", 100, 0., 1.1);
    fEventEfficiency = tfs->make<TH1D>("eventEfficiency", ";Efficiency;Events", 100, 0., 1.1);
    fEventPurityEfficiency =
      tfs->make<TH1D>("eventPurityEfficiency", ";purityEfficiency;Events", 110, 0., 1.1);
  }
  if (fCheckVertices) {
    fVertexPurity = tfs->make<TH1D>("vertexPurity", ";Purity;Vertices", 100, 0., 1.1);
    fVertexEfficiency = tfs->make<TH1D>("vertexEfficiency", ";Efficiency;Vertices", 100, 0., 1.1);
    fVertexPurityEfficiency =
      tfs->make<TH1D>("vertexPurityEfficiency", ";purityEfficiency;Vertex", 110, 0., 1.1);
  }
  if (fCheckTracks) {
    fTrackPurity = tfs->make<TH1D>("trackPurity", ";Purity;Tracks", 100, 0., 1.1);
    fTrackEfficiency = tfs->make<TH1D>("trackEfficiency", ";Efficiency;Tracks", 100, 0., 1.1);
    fTrackPurityEfficiency =
      tfs->make<TH1D>("trackPurityEfficiency", ";purityEfficiency;Tracks", 110, 0., 1.1);
    fTrackPurityEfficiency2D =
      tfs->make<TH2D>("trackPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
  }
  if (fCheckShowers) {
    fShowerPurity = tfs->make<TH1D>("showerPurity", ";Purity;Showers", 100, 0., 1.1);
    fShowerEfficiency = tfs->make<TH1D>("showerEfficiency", ";Efficiency;Showers", 100, 0., 1.1);
    fShowerPurityEfficiency =
      tfs->make<TH1D>("showerPurityEfficiency", ";purityEfficiency;Showers", 110, 0., 1.1);
    fShowerPurityEfficiency2D =
      tfs->make<TH2D>("showerPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
  }
  if (fCheckClusters) {
    fClusterPurity = tfs->make<TH1D>("clusterPurity", ";Purity;Clusters", 110, 0., 1.1);
    fClusterEfficiency = tfs->make<TH1D>("clusterEfficiency", ";Efficiency;Clusters", 110, 0., 1.1);
    fClusterPurityEfficiency =
      tfs->make<TH1D>("clusterPurityEfficiency", ";purityEfficiency;Clusters", 110, 0., 1.1);
    fClusterPurityEfficiency2D = tfs->make<TH2D>(
      "clusterPurityEfficiency2D", ";purity;efficiency", 110, 0., 1.1, 110, 0., 1.1);
  }

  fTree = tfs->make<TTree>("cheatertree", "cheater tree");
  fTree->Branch("run", &frun, "run/I");
  fTree->Branch("event", &fevent, "event/I");
  fTree->Branch("trackid", &ftrackid, "trackid/I");
  fTree->Branch("pdg", &fpdg, "pdg/I");
  fTree->Branch("pmom", &fpmom, "pmom/D");
  fTree->Branch("hiteff", &fhiteff, "hiteff/D");
  fTree->Branch("nclu", &fnclu, "nclu/I");
  fTree->Branch("clueff", &fclueff);
  fTree->Branch("clupur", &fclupur);
  fTree->Branch("cluid", &fcluid);
  fTree->Branch("nshw", &fnshw, "nshw/I");
  fTree->Branch("shweff", &fshweff);
  fTree->Branch("shwpur", &fshwpur);
  fTree->Branch("shwid", &fshwid);
  fTree->Branch("ntrk", &fntrk, "ntrk/I");
  fTree->Branch("trkeff", &ftrkeff);
  fTree->Branch("trkpur", &ftrkpur);
  fTree->Branch("trkid", &ftrkid);

  return;
}

void cheat::RecoCheckAna::CheckReco ( detinfo::DetectorClocksData const &  clockData, int const &  colID, std::vector< art::Ptr< recob::Hit >> const &  allhits, std::vector< art::Ptr< recob::Hit >> const &  colHits, std::map< std::pair< int, int >, std::pair< double, double >> &  g4RecoBaseIDToPurityEfficiency  )

private

Definition at line 301 of file RecoCheckAna_module.cc.

{

  // grab the set of track IDs for these hits
  std::set<int> trackIDs = fBT->GetSetOfTrackIds(clockData, colHits);

  geo::View_t view = colHits[0]->View();

  std::set<int>::iterator itr = trackIDs.begin();
  while (itr != trackIDs.end()) {

    std::set<int> id;
    id.insert(*itr);

    // use the cheat::BackTrackerService to find purity and efficiency for these
    // hits
    double purity = fBT->HitCollectionPurity(clockData, id, colHits);
    double efficiency = fBT->HitCollectionEfficiency(clockData, id, colHits, allhits, view);

    // make the purity and efficiency pair
    std::pair<double, double> pe(purity, efficiency);

    // make the pair of the RecoBase object id to the pair of purity/efficiency
    std::pair<int, int> g4reco(*itr, colID);

    // insert idpe into the map
    g4RecoBaseIDToPurityEfficiency[g4reco] = pe;

    itr++;

  } // end loop over eveIDs

  return;
}

void cheat::RecoCheckAna::CheckRecoClusters ( art::Event const &  evt, std::string const &  label, art::Handle< std::vector< recob::Cluster >> const &  clscol, std::vector< art::Ptr< recob::Hit >> const &  allhits  )

private

Definition at line 343 of file RecoCheckAna_module.cc.

{
  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
  art::FindManyP<recob::Hit> fmh(clscol, evt, label);

  for (size_t c = 0; c < clscol->size(); ++c) {

    // get the hits associated with this event
    std::vector<art::Ptr<recob::Hit>> hits = fmh.at(c);

    this->CheckReco(clockData, clscol->at(c).ID(), allhits, hits, fG4ClusterIDToPurityEfficiency);

  } // end loop over clusters

  return;
}

void cheat::RecoCheckAna::CheckRecoEvents ( art::Event const &  evt, std::string const &  label, art::Handle< std::vector< recob::Event >> const &  evtcol, std::vector< art::Ptr< recob::Hit >> const &  allhits  )

private

Todo:

need to divy it up in the case where there is more than 1 true interaction in a spill

Definition at line 473 of file RecoCheckAna_module.cc.

{
  const sim::ParticleList& plist = fPI->ParticleList();

  // loop over all primaries in the plist and grab them and their daughters to put into
  // the set of track ids to pass on to the back tracker
  std::set<int> ids;
  for (const auto& PartPair : plist) {
    auto trackID = PartPair.first;
    if (!plist.IsPrimary(trackID)) continue;
    const simb::MCParticle& part = *(PartPair.second);
    ids.insert(trackID);
    for (int d = 0; d < part.NumberDaughters(); ++d)
      ids.insert(part.Daughter(d));
  } // end loop over primaries

  art::FindManyP<recob::Hit> fmh(evtcol, evt, label);

  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
  for (size_t ev = 0; ev < evtcol->size(); ++ev) {

    // get the hits associated with this event
    std::vector<art::Ptr<recob::Hit>> hits = fmh.at(ev);

    // use the cheat::BackTrackerService to find purity and efficiency for these
    // hits
    double purity = fBT->HitCollectionPurity(clockData, ids, hits);
    double efficiency = fBT->HitCollectionEfficiency(clockData, ids, hits, allhits, geo::k3D);

    fEventPurity->Fill(purity);
    fEventEfficiency->Fill(efficiency);
    fEventPurityEfficiency->Fill(purity * efficiency);

  } // end loop over events

  return;
}

void cheat::RecoCheckAna::CheckRecoShowers ( art::Event const &  evt, std::string const &  label, art::Handle< std::vector< recob::Shower >> const &  scol, std::vector< art::Ptr< recob::Hit >> const &  allhits  )

private

Definition at line 387 of file RecoCheckAna_module.cc.

{
  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
  art::FindManyP<recob::Hit> fmh(scol, evt, label);

  for (size_t p = 0; p < scol->size(); ++p) {

    // get the hits associated with this event
    std::vector<art::Ptr<recob::Hit>> hits = fmh.at(p);

    this->CheckReco(clockData, scol->at(p).ID(), allhits, hits, fG4ShowerIDToPurityEfficiency);

  } // end loop over events

  return;
}

void cheat::RecoCheckAna::CheckRecoTracks ( art::Event const &  evt, std::string const &  label, art::Handle< std::vector< recob::Track >> const &  tcol, std::vector< art::Ptr< recob::Hit >> const &  allhits  )

private

Definition at line 365 of file RecoCheckAna_module.cc.

{
  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
  art::FindManyP<recob::Hit> fmh(tcol, evt, label);

  for (size_t p = 0; p < tcol->size(); ++p) {

    // get the hits associated with this event
    std::vector<art::Ptr<recob::Hit>> hits = fmh.at(p);

    this->CheckReco(clockData, tcol->at(p).ID(), allhits, hits, fG4TrackIDToPurityEfficiency);

  } // end loop over tracks

  return;
}

void cheat::RecoCheckAna::CheckRecoVertices ( art::Event const &  evt, std::string const &  label, art::Handle< std::vector< recob::Vertex >> const &  vtxcol, std::vector< art::Ptr< recob::Hit >> const &  allhits  )

private

Definition at line 411 of file RecoCheckAna_module.cc.

{
  const sim::ParticleList& plist = fPI->ParticleList();

  std::vector<std::set<int>> ids(1);
  // loop over all primary particles and put their ids into the first set of the
  // vector.  add another set for each primary particle that also has daughters
  // and put those daughters into the new set
  // PartPair is a (track ID, particle pointer) pair
  for (const auto& PartPair : plist) {
    auto trackID = PartPair.first;
    if (!plist.IsPrimary(trackID)) continue;
    const simb::MCParticle& part = *(PartPair.second);
    ids[0].insert(trackID);
    if (part.NumberDaughters() > 0) {
      std::set<int> dv;
      for (int d = 0; d < part.NumberDaughters(); ++d)
        dv.insert(part.Daughter(d));
      ids.push_back(std::move(dv));
    } // end if this primary particle has daughters
  }   // end loop over primaries

  art::FindManyP<recob::Hit> fmh(vtxcol, evt, label);

  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);

  for (size_t v = 0; v < vtxcol->size(); ++v) {

    // get the hits associated with this event
    std::vector<art::Ptr<recob::Hit>> hits = fmh.at(v);

    double maxPurity = -1.;
    double maxEfficiency = -1.;

    for (size_t tv = 0; tv < ids.size(); ++tv) {

      // use the cheat::BackTrackerService to find purity and efficiency for
      // these hits
      double purity = fBT->HitCollectionPurity(clockData, ids[tv], hits);
      double efficiency = fBT->HitCollectionEfficiency(clockData, ids[tv], hits, allhits, geo::k3D);

      if (purity > maxPurity) maxPurity = purity;
      if (efficiency > maxEfficiency) maxEfficiency = efficiency;
    }

    fVertexPurity->Fill(maxPurity);
    fVertexEfficiency->Fill(maxEfficiency);
    fVertexPurityEfficiency->Fill(maxPurity * maxEfficiency);

  } // end loop over vertices

  return;
}

void cheat::RecoCheckAna::FillResults ( detinfo::DetectorClocksData const &  clockData, std::vector< art::Ptr< recob::Hit >> const &  allhits  )

private

Definition at line 576 of file RecoCheckAna_module.cc.

{
  // map the g4 track id to energy deposited in a hit
  std::map<int, double> g4IDToHitEnergy;
  for (size_t h = 0; h < allhits.size(); ++h) {
    const std::vector<sim::TrackIDE> hitTrackIDs = fBT->HitToTrackIDEs(clockData, allhits[h]);
    for (size_t e = 0; e < hitTrackIDs.size(); ++e) {
      g4IDToHitEnergy[hitTrackIDs[e].trackID] += hitTrackIDs[e].energy;
    }
  } // end loop over hits to fill map

  // flatten the G4RecoBaseIDToPurityEfficiency maps to have just the g4ID as
  // the key and the rest of the information in vector form
  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
    g4IDToClusterPurityEfficiency;
  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
    g4IDToShowerPurityEfficiency;
  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>> g4IDToTrackPurityEfficiency;
  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>::iterator g4peItr;

  if (fCheckClusters)
    this->FlattenMap(fG4ClusterIDToPurityEfficiency,
                     g4IDToClusterPurityEfficiency,
                     fClusterPurity,
                     fClusterEfficiency,
                     fClusterPurityEfficiency,
                     fClusterPurityEfficiency2D);
  if (fCheckShowers)
    this->FlattenMap(fG4ShowerIDToPurityEfficiency,
                     g4IDToShowerPurityEfficiency,
                     fShowerPurity,
                     fShowerEfficiency,
                     fShowerPurityEfficiency,
                     fShowerPurityEfficiency2D);
  if (fCheckTracks)
    this->FlattenMap(fG4TrackIDToPurityEfficiency,
                     g4IDToTrackPurityEfficiency,
                     fTrackPurity,
                     fTrackEfficiency,
                     fTrackPurityEfficiency,
                     fTrackPurityEfficiency2D);

  // fill the tree vectors
  // get all the eveIDs from this event
  std::set<int> trackIDs = fBT->GetSetOfTrackIds();
  std::set<int>::const_iterator trackItr = trackIDs.begin();

  // loop over them
  while (trackItr != trackIDs.end()) {

    const simb::MCParticle* part = fPI->TrackIdToParticle_P(*trackItr);

    ftrackid = std::abs(*trackItr);
    fpdg = part->PdgCode();
    fpmom = part->P();

    // figure out how much of the energy deposited from this particle is stored in hits
    std::vector<const sim::IDE*> ides = fBT->TrackIdToSimIDEs_Ps(*trackItr);
    double totalDep = 0.;
    for (size_t i = 0; i < ides.size(); ++i)
      totalDep += ides[i]->energy;

    if (totalDep > 0.) fhiteff = g4IDToHitEnergy[*trackItr] / totalDep;

    std::vector<std::pair<int, std::pair<double, double>>> clVec;
    std::vector<std::pair<int, std::pair<double, double>>> shVec;
    std::vector<std::pair<int, std::pair<double, double>>> trVec;

    if (g4IDToClusterPurityEfficiency.find(*trackItr) != g4IDToClusterPurityEfficiency.end())
      clVec = g4IDToClusterPurityEfficiency.find(*trackItr)->second;

    if (g4IDToShowerPurityEfficiency.find(*trackItr) != g4IDToShowerPurityEfficiency.end())
      shVec = g4IDToShowerPurityEfficiency.find(*trackItr)->second;

    if (g4IDToTrackPurityEfficiency.find(*trackItr) != g4IDToTrackPurityEfficiency.end())
      trVec = g4IDToTrackPurityEfficiency.find(*trackItr)->second;

    fnclu = clVec.size();
    fnshw = shVec.size();
    fntrk = trVec.size();

    for (size_t c = 0; c < clVec.size(); ++c) {
      fcluid.push_back(clVec[c].first);
      fclupur.push_back(clVec[c].second.first);
      fclueff.push_back(clVec[c].second.second);
    }

    for (size_t s = 0; s < shVec.size(); ++s) {
      fshwid.push_back(shVec[s].first);
      fshwpur.push_back(shVec[s].second.first);
      fshweff.push_back(shVec[s].second.second);
    }

    for (size_t t = 0; t < trVec.size(); ++t) {
      ftrkid.push_back(trVec[t].first);
      ftrkpur.push_back(trVec[t].second.first);
      ftrkeff.push_back(trVec[t].second.second);
    }

    fTree->Fill();

    trackItr++;
  }

  // clean up for the next event

  // clear the maps of G4 track id to efficiency and purity for
  // various RecoBase objects
  fG4ClusterIDToPurityEfficiency.clear();
  fG4ShowerIDToPurityEfficiency.clear();
  fG4TrackIDToPurityEfficiency.clear();

  // clear the vectors hooked up to the tree
  fclueff.clear();
  fclupur.clear();
  fcluid.clear();
  ftrkeff.clear();
  ftrkpur.clear();
  ftrkid.clear();
  fshweff.clear();
  fshwpur.clear();
  fshwid.clear();

  return;
}

void cheat::RecoCheckAna::FlattenMap ( std::map< std::pair< int, int >, std::pair< double, double >> const &  g4RecoBaseIDToPurityEfficiency, std::map< int, std::vector< std::pair< int, std::pair< double, double >>>> &  g4IDToRecoBasePurityEfficiency, TH1D *  purity, TH1D *  efficiency, TH1D *  purityEfficiency, TH2D *  purityEfficiency2D  )

private

Definition at line 516 of file RecoCheckAna_module.cc.

{

  std::map<std::pair<int, int>, std::pair<double, double>>::const_iterator rbItr =
    g4RecoBaseIDToPurityEfficiency.begin();

  // map of key cluster ID to pair of purity, efficiency
  std::map<int, std::pair<double, double>> recoBIDToPurityEfficiency;
  std::map<int, std::pair<double, double>>::iterator rbpeItr;

  while (rbItr != g4RecoBaseIDToPurityEfficiency.end()) {

    // trackID, cluster ID
    std::pair<int, int> g4cl = rbItr->first;
    // purity, efficiency
    std::pair<double, double> pe = rbItr->second;

    // add the efficiency and purity values for clusters corresponding
    // to the current g4 id to the map
    // pair of cluster id, pair of purity, efficiency
    std::pair<int, std::pair<double, double>> clpe(g4cl.second, pe);
    // g4IDToRecoBasePurityEfficiency is a map with key of trackID of a vector of clusterIDs of pairs of purity and efficiency
    g4IDToRecoBasePurityEfficiency[g4cl.first].push_back(clpe);

    // now find the maximum purity to determine the purity and efficiency
    // for this RecoBase object
    rbpeItr = recoBIDToPurityEfficiency.find(g4cl.second);
    if (rbpeItr != recoBIDToPurityEfficiency.end()) {
      std::pair<double, double> curpe = rbpeItr->second;
      if (pe.first > curpe.first) recoBIDToPurityEfficiency[g4cl.second] = pe;
    }
    else
      recoBIDToPurityEfficiency[g4cl.second] = pe;

    rbItr++;
  }

  rbpeItr = recoBIDToPurityEfficiency.begin();

  // now fill the histograms,
  while (rbpeItr != recoBIDToPurityEfficiency.end()) {
    purity->Fill(rbpeItr->second.first);
    efficiency->Fill(rbpeItr->second.second);
    purityEfficiency->Fill(rbpeItr->second.first * rbpeItr->second.second);
    purityEfficiency2D->Fill(rbpeItr->second.first, rbpeItr->second.second);
    rbpeItr++;
  }

  return;
}

Member Data Documentation

art::ServiceHandle<cheat::BackTrackerService const> cheat::RecoCheckAna::fBT

private

the back tracker service

Definition at line 98 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckClusters

private

should we check the reconstruction of clusters?

Definition at line 108 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckEvents

private

should we check the reconstruction of events?

Definition at line 112 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckShowers

private

should we check the reconstruction of showers?

Definition at line 109 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckTracks

private

should we check the reconstruction of tracks?

Definition at line 110 of file RecoCheckAna_module.cc.

bool cheat::RecoCheckAna::fCheckVertices

private

should we check the reconstruction of vertices?

Definition at line 111 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::fclueff

private

cluster efficiencies

Definition at line 148 of file RecoCheckAna_module.cc.

std::vector<int> cheat::RecoCheckAna::fcluid

private

cluster IDs

Definition at line 150 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::fclupur

private

cluster purities

Definition at line 149 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fClusterEfficiency

private

histogram of cluster efficiency

Definition at line 115 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fClusterModuleLabel

private

label for module making the clusters

Definition at line 102 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fClusterPurity

private

histogram of cluster purity

Definition at line 114 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fClusterPurityEfficiency

private

histogram of cluster efficiency times purity

Definition at line 116 of file RecoCheckAna_module.cc.

TH2D* cheat::RecoCheckAna::fClusterPurityEfficiency2D

private

scatter histogram of cluster purity and efficiency

Definition at line 117 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fevent

private

event number

Definition at line 142 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fEventEfficiency

private

histogram of event efficiency

Definition at line 130 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fEventModuleLabel

private

label for module making the events

Definition at line 106 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fEventPurity

private

histogram of event purity

Definition at line 129 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fEventPurityEfficiency

private

histogram of event efficiency times purity

Definition at line 131 of file RecoCheckAna_module.cc.

std::map<std::pair<int, int>, std::pair<double, double> > cheat::RecoCheckAna::fG4ClusterIDToPurityEfficiency

private

Definition at line 136 of file RecoCheckAna_module.cc.

std::map<std::pair<int, int>, std::pair<double, double> > cheat::RecoCheckAna::fG4ShowerIDToPurityEfficiency

private

Definition at line 137 of file RecoCheckAna_module.cc.

std::map<std::pair<int, int>, std::pair<double, double> > cheat::RecoCheckAna::fG4TrackIDToPurityEfficiency

private

Definition at line 138 of file RecoCheckAna_module.cc.

double cheat::RecoCheckAna::fhiteff

private

hitfinder efficiency for this particle

Definition at line 146 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fHitModuleLabel

private

label for module making the hits

Definition at line 101 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fnclu

private

number of clusters for this particle

Definition at line 147 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fnshw

private

number of showers for this particle

Definition at line 151 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fntrk

private

number of tracks for this particle

Definition at line 155 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::fpdg

private

particle pdg code

Definition at line 144 of file RecoCheckAna_module.cc.

art::ServiceHandle<cheat::ParticleInventoryService const> cheat::RecoCheckAna::fPI

private

the back tracker service

Definition at line 99 of file RecoCheckAna_module.cc.

double cheat::RecoCheckAna::fpmom

private

particle momentum

Definition at line 145 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::frun

private

run number

Definition at line 141 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fShowerEfficiency

private

histogram of shower efficiency

Definition at line 119 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fShowerModuleLabel

private

label for module making the showers

Definition at line 103 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fShowerPurity

private

histogram of shower purity

Definition at line 118 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fShowerPurityEfficiency

private

histogram of shower efficiency times purity

Definition at line 120 of file RecoCheckAna_module.cc.

TH2D* cheat::RecoCheckAna::fShowerPurityEfficiency2D

private

scatter histogram of cluster purity and efficiency

Definition at line 121 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::fshweff

private

shower efficiencies

Definition at line 152 of file RecoCheckAna_module.cc.

std::vector<int> cheat::RecoCheckAna::fshwid

private

shower IDs

Definition at line 154 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::fshwpur

private

shower purities

Definition at line 153 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fTrackEfficiency

private

histogram of track efficiency

Definition at line 123 of file RecoCheckAna_module.cc.

int cheat::RecoCheckAna::ftrackid

private

geant track ID

Definition at line 143 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fTrackModuleLabel

private

label for module making the tracks

Definition at line 104 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fTrackPurity

private

histogram of track purity

Definition at line 122 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fTrackPurityEfficiency

private

histogram of track efficiency times purity

Definition at line 124 of file RecoCheckAna_module.cc.

TH2D* cheat::RecoCheckAna::fTrackPurityEfficiency2D

private

scatter histogram of cluster purity and efficiency

Definition at line 125 of file RecoCheckAna_module.cc.

TTree* cheat::RecoCheckAna::fTree

private

TTree to save efficiencies.

Definition at line 140 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::ftrkeff

private

track efficiencies

Definition at line 156 of file RecoCheckAna_module.cc.

std::vector<int> cheat::RecoCheckAna::ftrkid

private

track IDs

Definition at line 158 of file RecoCheckAna_module.cc.

std::vector<double> cheat::RecoCheckAna::ftrkpur

private

track purities

Definition at line 157 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fVertexEfficiency

private

histogram of vertex efficiency

Definition at line 127 of file RecoCheckAna_module.cc.

std::string cheat::RecoCheckAna::fVertexModuleLabel

private

label for module making the vertices

Definition at line 105 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fVertexPurity

private

histogram of vertex purity

Definition at line 126 of file RecoCheckAna_module.cc.

TH1D* cheat::RecoCheckAna::fVertexPurityEfficiency

private

histogram of vertex efficiency times purity

Definition at line 128 of file RecoCheckAna_module.cc.

---

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

• RecoCheckAna_module.cc