Implementing NN into Strip Pairing

include/MHit.h

@@ -47,14 +47,19 @@ class MHit
 
   // Strip hits:
 
-  //! Return the number of strip hits
+  //! Return the number of triggered strip hits
   unsigned int GetNStripHits() const { return m_StripHits.size(); }
   //! Return strip hit i or nullptr if i is out of bounds
   //! Ownership stays elsewhere
+  //! This includes only triggered strip hits
   MStripHit* GetStripHit(unsigned int i);
-  //! Add a strip hit
+  //! Return nearest neighbor strip hit i or nullptr if i is out of bounds
+  MStripHit* GetNearestNeighborStripHit(unsigned int i);
+  //! Add a triggered strip hit
   //! Ownership stays elsewhere
   void AddStripHit(MStripHit* StripHit);
+  //! Add a nearest neighbor strip hit
+  void AddNearestNeighborStripHit(MStripHit* StripHit);
   //! Remove strip hit i without deleting it
   void RemoveStripHit(unsigned int i);
   //! Remove a strip hit without deleting it
@@ -172,6 +177,9 @@ class MHit
   //! List of strip hits contributing to this hit
   //! Ownership stays elsewhere
   vector<MStripHit*> m_StripHits;
+
+  //! List of nearest neighbor strip hits associated with this hit
+  vector<MStripHit*> m_NearestNeighborStripHits;
 
   //! Position of the hit
   MVector m_Position;

include/MModuleStripPairingMultiRoundChiSquare.h

@@ -86,8 +86,14 @@ class MModuleStripPairingMultiRoundChiSquare : public MModule
   //! Function to apply charge trapping correction
     float ChargeTrappingCorrection(unsigned int d, const vector<vector<MStripHit*>>& StripHits);
 
-  //! Divide an event's strip hits by detector and LV/HV side
-    vector<vector<vector<MStripHit*>>> CollectStripHits(MReadOutAssembly* Event);
+  //! Divide an event's triggered strip hits by detector and LV/HV side
+    vector<vector<vector<MStripHit*>>> CollectTriggeredStripHits(MReadOutAssembly* Event);
+
+  //! Divide an event's nearest neighbor strip hits by detector and LV/HV side
+    vector<vector<vector<MStripHit*>>> CollectNearestNeighborStripHits(MReadOutAssembly* Event);
+
+  //! Assign nearest neighbor strip hits to their associated hits
+    void AssignNearestNeighbors(MReadOutAssembly* Event);
 
   //! Read in strip hits on each side for each detector and perform quality selections
     bool EventSelection(MReadOutAssembly* Event, const vector<vector<vector<MStripHit*>>>& StripHits);
@@ -97,6 +103,7 @@ class MModuleStripPairingMultiRoundChiSquare : public MModule
 
   //! Evaluate the reduced chi square for all possible strip pairings
     tuple<vector<vector<unsigned int>>, vector<vector<unsigned int>>, double> EvaluateAllCombinations(unsigned int d, const vector<vector<vector<vector<vector<unsigned int>>>>>& Combinations, const vector<vector<vector<MStripHit*>>>& StripHits);
+
   //! Create hits
     bool CreateHits(unsigned int d, MReadOutAssembly* Event, const vector<vector<vector<MStripHit*>>>& StripHits, const vector<vector<unsigned int>>& BestLVSideCombo, const vector<vector<unsigned int>>& BestHVSideCombo);
     //! Return the order of indices resulting from sorting a vector

include/MStripHit.h

@@ -128,8 +128,13 @@ class MStripHit
   void IsNearestNeighbor(bool NearestNeighbor) { m_IsNearestNeighbor = NearestNeighbor; }
   //! Return whether the strip is a nearest-neighbor hit
   bool IsNearestNeighbor() const { return m_IsNearestNeighbor; }
-
-  //! Set whether the strip has passed the fast threshold
+
+  //! Set if this is an ambiguous neighbor (ie. associated with multiple hits)
+  void IsAmbiguousNearestNeighbor(bool AmbiguousNearestNeighbor) { m_IsAmbiguousNearestNeighbor = AmbiguousNearestNeighbor; }
+  //! Return boolean indicating whether strip is an ambiguous nearest neighbor (default is false for triggered strips)
+  bool IsAmbiguousNearestNeighbor() const { return m_IsAmbiguousNearestNeighbor; }
+
+  //! Set the Fast Timing flag
   void HasFastTiming(bool FastTiming) { m_HasFastTiming = FastTiming; }
   //! Return whether the strip has passed the fast threshold
   bool HasFastTiming() const { return m_HasFastTiming; }
@@ -200,6 +205,9 @@ class MStripHit
   bool m_IsGuardRing;
   //! True if the hit is a nearest neighbor hit
   bool m_IsNearestNeighbor;
+  //! True if the nearest neighbor strip hit is associated with multiple strip paired hits
+  bool m_IsAmbiguousNearestNeighbor;
+
   //! True if the hit has fast timing
   bool m_HasFastTiming;
   //! True if the hit has calibrated timing

src/MHit.cxx

@@ -81,6 +81,7 @@ void MHit::Clear()
   m_EnergyResolution = g_DoubleNotDefined;
 
   m_StripHits.clear();
+  m_NearestNeighborStripHits.clear();
   m_Origins.clear();
 
   m_CrossTalk = false;
@@ -114,6 +115,24 @@ MStripHit* MHit::GetStripHit(unsigned int i)
 ////////////////////////////////////////////////////////////////////////////////
 
 
+MStripHit* MHit::GetNearestNeighborStripHit(unsigned int i)
+{
+  // Return strip hit i
+
+  if (i < m_NearestNeighborStripHits.size()) {
+    return m_NearestNeighborStripHits[i];
+  }
+
+  if (g_Verbosity >= c_Error) cout<<"Error in MHit::GetNearestNeighborStripHit: Strip hit index "<<i<<" is out of bounds: "<<m_NearestNeighborStripHits.size()<<" strip hits available"<<endl;
+
+  return nullptr;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+
 void MHit::AddStripHit(MStripHit* StripHit)
 {
   // Add a strip hit
@@ -129,6 +148,21 @@ void MHit::AddStripHit(MStripHit* StripHit)
 ////////////////////////////////////////////////////////////////////////////////
 
 
+void MHit::AddNearestNeighborStripHit(MStripHit* StripHit)
+{
+  // Add a strip hit
+
+  if (StripHit != nullptr) {
+    m_NearestNeighborStripHits.push_back(StripHit);
+  } else {
+    if (g_Verbosity >= c_Error) cout<<"Error in MHit::AddNearestNeighborStripHit: Strip hit is nullptr"<<endl;
+  }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
 void MHit::RemoveStripHit(unsigned int i)
 {
   // Remove a strip hit without deleting it
@@ -177,6 +211,9 @@ bool MHit::StreamDat(ostream& S, int Version)
     for (auto SH : m_StripHits) {
       SH->StreamDat(S, 0);
     }
+    for (auto SH : m_NearestNeighborStripHits) {
+      SH->StreamDat(S, 0);
+    }
   } else {
     if (g_Verbosity >= c_Error) cout<<"Error in MHit::StreamDat: Stream version "<<Version<<" not handled"<<endl;
     return false;