#include <Cuts.h>

Classes
struct	Config

struct	VolYZ

Public Member Functions
void	Initialize (const fhicl::ParameterSet &cfg, const geo::GeometryCore *geometry)

std::array< bool, nCuts >	ProcessRecoCuts (const numu::RecoEvent &event, unsigned reco_vertex_index, bool fSequentialCuts=true) const

std::array< bool, nTruthCuts >	ProcessTruthCuts (const numu::RecoEvent &event, const event::Event &core, unsigned truth_vertex_index, bool SequentialCuts=true) const

bool	SelectReco (std::array< bool, nCuts > &cuts)

bool	InFV (const TVector3 &v) const

bool	InFV (const geo::Point_t &v) const

bool	InCosmicContainment (const TVector3 &v) const

bool	InCalorimetricContainment (const TVector3 &v) const

float	CRTMatchTime (const numu::RecoTrack &track) const

bool	HasCRTHitMatch (const numu::RecoTrack &track) const

bool	TimeInSpill (float time) const

bool	TimeInCRTActiveSpill (float time) const

bool	HasCRTTrackMatch (const numu::RecoTrack &track) const

bool	PassFlashTrigger (const numu::RecoEvent &event) const

const std::vector< std::string > &	CutOrder () const

const std::vector< std::string > &	TruthCutOrder () const

Static Public Attributes
static const unsigned	nCuts = 11
	total number of cuts More...

static const unsigned	nTruthCuts = 6
	Total number of truth cuts. More...

static constexpr std::array < const char *, nTruthCuts >	truthCutNames = { "Truth", "T_fid", "T_trig", "T_vqual", "T_tqual", "T_reco"}

static constexpr std::array < const char *, nCuts >	cutNames

Private Attributes
Config	fConfig

Detailed Description

Definition at line 18 of file ysis/ana/SBNOscReco/PostProcess/Cuts.h.

Member Function Documentation

float ana::SBNOsc::Cuts::CRTMatchTime ( const numu::RecoTrack & track ) const

Gets the time of the CRT match to a track.

Parameters

track The track object

Returns: The time [us] of the CRT match. Returns nonsense if no such match exists.

Definition at line 211 of file Cuts.cc.

                                                          {
   if (HasCRTTrackMatch(track)) return track.crt_match.track.time;
   if (HasCRTHitMatch(track)) return track.crt_match.hit_match.time;
   return -99999;
 }

const std::vector<std::string>& ana::SBNOsc::Cuts::CutOrder ( ) const

inline

Definition at line 126 of file ysis/ana/SBNOscReco/PostProcess/Cuts.h.

                                                {
     return fConfig.CutOrder;
   }

bool ana::SBNOsc::Cuts::HasCRTHitMatch ( const numu::RecoTrack & track ) const

Whether a TPC track has a CRT hit match

Parameters

track the TPC track

Returns: Whether a TPC track has a CRT hit match

Definition at line 205 of file Cuts.cc.

                                                           {
   return track.crt_match.hit_match.present && 
          (fConfig.CRTHitDist < 0. || 
           track.crt_match.hit_match.distance < fConfig.CRTHitDist);
 }

bool ana::SBNOsc::Cuts::HasCRTTrackMatch ( const numu::RecoTrack & track ) const

Whether a TPC track has a CRT track match

Parameters

track the TPC track

Returns: Whether a TPC track has a CRT track match

Definition at line 199 of file Cuts.cc.

                                                             {
   return track.crt_match.track.present && 
          (fConfig.CRTTrackAngle < 0. || 
           track.crt_match.track.angle < fConfig.CRTTrackAngle);
 }

bool ana::SBNOsc::Cuts::InCalorimetricContainment ( const TVector3 & v ) const

Test whether a point is in the configured track containment volume

Parameters

v	The point to test

Returns: Whether the point is in the configured track containment volume

Definition at line 241 of file Cuts.cc.

                                                             {
   for (auto const& FV: fConfig.calorimetric_containment_volumes) {
     if (FV.ContainsPosition(v)) return true;
   }
   return false;
 }

bool ana::SBNOsc::Cuts::InCosmicContainment ( const TVector3 & v ) const

Test whether a point is in the configured track containment volume

Parameters

v	The point to test

Returns: Whether the point is in the configured track containment volume

Definition at line 248 of file Cuts.cc.

                                                       {
   for (auto const& CV: fConfig.cosmic_containment_volumes) {
     if (CV.Z[0] < v.Z() 
      && CV.Z[1] > v.Z() 
      && CV.Y[0] < v.Y()
      && CV.Y[1] > v.Y()) {
       return true;
     }
   }
   return false;
 }

bool ana::SBNOsc::Cuts::InFV ( const TVector3 & v ) const

Test whether a point is in the configured fiducial volume

Parameters

v	The point to test

Returns: Whether the point is in the configured fiducial volume

Definition at line 234 of file Cuts.cc.

                                        {
   for (auto const& FV: fConfig.fiducial_volumes) {
     if (FV.ContainsPosition(v)) return true;
   }
   return false;
 }

bool ana::SBNOsc::Cuts::InFV ( const geo::Point_t & v ) const

Test whether a point is in the configured fiducial volume

Parameters

v	The point to test

Returns: Whether the point is in the configured fiducial volume

Definition at line 227 of file Cuts.cc.

                                          {
   for (auto const& FV: fConfig.fiducial_volumes) {
     if (FV.ContainsPosition(v)) return true;
   }
   return false;
 }

void ana::SBNOsc::Cuts::Initialize	(	const fhicl::ParameterSet &	cfg,
		const geo::GeometryCore *	geometry
	)

Initialize this class.

Parameters

cfg	fhicl configuration for the class A pointer to the geoemtry of the detector to configure

Definition at line 10 of file Cuts.cc.

                                                                                    {
   fConfig.active_volumes.clear();
   fConfig.fiducial_volumes.clear();
 
   fConfig.UseTrueVertex = cfg.get<bool>("UseTrueVertex", false);
   fConfig.trackMatchCompletionCut = cfg.get<double>("trackMatchCompletionCut", -1);
   fConfig.active_volumes = SBNRecoUtils::ActiveVolumes(geometry); 
   fConfig.TruthCompletion = cfg.get<float>("TruthCompletion", 0.5);
   fConfig.TruthMatchDist = cfg.get<float>("TruthMatchDist", 5.);
 
   fConfig.MCSTrackLength = cfg.get<float>("MCSTrackLength", 100.);
   fConfig.TrackLength = cfg.get<float>("TrackLength", 50.);
 
   fConfig.CRTHitDist = cfg.get<float>("CRTHitDist", 35.);
   fConfig.CRTHitTimeRange = cfg.get<std::array<float, 2>>("CRTHitTimeRange", {-0.2, 2.0});
   fConfig.CRTActivityTimeRange = cfg.get<std::array<float, 2>>("CRTActivityTimeRange", {-0.2, 2.0});
   fConfig.CRTTrackAngle = cfg.get<float>("CRTTrackAngle", 0.4);
 
   fConfig.TruthFlashMatch = cfg.get<bool>("TruthFlashMatch", false);
   fConfig.FlashMatchScore = cfg.get<float>("FlashMatchScore", 10.);
 
   fConfig.PMTTriggerTreshold = cfg.get<int>("PMTTriggerTreshold", 7950);
   fConfig.PMTNAboveThreshold = cfg.get<unsigned>("PMTNAboveThreshold", 5);
 
   fConfig.CRTActivityPEThreshold = cfg.get<float>("CRTActivityPEThreshold", 100.);
 
   fConfig.CutOrder = cfg.get<std::vector<std::string>>("CutOrder");
   fConfig.TruthCutOrder = cfg.get<std::vector<std::string>>("TruthCutOrder");
 
   {
     fhicl::ParameterSet dFV = \
      cfg.get<fhicl::ParameterSet>("fiducial_volume_inset");
     double dx = dFV.get<double>("x");
     double dy = dFV.get<double>("y");
     double zfront = dFV.get<double>("zfront");
     double zback = dFV.get<double>("zback");
     for (const geo::BoxBoundedGeo &geo: fConfig.active_volumes) {
       fConfig.fiducial_volumes.emplace_back(geo.MinX() + dx, geo.MaxX() - dx, geo.MinY() + dy, geo.MaxY() - dy, geo.MinZ() + zfront, geo.MaxZ() - zback);
     }
   }
 
   {
     fhicl::ParameterSet dFV = \
      cfg.get<fhicl::ParameterSet>("calorimetric_containment_volume_inset");
     double dx = dFV.get<double>("x");
     double dy = dFV.get<double>("y");
     double zfront = dFV.get<double>("zfront");
     double zback = dFV.get<double>("zback");
     for (const geo::BoxBoundedGeo &geo: fConfig.active_volumes) {
       fConfig.calorimetric_containment_volumes.emplace_back(geo.MinX() + dx, 
                                                             geo.MaxX() - dx, 
                                                             geo.MinY() + dy, 
                                                             geo.MaxY() - dy, 
                                                             geo.MinZ() + 
                                                             zfront, 
                                                             geo.MaxZ() -zback);
     }
   }
 
   {
     fhicl::ParameterSet dFV = \
      cfg.get<fhicl::ParameterSet>("cosmic_containment_volume_inset");
     double ytop = dFV.get<double>("ytop");
     double ybottom = dFV.get<double>("ybottom");
     double zfront = dFV.get<double>("zfront");
     double zback = dFV.get<double>("zback");
     for (const geo::BoxBoundedGeo &geo: fConfig.active_volumes) {
       VolYZ contain;
       contain.Y = {geo.MinY() + ybottom, geo.MaxY() - ytop};
       contain.Z = {geo.MinZ() + zfront, geo.MaxZ() - zback};
       fConfig.cosmic_containment_volumes.emplace_back(contain);
     }
   }
 
 }

bool ana::SBNOsc::Cuts::PassFlashTrigger ( const numu::RecoEvent & event ) const

Definition at line 121 of file Cuts.cc.

                                                             {
   return numu::HasTrigger(event.flash_trigger_primitives, fConfig.PMTTriggerTreshold, fConfig.PMTNAboveThreshold);
 }

std::array< bool, Cuts::nCuts > ana::SBNOsc::Cuts::ProcessRecoCuts	(	const numu::RecoEvent &	event,
		unsigned	reco_vertex_index,
		bool	fSequentialCuts = `true`
	)		const

Process each cut associated with reconstructed events

Parameters

event	The reconstructed event information
reco_vertex_index	The index of the candidate reconstructed neutrino vertex into the list of such vertices in the RecoEvent

Returns: A list of bool's of whether the reco event passes each cut

Definition at line 125 of file Cuts.cc.

                                                                                 {
   std::map<std::string, bool> cuts;
   cuts["Reco"] = true;
 
   cuts["R_trig"] = PassFlashTrigger(event);
 
   // require an in-time flash time
   bool has_intime_flash = false;
   for (const numu::RecoInteraction &reco: event.reco) {
     if (reco.slice.flash_match.present && reco.slice.flash_match.time > 0. /*intime*/) {
       has_intime_flash = true;
       break;
     }
   }
   cuts["R_flashtime"] = has_intime_flash;
 
   // require fiducial
   if (fConfig.UseTrueVertex) {
     cuts["R_fid"] = false; // TODO: implement
   }
   else {
     cuts["R_fid"] = InFV(event.reco[reco_vertex_index].position);
   }
 
   const numu::RecoTrack &primary_track = event.tracks.at(event.reco[reco_vertex_index].slice.primary_track_index);
 
   //   good_mcs = track contain OR (range momentum OR mcs trk length)
   cuts["R_goodmcs"] = ( ( InCalorimetricContainment(primary_track.start) && 
                       InCalorimetricContainment(primary_track.end) )  || 
                     ( numu::MCSMomentum(primary_track) < 7. /*garbage value*/&& 
                       (fConfig.MCSTrackLength <0. || 
                        primary_track.length > fConfig.MCSTrackLength) )
                     );
 
   // allow truth-based flash matching or reco based
   bool time_in_spill = false;
   if (primary_track.match.has_match) {
     time_in_spill = TimeInSpill(event.particles.at(primary_track.match.mcparticle_id).start_time);
   }
 
   if (fConfig.TruthFlashMatch) cuts["R_flashmatch"] = time_in_spill;
   else cuts["R_flashmatch"] = fConfig.FlashMatchScore < 0. || (event.reco[reco_vertex_index].slice.flash_match.present && event.reco[reco_vertex_index].slice.flash_match.score < fConfig.FlashMatchScore);
 
   cuts["R_crttrack"] = !HasCRTTrackMatch(primary_track);
 
   cuts["R_crthit"] = ( !HasCRTHitMatch(primary_track) || 
                         TimeInSpill(CRTMatchTime(primary_track)) );
 
   cuts["R_length"]  = fConfig.TrackLength < 0. || 
                      primary_track.length > fConfig.TrackLength;
 
   cuts["R_contained"] = ( InCosmicContainment(primary_track.start) && 
                         InCosmicContainment(primary_track.end) );
 
 
   cuts["R_crtactive"]  = true; //is_contained;
   for (const numu::CRTHit &crt_hit: event.in_time_crt_hits) {
      if ( TimeInSpill(crt_hit.time)  && 
           crt_hit.pes > fConfig.CRTActivityPEThreshold )  {
        cuts["R_crtactive"]  = false;
        break;
      }
   }
 
   std::array<bool, Cuts::nCuts> ret;
   for (unsigned i = 0; i < fConfig.CutOrder.size(); i++) {
     if (fSequentialCuts && i > 0) ret[i] = ret[i-1] && cuts.at(fConfig.CutOrder[i]);
     else ret[i] = cuts.at(fConfig.CutOrder[i]);
   }
   return ret;
 }

std::array< bool, Cuts::nTruthCuts > ana::SBNOsc::Cuts::ProcessTruthCuts	(	const numu::RecoEvent &	event,
		const event::Event &	core,
		unsigned	truth_vertex_index,
		bool	SequentialCuts = `true`
	)		const

Process each cut associated with true events

Parameters

event	Event information
truth_vertex_index	The index of the true neutrino vertex into the lsit of true interactions in the RecoEvent

Returns: A list of bool's of whether the true event passes each cut

Definition at line 86 of file Cuts.cc.

                                                                                                                                                                 {
   std::map<std::string, bool> cuts;
   cuts["Truth"] = true;
 
 
   cuts["T_fid"]  = InFV(core.truth[truth_vertex_index].neutrino.position);
 
   cuts["T_trig"] = PassFlashTrigger(event);
 
   cuts["T_vqual"]  = (fConfig.TruthMatchDist < 0. || 
                      dist2Match(core.truth[truth_vertex_index], event.reco) < fConfig.TruthMatchDist); 
   cuts["T_tqual"]  = (fConfig.TruthCompletion < 0. || 
                        trackMatchCompletion(truth_vertex_index, event) > fConfig.TruthCompletion);
 
   bool has_reco = false;
   for (unsigned i = 0; i < event.reco.size(); i++) {
     const numu::RecoTrack &primary_track = event.tracks.at(event.reco[i].slice.primary_track_index);
     if (event.reco[i].match.has_match && 
         event.reco[i].match.mctruth_track_id == truth_vertex_index && 
         primary_track.match.is_primary) {
       has_reco = true;
       break;
     }
   }
   cuts["T_reco"] = has_reco;
 
   std::array<bool, Cuts::nTruthCuts> ret;
   for (unsigned i = 0; i < fConfig.TruthCutOrder.size(); i++) {
     if (SequentialCuts && i > 0) ret[i] = ret[i-1] && cuts.at(fConfig.TruthCutOrder[i]);
     else ret[i] = cuts.at(fConfig.TruthCutOrder[i]);
   }
   return ret;
 
 }

bool ana::SBNOsc::Cuts::SelectReco ( std::array< bool, nCuts > & cuts )

Select a reco event based on the cut values provided by ProcessRecoCuts

Parameters

cuts	the list of cuts returned by ProcessRecoCuts

Returns: whether to select this reconstructed neutrino vertex candidate

bool ana::SBNOsc::Cuts::TimeInCRTActiveSpill ( float time ) const

Definition at line 222 of file Cuts.cc.

                                                 {
   return time > fConfig.CRTActivityTimeRange[0] && 
          time < fConfig.CRTActivityTimeRange[1]; 
 }

bool ana::SBNOsc::Cuts::TimeInSpill ( float time ) const

Returns whether a time value is within the configured beam spill window

Parameters

time	The time to test

Returns: True when the time is in the beam spill window.

Definition at line 217 of file Cuts.cc.

                                        {
   return time > fConfig.CRTHitTimeRange[0] && 
          time < fConfig.CRTHitTimeRange[1]; 
 }

const std::vector<std::string>& ana::SBNOsc::Cuts::TruthCutOrder ( ) const

inline

Definition at line 130 of file ysis/ana/SBNOscReco/PostProcess/Cuts.h.

                                                     {
     return fConfig.TruthCutOrder;
   }

Member Data Documentation

constexpr std::array<const char *, nCuts> ana::SBNOsc::Cuts::cutNames

static

Initial value:

=
      {"Reco", "R_trig", "R_flashtime", "R_fid", "R_goodmcs", "R_flashmatch", 
       "R_crttrack", "R_crthit", "R_crtactive", "R_contained", "R_length"}