Only look for scalers in banks that might contain them.

  When the db file is read, a list of crate #s and a list of
  module types is made.  The tag of each bank searched for scalers
  must have a tag that is in one of these lists.
  If all scalers are in banks tagged with the module type, then,
  SetOnlyBanks(kTRUE) should be called in which case bank tags will
  be compared only against this list of module types.

src/THcScalerEvtHandler.cxx

@@ -68,8 +68,10 @@ static const UInt_t defaultDT = 4;
 THcScalerEvtHandler::THcScalerEvtHandler(const char *name, const char* description)
   : THaEvtTypeHandler(name,description), evcount(0), ifound(0), fNormIdx(-1),
     dvars(0), dvarsFirst(0), fScalerTree(0), fUseFirstEvent(kFALSE),
-    fDelayedType(-1)
+    fDelayedType(-1), fOnlyBanks(kFALSE)
 {
+  fRocSet.clear();
+  fModuleSet.clear();
 }
 
 THcScalerEvtHandler::~THcScalerEvtHandler()
@@ -180,13 +182,25 @@ Int_t THcScalerEvtHandler::AnalyzeBuffer(UInt_t* rdata)
     if((*p & 0xff00) == 0x1000) {	// Bank Containing banks
       p++;				// Now pointing to a bank in the bank
     } else if (((*p & 0xff00) == 0x100) && (*p != 0xC0000100)) {
-      // Bank containing integers.  Look for scaler data
+      // Bank containing integers.  Look for scalers
+      // This is either ROC bank containing integers or
+      // a bank within a ROC containing data from modules of a single type
+      // Look for scaler data
       // Assume that very first word is a scaler header
       // At any point in the bank where the word is not a matching
       // header, we stop.
+      UInt_t tag = (*p>>16) & 0xffff;
       UInt_t *pnext = p+*(p-1);	// Next bank
       p++;			// First data word
 
+      // Skip over banks that can't contain scalers
+      // If SetOnlyBanks(kTRUE) called, fRocSet will be empty
+      // so only bank tags matching module types will be considered.
+      if(fRocSet.find(tag)==fRocSet.end()
+	 && fModuleSet.find(tag)==fModuleSet.end()) {
+	p = pnext;		// Fall through to end of this else if
+      }
+
       // Look for normalization scaler module first.
       if(fNormIdx >= 0) {
 	UInt_t *psave = p;
@@ -379,21 +393,33 @@ THaAnalysisObject::EStatus THcScalerEvtHandler::Init(const TDatime& date)
 	switch (imodel) {
 	case 560:
 	  scalers.push_back(new Scaler560(icrate, islot));
+	  if(!fOnlyBanks) fRocSet.insert(icrate);
+	  fModuleSet.insert(imodel);
 	  break;
 	case 1151:
 	  scalers.push_back(new Scaler1151(icrate, islot));
+	  if(!fOnlyBanks) fRocSet.insert(icrate);
+	  fModuleSet.insert(imodel);
 	  break;
 	case 3800:
 	  scalers.push_back(new Scaler3800(icrate, islot));
+	  if(!fOnlyBanks) fRocSet.insert(icrate);
+	  fModuleSet.insert(imodel);
 	  break;
 	case 3801:
 	  scalers.push_back(new Scaler3801(icrate, islot));
+	  if(!fOnlyBanks) fRocSet.insert(icrate);
+	  fModuleSet.insert(imodel);
 	  break;
 	case 9001:		// TI Scalers
 	  scalers.push_back(new Scaler9001(icrate, islot));
+	  if(!fOnlyBanks) fRocSet.insert(icrate);
+	  fModuleSet.insert(imodel);
 	  break;
 	case 9250:		// FADC250 Scalers
 	  scalers.push_back(new Scaler9250(icrate, islot));
+	  if(!fOnlyBanks) fRocSet.insert(icrate);
+	  fModuleSet.insert(imodel);
 	  break;
 	}
 	if (scalers.size() > 0) {

src/THcScalerEvtHandler.h

@@ -39,6 +39,7 @@ public:
    virtual Int_t End( THaRunBase* r=0 );
    virtual void SetUseFirstEvent(Bool_t b = kFALSE) {fUseFirstEvent = b;}
    virtual void SetDelayedType(int evtype);
+   virtual void SetOnlyBanks(Bool_t b = kFALSE) {fOnlyBanks = b;fRocSet.clear();}
 
 private:
 
@@ -55,7 +56,10 @@ private:
    TTree *fScalerTree;
    Bool_t fUseFirstEvent;
    Int_t fDelayedType;
+   Bool_t fOnlyBanks;
    std::vector<UInt_t*> fDelayedEvents;
+   std::set<UInt_t> fRocSet;
+   std::set<UInt_t> fModuleSet;
 
    THcScalerEvtHandler(const THcScalerEvtHandler& fh);
    THcScalerEvtHandler& operator=(const THcScalerEvtHandler& fh);