RawTOFDigit.cxx

Go to the documentation of this file.

// $Id: RawTOFDigit.cxx,v 1.5 2003/07/10 19:36:30 rhatcher Exp $
// 
// RawTOFDigit
// 
// RawTOFDigit is an unpacked extended VA + TOF digit
//
// Author:  R. Hatcher 2001.05.31
//

#include "RawData/RawTOFDigit.h"

#include "MessageService/MsgService.h"
CVSID("$Id: RawTOFDigit.cxx,v 1.5 2003/07/10 19:36:30 rhatcher Exp $");

#include "MessageService/MsgFormat.h"
#include "MessageService/MsgStream.h"

ClassImp(RawTOFDigit)

//_____________________________________________________________________________
ostream& operator<<(ostream& os, const RawTOFDigit& r) 
{
   MsgFormat ifmt("%2d");
   MsgFormat ecfmt("%3d");
   MsgFormat adcfmt("%5d");
   MsgFormat timefmt("%10d");
   MsgFormat hexfmt("%8.8x");

   os << " " << r.GetName()
      << " ErrorCode " << ecfmt(r.fErrorCode) 
      << " ADC: " << adcfmt(r.fAdc) << " Time " << timefmt(r.fTdc);
   os << " TDC: " << r.GetNumberOfEntries()
      <<" entries (" << ((r.IsStructureOk()) ? "ok" : "bad structure")
      << "), tdc evt counter " << r.GetTdcEventCounter() << endl;
   int n = r.GetNumberOfEntries();
   if (n>0)
      os << "      channel value valid under over" << endl;
   for (int i=0; i<n; i++) {
      os << " [" << ifmt(i) << "]" << ecfmt(r.GetTdcChannel(i))
         << " " << adcfmt(r.GetTdcValue(i))
         << " " << (int)r.IsTdcValid(i)
         << " " << (int)r.IsTdcUnderThreshold(i)
         << " " << (int)r.IsTdcOverflow(i);
   }
   int NN = r.GetTdcArraySize();
   os << "  raw tdc block: ";
   for (int II=0; II<NN; II++)
      os << " 0x" << hexfmt(r.GetTdcArray()[II]);
   os << endl;

  return os;
}

//_____________________________________________________________________________
RawTOFDigit::RawTOFDigit()
{
   // Default constructor
}

//_____________________________________________________________________________
RawTOFDigit::RawTOFDigit(const Int_t *&p, const RawDigitCrateStatus *cstat)
   : RawVaDigit(p,cstat)
{
   // a RawTOFDigit looks like a RawVaDigit with extra words tacked
   // onto the end.

   // use fTDCArray just to reference back to real data in mother block
   // don't make any copy of the data
   fTDCArray = p;
   // advance pointer beyond entries
   int nskip = GetTdcArraySize();
   p += nskip;
}

//_____________________________________________________________________________
RawTOFDigit::~RawTOFDigit()
{
   // fTDCArray *isn't* an owned object ... don't delete it
}

//_____________________________________________________________________________
Int_t RawTOFDigit::GetNumberOfEntries() const
{
   // number of TDC channels read out per TOF "hit"
   // is dependent on the minor version id of the block
   // but for most cases actual count comes from header word

   const int cntMask  = 0x3f;
   const int cntShift = 8;

   static int nmsg = 5;

   // we can get this from the CrateStatus
   Int_t minor = fDigitCrateStatus->GetRawBlockId().GetMinor();
   switch (minor) {
   case 0:  
      // pull count size of block from header word
      return (fTDCArray[0]>>cntShift)&cntMask;
      break;
   default:
      if (nmsg > 0) {
         MSG("RawData",Msg::kWarning)
            << "RawTOFDigit::GetNumberOfEntries() unknown minor version "
            << minor << ", assume std TDC header format" << endl;
         nmsg--;
         if (nmsg==0) 
            MSG("RawData",Msg::kWarning)
               << " ... last warning" << endl;
      }
      // pull count size of block from header word
      return (fTDCArray[0]>>cntShift)&cntMask;
      break;
   }
      
}

//_____________________________________________________________________________
Int_t RawTOFDigit::GetTdcArraySize() const
{
   // the size of the Tdc array is dependent on the minor 
   // version id of the block but for most cases actual count 
   // comes from header word plus one each for the header and trailer

   static int nmsg = 5;

   Int_t minor = fDigitCrateStatus->GetRawBlockId().GetMinor();
   switch (minor) {
   case 0:  
      return 2+GetNumberOfEntries();
      break;
   default:
      if (nmsg > 0) {
         MSG("RawData",Msg::kWarning)
            << "RawTOFDigit::GetTdcArraySize() unknown minor version "
            << minor << ", assume std TDC header format" << endl;
         nmsg--;
         if (nmsg==0) 
            MSG("RawData",Msg::kWarning)
               << " ... last warning" << endl;
      }
      return 2+GetNumberOfEntries();
      break;
   }
      
}

//_____________________________________________________________________________
Int_t RawTOFDigit::GetTdcEventCounter() const
{
   // pull the "event counter" field from the trailer word
   // simply assume that minorid>0

   // skip past header + data words
   int indx = GetNumberOfEntries() + 1;

   return fTDCArray[indx]&0x00ffffff;
}

//_____________________________________________________________________________
Bool_t RawTOFDigit::IsStructureOk() const
{
   // verify that flag bits are all in the right places in the TDC block
   // simply assume minorid>0

   //           3         2         1
   //          10987654321098765432109876543210
   // header:  ggggg010cccccccc00nnnnnn--------
   // data:    ggggg00000cccccc-vuoaaaaaaaaaaaa
   // trailer: ggggg100eeeeeeeeeeeeeeeeeeeeeeee

   bool isokay = true;

   const Int_t *p = fTDCArray;

   if ((*p&0x0700c000) != 0x02000000) isokay = false;
   p++;

   int n = GetNumberOfEntries();
   for (int i=0; i<n; i++) {
      if ((*p&0x07c00000) != 0x00000000) isokay = false;
      p++;
   }

   if ((*p&0x07000000) != 0x04000000) isokay = false;

   return isokay;
}

//_____________________________________________________________________________
Short_t RawTOFDigit::GetTdcChannel(Int_t indx) const
{
   // pull the "channel" field from the data word "indx"
   // simply assume that minorid>0

   if (indx<0 || indx>=GetNumberOfEntries()) return -1;

   const int chanMask  = 0x3f;
   const int chanShift = 16;
   // index past header word
   return (fTDCArray[indx+1]>>chanShift)&chanMask;

}

//_____________________________________________________________________________
Short_t RawTOFDigit::GetTdcValue(Int_t indx) const
{
   // pull the "adc" field from the data word "indx"
   // simply assume that minorid>0

   if (indx<0 || indx>=GetNumberOfEntries()) return -1;

   const int adcMask  = 0x0fff;

   // index past header word
   return fTDCArray[indx+1]&adcMask;

}

//_____________________________________________________________________________
Bool_t RawTOFDigit::IsTdcValid(Int_t indx) const
{
   // pull the "valid" field from the data word "indx"
   // simply assume that minorid>0

   if (indx<0 || indx>=GetNumberOfEntries()) return false;

   const int validMask  = BIT(14);

   // index past header word
   return fTDCArray[indx+1]&validMask;

}

//_____________________________________________________________________________
Bool_t RawTOFDigit::IsTdcUnderThreshold(Int_t indx) const
{
   // pull the "underthreshold" field from the data word "indx"
   // simply assume that minorid>0

   if (indx<0 || indx>=GetNumberOfEntries()) return true;

   const int underMask  = BIT(13);

   // index past header word
   return fTDCArray[indx+1]&underMask;

}

//_____________________________________________________________________________
Bool_t RawTOFDigit::IsTdcOverflow(Int_t indx) const
{
   // pull the "overflow" field from the data word "indx"
   // simply assume that minorid>0

   if (indx<0 || indx>=GetNumberOfEntries()) return true;

   const int overMask  = BIT(12);

   // index past header word
   return fTDCArray[indx+1]&overMask;

}

//_____________________________________________________________________________
void RawTOFDigit::Print(Option_t* option) const
{
   // print out the digit
   RawVaDigit::Print(option);

   int nvalues = GetNumberOfEntries();
   int evtcntr = GetTdcEventCounter();
   bool isok   = IsStructureOk();
   cout << "  has " << nvalues << " values ("
        << "evtcntr: " << evtcntr << ","
        << ((isok) ? "isok" : "badbits") << ")" << endl;
   if (nvalues)
      cout << "   indx chan value valid thrsh overflow" << endl;
   for (int i=0; i<nvalues; i++) {
      cout << "  [" << setw(3) << i << "]"
           << " " << setw(4) << GetTdcChannel(i)
           << " " << setw(5) << GetTdcValue(i)
           << ((IsTdcValid(i))          ? "   yes" : "    no")
           << ((IsTdcUnderThreshold(i)) ? " under" : " above")
           << ((IsTdcOverflow(i))       ? "   yes" : "    no")
           << endl;
   }

#ifdef TOOVERBOSE
   int arraysize = GetTdcArraySize();
   const Int_t* array = GetTdcArray();
   for (int i=0; i<arraysize; i++) {
      cout << " 0x" << setfill('0') << hex << setw(8) 
           << array[i] << setfill(' ') << dec;
   }
   cout << endl;
#endif

}

//_____________________________________________________________________________

---