RawLIAdcSummary.cxx

Go to the documentation of this file.

// $Id: RawLIAdcSummary.cxx,v 1.19 2005/08/26 19:04:53 rhatcher Exp $
// 
// RawLIAdcSummary
// 
// RawLITimingSummary is the unpacked Adc summary for one channel
//
// Author:  R. Hatcher 2000.04.19
//

#include "RawData/RawLIAdcSummary.h"

#include "MessageService/MsgService.h"
CVSID("$Id: RawLIAdcSummary.cxx,v 1.19 2005/08/26 19:04:53 rhatcher Exp $");

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

ClassImp(RawLIAdcSummary)

//_____________________________________________________________________________
std::ostream& operator<<(std::ostream& os, const RawLIAdcSummary& s)
{ return s.FormatToOStream(os); }
 
//_____________________________________________________________________________
RawLIAdcSummary::RawLIAdcSummary()
   : fCrateStatus(0), fRawChannelId(0), fEntries(-1), fIntMean(-1), fIntRms(-1)
{
   // Default constructor

   // MSG("RawData",Msg::kWarning) << "RawLIAdcSummary default ctor" << endl;
}

//_____________________________________________________________________________
RawLIAdcSummary::RawLIAdcSummary(const Int_t *&p, 
                                 const RawCrateStatus* cstat,
                                 Int_t minorVersion)
   : fCrateStatus(cstat), fRawChannelId(0), fEntries(-1),
     fIntMean(-1), fIntRms(-1)
{
   // this is where the everything is actually unpacked

   // version 0:
   // 1st 32-bit word: no of entries (16); Chadd (16)
   // 2nd 32-bit word: RMS (16); Mean (16)
   // Mean and RMS are both scaled by a factor of 4, so that they have a
   // two-binal resolution.

   // version 1:
   // 1st 32-bit word: Chadd (16); no of entries (16)
   // 2nd 32-bit word: Mean (16);  RMS (16)
   // Mean and RMS are both scaled by a factor of 4, so that they have a
   // two-binal resolution.

   // version 2:
   // 1st 32-bit word: Chadd (16); no of entries (16)
   // 2nd 32-bit word: Mean (17);  RMS (15)
   // Mean is scaled by a factor of 4 and RMS scaled by 2.
   // Mean is a 2's complement # (ie. when unpacking high order bit
   // of the field must be sign extended).

   // version 3:
   // Same as 2 for VA electronics, but different for QIE electronics
   // 2nd 32-bin word: Mean (16); RMS (16) for QIE electronics
   // Mean is unscaled (positive int), RMS is unscaled
 
   // version 4:
   // Same as v3, but QIE Means have 50 counts added.
   // Put change in GetMean() only.

   // version 5:
   // Same as v4, but QIE Means use 17 bits and RMS only 15

   const Int_t maskShort = 0xffff;

   switch (minorVersion) {
   case 0:
   {
      // note this version had upper/lower swapped from v1, v2...
      Int_t chadd =   p[0]         & maskShort;
      BuildRawChannelId(cstat,chadd);

      fEntries   =  ( p[0] >> 16 ) & maskShort;
      fIntMean   =    p[1]         & maskShort;
      fIntRms    =  ( p[1] >> 16 ) & maskShort;

      // advance pointer by amount it eats up
      p += 2;
      break;
   }
   case 1:
   {
      Int_t chadd = ( p[0] >> 16 ) & maskShort;
      BuildRawChannelId(cstat,chadd);

      fEntries   =    p[0]         & maskShort;
      fIntMean   =  ( p[1] >> 16 ) & maskShort;
      fIntRms    =    p[1]         & maskShort;

      // advance pointer by amount it eats up
      p += 2;
      break;
   }
   case 2:
   {
      Int_t chadd = ( p[0] >> 16) & maskShort;
      BuildRawChannelId(cstat,chadd);

      const Int_t maskMean1    = 0x0001ffff;
      const Int_t maskRMS1     = 0x00007fff;
      const Int_t mean1signbit = 0x00010000;
      const Int_t mean1signext = 0xffff0000;
      
      fEntries   =    p[0]         & maskShort;
      fIntMean   =  ( p[1] >> 15 ) & maskMean1;
      if (fIntMean & mean1signbit ) fIntMean |= mean1signext;
      fIntRms    =    p[1]         & maskRMS1;
      
      // advance pointer by amount it eats up
      p += 2;
      break;
   }
   case 3:
   case 4:  
   {
      Int_t chadd = ( p[0] >> 16) & maskShort;
      BuildRawChannelId(cstat,chadd);
      fEntries   =    p[0]         & maskShort;

      ElecType::Elec_t elec = fCrateStatus->GetElecType();

      switch (elec) {
      default:
      {
        static Int_t nmsg = 10;
        if (nmsg>0) {
          --nmsg;
          MSG("RawData",Msg::kWarning)
            << "RawLIAdcSummary::ctor with unhandled electronics type "
            << (int)elec << " " << ElecType::AsString(elec) << endl;
        }
        // don't break, fall through to VA
      }
      case ElecType::kVA:
      {
        const Int_t maskVAMean    = 0x0001ffff;
        const Int_t maskVARMS     = 0x00007fff;
        const Int_t meanVAsignbit = 0x00010000;
        const Int_t meanVAsignext = 0xffff0000;
      
        fIntMean   =  ( p[1] >> 15 ) & maskVAMean;
        if (fIntMean & meanVAsignbit ) fIntMean |= meanVAsignext;
        fIntRms    =    p[1]         & maskVARMS;
        break;
      }
      case ElecType::kQIE:
      {
        const Int_t maskQIEMean    = 0x0000ffff;
        const Int_t maskQIERMS     = 0x0000ffff;
      
        fIntMean   =  ( p[1] >> 16 ) & maskQIEMean;
        fIntRms    =    p[1]         & maskQIERMS;
        break;
      }
      } // end ElecType case

      // advance pointer by amount it eats up
      p += 2;
      break;
   }
   default:  // minor version #
   {
     MAXMSG("RawData",Msg::kWarning,10)
       << "RawLIAdcSummary::ctor with minor id "
       << cstat->GetRawBlockId().GetMinor()
       << " unknown layout" << endl;
     // don't break, fall through to latest
   }
   case 5:
   {
      Int_t chadd = ( p[0] >> 16) & maskShort;
      BuildRawChannelId(cstat,chadd);
      fEntries   =    p[0]         & maskShort;

      ElecType::Elec_t elec = fCrateStatus->GetElecType();

      switch (elec) {
      default:
      {
        static Int_t nmsg = 10;
        if (nmsg>0) {
          --nmsg;
          MSG("RawData",Msg::kWarning)
            << "RawLIAdcSummary::ctor with unhandled electronics type "
            << (int)elec << " " << ElecType::AsString(elec) << endl;
        }
        // don't break, fall through to VA
      }
      case ElecType::kVA:
      {
        const Int_t maskVAMean    = 0x0001ffff;
        const Int_t maskVARMS     = 0x00007fff;
        const Int_t meanVAsignbit = 0x00010000;
        const Int_t meanVAsignext = 0xffff0000;
      
        fIntMean   =  ( p[1] >> 15 ) & maskVAMean;
        if (fIntMean & meanVAsignbit ) fIntMean |= meanVAsignext;
        fIntRms    =    p[1]         & maskVARMS;
        break;
      }
      case ElecType::kQIE:
      {
        const Int_t maskQIEMean    = 0x0001ffff;
        const Int_t maskQIERMS     = 0x00007fff;
      
        fIntMean   =  ( p[1] >> 15 ) & maskQIEMean;
        fIntRms    =    p[1]         & maskQIERMS;
        break;
      }
      } // end ElecType case

      // advance pointer by amount it eats up
      p += 2;
      break;
   }
   } // end minor version number switch

}

//_____________________________________________________________________________
RawLIAdcSummary::~RawLIAdcSummary()
{
   // delete all owned sub-objects

}

//_____________________________________________________________________________
Float_t RawLIAdcSummary::GetMean() const
{
   // return unscaled mean
   
   switch (fCrateStatus->GetRawBlockId().GetMinor()) {
   case 0:
   case 1:
      return fIntMean * 0.25;  // scale factor of 4
      break;
   case 2:
      return fIntMean * 0.25;  // scale factor of 4
      break;
   case 3:
      return fIntMean * 
        ( (fCrateStatus->GetElecType() == ElecType::kQIE) ? 1.0 : 0.25 );
      break;
   default:
     {
      MAXMSG("RawData",Msg::kWarning,100)
         << "RawLIAdcSummary::GetMean() with minor id "
         << fCrateStatus->GetRawBlockId().GetMinor()
         << " assumes default scale factor" << endl;
     }
      // don't break, fall through to latest
   case 4:
   case 5:
      return fIntMean * 
        ( (fCrateStatus->GetElecType() == ElecType::kQIE) ? 1.0 : 0.25 )
        + ((fCrateStatus->GetElecType() == ElecType::kQIE) ? -50 : 0 );
      break;
   }
}

//_____________________________________________________________________________
Float_t RawLIAdcSummary::GetRms() const
{
   // return unscaled RMS
   
   switch (fCrateStatus->GetRawBlockId().GetMinor()) {
   case 0:
   case 1:
      return fIntRms * 0.25;  // scale factor of 4
      break;
   case 2:
      return fIntRms * 0.5;   // scale factor of 2
      break;
   default:
     {
      MAXMSG("RawData",Msg::kWarning,100)
         << "RawLIAdcSummary::GetRms() with minor id "
         << fCrateStatus->GetRawBlockId().GetMinor()
         << " assumes default scale factor" << endl;
     }
      // don't break, fall through to latest
   case 3:
   case 4:  
   case 5:  
      return fIntRms * 
        ( (fCrateStatus->GetElecType() == ElecType::kQIE) ? 1.0 : 0.5 );
      break;
   }
}

//_____________________________________________________________________________
void RawLIAdcSummary::Print(Option_t *option) const
{
   FormatToOStream(cout,option);
}

//_____________________________________________________________________________
std::ostream& RawLIAdcSummary::FormatToOStream(std::ostream& os,
                                               Option_t * /* option */) const
{
   MsgFormat ffmt("%9.2f");
   MsgFormat ifmt("%7d");
   
   os << " "  << fRawChannelId
      << "  " << setw(5)  << fEntries 
      << "  " << ffmt(GetMean())
      << " (" << ifmt(fIntMean) << ")"
      << "  " << ffmt(GetRms())
      << " (" << ifmt(fIntRms) << ")"
      << endl;

   return os;
}

//_____________________________________________________________________________
void RawLIAdcSummary::BuildRawChannelId(const RawCrateStatus *cstat, Int_t chadd)
{
   Detector::Detector_t detector = 
                            cstat->GetRawBlockId().GetDetector();
   ElecType::Elec_t etype = cstat->GetElecType();
   Bool_t         pedMode = cstat->GetPedMode();
   Bool_t       sparsMode = cstat->GetSparsMode();
   Bool_t      commonMode = cstat->GetCommonMode();
   Int_t            crate = cstat->GetCrate();

   fRawChannelId = RawChannelId(detector,etype,crate,chadd);
   fRawChannelId.SetModeBits(commonMode,sparsMode,pedMode);
}
//_____________________________________________________________________________

---