ClusteringValidation::ClusterAnalyser Class Reference

Public Member Functions
	ClusterAnalyser (std::string &label)
void	Analyse (std::vector< art::Ptr< recob::Hit > > &hits, std::vector< art::Ptr< recob::Cluster > > &clusters, const art::FindManyP< recob::Hit > &fmh, int numHits)
TrackID	FindTrackID (art::Ptr< recob::Hit > &hit)
TrackID	FindTrueTrack (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
art::ServiceHandle< geo::Geometry >	geometry
art::ServiceHandle< cheat::ParticleInventoryService >	pi_serv
art::ServiceHandle< cheat::BackTrackerService >	bt_serv

Detailed Description

Definition at line 173 of file ClusteringValidation_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 213 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	(	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 246 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 (unsigned int tpc = 0; tpc < geometry->NTPC(0); ++tpc) {
    for (unsigned int plane = 0; plane < geometry->Nplanes(tpc,0); ++plane) {
      clusterMap[tpc][plane] = (std::unique_ptr<ClusterCounter>) new ClusterCounter(tpc, plane);
    }
  }

  // Save preclustered hits
  for (size_t hitIt = 0; hitIt < hits.size(); ++hitIt) {
    art::Ptr<recob::Hit> hit = hits.at(hitIt);
    TrackID trackID = FindTrackID(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(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(hit);
      if (trackID == trueTrackID) clusterMap[tpc][plane]->AddSignalHitPostClustering(id);
      else                        clusterMap[tpc][plane]->AddNoiseHitPostClustering (id);
    }
  }

  this->MakeHistograms();

}

double ClusteringValidation::ClusterAnalyser::FindPhotonAngle

(

)

Definition at line 334 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

(

art::Ptr< recob::Hit > &

hit

)

Definition at line 303 of file ClusteringValidation_module.cc.

                                                                              {
  double particleEnergy = 0;
  TrackID likelyTrackID = (TrackID)0;
  std::vector<sim::TrackIDE> trackIDs = bt_serv->HitToTrackIDEs(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

(

std::vector< art::Ptr< recob::Hit > > &

clusterHits

)

Definition at line 316 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(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 349 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 355 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 341 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 378 of file ClusteringValidation_module.cc.

References E, and min.

                                                         {

  // Loop over the tpcs and planes in the geometry
  for (unsigned int tpc = 0; tpc < geometry->NTPC(0); ++tpc) {
    for (unsigned int plane = 0; plane < geometry->Nplanes(tpc,0); ++plane) {

      ClusterIDs clusterIDs = clusterMap[tpc][plane]->GetListOfClusterIDs();

      // Fill histograms for the efficiency
      if (clusterMap[tpc][plane]->GetPhotons().size() == 2) {
        hPi0Angle               ->Fill(FindPhotonAngle());
        hPi0Energy              ->Fill(GetPi0()->Momentum().E());
        hPi0ConversionDistance  ->Fill(std::min(GetEndTrackDistance(clusterMap[tpc][plane]->GetPhotons().at(0).first, (TrackID)GetPi0()->TrackId()),
                                                GetEndTrackDistance(clusterMap[tpc][plane]->GetPhotons().at(1).first, (TrackID)GetPi0()->TrackId())));
        hPi0ConversionSeparation->Fill(GetEndTrackDistance(clusterMap[tpc][plane]->GetPhotons().at(0).first, clusterMap[tpc][plane]->GetPhotons().at(1).first));
        if (clusterMap[tpc][plane]->PassesCut()) {
          hPi0AngleCut               ->Fill(FindPhotonAngle());
          hPi0EnergyCut              ->Fill(GetPi0()->Momentum().E());
          hPi0ConversionDistanceCut  ->Fill(std::min(GetEndTrackDistance(clusterMap[tpc][plane]->GetPhotons().at(0).first, (TrackID)GetPi0()->TrackId()),
                                                     GetEndTrackDistance(clusterMap[tpc][plane]->GetPhotons().at(1).first, (TrackID)GetPi0()->TrackId())));
          hPi0ConversionSeparationCut->Fill(GetEndTrackDistance(clusterMap[tpc][plane]->GetPhotons().at(0).first, clusterMap[tpc][plane]->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 = clusterMap[tpc][plane]->GetCompleteness(clusID);
        double cleanliness = clusterMap[tpc][plane]->GetCleanliness(clusID);
        int numClusterHits = clusterMap[tpc][plane]->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 (clusterMap[tpc][plane]->IsNoise(clusID)) continue;

        double pi0Energy = GetPi0()->Momentum().E();
        double pi0DecayAngle = FindPhotonAngle();
        double conversionDistance = GetEndTrackDistance(clusterMap[tpc][plane]->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 (clusterMap[tpc][plane]->GetPhotons().size() != 2) continue;

        double conversionSeparation = GetEndTrackDistance(clusterMap[tpc][plane]->GetPhotons().at(0).first, clusterMap[tpc][plane]->GetPhotons().at(1).first);

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

    }
  }

}

void ClusteringValidation::ClusterAnalyser::WriteFile

(

)

Definition at line 450 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> ClusteringValidation::ClusterAnalyser::bt_serv

private

Definition at line 209 of file ClusteringValidation_module.cc.

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

private

Definition at line 203 of file ClusteringValidation_module.cc.

std::string ClusteringValidation::ClusterAnalyser::fClusterLabel

private

Definition at line 191 of file ClusteringValidation_module.cc.

TObjArray ClusteringValidation::ClusterAnalyser::fHistArray

private

Definition at line 201 of file ClusteringValidation_module.cc.

art::ServiceHandle<geo::Geometry> ClusteringValidation::ClusterAnalyser::geometry

private

Definition at line 207 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hCleanliness

private

Definition at line 194 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hCleanlinessAngle

private

Definition at line 198 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hCleanlinessConversionDistance

private

Definition at line 198 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hCleanlinessConversionSeparation

private

Definition at line 198 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCleanlinessEnergy

private

Definition at line 198 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hComplCleanl

private

Definition at line 194 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hComplCleanlAngle

private

Definition at line 199 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hComplCleanlConversionDistance

private

Definition at line 199 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hComplCleanlConversionSeparation

private

Definition at line 199 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hComplCleanlEnergy

private

Definition at line 199 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hCompleteness

private

Definition at line 194 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hCompletenessAngle

private

Definition at line 197 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hCompletenessConversionDistance

private

Definition at line 197 of file ClusteringValidation_module.cc.

TProfile * ClusteringValidation::ClusterAnalyser::hCompletenessConversionSeparation

private

Definition at line 197 of file ClusteringValidation_module.cc.

TProfile* ClusteringValidation::ClusterAnalyser::hCompletenessEnergy

private

Definition at line 197 of file ClusteringValidation_module.cc.

TEfficiency* ClusteringValidation::ClusterAnalyser::hEfficiencyAngle

private

Definition at line 200 of file ClusteringValidation_module.cc.

TEfficiency * ClusteringValidation::ClusterAnalyser::hEfficiencyConversionDistance

private

Definition at line 200 of file ClusteringValidation_module.cc.

TEfficiency * ClusteringValidation::ClusterAnalyser::hEfficiencyConversionSeparation

private

Definition at line 200 of file ClusteringValidation_module.cc.

TEfficiency * ClusteringValidation::ClusterAnalyser::hEfficiencyEnergy

private

Definition at line 200 of file ClusteringValidation_module.cc.

TH2* ClusteringValidation::ClusterAnalyser::hNumHitsCompleteness

private

Definition at line 196 of file ClusteringValidation_module.cc.

TH2 * ClusteringValidation::ClusterAnalyser::hNumHitsEnergy

private

Definition at line 196 of file ClusteringValidation_module.cc.

TH1* ClusteringValidation::ClusterAnalyser::hPi0Angle

private

Definition at line 195 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hPi0AngleCut

private

Definition at line 195 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hPi0ConversionDistance

private

Definition at line 195 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hPi0ConversionDistanceCut

private

Definition at line 195 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hPi0ConversionSeparation

private

Definition at line 195 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hPi0ConversionSeparationCut

private

Definition at line 195 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hPi0Energy

private

Definition at line 195 of file ClusteringValidation_module.cc.

TH1 * ClusteringValidation::ClusterAnalyser::hPi0EnergyCut

private

Definition at line 195 of file ClusteringValidation_module.cc.

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

private

Definition at line 208 of file ClusteringValidation_module.cc.

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

private

Definition at line 204 of file ClusteringValidation_module.cc.

---

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

• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/ClusterFinder/ClusteringValidation_module.cc