In hit lists use refindex reference times as well as refchan

  Separate methods for ref time subtracted and raw hits

src/THcDriftChamberPlane.cxx

@@ -316,7 +316,7 @@ Int_t THcDriftChamberPlane::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
     for(UInt_t mhit=0; mhit<hit->fNHits; mhit++) {
       fNRawhits++;
       /* Sort into early, late and ontime */
-      Int_t rawtdc = hit->fTDC[mhit];
+      Int_t rawtdc = hit->GetRawData(0,mhit);
       if((rawtdc-reftime) < fTdcWinMin) {
 	// Increment early counter  (Actually late because TDC is backward)
       } else if ((rawtdc-reftime) > fTdcWinMax) {

src/THcHitList.cxx

@@ -36,8 +36,58 @@ void THcHitList::InitHitList(THaDetMap* detmap,
   for(Int_t i=0;i<maxhits;i++) {
     fRawHitList->ConstructedAt(i);
   }
-  
+
   fdMap = detmap;
+
+  /* Pull out all the reference channels */
+  fNRefIndex = 0;
+  fRefIndexMaps.clear();
+  /* Find the biggest refindex */
+  for (Int_t i=0; i < fdMap->GetSize(); i++) {
+    THaDetMap::Module* d = fdMap->GetModule(i);
+    if(d->plane >= 1000) {
+      Int_t refindex = d->signal;
+      if(refindex>=fNRefIndex) {
+	fNRefIndex = refindex+1;
+      }
+    }
+  }
+  // Create the vector.  Could roll this into last loop
+  for(Int_t i=0;i<fNRefIndex;i++) {
+    RefIndexMap map;
+    map.defined = kFALSE;
+    map.hashit = kFALSE;
+    fRefIndexMaps.push_back(map);
+  }
+  // Put the refindex mapping information in the vector
+  for (Int_t i=0; i < fdMap->GetSize(); i++) {
+    THaDetMap::Module* d = fdMap->GetModule(i);
+    if(d->plane >= 1000) {	// This is a reference time definition
+      Int_t refindex = d->signal;
+      if(refindex >= 0) {
+	fRefIndexMaps[refindex].crate = d->crate;
+	fRefIndexMaps[refindex].slot = d->slot;
+	fRefIndexMaps[refindex].channel = d->lo;
+	fRefIndexMaps[refindex].defined = kTRUE;
+      } else {
+	cout << "Hitlist: Invalid refindex mapping" << endl;
+      }
+    }
+  }
+  // Should add another loop over fdMap and check that all detector
+  // channels that have a refindex, use a defined index
+  for (Int_t i=0; i < fdMap->GetSize(); i++) {
+    THaDetMap::Module* d = fdMap->GetModule(i);
+    if(d->plane < 1000) {
+      Int_t refindex = d->refindex;
+      if(!fRefIndexMaps[refindex].defined) {
+	cout << "Refindex " << refindex << " not defined for " <<
+		" (" << d->crate << ", " << d->slot <<
+		", " << d->lo << ")" << endl;
+      }
+    }
+  }
+	  
 }
 
 Int_t THcHitList::DecodeToHitList( const THaEvData& evdata ) {
@@ -53,26 +103,43 @@ Int_t THcHitList::DecodeToHitList( const THaEvData& evdata ) {
   fRawHitList->Clear( );
   fNRawHits = 0;
 
+  // Get the indexed reference times for this event
+  for(Int_t i=0;i<fNRefIndex;i++) {
+    if(fRefIndexMaps[i].defined) {
+      if(evdata.GetNumHits(fRefIndexMaps[i].crate,
+			   fRefIndexMaps[i].slot,
+			   fRefIndexMaps[i].channel) > 0) {
+	// Only take first hit in this reference channel
+	fRefIndexMaps[i].reftime =
+	  evdata.GetData(fRefIndexMaps[i].crate,fRefIndexMaps[i].slot,
+			 fRefIndexMaps[i].channel,0);
+	fRefIndexMaps[i].hashit = kTRUE;
+      } else {
+	fRefIndexMaps[i].hashit = kFALSE;
+      }
+    }
+  }
   for ( Int_t i=0; i < fdMap->GetSize(); i++ ) {
     THaDetMap::Module* d = fdMap->GetModule(i);
 
     // Loop over all channels that have a hit.
     //    cout << "Crate/Slot: " << d->crate << "/" << d->slot << endl;
+    Int_t plane = d->plane;
+    if (plane >= 1000) continue; // Skip reference times
+    Int_t signal = d->signal;
     for ( Int_t j=0; j < evdata.GetNumChan( d->crate, d->slot); j++) {
       THcRawHit* rawhit=0;
-      
+
       Int_t chan = evdata.GetNextChan( d->crate, d->slot, j );
       if( chan < d->lo || chan > d->hi ) continue;     // Not one of my channels
-      
+
       // Need to convert crate, slot, chan into plane, counter, signal
       // Search hitlist for this plane,counter,signal
-      Int_t plane = d->plane;
-      Int_t signal = d->signal;
       Int_t counter = d->reverse ? d->first + d->hi - chan : d->first + chan - d->lo;
       //cout << d->crate << " " << d->slot << " " << chan << " " << plane << " "
       // << counter << " " << signal << endl;
       // Search hit list for plane and counter
-      // We could do sorting 
+      // We could do sorting
       UInt_t thishit = 0;
       while(thishit < fNRawHits) {
 	rawhit = (THcRawHit*) (*fRawHitList)[thishit];
@@ -90,7 +157,7 @@ Int_t THcHitList::DecodeToHitList( const THaEvData& evdata ) {
 	rawhit->fPlane = plane;
 	rawhit->fCounter = counter;
       }
-	
+
       // Get the data from this channel
       // Allow for multiple hits
       Int_t nMHits = evdata.GetNumHits(d->crate, d->slot, chan);
@@ -100,11 +167,23 @@ Int_t THcHitList::DecodeToHitList( const THaEvData& evdata ) {
 	rawhit->SetData(signal,data);
       }
       // Get the reference time.  Only take the first hit
+      // If a reference channel
+      // was specified, it takes precidence of reference index
       if(d->refchan >= 0) {
 	if( evdata.GetNumHits(d->crate,d->slot,d->refchan) > 0) {
 	  Int_t reftime = evdata.GetData(d->crate, d->slot, d->refchan, 0);
 	  rawhit->SetReference(signal, reftime);
 	}
+      } else {
+	if(d->refindex >=0 && d->refindex < fNRefIndex) {
+	  if(fRefIndexMaps[d->refindex].hashit) {
+	    rawhit->SetReference(signal, fRefIndexMaps[d->refindex].reftime);
+	  } else {
+	    cout << "HitList: refindex " << d->refindex <<
+	      " missing for (" << d->crate << ", " << d->slot <<
+	      ", " << chan << ")" << endl;
+	  }
+	}
       }
     }
   }

src/THcHitList.h

@@ -41,6 +41,20 @@ public:
 
 protected:
 
+  struct RefIndexMap { // Mapping for one reference channel
+    Bool_t defined;
+    Bool_t hashit;
+    Int_t crate;
+    Int_t slot;
+    Int_t channel;
+    Int_t reftime;
+  };
+  std::vector<RefIndexMap> fRefIndexMaps;
+  // Should this be a sparse list instead in case user
+  // picks ridiculously large refindexes?
+
+  Int_t fNRefIndex;
+
   ClassDef(THcHitList,0);  // List of raw hits sorted by plane, counter
 };
 #endif

src/THcRawDCHit.cxx

@@ -17,6 +17,19 @@ void THcRawDCHit::SetData(Int_t signal, Int_t data) {
 
 // Return just the first hit
 Int_t THcRawDCHit::GetData(Int_t signal) {
+  if(fNHits>0) {
+    if(fHasRef) {
+      return(fTDC[0]-fReferenceTime);
+    } else {
+      return(fTDC[0]);
+    }
+  } else {
+    return(-1);
+  }
+}
+
+// Return just the first hit
+Int_t THcRawDCHit::GetRawData(Int_t signal) {
   if(fNHits>0) {
     return(fTDC[0]);
   } else {
@@ -24,8 +37,21 @@ Int_t THcRawDCHit::GetData(Int_t signal) {
   }
 }
 
-// Return a requested hit
+// Return a requested hit with reference time subtracted
 Int_t THcRawDCHit::GetData(Int_t signal, UInt_t ihit) {
+  if(ihit >=0 && ihit< fNHits) {
+    if(fHasRef) {
+      return(fTDC[ihit]-fReferenceTime);
+    } else {
+      return(fTDC[ihit]);
+    }
+  } else {
+    return(-1);
+  }
+}
+
+// Return a requested raw hit
+Int_t THcRawDCHit::GetRawData(Int_t signal, UInt_t ihit) {
   if(ihit >=0 && ihit< fNHits) {
     return(fTDC[ihit]);
   } else {

src/THcRawDCHit.h

@@ -23,6 +23,8 @@ public:
   void SetReference(Int_t signal, Int_t reference);
   Int_t GetData(Int_t signal);
   Int_t GetData(Int_t signal, UInt_t ihit);
+  Int_t GetRawData(Int_t signal);
+  Int_t GetRawData(Int_t signal, UInt_t ihit);
   Int_t GetReference(Int_t signal);
   
 

src/THcRawHit.h

@@ -26,7 +26,8 @@ public:
   //  virtual Bool_t  operator!=( const THcRawHit& ) = 0;
 
   virtual void SetData(Int_t signal, Int_t data) {};
-  virtual Int_t GetData(Int_t signal) {return 0;};
+  virtual Int_t GetData(Int_t signal) {return 0;}; /* Ref time subtracted */
+  virtual Int_t GetRawData(Int_t signal) {return 0;} /* Ref time not subtracted */
   virtual void SetReference(Int_t signal, Int_t reference) {};
   virtual Bool_t HasReference(Int_t signal) {return fHasRef;};
   virtual Int_t GetReference(Int_t signal) {return 0;};