sbn::Dazzle Class Reference

Inheritance diagram for sbn::Dazzle:

Public Member Functions
	Dazzle (fhicl::ParameterSet const &p)
	Dazzle (Dazzle const &)=delete
	Dazzle (Dazzle &&)=delete
Dazzle &	operator= (Dazzle const &)=delete
Dazzle &	operator= (Dazzle &&)=delete
void	produce (art::Event &e) override
void	beginJob () override

Private Member Functions
void	ClearTreeValues ()
void	FillPFPMetrics (const art::Ptr< recob::PFParticle > &pfp, const std::map< size_t, art::Ptr< recob::PFParticle >> &pfpMap, const art::FindManyP< recob::Cluster > &fmCluster, const art::FindManyP< recob::Hit > &fmHit, const art::FindManyP< larpandoraobj::PFParticleMetadata > &fmMeta)
void	FillTrueParticleMetrics (const detinfo::DetectorClocksData &clockData, const recob::Track &track, const std::vector< art::Ptr< recob::Hit >> &hits, std::vector< art::Ptr< sim::SimChannel >> &simChannels)
void	FillTrackMetrics (const recob::Track &track)
void	FillMCSMetrics (const recob::MCSFitResult &mcs)
void	FillChi2PIDMetrics (const anab::ParticleID &pid)
void	FillRangePMetrics (const RangeP &range)
void	FillClosestApproachMetrics (const ScatterClosestApproach &closestApproach)
void	FillStoppingChi2Metrics (const StoppingChi2Fit &stoppingChi2)
MVAPID	RunMVA ()
std::map< size_t, art::Ptr < recob::PFParticle > >	GetPFPMap (std::vector< art::Ptr< recob::PFParticle >> &pfps) const
unsigned int	GetPFPHierarchyDepth (const art::Ptr< recob::PFParticle > &pfp, const std::map< size_t, art::Ptr< recob::PFParticle >> &pfpMap) const
float	GetPFPTrackScore (const art::Ptr< recob::PFParticle > &pfp, const art::FindManyP< larpandoraobj::PFParticleMetadata > &fmMeta) const
bool	InFV (const TVector3 &pos) const
std::string	PdgString (const int pdg) const

Private Attributes
art::ServiceHandle < art::TFileService >	tfs
art::ServiceHandle < cheat::ParticleInventoryService >	particleInventory
art::InputTag	fSimChannelLabel
art::InputTag	fPFPLabel
art::InputTag	fTrackLabel
art::InputTag	fCaloLabel
art::InputTag	fMCSLabel
art::InputTag	fChi2Label
art::InputTag	fRangeLabel
art::InputTag	fClosestApproachLabel
art::InputTag	fStoppingChi2Label
const float	fMinTrackLength
const bool	fMakeTree
const bool	fRunMVA
const std::string	fMethodName
const std::string	fWeightFile
const float	fXMin
const float	fXMax
const float	fYMin
const float	fYMax
const float	fZMin
const float	fZMax
float	recoLen
float	chi2PIDMuon
float	chi2PIDProton
float	chi2PIDMuonPionDiff
float	mcsScatterMean
float	mcsScatterMaxRatio
float	meanDCA
float	stoppingChi2Ratio
float	chi2Pol0Fit
float	pDiff
float	numDaughters
float	maxDaughterHits
float	muonScore
float	pionScore
float	protonScore
float	otherScore
float	bestScore
int	bestPDG
TMVA::Reader *	reader
TTree *	trackTree
int	truePdg
int	chi2PIDPDG
int	chi2PIDPDGNoKaon
int	numHits
int	bestPlane
int	bestPlaneHits
int	hierarchyDepth
int	trueStopping
int	recoContained
int	recoPrimary
float	chi2PIDPion
float	chi2PIDKaon
float	chi2Pol0Chi2
float	chi2ExpChi2
float	stdDevDCA
float	maxDCA
float	mcsScatterMax
float	mcsMuonP
float	rangeMuonP
float	trackScore
float	daughterTrackScore
float	startX
float	startY
float	startZ
float	endX
float	endY
float	endZ
float	trueStartX
float	trueStartY
float	trueStartZ
float	trueEndX
float	trueEndY
float	trueEndZ
float	truePx
float	truePy
float	truePz
float	startDist
float	endDist
float	trueP
float	trueEndP
float	trueThetaXZ
float	trueThetaYZ
float	energyComp
float	energyPurity
std::string	trueType
std::string	trueEndProcess
std::string	chi2PIDType
std::string	chi2PIDTypeNoKaon

Detailed Description

Definition at line 72 of file Dazzle_module.cc.

Constructor & Destructor Documentation

sbn::Dazzle::Dazzle ( fhicl::ParameterSet const &  p )

explicit

Definition at line 158 of file Dazzle_module.cc.

    : EDProducer { p }
    , fSimChannelLabel(p.get<std::string>("SimChannelLabel"))
    , fPFPLabel(p.get<std::string>("PFPLabel"))
    , fTrackLabel(p.get<std::string>("TrackLabel"))
    , fCaloLabel(p.get<std::string>("CaloLabel"))
    , fMCSLabel(p.get<std::string>("MCSLabel"), std::string("muon"))
    , fChi2Label(p.get<std::string>("Chi2Label"))
    , fRangeLabel(p.get<std::string>("RangeLabel"), std::string("muon"))
    // , fLGCLabel(p.get<std::string>("LGCLabel"))
    , fClosestApproachLabel(p.get<std::string>("ClosestApproachLabel"))
    , fStoppingChi2Label(p.get<std::string>("StoppingChi2Label"))
    , fMinTrackLength(p.get<float>("MinTrackLength"))
    , fMakeTree(p.get<bool>("MakeTree"))
    , fRunMVA(p.get<bool>("RunMVA"))
    , fMethodName(p.get<std::string>("MethodName", ""))
    , fWeightFile(p.get<std::string>("WeightFile", ""))
    , fXMin(p.get<float>("XMin"))
    , fXMax(p.get<float>("XMax"))
    , fYMin(p.get<float>("YMin"))
    , fYMax(p.get<float>("YMax"))
    , fZMin(p.get<float>("ZMin"))
    , fZMax(p.get<float>("ZMax"))
// , lgFitter(p.get<float>("LGFitterNP", 100.f), p.get<float>("LGFitterSC", 8.f))
{
  if (!fMakeTree && !fRunMVA)
    throw cet::exception("Dazzle") << "Configured to do nothing";

  if (fRunMVA) {
    if (fMethodName == "" || fWeightFile == "")
      throw cet::exception("Dazzle") << "Trying to run MVA with inputs not set: MethodName: " << fMethodName << " and WeightFile: " << fWeightFile;

    cet::search_path searchPath("FW_SEARCH_PATH");
    std::string fWeightFileFullPath;
    if (!searchPath.find_file(fWeightFile, fWeightFileFullPath))
      throw cet::exception("Dazzle") << "Unable to find weight file: " << fWeightFile << " in FW_SEARCH_PATH: " << searchPath.to_string();

    reader = new TMVA::Reader("V");

    reader->AddVariable("recoLen", &recoLen);

    reader->AddVariable("chi2PIDMuon", &chi2PIDMuon);
    reader->AddVariable("chi2PIDProton", &chi2PIDProton);
    reader->AddVariable("chi2PIDMuonPionDiff", &chi2PIDMuonPionDiff);

    reader->AddVariable("mcsScatterMean", &mcsScatterMean);
    reader->AddVariable("mcsScatterMaxRatio", &mcsScatterMaxRatio);
    reader->AddVariable("meanDCA", &meanDCA);

    reader->AddVariable("stoppingChi2Ratio", &stoppingChi2Ratio);
    reader->AddVariable("chi2Pol0Fit", &chi2Pol0Fit);

    reader->AddVariable("pDiff", &pDiff);
    reader->AddVariable("numDaughters", &numDaughters);
    reader->AddVariable("maxDaughterHits", &maxDaughterHits);

    reader->BookMVA(fMethodName, fWeightFileFullPath);
  }
  // Call appropriate produces<>() functions here.
  produces<std::vector<MVAPID>>();
  produces<art::Assns<recob::Track, MVAPID>>();
}

sbn::Dazzle::Dazzle ( Dazzle const &  )

delete

sbn::Dazzle::Dazzle ( Dazzle &&  )

delete

Member Function Documentation

void sbn::Dazzle::beginJob ( )

override

Definition at line 221 of file Dazzle_module.cc.

{
  if (fMakeTree) {
    trackTree = tfs->make<TTree>("trackTree", "Tree filled per Track with  PID variables");

    // The metrics actually used in the MVA
    trackTree->Branch("recoLen", &recoLen);
    trackTree->Branch("chi2PIDMuon", &chi2PIDMuon);
    trackTree->Branch("chi2PIDPion", &chi2PIDPion);
    trackTree->Branch("chi2PIDProton", &chi2PIDProton);
    trackTree->Branch("chi2PIDMuonPionDiff", &chi2PIDMuonPionDiff);
    trackTree->Branch("mcsScatterMean", &mcsScatterMean);
    trackTree->Branch("mcsScatterMaxRatio", &mcsScatterMaxRatio);
    trackTree->Branch("meanDCA", &meanDCA);
    trackTree->Branch("stoppingChi2Ratio", &stoppingChi2Ratio);
    // trackTree->Branch("lgcMPV", &lgcMPV);
    trackTree->Branch("pDiff", &pDiff);
    trackTree->Branch("chi2Pol0Fit", &chi2Pol0Fit);
    trackTree->Branch("numDaughters", &numDaughters);
    trackTree->Branch("maxDaughterHits", &maxDaughterHits);

    if (fRunMVA) {
      trackTree->Branch("muonScore", &muonScore);
      trackTree->Branch("pionScore", &pionScore);
      trackTree->Branch("protonScore", &protonScore);
      trackTree->Branch("otherScore", &otherScore);
      trackTree->Branch("bestScore", &bestScore);
      trackTree->Branch("bestPDG", &bestPDG);
    }

    trackTree->Branch("truePdg", &truePdg);
    trackTree->Branch("trueP", &trueP);
    trackTree->Branch("trueEndP", &trueEndP);
    trackTree->Branch("trueThetaXZ", &trueThetaXZ);
    trackTree->Branch("trueThetaYZ", &trueThetaYZ);
    trackTree->Branch("trueType", &trueType);
    trackTree->Branch("trueEndProcess", &trueEndProcess);
    trackTree->Branch("energyComp", &energyComp);
    trackTree->Branch("energyPurity", &energyPurity);

    trackTree->Branch("trueStopping", &trueStopping);

    trackTree->Branch("startX", &startX);
    trackTree->Branch("startY", &startY);
    trackTree->Branch("startZ", &startZ);

    trackTree->Branch("endX", &endX);
    trackTree->Branch("endY", &endY);
    trackTree->Branch("endZ", &endZ);

    trackTree->Branch("trueStartX", &trueStartX);
    trackTree->Branch("trueStartY", &trueStartY);
    trackTree->Branch("trueStartZ", &trueStartZ);

    trackTree->Branch("trueEndX", &trueEndX);
    trackTree->Branch("trueEndY", &trueEndY);
    trackTree->Branch("trueEndZ", &trueEndZ);

    trackTree->Branch("truePx", &truePx);
    trackTree->Branch("truePy", &truePy);
    trackTree->Branch("truePz", &truePz);

    trackTree->Branch("startDist", &startDist);
    trackTree->Branch("endDist", &endDist);

    trackTree->Branch("numHits", &numHits);
    trackTree->Branch("bestPlane", &bestPlane);
    trackTree->Branch("bestPlaneHits", &bestPlaneHits);
    trackTree->Branch("hierarchyDepth", &hierarchyDepth);
    trackTree->Branch("trackScore", &trackScore);
    trackTree->Branch("daughterTrackScore", &daughterTrackScore);

    trackTree->Branch("recoPrimary", &recoPrimary);
    trackTree->Branch("recoContained", &recoContained);

    trackTree->Branch("chi2PIDKaon", &chi2PIDKaon);
    trackTree->Branch("chi2PIDPDG", &chi2PIDPDG);
    trackTree->Branch("chi2PIDPDGNoKaon", &chi2PIDPDGNoKaon);
    trackTree->Branch("chi2PIDType", &chi2PIDType);
    trackTree->Branch("chi2PIDTypeNoKaon", &chi2PIDTypeNoKaon);

    // trackTree->Branch("lgcAmp", &lgcAmp);
    // trackTree->Branch("lgcGaussWidth", &lgcGaussWidth);
    // trackTree->Branch("lgcLandauWidth", &lgcLandauWidth);
    // trackTree->Branch("lgcChi2", &lgcChi2);

    trackTree->Branch("chi2ExpChi2", &chi2ExpChi2);

    trackTree->Branch("mcsMuonP", &mcsMuonP);
    trackTree->Branch("mcsScatterMax", &mcsScatterMax);

    trackTree->Branch("rangeMuonP", &rangeMuonP);

    trackTree->Branch("stdDevDCA", &stdDevDCA);
    trackTree->Branch("maxDCA", &maxDCA);
  }
}

void sbn::Dazzle::ClearTreeValues ( )

private

Definition at line 442 of file Dazzle_module.cc.

{
  truePdg = -5;
  chi2PIDPDG = -5;
  chi2PIDPDGNoKaon = -5;
  numHits = -5;
  bestPlane = -5;
  numDaughters = -5;
  hierarchyDepth = -5;
  trackScore = -5;
  maxDaughterHits = -5;
  daughterTrackScore = -5;

  trueStopping = -5;
  recoContained = -5;
  recoPrimary = -5;

  muonScore = -5.f;
  pionScore = -5.f;
  protonScore = -5.f;
  otherScore = -5.f;
  bestScore = -5.f;
  bestPDG = -5;

  startX = -999.f;
  startY = -999.f;
  startZ = -999.f;
  endX = -999.f;
  endY = -999.f;
  endZ = -999.f;
  trueStartX = -999.f;
  trueStartY = -999.f;
  trueStartZ = -999.f;
  trueEndX = -999.f;
  trueEndY = -999.f;
  trueEndZ = -999.f;
  truePx = -999.f;
  truePy = -999.f;
  truePz = -999.f;
  startDist = -999.f;
  endDist = -999.f;

  trueP = -5.f;
  trueEndP = -5.f;
  trueThetaXZ = -5.f;
  trueThetaYZ = -5.f;
  energyPurity = -5.f;
  energyComp = -5.f;
  recoLen = -5.f;
  mcsMuonP = -5.f;
  rangeMuonP = -5.f;
  pDiff = -5.f;
  chi2PIDMuon = -5.f;
  chi2PIDPion = -5.f;
  chi2PIDKaon = -5.f;
  chi2PIDProton = -5.f;
  chi2PIDMuonPionDiff = -5.f;
  // lgcMPV = -5.f;
  // lgcAmp = -5.f;
  // lgcGaussWidth = -5.f;
  // lgcLandauWidth = -5.f;
  // lgcChi2 = -5.f;
  chi2Pol0Fit = -5.f;
  chi2Pol0Chi2 = -5.f;
  chi2ExpChi2 = -5.f;
  stoppingChi2Ratio = -5.f;
  mcsScatterMean = -5.f;
  mcsScatterMax = -5.f;
  mcsScatterMaxRatio = -5.f;
  meanDCA = -5.f;
  stdDevDCA = -5.f;
  maxDCA = -5.f;

  trueType = "";
  trueEndProcess = "";
  chi2PIDType = "";
  chi2PIDTypeNoKaon = "";
}

void sbn::Dazzle::FillChi2PIDMetrics ( const anab::ParticleID &  pid )

private

Definition at line 740 of file Dazzle_module.cc.

{
  // Assign dummy values.

  chi2PIDMuon = 0.;
  chi2PIDPion = 0.;
  chi2PIDKaon = 0.;
  chi2PIDProton = 0.;
  double chi2PIDBest = 0.;
  chi2PIDPDG = 0;

  // Loop over algorithm scores and extract the ones we want.
  // Also extract the preferred pdg.

  std::vector<anab::sParticleIDAlgScores> AlgScoresVec = pid.ParticleIDAlgScores();
  for (size_t i_algscore=0; i_algscore<AlgScoresVec.size(); i_algscore++){
    anab::sParticleIDAlgScores AlgScore = AlgScoresVec.at(i_algscore);
    if (AlgScore.fAlgName == "Chi2"){
      if (TMath::Abs(AlgScore.fAssumedPdg) == 13) { // chi2mu
        chi2PIDMuon = AlgScore.fValue;
        if(AlgScore.fValue < chi2PIDBest || chi2PIDBest == 0.) {
          chi2PIDBest = AlgScore.fValue;
          chi2PIDPDG = 13;
        }
      }
      else if (TMath::Abs(AlgScore.fAssumedPdg) == 211) { // chi2pi
        chi2PIDPion = AlgScore.fValue;
        if(AlgScore.fValue < chi2PIDBest || chi2PIDBest == 0.) {
          chi2PIDBest = AlgScore.fValue;
          chi2PIDPDG = 211;
        }
      }
      else if (TMath::Abs(AlgScore.fAssumedPdg) == 321) { // chi2ka
        chi2PIDKaon = AlgScore.fValue;
        if(AlgScore.fValue < chi2PIDBest || chi2PIDBest == 0.) {
          chi2PIDBest = AlgScore.fValue;
          chi2PIDPDG = 321;
        }
      }
      else if (TMath::Abs(AlgScore.fAssumedPdg) == 2212) { // chi2pr
        chi2PIDProton = AlgScore.fValue;
        if(AlgScore.fValue < chi2PIDBest || chi2PIDBest == 0.) {
          chi2PIDBest = AlgScore.fValue;
          chi2PIDPDG = 2212;
        }
      }
    }
  }
  chi2PIDMuonPionDiff = chi2PIDMuon - chi2PIDPion;

  if (!fMakeTree)
    return;

  chi2PIDType = this->PdgString(chi2PIDPDG);

  if (chi2PIDPDG != 321) {
    chi2PIDPDGNoKaon = chi2PIDPDG;
    chi2PIDTypeNoKaon = chi2PIDType;
  } else {
    if (chi2PIDMuon < chi2PIDProton && chi2PIDMuon < chi2PIDPion) {
      chi2PIDPDGNoKaon = 13;
    } else if (chi2PIDPion < chi2PIDProton) {
      chi2PIDPDGNoKaon = 211;
    } else {
      chi2PIDPDGNoKaon = 2212;
    }
    chi2PIDTypeNoKaon = this->PdgString(chi2PIDPDGNoKaon);
  }
}

void sbn::Dazzle::FillClosestApproachMetrics ( const ScatterClosestApproach &  closestApproach )

private

Definition at line 691 of file Dazzle_module.cc.

{
  meanDCA = closestApproach.mean;

  if (!fMakeTree)
    return;

  stdDevDCA = closestApproach.stdDev;
  maxDCA = closestApproach.max;
}

void sbn::Dazzle::FillMCSMetrics ( const recob::MCSFitResult &  mcs )

private

Definition at line 646 of file Dazzle_module.cc.

{
  mcsMuonP = mcs.fwdMomentum();

  if (mcs.scatterAngles().empty())
    return;

  unsigned int counter(0);
  float maxScatter(0), meanScatter(0);
  for (auto const& angle : mcs.scatterAngles()) {
    if (angle < 0)
      continue;
    maxScatter = std::max(maxScatter, angle);
    meanScatter += angle;
    counter++;
  }

  if (!counter)
    return;

  mcsScatterMax = maxScatter;
  mcsScatterMean = meanScatter / counter;
  mcsScatterMaxRatio = maxScatter / meanScatter;
}

void sbn::Dazzle::FillPFPMetrics ( const art::Ptr< recob::PFParticle > &  pfp, const std::map< size_t, art::Ptr< recob::PFParticle >> &  pfpMap, const art::FindManyP< recob::Cluster > &  fmCluster, const art::FindManyP< recob::Hit > &  fmHit, const art::FindManyP< larpandoraobj::PFParticleMetadata > &  fmMeta  )

private

Definition at line 521 of file Dazzle_module.cc.

{
  auto const parentId(pfp->Parent());
  auto const& parentIter(pfpMap.find(parentId));
  if (parentIter != pfpMap.end())
    recoPrimary = parentIter->second->IsPrimary();

  numDaughters = pfp->Daughters().size();
  trackScore = this->GetPFPTrackScore(pfp, fmMeta);

  if (!numDaughters)
    return;

  for (auto const daughterId : pfp->Daughters()) {
    auto const& daughterIter(pfpMap.find(daughterId));
    if (daughterIter == pfpMap.end())
      continue;

    auto const& clusters(fmCluster.at(daughterIter->second.key()));
    int daughterHits(0);
    for (auto const& cluster : clusters) {
      daughterHits += fmHit.at(cluster.key()).size();
    }

    if (daughterHits > maxDaughterHits) {
      maxDaughterHits = daughterHits;
      daughterTrackScore = this->GetPFPTrackScore(daughterIter->second, fmMeta);
    }
  }

  if (!fMakeTree)
    return;

  hierarchyDepth = this->GetPFPHierarchyDepth(pfp, pfpMap);
}

void sbn::Dazzle::FillRangePMetrics ( const RangeP &  range )

private

Definition at line 671 of file Dazzle_module.cc.

{
  rangeMuonP = range.range_p;

  pDiff = (rangeMuonP > 0 && mcsMuonP > 0) ? (mcsMuonP - rangeMuonP) / rangeMuonP : -5.f;
}

void sbn::Dazzle::FillStoppingChi2Metrics ( const StoppingChi2Fit &  stoppingChi2 )

private

Definition at line 702 of file Dazzle_module.cc.

{
  chi2Pol0Chi2 = stoppingChi2.pol0Chi2;
  chi2ExpChi2 = stoppingChi2.expChi2;

  stoppingChi2Ratio = (chi2Pol0Chi2 > 0.f && chi2ExpChi2 > 0.f) ? chi2Pol0Chi2 / chi2ExpChi2 : -5.f;

  if (!fMakeTree)
    return;

  chi2Pol0Fit = stoppingChi2.pol0Fit;
}

void sbn::Dazzle::FillTrackMetrics ( const recob::Track &  track )

private

Definition at line 621 of file Dazzle_module.cc.

{
  recoLen = track.Length();

  const TVector3 start(track.Start<TVector3>());
  const TVector3 end(track.End<TVector3>());
  recoContained = this->InFV(start) && this->InFV(end);

  if (!fMakeTree)
    return;

  startX = start.X();
  startY = start.Y();
  startZ = start.Z();

  endX = end.X();
  endY = end.Y();
  endZ = end.Z();
}

void sbn::Dazzle::FillTrueParticleMetrics ( const detinfo::DetectorClocksData &  clockData, const recob::Track &  track, const std::vector< art::Ptr< recob::Hit >> &  hits, std::vector< art::Ptr< sim::SimChannel >> &  simChannels  )

private

Definition at line 558 of file Dazzle_module.cc.

{
  art::ServiceHandle<cheat::BackTrackerService> bt_serv;
  const int bestMatch(TruthMatchUtils::TrueParticleIDFromTotalTrueEnergy(clockData, hits, true));

  if (!TruthMatchUtils::Valid(bestMatch))
    return;

  float totalHitEnergy(0.f), totalTrueHitEnergy(0.f);
  for (auto const& hit : hits) {
    const std::vector<sim::TrackIDE> trackIDEs(bt_serv->HitToTrackIDEs(clockData, hit));
    totalHitEnergy = std::accumulate(trackIDEs.cbegin(), trackIDEs.cend(), totalHitEnergy,
        [](float sum, auto const& ide) { return sum + ide.energy; });
    totalTrueHitEnergy = std::accumulate(trackIDEs.cbegin(), trackIDEs.cend(), totalTrueHitEnergy,
        [bestMatch](float sum, auto const& ide) { return (std::abs(ide.trackID) == bestMatch) ? sum + ide.energy : sum; });
  }

  const std::vector<const sim::IDE*> trackIDEs(bt_serv->TrackIdToSimIDEs_Ps(bestMatch));
  float totalTrueEnergy(std::accumulate(trackIDEs.cbegin(), trackIDEs.cend(), 0.f,
      [](float sum, auto const& ide) { return sum + ide->energy; }));

  energyComp = totalTrueHitEnergy / totalTrueEnergy;
  energyPurity = totalTrueHitEnergy / totalHitEnergy;

  const simb::MCParticle* const trueParticle(particleInventory->TrackIdToParticle_P(bestMatch));

  if (!trueParticle)
    return;

  truePdg = trueParticle->PdgCode();
  trueType = this->PdgString(truePdg);
  trueEndProcess = trueParticle->EndProcess();

  trueStopping = (int)(trueEndProcess == "CoupledTransportation" || trueEndProcess == "FastScintillation" || trueEndProcess == "Decay" || trueEndProcess == "muMinusCaptureAtRest");

  trueP = trueParticle->P();
  trueEndP = trueParticle->P(trueParticle->NumberTrajectoryPoints() - 2);

  const TVector3 trackStart(track.Start<TVector3>());
  const TVector3 trackEnd(track.End<TVector3>());

  const TVector3 trueStart(trueParticle->Position().Vect());
  const TVector3 trueEnd(trueParticle->EndPosition().Vect());

  trueStartX = trueStart.X();
  trueStartY = trueStart.Y();
  trueStartZ = trueStart.Z();

  trueEndX = trueEnd.X();
  trueEndY = trueEnd.Y();
  trueEndZ = trueEnd.Z();

  truePx = trueParticle->Px() / trueP;
  truePy = trueParticle->Py() / trueP;
  truePz = trueParticle->Pz() / trueP;

  trueThetaXZ = std::atan2(truePx, truePz);
  trueThetaYZ = std::atan2(truePy, truePz);

  startDist = (trueStart - trackStart).Mag();
  endDist = (trueEnd - trackEnd).Mag();
}

unsigned int sbn::Dazzle::GetPFPHierarchyDepth ( const art::Ptr< recob::PFParticle > &  pfp, const std::map< size_t, art::Ptr< recob::PFParticle >> &  pfpMap  ) const

private

Definition at line 819 of file Dazzle_module.cc.

{
  if (pfp->Daughters().empty()) {
    return 1;
  }
  unsigned int maxDepth(0);
  for (auto const daughter : pfp->Daughters()) {
    maxDepth = std::max(maxDepth, this->GetPFPHierarchyDepth(pfpMap.at(daughter), pfpMap));
  }
  return maxDepth + 1;
}

std::map< size_t, art::Ptr< recob::PFParticle > > sbn::Dazzle::GetPFPMap ( std::vector< art::Ptr< recob::PFParticle >> &  pfps ) const

private

Definition at line 810 of file Dazzle_module.cc.

{
  std::map<size_t, art::Ptr<recob::PFParticle>> pfpMap;
  for (auto const& pfp : pfps) {
    pfpMap[pfp->Self()] = pfp;
  }
  return pfpMap;
}

float sbn::Dazzle::GetPFPTrackScore ( const art::Ptr< recob::PFParticle > &  pfp, const art::FindManyP< larpandoraobj::PFParticleMetadata > &  fmMeta  ) const

private

Definition at line 831 of file Dazzle_module.cc.

{
  auto const pfpMetaVec(fmMeta.at(pfp.key()));
  if (pfpMetaVec.size() != 1)
    return -5.f;
  const larpandoraobj::PFParticleMetadata::PropertiesMap propertiesMap(pfpMetaVec.front()->GetPropertiesMap());
  auto const& pfpTrackScoreIter = propertiesMap.find("TrackScore");
  return pfpTrackScoreIter == propertiesMap.end() ? -5.f : pfpTrackScoreIter->second;
}

bool sbn::Dazzle::InFV ( const TVector3 &  pos ) const

private

Definition at line 641 of file Dazzle_module.cc.

{
  return (pos.X() > fXMin && pos.X() < fXMax && pos.Y() > fYMin && pos.Y() < fYMax && pos.Z() > fZMin && pos.Z() < fZMax);
}

Dazzle& sbn::Dazzle::operator= ( Dazzle const &  )

delete

Dazzle& sbn::Dazzle::operator= ( Dazzle &&  )

delete

std::string sbn::Dazzle::PdgString ( const int  pdg ) const

private

Definition at line 841 of file Dazzle_module.cc.

{
  switch (std::abs(pdg)) {
  case 13:
    return "Mu";
  case 211:
    return "Pion";
  case 321:
    return "Kaon";
  case 2212:
    return "Proton";
  default:
    return "Other";
  }
}

void sbn::Dazzle::produce ( art::Event &  e )

override

Definition at line 319 of file Dazzle_module.cc.

{
  auto const clockData(art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e));

  auto const pfpHandle(e.getValidHandle<std::vector<recob::PFParticle>>(fPFPLabel));
  auto const clusterHandle(e.getValidHandle<std::vector<recob::Cluster>>(fPFPLabel));
  auto const simChannelHandle(e.getValidHandle<std::vector<sim::SimChannel>>(fSimChannelLabel));
  auto const trackHandle(e.getValidHandle<std::vector<recob::Track>>(fTrackLabel));

  std::vector<art::Ptr<recob::PFParticle>> pfps;
  art::fill_ptr_vector(pfps, pfpHandle);

  std::vector<art::Ptr<sim::SimChannel>> simChannels;
  art::fill_ptr_vector(simChannels, simChannelHandle);

  art::FindManyP<recob::Cluster> fmPFPCluster(pfpHandle, e, fPFPLabel);
  art::FindManyP<larpandoraobj::PFParticleMetadata> fmPFPMeta(pfpHandle, e, fPFPLabel);
  art::FindManyP<recob::Hit> fmClusterHit(clusterHandle, e, fPFPLabel);

  art::FindManyP<recob::Track> fmPFPTrack(pfpHandle, e, fTrackLabel);
  art::FindManyP<recob::Hit> fmTrackHit(trackHandle, e, fTrackLabel);
  art::FindManyP<anab::Calorimetry> fmTrackCalo(trackHandle, e, fCaloLabel);
  art::FindManyP<recob::MCSFitResult> fmTrackMCS(trackHandle, e, fMCSLabel);
  art::FindManyP<anab::ParticleID> fmTrackChi2(trackHandle, e, fChi2Label);

  // art::FindManyP<LGCFit> fmTrackLGC(trackHandle, e, fLGCLabel);
  art::FindManyP<RangeP> fmTrackRange(trackHandle, e, fRangeLabel);
  art::FindManyP<ScatterClosestApproach> fmTrackClosestApproach(trackHandle, e, fClosestApproachLabel);
  art::FindManyP<StoppingChi2Fit> fmTrackStoppingChi2(trackHandle, e, fStoppingChi2Label);

  auto mvaPIDVec = std::make_unique<std::vector<MVAPID>>();
  auto trackAssns = std::make_unique<art::Assns<recob::Track, MVAPID>>();

  const std::map<size_t, art::Ptr<recob::PFParticle>> pfpMap(this->GetPFPMap(pfps));

  for (auto const& pfp : pfps) {
    this->ClearTreeValues();

    // Get the track for the PFP
    std::vector<art::Ptr<recob::Track>> pfpTrackVec(fmPFPTrack.at(pfp.key()));

    // Skip showers and primaries
    if (pfpTrackVec.empty())
      continue;

    // There should be 1-1 PFP to tracks
    if (pfpTrackVec.size() > 1)
      throw cet::exception("Dazzle") << "Too many tracks: " << pfpTrackVec.size();

    art::Ptr<recob::Track>& pfpTrack(pfpTrackVec.front());

    if (pfpTrack->Length() < fMinTrackLength)
      continue;

    this->FillTrackMetrics(*pfpTrack);

    // // TODO look at in terms of runtime
    // if (!recoContained)
    //   continue;

    // We expect a calo for each plane
    auto const caloVec(fmTrackCalo.at(pfpTrack.key()));
    if (caloVec.size() != 3)
      continue;

    // Fill only for the best plane, defined as the one with the most hits
    // Prefer collection plane > 1st induction > 2nd induction
    const unsigned int maxHits(std::max({ caloVec[0]->dEdx().size(), caloVec[1]->dEdx().size(), caloVec[2]->dEdx().size() }));
    bestPlane = (caloVec[2]->dEdx().size() == maxHits) ? 2 : (caloVec[0]->dEdx().size() == maxHits) ? 0 : (caloVec[1]->dEdx().size() == maxHits) ? 1 : -1;
    bestPlaneHits = maxHits;

    if (bestPlane < 0 || bestPlane > 3)
      throw cet::exception("Dazzle") << "Best plane: " << bestPlane;

    this->FillPFPMetrics(pfp, pfpMap, fmPFPCluster, fmClusterHit, fmPFPMeta);

    // We should have a MCS fit result for muon, proton, pion and kaon hypotheses
    // For now, just consider the muon
    auto const mcsVec(fmTrackMCS.at(pfpTrack.key()));
    if (mcsVec.size() == 1)
      this->FillMCSMetrics(*mcsVec.front());

    // We should have a rangeP fit for muon and proton
    // For now, just consider the muon
    auto const rangeVec(fmTrackRange.at(pfpTrack.key()));
    if (rangeVec.size() == 1)
      this->FillRangePMetrics(*rangeVec.front());

    // We expect a chi2 for each plane
    auto const chi2Vec(fmTrackChi2.at(pfpTrack.key()));
    if (chi2Vec.size() == 3)
      this->FillChi2PIDMetrics(*chi2Vec[bestPlane]);

    // auto const lgcVec(fmTrackLGC.at(pfpTrack.key()));
    // if (lgcVec.size() == 1)
    //   this->FillLGCMetrics(*lgcVec.front());

    auto const closestApproachVec(fmTrackClosestApproach.at(pfpTrack.key()));
    if (closestApproachVec.size() == 1)
      this->FillClosestApproachMetrics(*closestApproachVec.front());

    auto const stoppingChi2Vec(fmTrackStoppingChi2.at(pfpTrack.key()));
    if (stoppingChi2Vec.size() == 1)
      this->FillStoppingChi2Metrics(*stoppingChi2Vec.front());

    if (fRunMVA) {
      MVAPID mvaPID(this->RunMVA());
      mvaPIDVec->push_back(mvaPID);
      util::CreateAssn(*this, e, *mvaPIDVec, pfpTrack, *trackAssns);
    }

    // Only fill the truth metrics if we are saving a TTree
    if (fMakeTree) {
      std::vector<art::Ptr<recob::Hit>> trackHitVec(fmTrackHit.at(pfpTrack.key()));
      numHits = trackHitVec.size();
      this->FillTrueParticleMetrics(clockData, *pfpTrack, trackHitVec, simChannels);
      trackTree->Fill();
    }
  }
  e.put(std::move(mvaPIDVec));
  e.put(std::move(trackAssns));
}

MVAPID sbn::Dazzle::RunMVA ( )

private

Definition at line 715 of file Dazzle_module.cc.

{
  const std::vector<float> mvaScores(reader->EvaluateMulticlass(fMethodName));

  MVAPID pidResults;

  pidResults.AddScore(13, mvaScores.at(0));
  pidResults.AddScore(211, mvaScores.at(1));
  pidResults.AddScore(2212, mvaScores.at(2));
  pidResults.AddScore(0, mvaScores.at(3));

  if (!fMakeTree)
    return pidResults;

  muonScore = mvaScores.at(0);
  pionScore = mvaScores.at(1);
  protonScore = mvaScores.at(2);
  otherScore = mvaScores.at(3);

  bestScore = pidResults.BestScore();
  bestPDG = pidResults.BestPDG();

  return pidResults;
}

Member Data Documentation

int sbn::Dazzle::bestPDG

private

Definition at line 119 of file Dazzle_module.cc.

int sbn::Dazzle::bestPlane

private

Definition at line 125 of file Dazzle_module.cc.

int sbn::Dazzle::bestPlaneHits

private

Definition at line 125 of file Dazzle_module.cc.

float sbn::Dazzle::bestScore

private

Definition at line 118 of file Dazzle_module.cc.

float sbn::Dazzle::chi2ExpChi2

private

Definition at line 128 of file Dazzle_module.cc.

float sbn::Dazzle::chi2PIDKaon

private

Definition at line 127 of file Dazzle_module.cc.

float sbn::Dazzle::chi2PIDMuon

private

Definition at line 103 of file Dazzle_module.cc.

float sbn::Dazzle::chi2PIDMuonPionDiff

private

Definition at line 105 of file Dazzle_module.cc.

int sbn::Dazzle::chi2PIDPDG

private

Definition at line 125 of file Dazzle_module.cc.

int sbn::Dazzle::chi2PIDPDGNoKaon

private

Definition at line 125 of file Dazzle_module.cc.

float sbn::Dazzle::chi2PIDPion

private

Definition at line 127 of file Dazzle_module.cc.

float sbn::Dazzle::chi2PIDProton

private

Definition at line 103 of file Dazzle_module.cc.

std::string sbn::Dazzle::chi2PIDType

private

Definition at line 135 of file Dazzle_module.cc.

std::string sbn::Dazzle::chi2PIDTypeNoKaon

private

Definition at line 135 of file Dazzle_module.cc.

float sbn::Dazzle::chi2Pol0Chi2

private

Definition at line 128 of file Dazzle_module.cc.

float sbn::Dazzle::chi2Pol0Fit

private

Definition at line 112 of file Dazzle_module.cc.

float sbn::Dazzle::daughterTrackScore

private

Definition at line 132 of file Dazzle_module.cc.

float sbn::Dazzle::endDist

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::endX

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::endY

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::endZ

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::energyComp

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::energyPurity

private

Definition at line 133 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fCaloLabel

private

Definition at line 93 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fChi2Label

private

Definition at line 93 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fClosestApproachLabel

private

Definition at line 93 of file Dazzle_module.cc.

const bool sbn::Dazzle::fMakeTree

private

Definition at line 95 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fMCSLabel

private

Definition at line 93 of file Dazzle_module.cc.

const std::string sbn::Dazzle::fMethodName

private

Definition at line 96 of file Dazzle_module.cc.

const float sbn::Dazzle::fMinTrackLength

private

Definition at line 94 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fPFPLabel

private

Definition at line 93 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fRangeLabel

private

Definition at line 93 of file Dazzle_module.cc.

const bool sbn::Dazzle::fRunMVA

private

Definition at line 95 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fSimChannelLabel

private

Definition at line 93 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fStoppingChi2Label

private

Definition at line 93 of file Dazzle_module.cc.

art::InputTag sbn::Dazzle::fTrackLabel

private

Definition at line 93 of file Dazzle_module.cc.

const std::string sbn::Dazzle::fWeightFile

private

Definition at line 96 of file Dazzle_module.cc.

const float sbn::Dazzle::fXMax

private

Definition at line 99 of file Dazzle_module.cc.

const float sbn::Dazzle::fXMin

private

Definition at line 99 of file Dazzle_module.cc.

const float sbn::Dazzle::fYMax

private

Definition at line 99 of file Dazzle_module.cc.

const float sbn::Dazzle::fYMin

private

Definition at line 99 of file Dazzle_module.cc.

const float sbn::Dazzle::fZMax

private

Definition at line 99 of file Dazzle_module.cc.

const float sbn::Dazzle::fZMin

private

Definition at line 99 of file Dazzle_module.cc.

int sbn::Dazzle::hierarchyDepth

private

Definition at line 125 of file Dazzle_module.cc.

float sbn::Dazzle::maxDaughterHits

private

Definition at line 115 of file Dazzle_module.cc.

float sbn::Dazzle::maxDCA

private

Definition at line 130 of file Dazzle_module.cc.

float sbn::Dazzle::mcsMuonP

private

Definition at line 131 of file Dazzle_module.cc.

float sbn::Dazzle::mcsScatterMax

private

Definition at line 131 of file Dazzle_module.cc.

float sbn::Dazzle::mcsScatterMaxRatio

private

Definition at line 107 of file Dazzle_module.cc.

float sbn::Dazzle::mcsScatterMean

private

Definition at line 107 of file Dazzle_module.cc.

float sbn::Dazzle::meanDCA

private

Definition at line 108 of file Dazzle_module.cc.

float sbn::Dazzle::muonScore

private

Definition at line 118 of file Dazzle_module.cc.

float sbn::Dazzle::numDaughters

private

Definition at line 115 of file Dazzle_module.cc.

int sbn::Dazzle::numHits

private

Definition at line 125 of file Dazzle_module.cc.

float sbn::Dazzle::otherScore

private

Definition at line 118 of file Dazzle_module.cc.

art::ServiceHandle<cheat::ParticleInventoryService> sbn::Dazzle::particleInventory

private

Definition at line 91 of file Dazzle_module.cc.

float sbn::Dazzle::pDiff

private

Definition at line 113 of file Dazzle_module.cc.

float sbn::Dazzle::pionScore

private

Definition at line 118 of file Dazzle_module.cc.

float sbn::Dazzle::protonScore

private

Definition at line 118 of file Dazzle_module.cc.

float sbn::Dazzle::rangeMuonP

private

Definition at line 131 of file Dazzle_module.cc.

TMVA::Reader* sbn::Dazzle::reader

private

Definition at line 122 of file Dazzle_module.cc.

int sbn::Dazzle::recoContained

private

Definition at line 125 of file Dazzle_module.cc.

float sbn::Dazzle::recoLen

private

Definition at line 102 of file Dazzle_module.cc.

int sbn::Dazzle::recoPrimary

private

Definition at line 125 of file Dazzle_module.cc.

float sbn::Dazzle::startDist

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::startX

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::startY

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::startZ

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::stdDevDCA

private

Definition at line 130 of file Dazzle_module.cc.

float sbn::Dazzle::stoppingChi2Ratio

private

Definition at line 109 of file Dazzle_module.cc.

art::ServiceHandle<art::TFileService> sbn::Dazzle::tfs

private

Definition at line 90 of file Dazzle_module.cc.

float sbn::Dazzle::trackScore

private

Definition at line 132 of file Dazzle_module.cc.

TTree* sbn::Dazzle::trackTree

private

Definition at line 123 of file Dazzle_module.cc.

float sbn::Dazzle::trueEndP

private

Definition at line 133 of file Dazzle_module.cc.

std::string sbn::Dazzle::trueEndProcess

private

Definition at line 135 of file Dazzle_module.cc.

float sbn::Dazzle::trueEndX

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::trueEndY

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::trueEndZ

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::trueP

private

Definition at line 133 of file Dazzle_module.cc.

int sbn::Dazzle::truePdg

private

Definition at line 125 of file Dazzle_module.cc.

float sbn::Dazzle::truePx

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::truePy

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::truePz

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::trueStartX

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::trueStartY

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::trueStartZ

private

Definition at line 133 of file Dazzle_module.cc.

int sbn::Dazzle::trueStopping

private

Definition at line 125 of file Dazzle_module.cc.

float sbn::Dazzle::trueThetaXZ

private

Definition at line 133 of file Dazzle_module.cc.

float sbn::Dazzle::trueThetaYZ

private

Definition at line 133 of file Dazzle_module.cc.

std::string sbn::Dazzle::trueType

private

Definition at line 135 of file Dazzle_module.cc.

---

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

• Dazzle_module.cc