AlgStripSRList.cxx

Go to the documentation of this file.

// $Id: AlgStripSRList.cxx,v 1.37 2010/01/06 18:27:37 rhatcher Exp $
//
// AlgStripSRList.cxx
//
// Begin_Html<img src="../../pedestrians.gif" align=center>
// <a href="../source_warning.html">Warning for beginners</a>.<br> 
//
// AlgStripSRList is a concrete StripSRList Algorithm class.
//
// Author:  R. Lee 2001.01.23
//
// Also see <a href="../../root_crib/index.html">The ROOT Crib</a> and 
// <a href="../CandStrip.html"> CandStrip Classes</a> (part of
// <a href="../index.html">The MINOS Class User Guide</a>)End_Html

#include <cassert>
#include <cmath>

#include <iostream>
using namespace std;

#include "TROOT.h"

#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"
#include "Algorithm/AlgConfig.h"
#include "CandDigit/CandDigitHandle.h"
#include "CandDigit/CandDigitListHandle.h"
#include "Candidate/CandContext.h"
#include "CandStripSR/StripSRListModule.h"
#include "CandStripSR/AlgStripSRList.h"
#include "RecoBase/CandStrip.h"
#include "RecoBase/CandStripHandle.h"
#include "RecoBase/CandStripList.h"
#include "RecoBase/CandStripListHandle.h"
#include "Conventions/Munits.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "Navigation/NavKey.h"
#include "Navigation/NavSet.h"
#include "RawData/RawDigit.h"
#include "RawData/RawHeader.h"
#include "RawData/RawRecord.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawDaqHeaderBlock.h"
#include "RawData/RawDigitDataBlock.h"
#include "Validity/VldContext.h"
#include "DataUtil/GetRawBlock.h"

ClassImp(AlgStripSRList)

static NavKey StripSRKeyFromPSEId(const CandDigitHandle *);
static NavKey StripSRKeyFromTime(const CandDigitHandle *);
static NavKey StripSRKeyFromTube(const CandDigitHandle *);

//______________________________________________________________________

CVSID("$Id: AlgStripSRList.cxx,v 1.37 2010/01/06 18:27:37 rhatcher Exp $");

//______________________________________________________________________
AlgStripSRList::AlgStripSRList(): fNoiseStatsSet(false)
{
}
//_______________________________________________________________________
AlgStripSRList::~AlgStripSRList()
{
}

//______________________________________________________________________

void AlgStripSRList::RunAlg(AlgConfig &ac, CandHandle &ch,CandContext &cx)
{
   assert(cx.GetDataIn());
// Check for CandDigitListHandle input
   if (cx.GetDataIn()->InheritsFrom("CandDigitListHandle")) {
      const CandDigitListHandle *cdlh =
            dynamic_cast<const CandDigitListHandle*>(cx.GetDataIn());
      const MomNavigator *mom = cx.GetMom();

      const RawDigitDataBlock *rddb = 
                DataUtil::GetRawBlock<RawDigitDataBlock>(mom);
      if (!rddb) {
        MSG("AlgStripSRList", Msg::kWarning) << "No RawDigitDataBlock in RawRecord." << endl;
        return;
      }
      TIter digitItr(cdlh->GetDaughterIterator());
      Bool_t found(0);
      CandDigitHandle *digit = dynamic_cast<CandDigitHandle*>(digitItr());
      switch (cdlh->GetVldContext()->GetDetector()) {
      case Detector::kNear:
        RunAlgNear(ac,ch,cx);
        break;
      case Detector::kFar:
        RunAlgFar(ac,ch,cx);
        break;
      case Detector::kCalib:
         // need to check if far or near electronics
        while (digit && !found) {
          const RawDigit *rd = rddb->At(digit->GetRawDigitIndex());
          assert(rd);
          RawChannelId rawid = rd->GetChannel();
          if (rawid.GetElecType()==ElecType::kQIE) found=1;
          digit = dynamic_cast<CandDigitHandle*>(digitItr());
        }
        if (found) {
          RunAlgMixed(ac,ch,cx);
        } else {
          RunAlgFar(ac,ch,cx);
        }
        break;
      default:
        break;
      }
   }
}

//______________________________________________________________________
void AlgStripSRList::RunAlgMixed(AlgConfig &ac, CandHandle &ch,CandContext &cx)
{

   const CandDigitListHandle *cdlh =
         dynamic_cast<const CandDigitListHandle*>(cx.GetDataIn());

   // load parameters
   Double_t ldtime = ac.GetDouble("MaxLocTimeSep");
   Double_t gdtime = ac.GetDouble("MaxGloTimeSep");
   Int_t begplane = ac.GetInt("BegPlane");
   Int_t endplane = ac.GetInt("EndPlane");
   CalTimeType::CalTimeType_t caltimetype = (CalTimeType::CalTimeType_t)(ac.GetInt("CalTimeType"));
   
   /*CandDigits are sorted by plane, strip. */

   CandDigitHandleItr cdhItr(cdlh->GetDaughterIterator());
   CandDigitHandleKeyFunc *cdhKf = cdhItr.CreateKeyFunc();
   cdhKf->SetFun(StripSRKeyFromPSEId);
   cdhItr.GetSet()->AdoptSortKeyFunc(cdhKf);
   cdhKf = 0;

   AlgFactory &af = AlgFactory::GetInstance();
   AlgHandle ah = af.GetAlgHandle("AlgStripSR","default");
   CandContext cxx(this,cx.GetMom());

   /* Nested passes are made through the sorted list. The outer loop constructs an array of candigits  until a new strip id is seen. The inner loop is then made over this list of digits, which is sorted by time.  */
   CandDigitHandle *prev = 0;
   CandDigitHandle *first = 0;
   TObjArray cdhAr;
   cdhAr.Clear();
   TObjArray digitlist;
   digitlist.Clear();
   while (CandDigitHandle *curr = cdhItr()) {
     PlexSEIdAltL pseid = curr->GetPlexSEIdAltL();
     if (pseid.GetPlane()>=begplane && 
         pseid.GetPlane()<=endplane &&
         pseid.GetSize()>0) {
       if (prev) {
         PlexStripEndId pSEId = prev->GetPlexSEIdAltL().GetBestSEId();
         PlexStripEndId cSEId = curr->GetPlexSEIdAltL().GetBestSEId();
         if (pSEId.IsSameStrip(cSEId)) {
           digitlist.Add(curr);
         } else {
           TIter digitItr(&digitlist);
           CandDigitHandleItr timeItr(digitItr);
           CandDigitHandleKeyFunc *timeItrKf = timeItr.CreateKeyFunc();
           timeItrKf->SetFun(StripSRKeyFromTime);
           timeItr.GetSet()->AdoptSortKeyFunc(timeItrKf);
           timeItrKf = 0;
           first = 0;
           cdhAr.Clear();
           CandDigitHandle *prevdigit = 0;
           /* we check that adjacent entries are within the tolerances set by the variables MaxLocTimeSep and MaxGloTimeSep.  The first variable is used to check that no large time gaps occur within a CandStrip, and the second is used to ensure that the total duration of a CandStrip is sensible.*/
           while (CandDigitHandle *digit = timeItr()) {
             if (!first) {
               first = digit;
               cdhAr.Add(digit);
             } else if (digit->GetTime(caltimetype)-prevdigit->GetTime(caltimetype)<ldtime && 
                        digit->GetTime(caltimetype)-first->GetTime(caltimetype)<gdtime) {
               // CandDigit satisfies the requirements above, so add to the CandStrip. 
               cdhAr.Add(digit);
             } else {
               // else done, build this CandStrip
               cxx.SetDataIn(&cdhAr);
               CandStripHandle csh = CandStrip::MakeCandidate(ah,cxx);
               ch.AddDaughterLink(csh);
               cdhAr.Clear();
               cdhAr.Add(digit);
               first = digit;
             }
             prevdigit = digit;
           }
           if (cdhAr.GetSize()>=0) {
             cxx.SetDataIn(&cdhAr);
             CandStripHandle csh = CandStrip::MakeCandidate(ah,cxx);
             ch.AddDaughterLink(csh);
             cdhAr.Clear();
           }
           digitlist.Clear();
           digitlist.Add(curr);
         }
       } else {
         digitlist.Add(curr);
       }
       prev = curr;
     }
   }
 
   // final cleanup of digitlist to find remaining CandStrips
  if (digitlist.GetSize()>=0) {
     TIter digitItr(&digitlist);
     CandDigitHandleItr timeItr(digitItr);
     CandDigitHandleKeyFunc *timeItrKf = timeItr.CreateKeyFunc();
     timeItrKf->SetFun(StripSRKeyFromTime);
     timeItr.GetSet()->AdoptSortKeyFunc(timeItrKf);
     timeItrKf = 0;
     first = 0;
     cdhAr.Clear();
     CandDigitHandle *prevdigit = 0;
     while (CandDigitHandle *digit = timeItr()) {
       if (!first) {
         first = digit;
         cdhAr.Add(digit);
       } else if (digit->GetTime(caltimetype)-prevdigit->GetTime(caltimetype)<ldtime && 
                  digit->GetTime(caltimetype)-first->GetTime(caltimetype)<gdtime) {
         cdhAr.Add(digit);
       } else {
         cxx.SetDataIn(&cdhAr);
         CandStripHandle csh = CandStrip::MakeCandidate(ah,cxx);
         ch.AddDaughterLink(csh);
         cdhAr.Clear();
         cdhAr.Add(digit);
         first = digit;
       }
       prevdigit = digit;
     }
     if (cdhAr.GetSize()>=0) {
       cxx.SetDataIn(&cdhAr);
       CandStripHandle csh = CandStrip::MakeCandidate(ah,cxx);
       ch.AddDaughterLink(csh);
       cdhAr.Clear();
     }
     digitlist.Clear();
   }

}

//______________________________________________________________________
void AlgStripSRList::RunAlgNear(AlgConfig &ac, CandHandle &ch,CandContext &cx)
{

   // NOTE: for the present, do not remove xtalk from ND data.
   // load parameters
   Double_t ldtime;
   Double_t gdtime;
   Double_t timewin;
   
// N. Saoulidou (niki@fnal.gov), 10-24-05. This time cut is introduced in order to exclude 
// from the strip making process, digits that appear within xxx microseconds after a strip
// has already been formed  in the same physical location (the same electronics channel).
 
   timewin = ac.GetDouble("TimeWin");
   ldtime  = ac.GetDouble("MaxLocTimeSep");
   gdtime  = ac.GetDouble("MaxGloTimeSep");
   Int_t    begplane = ac.GetInt("BegPlane");
   Int_t    endplane = ac.GetInt("EndPlane");
   Bool_t doNoiseNear=ac.GetInt("DoNoiseNear");
   Bool_t doNoiseStats=ac.GetInt("DoNoiseStats");
   Double_t nearNoiseAdc=ac.GetDouble("NearNoiseAdc");
  
   StripStat *NoiseStats=0;
   if (doNoiseNear&&doNoiseStats|| !fNoiseStatsSet)
   {
        NoiseStats=FindWhiteBoardStats(nearNoiseAdc);
   }
     
   //   Double_t maxAdjPixelChargeFraction = ac.GetDouble("AdjPixelChargeFraction");
   // Mike Kordosky : Jan 19, 2005 ... noticed while browsing
   // see comment on xtalkmap below
   // Double_t timewindow=ac.GetDouble("MaxXtalkTimeWindow");

   const CandDigitListHandle *cdlh =
         dynamic_cast<const CandDigitListHandle*>(cx.GetDataIn());

   /*  CandDigits are sorted by plane, strip, and time, which ensures that CandDigits wwhich will be associated into CandStrips occupy adjacent entries in this sorted list, and that the CandDigit with the earliest time in a given strip and plane will appear first.
    */

   CandDigitHandleItr cdhItr(cdlh->GetDaughterIterator());
   CandDigitHandleKeyFunc *cdhKf = cdhItr.CreateKeyFunc();
   
   //Rustem Ospanov: fixing NavKey bug 2005.01.20
   //Create NavKey for sorting by encoded PlexStripEndId
   //Do not sort until time NavKey is adopted
   cdhKf->SetFun(StripSRKeyFromPSEId);
   cdhItr.GetSet()->AdoptSortKeyFunc(cdhKf, kTRUE, kFALSE);

   //Created NavKey for sorting by time
   cdhKf = cdhItr.CreateKeyFunc();
   cdhKf -> SetFun(StripSRKeyFromTime);

   //Sort CandDigits first by encoded PlexStripEndId and then by time
   cdhItr.GetSet()->AdoptSortKeyFunc(cdhKf, kFALSE);
   cdhKf = 0;


// Get singleton instance of AlgFactory
   AlgFactory &af = AlgFactory::GetInstance();

// Get an AlgHandle to AlgStripSR with default AlgConfig
   AlgHandle ah = af.GetAlgHandle("AlgStripSR","default");

// Create Candcontext
   CandContext cxx(this,cx.GetMom());

// Iterate over CandDigitList daughters
   CandDigitHandle *prev = 0;
   CandDigitHandle *first = 0;
   TObjArray cdhAr;
   cdhAr.Clear();

   CalTimeType::CalTimeType_t caltimetype = (CalTimeType::CalTimeType_t)(ac.GetInt("CalTimeType"));

   // generate map containing ratio of digitization charge to 
   // xtalk charge associated with each digitization.
   // xtalk is defined to be the charge seen in adjacent pixels.  Diagonal
   // pixels are not included. 

   // Mike Kordosky : Jan 19, 2005 ... noticed while browsing
   // Why waste time making the map below if it's never used?
   // map<CandDigitHandle*,float> xtalkmap = MakeXtalkMap(cdlh,timewindow);


   /* One pass is made through the sorted list, checking for identical strip/plane values in adjacent entries, and checking that the time is within the tolerances set by the variables MaxLocTimeSep and MaxGloTimeSep.  The first variable is used to check that no large time gaps occur within a CandStrip, and the second is used to ensure that the total duration of a CandStrip is sensible.  If this occurs, and the CandDigit satisfies the requirements above, the CandDigits are added to the CandStrip.   */
   TObjArray cdhAru;
   cdhAru.Clear();
   
   while (CandDigitHandle *curr = cdhItr()) {
    
     PlexSEIdAltL pseid = curr->GetPlexSEIdAltL();     
     Bool_t dig_notprev  =true;
     Bool_t dig_notprev2 =true;
     PlexStripEndId pseid1 = curr->GetPlexSEIdAltL().GetBestSEId();     
     Bool_t isfirst2=false;
     
     for(Int_t i=0;i<cdhAru.GetLast()+1;i++){
      CandDigitHandle *prevv=dynamic_cast<CandDigitHandle*>(cdhAru.At(i));
      PlexStripEndId pseid2 = prevv->GetPlexSEIdAltL().GetBestSEId();      
      if( pseid1.IsSameStrip(pseid2) && isfirst2==false){
       isfirst2=true;
       Double_t timediff=curr->GetTime(caltimetype)-prevv->GetTime(caltimetype);
       if(timediff<timewin) dig_notprev=false;       
      }
     }       
     
     if (pseid.GetPlane()>=begplane && pseid.GetPlane()<=endplane && pseid.GetSize()>0&& dig_notprev) {
       if (prev) {
         PlexStripEndId pSEId = prev->GetPlexSEIdAltL().GetBestSEId();
         PlexStripEndId cSEId = curr->GetPlexSEIdAltL().GetBestSEId();
         if (pSEId.IsSameStrip(cSEId) &&
             curr->GetTime(caltimetype)-prev->GetTime(caltimetype)<ldtime && 
             curr->GetTime(caltimetype)-first->GetTime(caltimetype)<gdtime) {
           cdhAr.Add(curr);
         } 
         else {    
        
            for(Int_t ii=0;ii<cdhAr.GetLast()+1;ii++){       
              cdhAru.Add(cdhAr.At(ii));       
            }    
           if (!doNoiseNear || PassNearNoise(&cdhAr,nearNoiseAdc,NoiseStats)) { 
            //cout << " I AM LETTING IT " << endl;
            cxx.SetDataIn(&cdhAr);
            CandStripHandle csh = CandStrip::MakeCandidate(ah,cxx);
            ch.AddDaughterLink(csh);
           }       
           cdhAr.Clear();
           dig_notprev2=true;      
           Bool_t isfirst=false;
          
           for(Int_t i=0;i<cdhAru.GetLast()+1;i++){
             CandDigitHandle *prevv=dynamic_cast<CandDigitHandle*>(cdhAru.At(i));
             PlexStripEndId pseid2 = prevv->GetPlexSEIdAltL().GetBestSEId();
             if(pseid1.IsSameStrip(pseid2) && isfirst==false){
             isfirst=true;
             Double_t timediff2=curr->GetTime(caltimetype)-prevv->GetTime(caltimetype);
             if(timediff2<timewin) {
              dig_notprev2=false;             
             }
            }
           }
           if(dig_notprev2) {
            cdhAr.Add(curr);
            first=curr;
           }
         }
       } // end if if previous  
       else {
         cdhAr.Add(curr);
         first = curr;
       }
       if(dig_notprev2)       prev = curr;
       else if(!dig_notprev2) prev=0;
     }
   }
   
   if (prev) {
      if ( !doNoiseNear || PassNearNoise(&cdhAr,nearNoiseAdc,NoiseStats) )
      {
      cxx.SetDataIn(&cdhAr);
      CandStripHandle csh = CandStrip::MakeCandidate(ah,cxx);
      ch.AddDaughterLink(csh);
   }
  }

}

//______________________________________________________________________
void AlgStripSRList::RunAlgFar(AlgConfig &ac, CandHandle &ch,CandContext &cx)
{
  MSG("Alg", Msg::kDebug)
                          << "Starting AlgStripSRList::RunAlgFar()" << endl;

  const CandDigitListHandle *cdlh =
        dynamic_cast<const CandDigitListHandle*>(cx.GetDataIn());
  const MomNavigator *mom = cx.GetMom();

  const RawDigitDataBlock *rddb = 
    DataUtil::GetRawBlock<RawDigitDataBlock>(mom);
  if (!rddb) {                                         
    MSG("StripSR", Msg::kWarning) << "No RawDigitDataBlock in RawRecord." << endl;
    return;
  }
 
  Int_t begplane = ac.GetInt("BegPlane");
  Int_t endplane = ac.GetInt("EndPlane");
  Double_t maxAdjPixelChargeFraction = ac.GetDouble("AdjPixelChargeFraction");
  Double_t timewindow=ac.GetDouble("MaxXtalkTimeWindow");

  // generate map containing ratio of digitization charge to 
  // xtalk charge associated with each digitization.
  // xtalk is defined to be the charge seen in adjacent pixels.  Diagonal
  // pixels are not included. 

  map<CandDigitHandle*,float> xtalkmap = MakeXtalkMap(cdlh, timewindow);

  /*  CandDigits are sorted by plane and strip, which ensures that CandDigits which will be  associated into CandStrips occupy adjacent entries in this sorted list. */
   CandDigitHandleItr cdhItr(cdlh->GetDaughterIterator());
   CandDigitHandleKeyFunc *cdhKf = cdhItr.CreateKeyFunc();
   cdhKf->SetFun(StripSRKeyFromPSEId);
   cdhItr.GetSet()->AdoptSortKeyFunc(cdhKf);
   cdhKf = 0;

   AlgFactory &af = AlgFactory::GetInstance();
   AlgHandle ah = af.GetAlgHandle("AlgStripSR","default");
   CandContext cxx(this,cx.GetMom());

   /*
 One pass is made through the sorted list, checking for identical strip/plane values in adjacent entries.  If this occurs, and the CandDigit satisfies the requirements above, the CandDigits are added to the CandStrip.
   */

   CandDigitHandle *prev = 0;
   TObjArray cdhAr;
   cdhAr.Clear();
   while (CandDigitHandle *curr = cdhItr()) {
     if (curr->GetPlexSEIdAltL().GetPlane()>=begplane &&
         curr->GetPlexSEIdAltL().GetPlane()<=endplane &&
         xtalkmap[curr]>=maxAdjPixelChargeFraction &&
         !curr->GetPlexSEIdAltL().IsVetoShield() &&
         !curr->GetPlexSEIdAltL().GetDemuxVetoFlag() &&
         curr->GetPlexSEIdAltL().GetSize()>0) {
       if (prev) {
         PlexStripEndId pSEId = prev->GetPlexSEIdAltL().GetBestSEId();
         PlexStripEndId cSEId = curr->GetPlexSEIdAltL().GetBestSEId();
         if (pSEId.IsSameStrip(cSEId)) {
            cdhAr.Add(curr);
         } else {
            cxx.SetDataIn(&cdhAr);
            CandStripHandle csh = CandStrip::MakeCandidate(ah,cxx);
            ch.AddDaughterLink(csh);
            cdhAr.Clear();
            cdhAr.Add(curr);
         }
      } else {
         cdhAr.Add(curr);
      }
      prev = curr;
     }
   }
   if (prev) {
      cxx.SetDataIn(&cdhAr);
      CandStripHandle csh = CandStrip::MakeCandidate(ah,cxx);
      ch.AddDaughterLink(csh);
   }



}

//---------------------------------------------
map<CandDigitHandle*,float> AlgStripSRList::MakeXtalkMap(const CandDigitListHandle * cdlh, Double_t timewindow){

  Int_t pmtcolumnsize=4;
  if(cdlh->GetVldContext()->GetDetector()==Detector::kNear)pmtcolumnsize=8;
       
  map<CandDigitHandle*,float> xtalkmap;

  // For inner loop, select digitizations on same PMT
 
  CandDigitHandleItr digitItr2(cdlh->GetDaughterIterator());
  CandDigitHandleKeyFunc *cdhKf = digitItr2.CreateKeyFunc();
  cdhKf->SetFun(StripSRKeyFromTube);
  digitItr2.GetSet()->AdoptSortKeyFunc(cdhKf);
  cdhKf = 0;

  CandDigitHandleItr digitItr1(cdlh->GetDaughterIterator());
  while (CandDigitHandle *digit1 = dynamic_cast<CandDigitHandle*>(digitItr1())) {
    Int_t pixel1=digit1->GetPlexSEIdAltL().GetBestItem().GetPixelSpotId().GetPixel();
    Int_t tube1=digit1->GetPlexSEIdAltL().GetBestItem().GetPixelSpotId().GetUniquePmtEncodedValue();
    Int_t ix1 = (pixel1)%pmtcolumnsize;
    Int_t iy1 = (Int_t)((pixel1)/pmtcolumnsize+.5);
    float pixelcharge = digit1->GetCharge();
    float xcharge = 0;

    // set digitIt2 to iterate over digitizations on same tube as digitItr1
    // Note:  This technique turned out to be a net time sink
    //    digitItr2.GetSet()->ClearSlice();
    //  digitItr2.GetSet()->Slice(tube1);
    
    digitItr2.Reset();
    while (CandDigitHandle *digit2 = dynamic_cast<CandDigitHandle*>(digitItr2())) {
      if (digit1!=digit2) {
        Int_t pixel2=digit2->GetPlexSEIdAltL().GetBestItem().GetPixelSpotId().GetPixel();
        Int_t tube2=digit1->GetPlexSEIdAltL().GetBestItem().GetPixelSpotId().GetUniquePmtEncodedValue();
        // break out of loop when we have passed the tube match
        Int_t comptube = StripSRKeyFromTube(digit2).CompareValue(tube1);
        if(comptube<0) break;
        if(tube1==tube2){
          if (pixel1!=pixel2) {
            Int_t ix2 = (pixel2)%pmtcolumnsize;
            Int_t iy2 = (Int_t)((pixel2)/pmtcolumnsize+.5);
            if(abs(ix1-ix2)+abs(iy1-iy2)==1 && 
               fabs(digit1->GetTime()-digit2->GetTime())<timewindow){
              xcharge += digit2->GetCharge();
            }
          }
          else if((pixel1==pixel2) &&
                  fabs(digit1->GetTime()-digit2->GetTime())<timewindow ){
            pixelcharge +=digit2->GetCharge();
          }
        }
      }
    }//end inner loop over digits to find xtalk
    if(xcharge+pixelcharge != 0.) xtalkmap[digit1] = pixelcharge/(xcharge+pixelcharge);
    else xtalkmap[digit1] = 0.;
  }//end loop over digit
  return xtalkmap;
}

//______________________________________________________________________
void AlgStripSRList::Trace(const char * /* c */) const
{
}

NavKey StripSRKeyFromPSEId(const CandDigitHandle *cdh)
{
//
//  Purpose:  Generate a sort key based on the encoded strip end ID of
//            a CandDigit.
//
//  Arguments:
//    cdh        in    Handle to CandDigit to be sorted.
//
//  Return:   Encoded strip end ID.
//

   return const_cast<CandDigitHandle *>(cdh)->GetPlexSEIdAltL()
                                      .GetBestSEId().GetEncoded();
}


NavKey StripSRKeyFromTime(const CandDigitHandle *cdh)
{
//
//  Purpose:  Generate a sort key based on the encoded strip end ID and
//            time of a CandDigit.
//
//  Arguments:
//    cdh        in    Handle to CandDigit to be sorted.
//
//  Return:   Encoded strip end ID.
//

// Get Singleton instance of AlgFactory.
  AlgFactory &af = AlgFactory::GetInstance();
  AlgHandle adf = af.GetAlgHandle("AlgStripSRList","default");
  AlgConfig &ac = adf.GetAlgConfig(); 

  CalTimeType::CalTimeType_t caltimetype = (CalTimeType::CalTimeType_t)(ac.GetInt("CalTimeType"));
 
   Double_t time = cdh->GetTime(caltimetype);
   Int_t itime = static_cast<Int_t>((time/(1.*Munits::ns))+.5);

   Int_t navkey = itime;
   return navkey;
}

NavKey StripSRKeyFromTube(const CandDigitHandle *cdh)
{
//
//  Purpose:  Generate a sort key based on the unique PMT id
//           
//
//  Arguments:
//    cdh        in    Handle to CandDigit to be sorted.
//
//  Return:   PMT id
//
 
  Int_t navkey=cdh->GetPlexSEIdAltL().GetBestItem().GetPixelSpotId().GetUniquePmtEncodedValue();
   return navkey;
}
Bool_t AlgStripSRList::PassNearNoise(TObjArray* cdhAr, Float_t adcMin,
                        StripStat* stats)
{


        Int_t ndig=cdhAr->GetEntriesFast();
        
        
        
        CandDigitHandle *cdh=(CandDigitHandle*)cdhAr->First();

        Float_t q=cdh->GetCharge(CalDigitType::kNone);

        //cout << " I am getting the entries in pass near noise " << ndig << " charge  " << q  << endl;

        RawChannelId rcid=cdh->GetChannelId();
        rcid.ClearModeBits();

        Bool_t isnoise=( 1 == ndig  && q < adcMin) ;

        MSG("AlgStripSRList", Msg::kDebug) <<
        " encoutered RawChannelId:"<<rcid<<
        " ndig="<<ndig << 
        " ADC="<<q << 
        " Noise=="<<isnoise << endl;

        if ( stats ) stats->Add(rcid,isnoise);

        return !isnoise;



}
StripStat* AlgStripSRList::FindWhiteBoardStats(Double_t adcMin)
{

// from George Irwin/Brian Rebel:
// Find the StripStat object or create one for needed scratch space
        StripStat *stats = dynamic_cast<StripStat*>(gROOT->GetRootFolder()->
        FindObject("Loon/CandStripSR/StripStat"));
        if (stats == 0) {
                MSG("AlgStripSRList", Msg::kWarning)
                << "//root/Loon/CandStripSR/StripStat not found,"
                << " although DoNoiseStats=true"
                << endl;
        } else if (!fNoiseStatsSet) {
                        // the stats copies of these parameters are for
                        // printing only, and don't affect the Alg
                stats->fDoNoiseNear=true;
                stats->fDoNoiseStats=true;
                stats->fNearNoiseADC=adcMin;
                fNoiseStatsSet=true;
        }

        return stats;

}

---