AlgCalDetSI.cxx

Go to the documentation of this file.

/********************************************************************************/
/*  AlgCalDetSI                                                                 */
/*  A class to fill CandCalDetSI                                                */
/*  Tricia Vahle & Mike Kordosky                                                */
/*  January 8, 2002                                                             */
/********************************************************************************/
#include <cmath>
#include <map>
#include "CalDetSI/AlgCalDetSI.h"
#include "CalDetSI/CandCalDetSIHandle.h"
#include "CalDetSI/Helpers.h"
#include "Candidate/CandContext.h"
#include "CandData/CandRecord.h"
#include "CandData/CandHeader.h"
#include "Conventions/Munits.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawDigit.h"
#include "RawData/RawHeader.h"
#include "RawData/RawRecord.h"
#include "RawData/RawSnarlHeaderBlock.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawDeadChipBlock.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawOvershootBlock.h"
#include "RawData/RawVarcErrorInTfBlock.h"
#include "RawData/RawTOFBlock.h"
#include "RawData/RawTOFDigit.h"
#include "RawData/RawVaDigit.h"
#include "Validity/VldContext.h"
#include "OnlineUtil/mdBlockDefinitions.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexHandle.h"

ClassImp(AlgCalDetSI)  //macro for rootifying
CVSID("$Id: AlgCalDetSI.cxx,v 1.9 2005/04/12 21:09:05 kordosky Exp $");

//______________________________________________________________________________

Int_t AlgCalDetSI::fLastSnarlTick = 0;
Int_t AlgCalDetSI::fLastSnarlSec = 0;
Int_t AlgCalDetSI::fTimeFrame = 0;
set<Int_t> AlgCalDetSI::fVarcErrSet;



RawChannelId AlgCalDetSI::kCerenkovChannel1;
RawChannelId AlgCalDetSI::kCerenkovChannel2;
RawChannelId AlgCalDetSI::kCerenkovChannel3;
RawChannelId AlgCalDetSI::kTriggerPMTChannel;
RawChannelId AlgCalDetSI::kTofADCChannel0;
RawChannelId AlgCalDetSI::kTofADCChannel1;
RawChannelId AlgCalDetSI::kTofADCChannel2;
RawChannelId AlgCalDetSI::kTofTimeStampChannel;
std::vector<RawChannelId> AlgCalDetSI::kTriggerORs;
UInt_t AlgCalDetSI::kGoodTriggerORBits=0;
const Int_t AlgCalDetSI::kNTIMEBLOCKS=40;

AlgCalDetSI::AlgCalDetSI():
  fRunNumber(0),
  fRawDDB(0),
  fRawDCB(0),
  fRawOSB(0),
  fRawTOFB(0),
  fRawSDB(0),
  fRawDSH(0),
  fRawVErrB(0)


{} //end constructor

//______________________________________________________________________________

AlgCalDetSI::~AlgCalDetSI() {} //destructor

//______________________________________________________________________________

void AlgCalDetSI::RunAlg(AlgConfig & /* ac */, CandHandle &ch, CandContext &cx)
{

   //get the special channel RawChannelId's from the database
//but first get the run number, so we only get the channel id's once per run
   CandRecord *cr = dynamic_cast<CandRecord *>
      (cx.GetMom()->GetFragment("CandRecord"));
//   CandRecord *cr = cx.GetCandRecord();
   const CandHeader *chead = cr->GetCandHeader();
   if(chead->GetRun()!=fRunNumber){
      const VldContext *vc = cr->GetVldContext();
      MSG("AlgCalDetSI",Msg::kDebug)<<" Validity context "<<*vc<<endl;
      VldTimeStamp sanity(1990,0,0,0,0,0);
      if(vc->GetTimeStamp()<sanity){
         MSG("AlgCalDetSI",Msg::kWarning)<<" Skipping silly record with "
                                         <<"silly timestamp <1990 "<<endl
                                         <<" vc is "<<*vc<<endl;
         return;
      }
      PlexHandle ph(*vc,kTRUE);
      kCerenkovChannel1=ph.GetSpecialChannelContains("DSCER");
      kCerenkovChannel2=ph.GetSpecialChannelContains("MIDCER");
      kCerenkovChannel3=ph.GetSpecialChannelContains("USCER");
      kTriggerPMTChannel=ph.GetSpecialChannelContains("FlashTrigPMT");
      kTofADCChannel0=ph.GetSpecialChannelContains("TADC0");
      kTofADCChannel1=ph.GetSpecialChannelContains("TTAG");
      if(kTofADCChannel1==0){
         kTofADCChannel1=ph.GetSpecialChannelContains("TADC1");
      }
      kTofADCChannel2=ph.GetSpecialChannelContains("TimingFid");
      if(kTofADCChannel2==0){
         kTofADCChannel2=ph.GetSpecialChannelContains("TADC2");
      }
      kTofTimeStampChannel=ph.GetSpecialChannelContains("TTIME");
      
      // MAK: 15 Feb, 2005
      // multiple channels labeled TriggerOR in the DB
      // all refer to lemo inputs on the varcs
      // a good trigger should have hits on all these channels
      // ... we might want to check that!
      //
      const std::map<RawChannelId, std::string>& spec_chan_map 
        = ph.GetSpecialDescriptMap();
      std::map<RawChannelId, std::string>::const_iterator it = 
        spec_chan_map.begin();
      for( ; it!=spec_chan_map.end(); it++){
        const std::string& chan_description = it->second;
        if(chan_description.find("TriggerOR")!=std::string::npos){
          kTriggerORs.push_back(it->first);
        }
      }
      //
      fRunNumber = chead->GetRun();
      MSG("AlgCalDetSI",Msg::kDebug)<<"The special channels:"<<endl;
      MSG("AlgCalDetSI",Msg::kDebug)<<"tof 0 "<<kTofADCChannel0<<endl;
      MSG("AlgCalDetSI",Msg::kDebug)<<"tof 1 "<<kTofADCChannel1<<endl;
      MSG("AlgCalDetSI",Msg::kDebug)<<"tof 2 "<<kTofADCChannel2<<endl;
      MSG("AlgCalDetSI",Msg::kDebug)<<"cer 1 "<<kCerenkovChannel1<<endl;
      MSG("AlgCalDetSI",Msg::kDebug)<<"cer 2 "<<kCerenkovChannel2<<endl;
      MSG("AlgCalDetSI",Msg::kDebug)<<"cer 3 "<<kCerenkovChannel3<<endl;
      MSG("AlgCalDetSI",Msg::kDebug)<<"trig pmt "<<kTriggerPMTChannel<<endl;
      MSG("AlgCalDetSI",Msg::kDebug)<<"TriggerOR channels: "<<endl;
      kGoodTriggerORBits=0;
      std::vector<RawChannelId>::iterator torit = kTriggerORs.begin();
      for(; torit!=kTriggerORs.end(); torit++){
        MSG("AlgCalDetSI",Msg::kDebug)<<(*torit)<<endl;
        kGoodTriggerORBits|=CandCalDetSIHandle::ComputeTORBits(torit->GetCrate(), torit->GetVarcId());
      }
      MSG("AlgCalDetSI",Msg::kDebug)<<"GoodTORBits: "<<kGoodTriggerORBits<<std::endl;

   }
   

  //get data and use CandCalDetSIHandle methods 
  //to set CandCalDetSI member variables

  if(!ch.InheritsFrom("CandCalDetSIHandle")){
    MSG("AlgCalDetSI",Msg::kError)<<"Bad parameter in RunAlg"<<endl; 
    return;
  }

  CandCalDetSIHandle *ccdhp = dynamic_cast<CandCalDetSIHandle *>(&ch);
  if(ccdhp==0){
    MSG("AlgCalDetSI", Msg::kError)<<"Could not make a CandCalDetSIHandle"<<endl;
    return;
  }
  CandCalDetSIHandle &ccdh = *ccdhp;


  MSG("AlgCalDetSI",Msg::kDebug)<<"Datapointers before setting: "<<endl
                                <<"fRawDDB "<<fRawDDB<<endl
                                <<"fRawDCB "<<fRawDCB<<endl
                                <<"fRawOSB "<<fRawOSB<<endl
                                <<"fRawTOFB "<<fRawTOFB<<endl
                                <<"fRawSDB "<<fRawSDB<<endl
                                <<"fRawVErrB "<<fRawVErrB<<endl
                                <<endl;

  SetDataPointers(cx);  

  MSG("AlgCalDetSI",Msg::kDebug)<<"Datapointers after setting: "<<endl
                                <<"fRawDDB "<<fRawDDB<<endl
                                <<"fRawDCB "<<fRawDCB<<endl
                                <<"fRawOSB "<<fRawOSB<<endl
                                <<"fRawTOFB "<<fRawTOFB<<endl
                                <<"fRawSDB "<<fRawSDB<<endl
                                <<"fRawVErrB "<<fRawVErrB<<endl
                                <<endl;

  Int_t timestamp; //timestamp of first digit in the list
  Int_t earliestts = 640000000; //earliest timestamp (640000000 is largest tick can be)
  Int_t latestts = 0;  //latest timestamp
  Int_t timeframe; //timeframe

  ccdh.SetCerenkovChannel1(kCerenkovChannel1);
  ccdh.SetCerenkovChannel2(kCerenkovChannel2);
  ccdh.SetCerenkovChannel3(kCerenkovChannel3);
  
  if(fRawDDB!=0){
    MSG("AlgCalDetSI",Msg::kDebug)<<"Found RawDataBlock"<<endl;
    //fRawDDB->Print();
    int size = fRawDDB->GetSize();
    const Int_t *ptr = fRawDDB->GetData();
    for (int i=0;i<size;i++) {
      MSG("AlgCalDetSI",Msg::kDebug)<<i<<" "<<hex<<ptr[i]<<dec<<endl;
    }
    MSG("AlgCalDetSI",Msg::kDebug)<<endl;
    int NDigits = fRawDDB->GetNumberOfDigits();
    for(int i=0;i<NDigits;i++){ //loop over digits
      const RawDigit *digit = fRawDDB->At(i);
      MSG("AlgCalDetSI",Msg::kDebug)<<"******RawDigit info ****************"<<endl;
      //digit->Print();
      MSG("AlgCalDetSI",Msg::kDebug)<<endl<<"*********************"<<endl;
      Int_t ts = digit->GetTDC();
      const RawChannelId cid = digit->GetChannel();
      if(i==0){//get timestamp of first digit, used later when reading errors
        timestamp = ts;
      }

      //find max and min timestamps of detector hits
      Bool_t dtorhit = kTRUE;
      if(IsCosmic(cid)) dtorhit = kFALSE;
      if(cid.GetElecType()==ElecType::kVA){
         if(kCerenkovChannel1.GetElecType()==ElecType::kVA){
            if(cid.IsSameVAChip(kCerenkovChannel1)) dtorhit = kFALSE;
         }
         if(kCerenkovChannel2.GetElecType()==ElecType::kVA){
            if(cid.IsSameVAChip(kCerenkovChannel2)) dtorhit = kFALSE;
         }
         if(kCerenkovChannel3.GetElecType()==ElecType::kVA){
            if(cid.IsSameVAChip(kCerenkovChannel3)) dtorhit = kFALSE;
         }
         if(kTriggerPMTChannel.GetElecType()==ElecType::kVA){
            if(cid.IsSameVAChip(kTriggerPMTChannel)) dtorhit = kFALSE;
         }
         if(kTofTimeStampChannel.GetElecType()==ElecType::kVA){
            if(cid.IsSameVAChip(kTofTimeStampChannel)) dtorhit = kFALSE;
         }
         if(kTofADCChannel0.GetElecType()==ElecType::kVA){
            if(cid.IsSameVAChip(kTofADCChannel0)) dtorhit = kFALSE;
         }
         if(kTofADCChannel1.GetElecType()==ElecType::kVA){
            if(cid.IsSameVAChip(kTofADCChannel1)) dtorhit = kFALSE;
         }
         if(kTofADCChannel2.GetElecType()==ElecType::kVA){
            if(cid.IsSameVAChip(kTofADCChannel2)) dtorhit = kFALSE;
         } 
      }
      else if(cid.GetElecType()==ElecType::kQIE){
         if(kCerenkovChannel1.GetElecType()==ElecType::kQIE){
            if(cid.IsSameChannel(kCerenkovChannel1)) dtorhit = kFALSE;
         }
         if(kCerenkovChannel2.GetElecType()==ElecType::kQIE){
            if(cid.IsSameChannel(kCerenkovChannel2)) dtorhit = kFALSE;
         }
         if(kCerenkovChannel3.GetElecType()==ElecType::kQIE){
            if(cid.IsSameChannel(kCerenkovChannel3)) dtorhit = kFALSE;
         }
         if(kTriggerPMTChannel.GetElecType()==ElecType::kQIE){
            if(cid.IsSameChannel(kTriggerPMTChannel)) dtorhit = kFALSE;
         }
         if(kTofTimeStampChannel.GetElecType()==ElecType::kQIE){
            if(cid.IsSameChannel(kTofTimeStampChannel)) dtorhit = kFALSE;
         }
         if(kTofADCChannel0.GetElecType()==ElecType::kQIE){
            if(cid.IsSameChannel(kTofADCChannel0)) dtorhit = kFALSE;
         }
         if(kTofADCChannel1.GetElecType()==ElecType::kQIE){
            if(cid.IsSameChannel(kTofADCChannel1)) dtorhit = kFALSE;
         }
         if(kTofADCChannel2.GetElecType()==ElecType::kQIE){
            if(cid.IsSameChannel(kTofADCChannel2)) dtorhit = kFALSE;
         } 
      }
      if(dtorhit){
         if(earliestts>ts){
            //find tick of earliest hit
            earliestts =ts;
            ccdh.SetSnarlMinTimeStamp(ts);
         }
         if(latestts<ts){
            latestts = ts;
            ccdh.SetSnarlMaxTimeStamp(ts);
         }
      }

      if(digit->GetErrorCode()&RawVaDigit::kWarningState){ //check for faf
        ccdh.SetFafErr(kTRUE);
      }
      if(cid.IsSameChannel(kCerenkovChannel1)){  //check for Kov hit
        ccdh.SetKovADC1(digit->GetADC());
        ccdh.SetKovTimeStamp1(digit->GetTDC());
        MSG("AlgCalDetSI",Msg::kDebug)<<"Found a Kov hit : ADC1="<<ccdh.GetKovADC1()
                                      <<" at time "<<ccdh.GetKovTimeStamp1()<<endl;
      }
      if(cid.IsSameChannel(kCerenkovChannel2)){  //check for Kov hit
        ccdh.SetKovADC2(digit->GetADC());
        ccdh.SetKovTimeStamp2(digit->GetTDC());
        MSG("AlgCalDetSI",Msg::kDebug)<<"Found a Kov hit : ADC2="<<ccdh.GetKovADC2()
                                      <<" at time "<<ccdh.GetKovTimeStamp2()<<endl;
      }
      if(cid.IsSameChannel(kCerenkovChannel3)){  //check for Kov hit
        ccdh.SetKovADC3(digit->GetADC());
        ccdh.SetKovTimeStamp3(digit->GetTDC());
        MSG("AlgCalDetSI",Msg::kDebug)<<"Found a Kov hit : ADC3="<<ccdh.GetKovADC3()
                                      <<" at time "<<ccdh.GetKovTimeStamp3()<<endl;
      }
      // TofADC added by MAK -- July 5, 2002
      if(cid.IsSameChannel(kTofADCChannel0)){  //check for Kov hit
        ccdh.SetTofADC0(digit->GetADC());
        ccdh.SetTofADCTimeStamp0(digit->GetTDC());
        MSG("AlgCalDetSI",Msg::kDebug)<<"Found a Tof ADC hit : ADC0="<<ccdh.GetTofADC0()
                                      <<endl;
      }
      if(cid.IsSameChannel(kTofADCChannel1)){  //check for Kov hit
        ccdh.SetTofADC1(digit->GetADC());
        ccdh.SetTofADCTimeStamp1(digit->GetTDC());
        MSG("AlgCalDetSI",Msg::kDebug)<<"Found a Tof ADC hit : ADC1="
                                      <<ccdh.GetTofADC1()
                                      <<endl;
      }
      if(cid.IsSameChannel(kTofADCChannel2)){  //check for Kov hit
        ccdh.SetTofADC2(digit->GetADC());
        ccdh.SetTofADCTimeStamp2(digit->GetTDC());
        MSG("AlgCalDetSI",Msg::kDebug)<<"Found a Tof ADC hit : ADC1="
                                      <<ccdh.GetTofADC2()
                                      <<endl;
      }
      if(cid.IsSameChannel(kTofTimeStampChannel)){
        ccdh.SetTofTimeStamp(digit->GetTDC());
      }

      // modified by MAK -- July 5, 2002
      //      if(cid==kTriggerPMTChannel){ //check for TriggerPMT hit
      if(cid.IsSameChannel(kTriggerPMTChannel)){ //check for TriggerPMT hit
        ccdh.SetTriggerPMT(kTRUE);
      }
      if(IsCosmic(cid)){  //check for Cosmic Counter hit
        ccdh.SetCosmicCnt(kTRUE);
      }
      
      // check to see if this is a triggerOR channel (e.g. varc lemo)
      // if so, set a bit
      std::vector<RawChannelId>::iterator torit=kTriggerORs.begin();
      for(; torit!=kTriggerORs.end(); torit++){
        if(cid.IsSameChannel(*torit)){
          UShort_t crate = torit->GetCrate();
          UShort_t varc = torit->GetVarcId();
          ccdh.SetTriggerORBits(crate,varc);
        }
      }
    }//end loop over digits
    // after all digits have been looked at compare the triggerOR bits 
    // to kGoodTORBits (e.g. the case where all bits are true)
    MSG("AlgCalDetSI",Msg::kDebug)<<"TriggerORBits = "
                                  <<ccdh.GetTriggerORBits()
                                  <<"    (all set = "<<kGoodTriggerORBits
                                  <<" )"<<endl;

    if(ccdh.GetTriggerORBits() == kGoodTriggerORBits){
      ccdh.SetTriggerOROK(kTRUE);
    }
    else{
      ccdh.SetTriggerOROK(kFALSE);
    }
      

  }//end if fRawDDB!=0
  else{//if fRawDDB==0, there is no data and something is wrong with this event
    ccdh.SetFafErr(kTRUE);
    ccdh.SetKovADC1(-999);
    ccdh.SetKovADC2(-999);
    ccdh.SetKovADC3(-999);
    ccdh.SetTriggerPMT(kTRUE);
    ccdh.SetCosmicCnt(kTRUE);
    ccdh.SetIsSnarlRecord(kFALSE);
  }

  MSG("AlgCalDetSI",Msg::kDebug)<<endl<<"Faf err "<<(int)ccdh.GetFafErr()<<endl
                                <<"KovADC "<<ccdh.GetKovADC1()<<endl
                                <<"Kov Time Stamp "<<ccdh.GetKovTimeStamp1()<<endl
                                <<"KovADC "<<ccdh.GetKovADC2()<<endl
                                <<"Kov Time Stamp "<<ccdh.GetKovTimeStamp2()<<endl
                                <<"KovADC "<<ccdh.GetKovADC3()<<endl
                                <<"Kov Time Stamp "<<ccdh.GetKovTimeStamp3()<<endl
                                <<"Trigger PMT "<<(int)ccdh.GetTriggerPMT()<<endl
                                <<"Cosmic Cnt "<<(int)ccdh.GetCosmicCnt()<<endl;
    

  if(fRawDCB!=0){
    MSG("AlgCalDetSI",Msg::kDebug)<<"Found DeadChipBlock"<<endl;
    //Stolen code from RawDataBlock::Print
    DetectorType::Detector_t det = fRawDCB->GetBlockId().GetDetector();
    // assume this block is only sensible for VA electronics
    ElecType::Elec_t elec = ElecType::kVA;
    Int_t  crate = -1;
    const Int_t* realdata = fRawDCB->GetData();
//    const Int_t* ptr = (int*)realdata+3;  //zzzz_last in roberts code
    const Int_t* ptr = realdata+3;  //zzzz_last in roberts code
    //need to clear deadchip vector before filling for next event
    //ccdh.ClearDeadChips();
//    while (ptr < (int *)realdata+(fRawDCB->GetSize())) {
    while (ptr < realdata+(fRawDCB->GetSize())) {
      // start of new crate
      crate++;
      int ndead = *ptr; ptr++;
      for (int i=0; i<ndead; i++,ptr++) {
/*
        Int_t chad = *ptr; ptr++;

        RawChannelId rcid(det,elec,crate,chad);
        ccdh.AddDeadChips(rcid); //add rawchannelid to deadchip vector
*/
        ccdh.AddDeadChips(RawChannelId(det,elec,crate,*ptr));
      }//end for
    }//end while
    //End Stolen Code
  }//end if
  
  MSG("AlgCalDetSI",Msg::kDebug)<<"DCvector: "<<ccdh.GetDeadChips().size()<<endl;
  /*Prints out dead chips, for debugging
  for(UShort_t i=0;i<ccdh.GetDeadChips().size();i++){
    int varc = ccdh.GetDeadChips()[i].GetVarcId();
    int vmm =  ccdh.GetDeadChips()[i].GetVmm();
    int vaadc =  ccdh.GetDeadChips()[i].GetVaAdcSel();
    int chip =  ccdh.GetDeadChips()[i].GetVaChip();
    int channel = ccdh.GetDeadChips()[i].GetVaChannel();

    MSG("AlgCalDetSI", Msg::kDebug)<<"Dead chips: "<<varc<<","<<vmm<<","<<vaadc
                                   <<","<<chip<<","<<channel<<endl;
  }
  */

  if(fRawOSB!=0){
    MSG("AlgCalDetSI",Msg::kDebug)<<"Found UnderShootBlock"<<endl;
    //More Stolen Code (from RawOvershootBlock::Print
    DetectorType::Detector_t det = fRawOSB->GetBlockId().GetDetector();
    // assume this block is only sensible for VA electronics
    ElecType::Elec_t elec = ElecType::kVA;
    Int_t  crate = -1;
    const Int_t* ptr = fRawOSB->GetData()+3;
    //need to clear the overshoot map before filling again
//    ccdh.ClearUnderShoots();
    while (ptr < fRawOSB->GetData()+(fRawOSB->GetSize())) {
      // start of new crate
      crate++;
      int ndead = *ptr; ptr++;
      for (int i=0; i<ndead; i++,ptr++) {
/*
         Int_t tmp   = *ptr; ptr++;
         Int_t chad  = tmp & 0x1fff;
         Int_t ticks = tmp>>13;
         RawChannelId rcid(det,elec,crate,chad);
         ccdh.AddUnderShootChips(rcid, ticks); //add undershoot channels to map
*/
           ccdh.AddUnderShootChips(RawChannelId(det,elec,crate,(*ptr)&0x1fff),
                                   (*ptr)>>13);

      }//end for
    }//end while
    //End of stolen code
  }//end if

  /*Prints out the UnderShoot chips, for debugging
  map<RawChannelId, Int_t>::const_iterator it 
    = (ccdh.GetUnderShootChips()).begin();
  while(it!=(ccdh.GetUnderShootChips()).end()){
    int varc = (it->first).GetVarcId();
    int vmm =  (it->first).GetVmm();
    int vaadc = (it->first).GetVaAdcSel();
    int chip = (it->first).GetVaChip();
    int channel = (it->first).GetVaChannel();

    MSG("AlgCalDetSI", Msg::kDebug)<<"UnderShoots: "<<varc<<","<<vmm<<","<<vaadc
                                   <<","<<chip<<","<<channel<<","
                                   <<it->second<<endl;
    it++;
  }
  */

  /* Removing this block of code until the TOF blocks are fixed
  if(fRawTOFB!=0){
    MSG("AlgCalDetSI",Msg::kDebug)<<"Found TOFBlock"<<endl;
    Int_t NDigits = fRawTOFB->GetNumberOfDigits();
    MSG("AlgCalDetSI",Msg::kError)<<"Number of TOF digits "<<NDigits<<endl;
    MSG("AlgCalDetSI", Msg::kError)<<"__________________________"<<endl
                                   <<*fRawTOFB<<endl
                                   <<"__________________________"<<endl;
    for(int i=0;i<NDigits;i++){ //loop over tof digits
      MSG("AlgCalDetSI", Msg::kDebug)<<"In tof digit loop "<<i<<endl;
      const RawTOFDigit *tofdigit = fRawTOFB->At(i);
      MSG("AlgCalDetSI", Msg::kDebug)<<"Got RawTOF Digit "<<tofdigit<<endl;
      //If tof info is not valid, continue
      if(!tofdigit->IsTdcValid(i)||
         tofdigit->IsTdcUnderThreshold(i)||tofdigit->IsTdcOverflow(i)){
        MSG("AlgCalDetSI", Msg::kError)<<*tofdigit<<endl;
        MSG("AlgCalDetSI", Msg::kError)<<"Tof not valid"<<endl;
        continue;
      }
      if(!tofdigit->IsStructureOk()){
        MSG("AlgCalDetSI", Msg::kError)<<"Bad TOF structure"<<endl;
        continue;
      }
      Short_t chan = tofdigit->GetTdcChannel(i);
      MSG("AlgCalDetSI",Msg::kDebug)<<"Tof channel "<<chan<<endl;
      switch (chan){
      case 0: 
        ccdh.SetTofTDC0(tofdigit->GetTdcValue(i));
        break;
      case 1: 
        ccdh.SetTofTDC1(tofdigit->GetTdcValue(i));
          break;
      case 2:
        ccdh.SetTofTDC2(tofdigit->GetTdcValue(i));
        break;
      default:
          break;
      }//end switch
    }//end for
  }//end if

  MSG("AlgCalDetSI",Msg::kDebug)<<"TDC0 "<<ccdh.GetTofTDC0()
                                <<" TDC1 "<<ccdh.GetTofTDC1()
                                <<" TDC2 "<<ccdh.GetTofTDC2()<<endl;
  
  */
  //Assuming just one digit in the TOF block, and that the data is valid
  if(fRawTOFB!=0){
    MSG("AlgCalDetSI",Msg::kDebug)<<"Found TOFBlock"<<endl;
//    Int_t NDigits = fRawTOFB->GetNumberOfDigits();
    MSG("AlgCalDetSI", Msg::kDebug)<<"__________________________"<<endl
                                   <<*fRawTOFB<<endl
                                   <<"__________________________"<<endl;
    const RawTOFDigit *tofdigit = fRawTOFB->At(0);
    MSG("AlgCalDetSI", Msg::kDebug)<<"Got RawTOF Digit "<<tofdigit<<endl;
    if(tofdigit!=0){
      if(!tofdigit->IsStructureOk()){
        MSG("AlgCalDetSI", Msg::kError)<<"Bad TOF structure"<<endl;
      }
      for(int i=0;i<3;i++){//loop over three tof channels
        Short_t chan = tofdigit->GetTdcChannel(i);
        MSG("AlgCalDetSI",Msg::kDebug)<<"Tof channel "<<chan<<endl;
        switch (chan){
        case 0: 
          ccdh.SetTofTDC0(tofdigit->GetTdcValue(i));
          break;
        case 1: 
          ccdh.SetTofTDC1(tofdigit->GetTdcValue(i));
          break;
        case 2:
          ccdh.SetTofTDC2(tofdigit->GetTdcValue(i));
          break;
        default:
          break;
        }//end switch
      }//end for
    }//end if(tofdigit!=0)
  }//end if(fRawTOFB!=0)
  
  MSG("AlgCalDetSI",Msg::kDebug)<<"TDC0 "<<ccdh.GetTofTDC0()
                                <<" TDC1 "<<ccdh.GetTofTDC1()
                                <<" TDC2 "<<ccdh.GetTofTDC2()<<endl;

        
  if(fRawSDB!=0){
    MSG("AlgCalDetSI",Msg::kDebug)<<"Found SnarlHeaderBlock"<<endl;
    ccdh.SetTrigSource(fRawSDB->GetTriggerSource());
    ccdh.SetSnarl(fRawSDB->GetSnarl());
    timeframe = fRawSDB->GetTimeFrameNo();
    ccdh.SetSnarlTimeFrame(timeframe);
  }
  else if(fRawDSH!=0){ // MAK: 12 April, 2005: added as no snarlheaderblocks in mc for whatever reason... note, doesn't change behavior if there is one
        MSG("AlgCalDetSI",Msg::kDebug)<<"Found DaqSnarlHeader"<<endl;
        ccdh.SetTrigSource(fRawDSH->GetTrigSrc());
        ccdh.SetSnarl(fRawDSH->GetSnarl());
        timeframe = fRawDSH->GetTimeFrameNum();
        ccdh.SetSnarlTimeFrame(timeframe);
  }

  MSG("AlgCalDetSI",Msg::kDebug)<<"Trigger Source "<<ccdh.GetTrigSource()
                                <<" Snarl "<<ccdh.GetSnarl()<<endl;
 

  MSG("AlgCalDetSI", Msg::kDebug)<<"Timing: "<<endl
                                 <<"last snarl sec "<<fLastSnarlSec<<" last snarl ticks "
                                 <<fLastSnarlTick<<endl
                                 <<"this snarl sec "<<timeframe<<" this snarl tick "
                                 <<earliestts<<" end tick "<<latestts<<endl;

  // Could we do this only for snarls ?
  //NOTE hardwired conversion from seconds to ticks
  ccdh.SetTickSinceLast((timeframe-fLastSnarlSec)*640000000+(earliestts-fLastSnarlTick)); 
  //640000000 ticks in a second


  if(ccdh.GetIsSnarlRecord()){ //if this was a snarl record, 
                               //change the LastSnarl timing varibles to this record
    fLastSnarlSec = timeframe;
    fLastSnarlTick = latestts;
  } //do nothing if it was not a snarl record
 
  MSG("AlgCalDetSI",Msg::kDebug)<<"Ticks Since Last Snarl "<<ccdh.GetTickSinceLast()<<endl;


  //Check for SparseErrs, special case since there can be two
  //error blocks (one from each crate) per timeframe
  MSG("AlgCalDetSI",Msg::kDebug)<<"Checking fVarcErrSet"<<endl;
  ccdh.SetSparseErr(kFALSE);

  Int_t tb = timeframe/kNTIMEBLOCKS;

  if(fVarcErrSet.find(tb)!=fVarcErrSet.end()){//if tb is in fVarcErrSet
    ccdh.SetSparseErr(kTRUE); //then there is a SparseErr
  }
  MSG("AlgCalDetSI",Msg::kDebug)<<"Sparse Errors "<<(int)ccdh.GetSparseErr()<<endl;
  
  /*
   since there is a problem with the varc error blocks, we can not just 
     throw away a time block with an error, we must throw the entire time frame 
     awaw!
  if there are any varc sparse errors in the time frame, the whole time 
  frame is suspect
  
  if(fVarcErrSet.find(timeframe)!=fVarcErrSet.end()){
    MSG("AlgCalDetSI",Msg::kDebug)<<"Number of sparse errors in this timeframe: "
                                 <<fVarcErrSet.size()
                                 <<" timeframe "<<timeframe<<endl;

    ccdh.SetSparseErr(kTRUE);
  }
  */

  return;
}//end RunAlg

//______________________________________________________________________________

void AlgCalDetSI::SetDataPointers(CandContext &cx)
{

  //We are assuming that cx contains a raw record

  //zero pointers from previous event. 
  fRawDDB = 0;
  fRawDCB = 0;
  fRawOSB = 0;
  fRawTOFB = 0;
  fRawSDB = 0;
  fRawVErrB = 0;
  fRawDSH = 0;
  const RawRecord *rr = dynamic_cast<const RawRecord *>(cx.GetDataIn());
  if(rr==0){
    return;  //if cast fails, do nothing for the time being at least
  }
  
  fRawDSH = dynamic_cast<const RawDaqSnarlHeader*>(rr->GetRawHeader());

  MSG("AlgCalDetSI",Msg::kDebug)<<"Found a RawRecord in SetDataPointers"<<endl;

  //Get a RawBlockIterator
  TIter rbi = const_cast<RawRecord*>(rr)->GetRawBlockIter();

  //Iterate over RawBlocks
  while(TObject* obj = rbi.Next()){
    MSG("AlgCalDetSI",Msg::kDebug)<<"Iterating over RawBlocks"<<endl;
    //cast iterator object to a RawDataBlock
    RawDataBlock* rdb=static_cast<RawDataBlock *>(obj);
    if(rdb==0){ //if cast fails
      continue;
    }

    //Get the RawBlockID
/*
    RawBlockId bid=rdb->GetBlockId();
    int maj=bid.GetMajor();
*/
    
    // June 20, 2003 -- Robert points out that the tests like fRawSDB==0
    // will never be true because we require rdb!=0 and then look at the block
    // id and then static cast to the correct block type.
    // I will comment out the offending code.

    Int_t maj = rdb->GetBlockId().GetMajor();
    //Compare block ID to the various cases and set the appropriate pointer
    switch (maj){
    case kMdBlockSnarlHeader:
      fRawSDB = static_cast<RawSnarlHeaderBlock *> (rdb);
//      MSG("AlgCalDetSI",Msg::kDebug)<<"fRawSDB="<<fRawSDB<<endl;
//      if(fRawSDB==0){
//      MSG("AlgCalDetSI", Msg::kError)<<"Could not cast to"
//                                     <<"RawSnarlHeaderBlock"<<endl;
//      }
      break;
    case kMdBlockVarcErrorInTf:  //not as simple as setting pointers 
                                 //since the errors from the 2 crates are 
                                 //written in separate blocks
      {
      fRawVErrB = static_cast<RawVarcErrorInTfBlock *> (rdb);
//      MSG("AlgCalDetSI",Msg::kDebug)<<"fRawVErrB="<<fRawVErrB<<endl;
//      if(fRawVErrB==0){
//      MSG("AlgCalDetSI", Msg::kError)<<"Could not cast to"
//                                     <<"RawVarcErrorInTfBlock"<<endl;
//      }
      FillVarcErrs();
      break;
      }
    case kMdBlockCrateReadout:
      fRawDDB = static_cast<RawDigitDataBlock *> (rdb);
//      MSG("AlgCalDetSI",Msg::kDebug)<<"fRawDDB="<<fRawDDB<<endl;
//      if(fRawSDB==0){
//              MSG("AlgCalDetSI", Msg::kError)<<"Could not cast to"
//                                     <<"RawDigitDataBlock"<<endl;
//      }
      break;
    case kMdBlockVaDeadChips:
      fRawDCB = static_cast<RawDeadChipBlock *> (rdb);
//      MSG("AlgCalDetSI",Msg::kDebug)<<"fRawDCB="<<fRawDCB<<endl;
//      if(fRawSDB==0){
//      MSG("AlgCalDetSI", Msg::kError)<<"Could not cast to"
//                                     <<"RawDeadChipBlock"<<endl;
//      }
      break;
    case kMdBlockVaOvershoot:
      fRawOSB = static_cast<RawOvershootBlock *> (rdb);
      MSG("AlgCalDetSI",Msg::kDebug)<<"fRawOSB="<<fRawOSB<<endl;
//      if(fRawSDB==0){
//      MSG("AlgCalDetSI", Msg::kError)<<"Could not cast to"
//                                     <<"RawOvershootBlock"<<endl;
//      }
      break;
    case kMdBlockTofReadout:
      fRawTOFB = static_cast<RawTOFBlock *> (rdb);
//      MSG("AlgCalDetSI",Msg::kDebug)<<"fRawTOFB="<<fRawTOFB<<","<<*fRawTOFB<<endl;
//      if(fRawSDB==0){
//      MSG("AlgCalDetSI", Msg::kError)<<"Could not cast to"
//                                     <<"RawTOFBlock"<<endl;
//      }
      break;
    default:
      MSG("AlgCalDetSI",Msg::kDebug)<<"ID did not match any options: "<<maj<<endl;
      break;
    }//end switch
  }//End loop over RawDataBlocks
  return;
}//end SetDataPointers

//_________________________________________________________________________________

void AlgCalDetSI::FillVarcErrs()
{

  MSG("AlgCalDetSI", Msg::kDebug)<<"In FillVarcErrs"<<endl;
  Int_t thisTF = fRawVErrB->GetTimeFrame();
  if(thisTF!=fTimeFrame){ //if we've moved on to a new time frame, clear fVarcErrSet
    MSG("AlgCalDetSI", Msg::kDebug)<<"New time frame, clearing VErrs.  Old TimeFrame="
                                   <<fTimeFrame<<" New TF="<<thisTF<<endl;
    fVarcErrSet.clear();
    fTimeFrame = thisTF;  //change fTimeFrame to the current TimeFrame;
  }

  const Int_t NSErrs = fRawVErrB->GetNumberOfSparsErrors();
  if(NSErrs>0){
    fVarcErrSet.insert(thisTF); //insert the timeframe into fVarcErrSet  
  }

  /*  If the varc errors were correct, the following code would 
      determine the time block of the error and put that into a vector,
      but since they are not correct, we just put the time frame into the vector
      (as done above)
  MSG("AlgCalDetSI",Msg::kInfo)<<NSErrs<<" Sparse Errors follow:"<<endl
                               <<"********************************"<<endl;
  for(UInt_t i=0;i<NSErrs;i++){ //loop over elements of error array
    UShort_t ctb;  //variable to hold the current time block
    UShort_t varc; //variable to hold the varc
    UShort_t errcode; //variable to hold the errorcode
    //    MSG("AlgCalDetSI", Msg::kDebug)<<"Raw Error Block:"<<endl
    //                             <<"_____________________________"<<endl;
    //    fRawVErrB->Print();
    // MSG("AlgCalDetSI", Msg::kDebug)<<endl<<"____________________________"<<endl;
    if(fRawVErrB->UnpackSparsError(i, ctb, varc, errcode)){
      fVarcErrSet.insert(ctb); //insert the timeblock into fVarcErrSet  
    }

    MSG("AlgCalDetSI",Msg::kInfo)<<"Timeframe "<<fTimeFrame<<" timeblock "<<ctb
                                 <<" varc "<<varc<<" error code "
                                 <<hex<<errcode<<dec<<endl;
  }//end loop over error array
  */

  //  MSG("AlgCalDetSI",Msg::kInfo)<<"********************************"<<endl;
  return;
}//end FillVarcErrs
  
//____________________________________________________________________________

---