RecoUtils Namespace Reference

Functions
int	TrueParticleID (detinfo::DetectorClocksData const &clockData, const art::Ptr< recob::Hit > hit, bool rollup_unsaved_ids=1)
int	TrueParticleIDFromTotalTrueEnergy (detinfo::DetectorClocksData const &clockData, const std::vector< art::Ptr< recob::Hit > > &hits, bool rollup_unsaved_ids=1)
int	TrueParticleIDFromTotalRecoCharge (detinfo::DetectorClocksData const &clockData, const std::vector< art::Ptr< recob::Hit > > &hits, bool rollup_unsaved_ids=1)
int	TrueParticleIDFromTotalRecoHits (detinfo::DetectorClocksData const &clockData, const std::vector< art::Ptr< recob::Hit > > &hits, bool rollup_unsaved_ids=1)
bool	IsInsideTPC (TVector3 position, double distance_buffer)
double	CalculateTrackLength (const art::Ptr< recob::Track > track)
int	TrueParticleID (const detinfo::DetectorClocksData &clockData, const art::Ptr< recob::Hit > &hit)
int	TrueParticleIDFromTotalTrueEnergy (const detinfo::DetectorClocksData &clockData, const std::vector< art::Ptr< recob::Hit > > &hits)
int	TrueParticleIDFromTotalRecoCharge (const detinfo::DetectorClocksData &clockData, const std::vector< art::Ptr< recob::Hit > > &hits)
int	TrueParticleIDFromTotalRecoHits (const detinfo::DetectorClocksData &clockData, const std::vector< art::Ptr< recob::Hit > > &hits)

Function Documentation

double RecoUtils::CalculateTrackLength

(

const art::Ptr< recob::Track >

track

)

Definition at line 165 of file icaruscode/icaruscode/CRT/CRTUtils/RecoUtils.cc.

                                                                    {
  double length = 0;
  if (track->NumberTrajectoryPoints()==1) return length; //Nothing to calculate if there is only one point

  for (size_t i_tp = 0; i_tp < track->NumberTrajectoryPoints()-1; i_tp++){ //Loop from the first to 2nd to last point
    TVector3 this_point(track->TrajectoryPoint(i_tp).position.X(),track->TrajectoryPoint(i_tp).position.Y(),track->TrajectoryPoint(i_tp).position.Z());
    if (!RecoUtils::IsInsideTPC(this_point,0)){
      std::cout<<"RecoUtils::CalculateTrackLength - Current trajectory point not in the TPC volume.  Skip over this point in the track length calculation"<<std::endl;
      continue;
    }
    TVector3 next_point(track->TrajectoryPoint(i_tp+1).position.X(),track->TrajectoryPoint(i_tp+1).position.Y(),track->TrajectoryPoint(i_tp+1).position.Z());
    if (!RecoUtils::IsInsideTPC(next_point,0)){
      std::cout<<"RecoUtils::CalculateTrackLength - Next trajectory point not in the TPC volume.  Skip over this point in the track length calculation"<<std::endl;
      continue;
    }

    length+=(next_point-this_point).Mag();
  }
  return length;
}

bool RecoUtils::IsInsideTPC	(	TVector3	position,
		double	distance_buffer
	)

Definition at line 115 of file icaruscode/icaruscode/CRT/CRTUtils/RecoUtils.cc.

                                                                    {
  double vtx[3] = {position.X(), position.Y(), position.Z()};
  bool inside = false;
  art::ServiceHandle<geo::Geometry> geom;
  geo::TPCID idtpc = geom->FindTPCAtPosition(vtx);

  if (geom->HasTPC(idtpc))
    {
      const geo::TPCGeo& tpcgeo = geom->GetElement(idtpc);
      double minx = tpcgeo.MinX(); double maxx = tpcgeo.MaxX();
      double miny = tpcgeo.MinY(); double maxy = tpcgeo.MaxY();
      double minz = tpcgeo.MinZ(); double maxz = tpcgeo.MaxZ();

      for (size_t c = 0; c < geom->Ncryostats(); c++)
        {
          const geo::CryostatGeo& cryostat = geom->Cryostat(c);
          for (size_t t = 0; t < cryostat.NTPC(); t++)
            {
              const geo::TPCGeo& tpcg = cryostat.TPC(t);
              if (tpcg.MinX() < minx) minx = tpcg.MinX();
              if (tpcg.MaxX() > maxx) maxx = tpcg.MaxX();
              if (tpcg.MinY() < miny) miny = tpcg.MinY();
              if (tpcg.MaxY() > maxy) maxy = tpcg.MaxY();
              if (tpcg.MinZ() < minz) minz = tpcg.MinZ();
              if (tpcg.MaxZ() > maxz) maxz = tpcg.MaxZ();
            }
        }

      //x
      double dista = fabs(minx - position.X());
      double distb = fabs(position.X() - maxx);
      if ((position.X() > minx) && (position.X() < maxx) &&
          (dista > distance_buffer) && (distb > distance_buffer)) inside = true;
      //y
      dista = fabs(maxy - position.Y());
      distb = fabs(position.Y() - miny);
      if (inside && (position.Y() > miny) && (position.Y() < maxy) &&
          (dista > distance_buffer) && (distb > distance_buffer)) inside = true;
      else inside = false;
      //z
      dista = fabs(maxz - position.Z());
      distb = fabs(position.Z() - minz);
      if (inside && (position.Z() > minz) && (position.Z() < maxz) &&
          (dista > distance_buffer) && (distb > distance_buffer)) inside = true;
      else inside = false;
    }

  return inside;
}

int RecoUtils::TrueParticleID	(	const detinfo::DetectorClocksData &	clockData,
		const art::Ptr< recob::Hit > &	hit
	)

Definition at line 3 of file icaruscode/icaruscode/RecoUtils/RecoUtils.cc.

                                                           {
  double particleEnergy = 0;
  int likelyTrackID = 0;
  art::ServiceHandle<cheat::BackTrackerService> bt;
  std::vector<sim::TrackIDE> trackIDs = bt->HitToTrackIDEs(clockData, hit);
  for (unsigned int idIt = 0; idIt < trackIDs.size(); ++idIt) {
    if (trackIDs.at(idIt).energy > particleEnergy) {
      particleEnergy = trackIDs.at(idIt).energy;
      likelyTrackID = trackIDs.at(idIt).trackID;
    }
  }
  return likelyTrackID;
}

int RecoUtils::TrueParticleID	(	detinfo::DetectorClocksData const &	clockData,
		const art::Ptr< recob::Hit >	hit,
		bool	rollup_unsaved_ids = 1
	)

Definition at line 4 of file icaruscode/icaruscode/CRT/CRTUtils/RecoUtils.cc.

                                                                                   {
  std::map<int,double> id_to_energy_map;
  art::ServiceHandle<cheat::BackTrackerService> bt_serv;
  std::vector<sim::TrackIDE> track_ides = bt_serv->HitToTrackIDEs(clockData, hit);
  for (unsigned int idIt = 0; idIt < track_ides.size(); ++idIt) {
    int id = track_ides.at(idIt).trackID;
    if (rollup_unsaved_ids) id = std::abs(id);
    double energy = track_ides.at(idIt).energy;
    id_to_energy_map[id]+=energy;
  }
  //Now loop over the map to find the maximum contributor
  double likely_particle_contrib_energy = -99999;
  int likely_track_id = 0;
  for (std::map<int,double>::iterator mapIt = id_to_energy_map.begin(); mapIt != id_to_energy_map.end(); mapIt++){
    double particle_contrib_energy = mapIt->second;
    if (particle_contrib_energy > likely_particle_contrib_energy){
      likely_particle_contrib_energy = particle_contrib_energy;
      likely_track_id = mapIt->first;
    }
  }
  return likely_track_id;
}

int RecoUtils::TrueParticleIDFromTotalRecoCharge	(	const detinfo::DetectorClocksData &	clockData,
		const std::vector< art::Ptr< recob::Hit > > &	hits
	)

Definition at line 48 of file icaruscode/icaruscode/RecoUtils/RecoUtils.cc.

                                                                                           {
  // Make a map of the tracks which are associated with this object and the charge each contributes
  std::map<int,double> trackMap;
  for (std::vector<art::Ptr<recob::Hit> >::const_iterator hitIt = hits.begin(); hitIt != hits.end(); ++hitIt) {
    art::Ptr<recob::Hit> hit = *hitIt;
    int trackID = TrueParticleID(clockData, hit);
    trackMap[trackID] += hit->Integral();
  }

  // Pick the track with the highest charge as the 'true track'
  double highestCharge = 0;
  int objectTrack = -99999;
  for (std::map<int,double>::iterator trackIt = trackMap.begin(); trackIt != trackMap.end(); ++trackIt) {
    if (trackIt->second > highestCharge) {
      highestCharge = trackIt->second;
      objectTrack  = trackIt->first;
    }
  }
  return objectTrack;
}

int RecoUtils::TrueParticleIDFromTotalRecoCharge	(	detinfo::DetectorClocksData const &	clockData,
		const std::vector< art::Ptr< recob::Hit > > &	hits,
		bool	rollup_unsaved_ids = 1
	)

Definition at line 60 of file icaruscode/icaruscode/CRT/CRTUtils/RecoUtils.cc.

                                                                                                                                                              {
  // Make a map of the tracks which are associated with this object and the charge each contributes
  std::map<int,double> trackMap;
  for (std::vector<art::Ptr<recob::Hit> >::const_iterator hitIt = hits.begin(); hitIt != hits.end(); ++hitIt) {
    art::Ptr<recob::Hit> hit = *hitIt;
    int trackID = TrueParticleID(clockData, hit, rollup_unsaved_ids);
    trackMap[trackID] += hit->Integral();
  }

  // Pick the track with the highest charge as the 'true track'
  double highestCharge = 0;
  int objectTrack = -99999;
  for (std::map<int,double>::iterator trackIt = trackMap.begin(); trackIt != trackMap.end(); ++trackIt) {
    if (trackIt->second > highestCharge) {
      highestCharge = trackIt->second;
      objectTrack  = trackIt->first;
    }
  }
  return objectTrack;
}

int RecoUtils::TrueParticleIDFromTotalRecoHits	(	const detinfo::DetectorClocksData &	clockData,
		const std::vector< art::Ptr< recob::Hit > > &	hits
	)

Definition at line 72 of file icaruscode/icaruscode/RecoUtils/RecoUtils.cc.

                                                                                         {
  // Make a map of the tracks which are associated with this object and the number of hits they are the primary contributor to
  std::map<int,int> trackMap;
  for (std::vector<art::Ptr<recob::Hit> >::const_iterator hitIt = hits.begin(); hitIt != hits.end(); ++hitIt) {
    art::Ptr<recob::Hit> hit = *hitIt;
    int trackID = TrueParticleID(clockData, hit);
    trackMap[trackID]++;
  }

  // Pick the track which is the primary contributor to the most hits as the 'true track'
  int objectTrack = -99999;
  int highestCount = -1;
  for (std::map<int,int>::iterator trackIt = trackMap.begin(); trackIt != trackMap.end(); ++trackIt) {
    if (trackIt->second > highestCount) {
      highestCount = trackIt->second;
      objectTrack  = trackIt->first;
    }
  }
  return objectTrack;
}

int RecoUtils::TrueParticleIDFromTotalRecoHits	(	detinfo::DetectorClocksData const &	clockData,
		const std::vector< art::Ptr< recob::Hit > > &	hits,
		bool	rollup_unsaved_ids = 1
	)

Definition at line 83 of file icaruscode/icaruscode/CRT/CRTUtils/RecoUtils.cc.

                                                                                                                                                           {
  // Make a map of the tracks which are associated with this object and the number of hits they are the primary contributor to
  std::map<int,int> trackMap;
  for (std::vector<art::Ptr<recob::Hit> >::const_iterator hitIt = hits.begin(); hitIt != hits.end(); ++hitIt) {
    art::Ptr<recob::Hit> hit = *hitIt;
    int trackID = TrueParticleID(clockData, hit, rollup_unsaved_ids);
    trackMap[trackID]++;
  }

  // Pick the track which is the primary contributor to the most hits as the 'true track'
  int objectTrack = -99999;
  int highestCount = -1;
  int NHighestCounts = 0;
  for (std::map<int,int>::iterator trackIt = trackMap.begin(); trackIt != trackMap.end(); ++trackIt) {
    if (trackIt->second > highestCount) {
      highestCount = trackIt->second;
      objectTrack  = trackIt->first;
      NHighestCounts = 1;
    }
    else if (trackIt->second == highestCount){
      NHighestCounts++;
    }
  }
  if (NHighestCounts > 1){
    std::cout<<"RecoUtils::TrueParticleIDFromTotalRecoHits - There are " << NHighestCounts << " particles which tie for highest number of contributing hits (" << highestCount<<" hits).  Using RecoUtils::TrueParticleIDFromTotalTrueEnergy instead."<<std::endl;
    objectTrack = RecoUtils::TrueParticleIDFromTotalTrueEnergy(clockData, hits,rollup_unsaved_ids);
  }
  return objectTrack;
}

int RecoUtils::TrueParticleIDFromTotalTrueEnergy	(	const detinfo::DetectorClocksData &	clockData,
		const std::vector< art::Ptr< recob::Hit > > &	hits
	)

Definition at line 19 of file icaruscode/icaruscode/RecoUtils/RecoUtils.cc.

                                                                                           {
  art::ServiceHandle<cheat::BackTrackerService> bt;
  std::map<int,double> trackIDToEDepMap;
  for (std::vector<art::Ptr<recob::Hit> >::const_iterator hitIt = hits.begin(); hitIt != hits.end(); ++hitIt) {
    art::Ptr<recob::Hit> hit = *hitIt;
    std::vector<sim::TrackIDE> trackIDs = bt->HitToTrackIDEs(clockData, hit);
    for (unsigned int idIt = 0; idIt < trackIDs.size(); ++idIt) {
      trackIDToEDepMap[trackIDs[idIt].trackID] += trackIDs[idIt].energy;
    }
  }

  //Loop over the map and find the track which contributes the highest energy to the hit vector
  double maxenergy = -1;
  int objectTrack = -99999;
  for (std::map<int,double>::iterator mapIt = trackIDToEDepMap.begin(); mapIt != trackIDToEDepMap.end(); mapIt++){
    double energy = mapIt->second;
    double trackid = mapIt->first;
    if (energy > maxenergy){
      maxenergy = energy;
      objectTrack = trackid;
    }
  }

  return objectTrack;
}

int RecoUtils::TrueParticleIDFromTotalTrueEnergy	(	detinfo::DetectorClocksData const &	clockData,
		const std::vector< art::Ptr< recob::Hit > > &	hits,
		bool	rollup_unsaved_ids = 1
	)

Definition at line 30 of file icaruscode/icaruscode/CRT/CRTUtils/RecoUtils.cc.

                                                                                                                                                              {
  art::ServiceHandle<cheat::BackTrackerService> bt_serv;
  std::map<int,double> trackIDToEDepMap;
  for (std::vector<art::Ptr<recob::Hit> >::const_iterator hitIt = hits.begin(); hitIt != hits.end(); ++hitIt) {
    art::Ptr<recob::Hit> hit = *hitIt;
    std::vector<sim::TrackIDE> trackIDs = bt_serv->HitToTrackIDEs(clockData, hit);
    for (unsigned int idIt = 0; idIt < trackIDs.size(); ++idIt) {
      int id = trackIDs[idIt].trackID;
      if (rollup_unsaved_ids) id = std::abs(id);
      trackIDToEDepMap[id] += trackIDs[idIt].energy;
    }
  }

  //Loop over the map and find the track which contributes the highest energy to the hit vector
  double maxenergy = -1;
  int objectTrack = -99999;
  for (std::map<int,double>::iterator mapIt = trackIDToEDepMap.begin(); mapIt != trackIDToEDepMap.end(); mapIt++){
    double energy = mapIt->second;
    double trackid = mapIt->first;
    if (energy > maxenergy){
      maxenergy = energy;
      objectTrack = trackid;
    }
  }

  return objectTrack;
}