ClusteringValidation::ClusterAnalyser Class Reference

Public Member Functions
	ClusterAnalyser (std::string &label)
void	Analyse (detinfo::DetectorClocksData const &clockData, std::vector< art::Ptr< recob::Hit >> &hits, std::vector< art::Ptr< recob::Cluster >> &clusters, const art::FindManyP< recob::Hit > &fmh, int numHits)
TrackID	FindTrackID (detinfo::DetectorClocksData const &clockData, art::Ptr< recob::Hit > &hit)
TrackID	FindTrueTrack (detinfo::DetectorClocksData const &clockData, std::vector< art::Ptr< recob::Hit >> &clusterHits)
double	FindPhotonAngle ()
double	GetEndTrackDistance (TrackID id1, TrackID id2)
const simb::MCParticle *	GetPi0 ()
TObjArray	GetHistograms ()
void	MakeHistograms ()
void	WriteFile ()

Private Attributes
std::string	fClusterLabel
TH1 *	hCompleteness
TH1 *	hCleanliness
TH1 *	hComplCleanl
TH1 *	hPi0Angle
TH1 *	hPi0Energy
TH1 *	hPi0ConversionDistance
TH1 *	hPi0ConversionSeparation
TH1 *	hPi0AngleCut
TH1 *	hPi0EnergyCut
TH1 *	hPi0ConversionDistanceCut
TH1 *	hPi0ConversionSeparationCut
TH2 *	hNumHitsCompleteness
TH2 *	hNumHitsEnergy
TProfile *	hCompletenessEnergy
TProfile *	hCompletenessAngle
TProfile *	hCompletenessConversionDistance
TProfile *	hCompletenessConversionSeparation
TProfile *	hCleanlinessEnergy
TProfile *	hCleanlinessAngle
TProfile *	hCleanlinessConversionDistance
TProfile *	hCleanlinessConversionSeparation
TProfile *	hComplCleanlEnergy
TProfile *	hComplCleanlAngle
TProfile *	hComplCleanlConversionDistance
TProfile *	hComplCleanlConversionSeparation
TEfficiency *	hEfficiencyAngle
TEfficiency *	hEfficiencyEnergy
TEfficiency *	hEfficiencyConversionDistance
TEfficiency *	hEfficiencyConversionSeparation
TObjArray	fHistArray
std::map< unsigned int, std::map< unsigned int, std::unique_ptr< ClusterCounter > > >	clusterMap
std::map< TrackID, const simb::MCParticle * >	trueParticles
geo::WireReadoutGeom const &	wireReadoutGeom = art::ServiceHandle<geo::WireReadout>()->Get()
art::ServiceHandle< cheat::ParticleInventoryService const >	pi_serv
art::ServiceHandle< cheat::BackTrackerService const >	bt_serv

Detailed Description

Definition at line 214 of file ClusteringValidation_module.cc.

Constructor & Destructor Documentation

ClusteringValidation::ClusterAnalyser::ClusterAnalyser ( std::string &  label )

explicit

Definition at line 278 of file ClusteringValidation_module.cc.

{

  fClusterLabel = clusterLabel;

  // Make the histograms
  hCompleteness = new TH1D("Completeness", ";Completeness;", 101, 0, 1.01);
  hCompletenessEnergy =
    new TProfile("CompletenessEnergy", ";True Energy (GeV);Completeness", 100, 0, 2);
  hCompletenessAngle =
    new TProfile("CompletenessAngle", ";True Angle (deg);Completeness;", 100, 0, 180);
  hCompletenessConversionDistance = new TProfile(
    "CompletenessConversionDistance", ";True Distance from Vertex (cm);Completeness", 100, 0, 200);
  hCompletenessConversionSeparation = new TProfile("CompletenessConversionSeparation",
                                                   ";True Conversion Separation (cm);Completeness",
                                                   100,
                                                   0,
                                                   200);
  hCleanliness = new TH1D("Cleanliness", ";Cleanliness;", 101, 0, 1.01);
  hCleanlinessEnergy =
    new TProfile("CleanlinessEnergy", ";True Energy (GeV);Cleanliness", 100, 0, 2);
  hCleanlinessAngle =
    new TProfile("CleanlinessAngle", ";True Angle (deg);Cleanliness;", 100, 0, 180);
  hCleanlinessConversionDistance = new TProfile(
    "CleanlinessConversionDistance", ";True Distance from Vertex (cm);Cleanliness", 100, 0, 200);
  hCleanlinessConversionSeparation = new TProfile(
    "CleanlinessConversionSeparation", ";True Conversion Separation (cm);Cleanliness", 100, 0, 200);
  hComplCleanl = new TH1D("CompletenessCleanliness", ";Completeness * Cleanliness;", 101, 0, 1.01);
  hComplCleanlEnergy = new TProfile(
    "CompletenessCleanlinessEnergy", ";True Energy (GeV);Completeness * Cleanliness", 100, 0, 2);
  hComplCleanlAngle = new TProfile(
    "CompletenessCleanlinessAngle", ";True Angle (deg);Completeness * Cleanliness;", 100, 0, 180);
  hComplCleanlConversionDistance =
    new TProfile("CompletenessCleanlinessConversionDistance",
                 ";True Distance from Vertex (cm);Completeness * Cleanliness",
                 100,
                 0,
                 200);
  hComplCleanlConversionSeparation =
    new TProfile("CompletenessCleanlinessConversionSeparation",
                 ";True Conversion Separation (cm);Completeness * Cleanliness",
                 100,
                 0,
                 200);
  hPi0Energy = new TH1D("Pi0EnergyCut", ";True Energy (GeV);", 25, 0, 2);
  hPi0Energy->Sumw2();
  hPi0Angle = new TH1D("Pi0AngleCut", ";True Angle (deg);", 25, 0, 180);
  hPi0Angle->Sumw2();
  hPi0ConversionDistance =
    new TH1D("Pi0ConversionDistanceCut", ";True Distance from Vertex (cm);", 25, 0, 200);
  hPi0ConversionDistance->Sumw2();
  hPi0ConversionSeparation =
    new TH1D("Pi0ConversionSeparationCut", ";True Separation from Vertex (cm);", 25, 0, 200);
  hPi0ConversionSeparation->Sumw2();
  hPi0EnergyCut = new TH1D("Pi0EnergyCut", ";True Energy (GeV);Efficiency", 25, 0, 2);
  hPi0EnergyCut->Sumw2();
  hPi0AngleCut = new TH1D("Pi0AngleCut", ";True Angle (deg);Efficiency", 25, 0, 180);
  hPi0AngleCut->Sumw2();
  hPi0ConversionDistanceCut =
    new TH1D("Pi0ConversionDistanceCut", ";True Distance from Vertex (cm);Efficiency", 25, 0, 200);
  hPi0ConversionDistanceCut->Sumw2();
  hPi0ConversionSeparationCut = new TH1D(
    "Pi0ConversionSeparationCut", ";True Separation from Vertex (cm);Efficiency", 25, 0, 200);
  hPi0ConversionSeparationCut->Sumw2();
  hNumHitsCompleteness =
    new TH2D("NumHitsCompleteness", ";Completeness;Size of Cluster", 101, 0, 1.01, 100, 0, 100);
  hNumHitsEnergy =
    new TH2D("NumHitsEnergy", ";True Energy (GeV);Size of Cluster", 100, 0, 2, 100, 0, 100);
}

Member Function Documentation

void ClusteringValidation::ClusterAnalyser::Analyse	(	detinfo::DetectorClocksData const &	clockData,
		std::vector< art::Ptr< recob::Hit >> &	hits,
		std::vector< art::Ptr< recob::Cluster >> &	clusters,
		const art::FindManyP< recob::Hit > &	fmh,
		int	numHits
	)

Definition at line 348 of file ClusteringValidation_module.cc.

References sim::ParticleList::begin(), sim::ParticleList::end(), hits(), sim::ParticleList::ParticleList(), geo::PlaneID::Plane, geo::TPCID::TPC, simb::MCParticle::TrackId(), lar::dump::vector(), and recob::Hit::WireID().

{

  // Make a map of cluster counters in TPC/plane space
  for (auto const& id : wireReadoutGeom.Iterate<geo::PlaneID>(geo::CryostatID{0})) {
    auto const [tpc, plane] = std::make_tuple(id.TPC, id.Plane);
    clusterMap[tpc][plane] = std::make_unique<ClusterCounter>();
  }

  // Save preclustered hits
  for (size_t hitIt = 0; hitIt < hits.size(); ++hitIt) {
    art::Ptr<recob::Hit> hit = hits.at(hitIt);
    TrackID trackID = FindTrackID(clockData, hit);
    clusterMap[hit->WireID().TPC % 2][hit->WireID().Plane]->AddHitPreClustering(trackID);
  }

  // Save true tracks
  trueParticles.clear();
  const sim::ParticleList& particles = pi_serv->ParticleList();
  for (sim::ParticleList::const_iterator particleIt = particles.begin();
       particleIt != particles.end();
       ++particleIt) {
    const simb::MCParticle* particle = particleIt->second;
    trueParticles[(TrackID)particle->TrackId()] = particle;
  }

  // Save the clustered hits
  for (size_t clusIt = 0; clusIt < clusters.size(); ++clusIt) {

    // Get cluster information
    unsigned int tpc = clusters.at(clusIt)->Plane().TPC % 2;
    unsigned int plane = clusters.at(clusIt)->Plane().Plane;
    ClusterID id = (ClusterID)clusters.at(clusIt)->ID();

    // Only analyse planes with enough hits in to fairly represent the clustering
    if (clusterMap[tpc][plane]->GetNumberHitsInPlane() < minHits) continue;

    // Get the hits from the cluster
    std::vector<art::Ptr<recob::Hit>> clusterHits = fmh.at(clusIt);

    if (clusterHits.size() < 10) continue;

    // Find which track this cluster belongs to
    TrackID trueTrackID = FindTrueTrack(clockData, clusterHits);

    // Save the info for this cluster
    clusterMap[tpc][plane]->AssociateClusterAndTrack(id, trueTrackID);
    for (std::vector<art::Ptr<recob::Hit>>::iterator clusHitIt = clusterHits.begin();
         clusHitIt != clusterHits.end();
         ++clusHitIt) {
      art::Ptr<recob::Hit> hit = *clusHitIt;
      TrackID trackID = FindTrackID(clockData, hit);
      if (trackID == trueTrackID)
        clusterMap[tpc][plane]->AddSignalHitPostClustering(id);
      else
        clusterMap[tpc][plane]->AddNoiseHitPostClustering(id);
    }
  }

  this->MakeHistograms();
}

double ClusteringValidation::ClusterAnalyser::FindPhotonAngle

(

)

Definition at line 454 of file ClusteringValidation_module.cc.

References simb::MCParticle::Daughter(), and simb::MCParticle::NumberDaughters().

{
  const simb::MCParticle* pi0 = GetPi0();
  if (pi0->NumberDaughters() != 2) return -999;
  double angle = (trueParticles.at((TrackID)pi0->Daughter(0))
                    ->Momentum()
                    .Angle(trueParticles.at((TrackID)pi0->Daughter(1))->Momentum().Vect()) *
                  (180 / TMath::Pi()));
  return angle;
}

TrackID ClusteringValidation::ClusterAnalyser::FindTrackID	(	detinfo::DetectorClocksData const &	clockData,
		art::Ptr< recob::Hit > &	hit
	)

Definition at line 414 of file ClusteringValidation_module.cc.

{
  double particleEnergy = 0;
  TrackID likelyTrackID = (TrackID)0;
  std::vector<sim::TrackIDE> trackIDs = bt_serv->HitToTrackIDEs(clockData, hit);
  for (unsigned int idIt = 0; idIt < trackIDs.size(); ++idIt) {
    if (trackIDs.at(idIt).energy > particleEnergy) {
      particleEnergy = trackIDs.at(idIt).energy;
      likelyTrackID = (TrackID)TMath::Abs(trackIDs.at(idIt).trackID);
    }
  }
  return likelyTrackID;
}

TrackID ClusteringValidation::ClusterAnalyser::FindTrueTrack	(	detinfo::DetectorClocksData const &	clockData,
		std::vector< art::Ptr< recob::Hit >> &	clusterHits
	)

Definition at line 430 of file ClusteringValidation_module.cc.

References recob::Hit::Integral(), and lar::dump::vector().

{
  std::map<TrackID, double> trackMap;
  for (std::vector<art::Ptr<recob::Hit>>::iterator clusHitIt = clusterHits.begin();
       clusHitIt != clusterHits.end();
       ++clusHitIt) {
    art::Ptr<recob::Hit> hit = *clusHitIt;
    TrackID trackID = FindTrackID(clockData, hit);
    trackMap[trackID] += hit->Integral();
  }
  //return std::max_element(trackMap.begin(), trackMap.end(), [](const std::pair<int,double>& p1, const std::pair<int,double>& p2) {return p1.second < p2.second;} )->first;
  double highestCharge = 0;
  TrackID clusterTrack = (TrackID)0;
  for (std::map<TrackID, double>::iterator trackIt = trackMap.begin(); trackIt != trackMap.end();
       ++trackIt)
    if (trackIt->second > highestCharge) {
      highestCharge = trackIt->second;
      clusterTrack = trackIt->first;
    }
  return clusterTrack;
}

double ClusteringValidation::ClusterAnalyser::GetEndTrackDistance	(	TrackID	id1,
		TrackID	id2
	)

Definition at line 475 of file ClusteringValidation_module.cc.

{
  return TMath::Sqrt(
    TMath::Power(
      trueParticles.at(id1)->EndPosition().X() - trueParticles.at(id2)->EndPosition().X(), 2) +
    TMath::Power(
      trueParticles.at(id1)->EndPosition().Y() - trueParticles.at(id2)->EndPosition().Y(), 2) +
    TMath::Power(
      trueParticles.at(id1)->EndPosition().Z() - trueParticles.at(id2)->EndPosition().Z(), 2));
}

TObjArray ClusteringValidation::ClusterAnalyser::GetHistograms

(

)

Definition at line 486 of file ClusteringValidation_module.cc.

{

  // Make efficiency histograms
  hEfficiencyEnergy = new TEfficiency(*hPi0EnergyCut, *hPi0Energy);
  hEfficiencyAngle = new TEfficiency(*hPi0AngleCut, *hPi0Angle);
  hEfficiencyConversionDistance =
    new TEfficiency(*hPi0ConversionDistanceCut, *hPi0ConversionDistance);
  hEfficiencyConversionSeparation =
    new TEfficiency(*hPi0ConversionSeparationCut, *hPi0ConversionSeparation);

  hEfficiencyEnergy->SetName("EfficiencyEnergy");
  hEfficiencyAngle->SetName("EnergyAngle");
  hEfficiencyConversionDistance->SetName("EfficiencyConversionDistance");
  hEfficiencyConversionSeparation->SetName("EfficiencyConversionSeparation");

  // Add all the histograms to the object array
  fHistArray.Add(hCompleteness);
  fHistArray.Add(hCompletenessEnergy);
  fHistArray.Add(hCompletenessAngle);
  fHistArray.Add(hCompletenessConversionDistance);
  fHistArray.Add(hCompletenessConversionSeparation);
  fHistArray.Add(hCleanliness);
  fHistArray.Add(hCleanlinessEnergy);
  fHistArray.Add(hCleanlinessAngle);
  fHistArray.Add(hCleanlinessConversionDistance);
  fHistArray.Add(hCleanlinessConversionSeparation);
  fHistArray.Add(hComplCleanl);
  fHistArray.Add(hComplCleanlEnergy);
  fHistArray.Add(hComplCleanlAngle);
  fHistArray.Add(hComplCleanlConversionDistance);
  fHistArray.Add(hComplCleanlConversionSeparation);
  fHistArray.Add(hEfficiencyEnergy);
  fHistArray.Add(hEfficiencyAngle);
  fHistArray.Add(hEfficiencyConversionDistance);
  fHistArray.Add(hEfficiencyConversionSeparation);
  fHistArray.Add(hNumHitsCompleteness);
  fHistArray.Add(hNumHitsEnergy);

  return fHistArray;
}

const simb::MCParticle * ClusteringValidation::ClusterAnalyser::GetPi0

(

)

Definition at line 465 of file ClusteringValidation_module.cc.

{
  const simb::MCParticle* pi0 = nullptr;
  for (std::map<TrackID, const simb::MCParticle*>::iterator particleIt = trueParticles.begin();
       particleIt != trueParticles.end();
       ++particleIt)
    if (particleIt->second->PdgCode() == 111) pi0 = particleIt->second;
  return pi0;
}

void ClusteringValidation::ClusterAnalyser::MakeHistograms

(

)

Definition at line 528 of file ClusteringValidation_module.cc.

References util::counter(), and E.

{

  // Loop over the tpcs and planes in the geometry
  for (auto const& id : wireReadoutGeom.Iterate<geo::PlaneID>(geo::CryostatID{0})) {
    auto const [tpc, plane] = std::make_tuple(id.TPC, id.Plane);
    auto& counter = clusterMap[tpc][plane];
    ClusterIDs clusterIDs = counter->GetListOfClusterIDs();

    // Fill histograms for the efficiency
    if (counter->GetPhotons().size() == 2) {
      hPi0Angle->Fill(FindPhotonAngle());
      hPi0Energy->Fill(GetPi0()->Momentum().E());
      hPi0ConversionDistance->Fill(std::min(
        GetEndTrackDistance(counter->GetPhotons().at(0).first, (TrackID)GetPi0()->TrackId()),
        GetEndTrackDistance(counter->GetPhotons().at(1).first, (TrackID)GetPi0()->TrackId())));
      hPi0ConversionSeparation->Fill(
        GetEndTrackDistance(counter->GetPhotons().at(0).first, counter->GetPhotons().at(1).first));
      if (counter->PassesCut()) {
        hPi0AngleCut->Fill(FindPhotonAngle());
        hPi0EnergyCut->Fill(GetPi0()->Momentum().E());
        hPi0ConversionDistanceCut->Fill(std::min(
          GetEndTrackDistance(counter->GetPhotons().at(0).first, (TrackID)GetPi0()->TrackId()),
          GetEndTrackDistance(counter->GetPhotons().at(1).first, (TrackID)GetPi0()->TrackId())));
        hPi0ConversionSeparationCut->Fill(GetEndTrackDistance(counter->GetPhotons().at(0).first,
                                                              counter->GetPhotons().at(1).first));
      }
      else
        std::cout << "TPC " << tpc << ", Plane " << plane << " fails the cut" << std::endl;
    }

    // Look at all the clusters
    for (unsigned int cluster = 0; cluster < clusterIDs.size(); ++cluster) {

      ClusterID clusID = clusterIDs.at(cluster);
      double completeness = counter->GetCompleteness(clusID);
      double cleanliness = counter->GetCleanliness(clusID);
      int numClusterHits = counter->GetNumberHitsInCluster(clusID);

      // Fill histograms for this cluster
      hCompleteness->Fill(completeness, numClusterHits);
      hCleanliness->Fill(cleanliness, numClusterHits);
      hComplCleanl->Fill(completeness * cleanliness, numClusterHits);
      hNumHitsCompleteness->Fill(completeness, numClusterHits);

      // Is this cluster doesn't correspond to a true particle continue
      if (counter->IsNoise(clusID)) continue;

      double pi0Energy = GetPi0()->Momentum().E();
      double pi0DecayAngle = FindPhotonAngle();
      double conversionDistance =
        GetEndTrackDistance(counter->GetTrack(clusID), (TrackID)GetPi0()->TrackId());

      hCompletenessEnergy->Fill(pi0Energy, completeness, numClusterHits);
      hCompletenessAngle->Fill(pi0DecayAngle, completeness, numClusterHits);
      hCompletenessConversionDistance->Fill(conversionDistance, completeness, numClusterHits);
      hCleanlinessEnergy->Fill(pi0Energy, cleanliness, numClusterHits);
      hCleanlinessAngle->Fill(pi0DecayAngle, cleanliness, numClusterHits);
      hCleanlinessConversionDistance->Fill(conversionDistance, cleanliness, numClusterHits);
      hComplCleanlEnergy->Fill(pi0Energy, cleanliness * completeness, numClusterHits);
      hComplCleanlAngle->Fill(pi0DecayAngle, cleanliness * completeness, numClusterHits);
      hComplCleanlConversionDistance->Fill(
        conversionDistance, cleanliness * completeness, numClusterHits);
      hNumHitsEnergy->Fill(pi0Energy, numClusterHits);

      // Continue if there are not two photons in the view
      if (counter->GetPhotons().size() != 2) continue;

      double conversionSeparation =
        GetEndTrackDistance(counter->GetPhotons()[0].first, counter->GetPhotons()[1].first);

      hCompletenessConversionSeparation->Fill(conversionSeparation, completeness, numClusterHits);
      hCleanlinessConversionSeparation->Fill(conversionSeparation, cleanliness, numClusterHits);
    }
  }
}

void ClusteringValidation::ClusterAnalyser::WriteFile

(

)

Definition at line 605 of file ClusteringValidation_module.cc.

{

  // Average completeness/cleanliness
  double avCompleteness = hCompleteness->GetMean();
  double avCleanliness = hCleanliness->GetMean();

  // Write file
  std::ofstream outFile("effpur");
  outFile << avCompleteness << " " << avCleanliness;
  outFile.close();
}

Member Data Documentation

art::ServiceHandle<cheat::BackTrackerService const> ClusteringValidation::ClusterAnalyser::bt_serv

private

Definition at line 275 of file ClusteringValidation_module.cc.

std::map<unsigned int, std::map<unsigned int, std::unique_ptr<ClusterCounter> > > ClusteringValidation::ClusterAnalyser::clusterMap

private

Definition at line 269 of file ClusteringValidation_module.cc.

std::string ClusteringValidation::ClusterAnalyser::fClusterLabel

private

Definition at line 235 of file ClusteringValidation_module.cc.

TObjArray ClusteringValidation::ClusterAnalyser::fHistArray

private

Definition at line 267 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hCleanliness

private

Definition at line 239 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCleanlinessAngle

private

Definition at line 256 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCleanlinessConversionDistance

private

Definition at line 257 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCleanlinessConversionSeparation

private

Definition at line 258 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCleanlinessEnergy

private

Definition at line 255 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hComplCleanl

private

Definition at line 240 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hComplCleanlAngle

private

Definition at line 260 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hComplCleanlConversionDistance

private

Definition at line 261 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hComplCleanlConversionSeparation

private

Definition at line 262 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hComplCleanlEnergy

private

Definition at line 259 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hCompleteness

private

Definition at line 238 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCompletenessAngle

private

Definition at line 252 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCompletenessConversionDistance

private

Definition at line 253 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCompletenessConversionSeparation

private

Definition at line 254 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCompletenessEnergy

private

Definition at line 251 of file ClusteringValidation_module.cc.

TEfficiency* ClusteringValidation::ClusterAnalyser::hEfficiencyAngle

private

Definition at line 263 of file ClusteringValidation_module.cc.

TEfficiency* ClusteringValidation::ClusterAnalyser::hEfficiencyConversionDistance

private

Definition at line 265 of file ClusteringValidation_module.cc.

TEfficiency* ClusteringValidation::ClusterAnalyser::hEfficiencyConversionSeparation

private

Definition at line 266 of file ClusteringValidation_module.cc.

TEfficiency* ClusteringValidation::ClusterAnalyser::hEfficiencyEnergy

private

Definition at line 264 of file ClusteringValidation_module.cc.

TH2* ClusteringValidation::ClusterAnalyser::hNumHitsCompleteness

private

Definition at line 249 of file ClusteringValidation_module.cc.

TH2* ClusteringValidation::ClusterAnalyser::hNumHitsEnergy

private

Definition at line 250 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0Angle

private

Definition at line 241 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0AngleCut

private

Definition at line 245 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0ConversionDistance

private

Definition at line 243 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0ConversionDistanceCut

private

Definition at line 247 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0ConversionSeparation

private

Definition at line 244 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0ConversionSeparationCut

private

Definition at line 248 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0Energy

private

Definition at line 242 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0EnergyCut

private

Definition at line 246 of file ClusteringValidation_module.cc.

art::ServiceHandle<cheat::ParticleInventoryService const> ClusteringValidation::ClusterAnalyser::pi_serv

private

Definition at line 274 of file ClusteringValidation_module.cc.

std::map<TrackID, const simb::MCParticle*> ClusteringValidation::ClusterAnalyser::trueParticles

private

Definition at line 270 of file ClusteringValidation_module.cc.

geo::WireReadoutGeom const& ClusteringValidation::ClusterAnalyser::wireReadoutGeom = art::ServiceHandle<geo::WireReadout>()->Get()

private

Definition at line 273 of file ClusteringValidation_module.cc.

---

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

• larreco/v10_01_07/source/larreco/ClusterFinder/ClusteringValidation_module.cc