RawQieCalibrationDataBlock.cxx

Go to the documentation of this file.

// $Id: RawQieCalibrationDataBlock.cxx,v 1.9 2004/01/29 18:14:19 rhatcher Exp $
// 
// RawQieCalibrationDataBlock  
// 
// RawQieCalibrationDataBlock holds a block of QIE calibration data
//
// Author:  R. Hatcher 2002.07.15
//

#include "RawData/RawQieCalibrationDataBlock.h"
#include "TMath.h"

UInt_t RawQieCalibrationDataBlock::fgDebugFlags = 0;

#include "MessageService/MsgService.h"
CVSID("$Id: RawQieCalibrationDataBlock.cxx,v 1.9 2004/01/29 18:14:19 rhatcher Exp $");
#include "MessageService/MsgFormat.h"

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawQieCalibrationDataBlock,kMdBlockQieCalibrationData,0);

ClassImp(RawQieCalibrationDataBlock)

enum EQieCalibBlkPos {
   indx_size       = 0,
   indx_checksum   = 1,
   indx_blockid    = 2,
   indx_run        = 3,
   indx_subrun     = 4,
   indx_runtype    = indx_subrun,
   indx_ncalpts_v0 = 5,
   indx_daqvals_v0 = 6,
   indx_crateid    = 5,
   indx_ncalpts    = 6,
   indx_nloc       = 7,
   indx_daqvals    = 8,
   zzzz_last      = indx_daqvals
};
 
struct QieCalibPoint
{
  long              nEntries;
  long              range;
  long unsigned int sum;
  long unsigned int sum_sqr;
};
const UInt_t qieCalibPointIntSize = sizeof(QieCalibPoint)/sizeof(Int_t);
 
const UInt_t illegalLocation = 0xFFFFFFFF;

//_____________________________________________________________________________
RawQieCalibrationDataBlock::RawQieCalibrationDataBlock()
  : RawDataBlock()
{
   // Default constructor
}

//_____________________________________________________________________________
RawQieCalibrationDataBlock::RawQieCalibrationDataBlock(const Int_t *block)
   : RawDataBlock(block)
{
   //  stored block format is:
   //---------------------
   //      version 0             version 1
   //  0   # words in block      # words in block     
   //  1   checksum              checksum             
   //  2   Block Id              Block Id             
   //-----                                            
   //  3   run #                 run #                
   //  4   {subrun #| run type}  {subrun #| run type} 
   //  5   numCalPoints          crateid
   //  6     --n/a--             numCalPoints
   //  7     --n/a--             nlocations
  /*
   * The data then has the following format:
   *  unsigned long dacValue[numCalPoints]; -- values of the current injection
   *
   * then repeating data structure until all channels are completed:
   *           long unsigned int  location;  -- bit packed
   *           long               nPoints;
   * nPoints * struct  {  long             nEntries;
   *                      long              range;
   *                      long unsigned int sum;
   *                      long unsigned int sum_sqr;
   *                   }
   */

}

//_____________________________________________________________________________
RawQieCalibrationDataBlock::~RawQieCalibrationDataBlock()
{
   // dtor
}

//____________________________________________________________________________
RawQieCalibrationDataBlock& 
RawQieCalibrationDataBlock::operator=(const RawQieCalibrationDataBlock& rhs)
{
   // deep copy assignment 
   if (this != &rhs) {
     RawDataBlock::operator=(rhs);
     fCrateId = rhs.fCrateId;
     // clear these to allow them to be re-filled
     fLocation.clear();
     fLocStart.clear();
   }
   return *this;
}

//_____________________________________________________________________________
Int_t RawQieCalibrationDataBlock::GetRun() const
{
   // get the run number
   if (fSize > indx_run) return fRawBlock[indx_run];
   return -1;
}
 
//_____________________________________________________________________________
Short_t RawQieCalibrationDataBlock::GetSubRun() const
{
   // get the subrun number
   if (fSize > indx_subrun) return (fRawBlock[indx_subrun]>>16)&0xffff;
   return -1;
}
 
//_____________________________________________________________________________
Short_t RawQieCalibrationDataBlock::GetRunType() const
{
   // get the run type
   if (fSize > indx_runtype) return fRawBlock[indx_runtype]&0xffff;
   return -1;
}
 
//_____________________________________________________________________________
Int_t RawQieCalibrationDataBlock::GetCrateIdInfo() const
{
   // get the crate id word
   if (GetMinorId() <= 0) return -1; //didn't exist in this version
   if (fSize > indx_crateid) return fRawBlock[indx_crateid];
   return -1;
}
//_____________________________________________________________________________
UInt_t RawQieCalibrationDataBlock::GetNumCalPoints() const
{
   // get the number of calibration points
   int indx_ncalpts_v = indx_ncalpts;
   if (GetMinorId() <= 0) indx_ncalpts_v = indx_ncalpts_v0;
   if (fSize > indx_ncalpts_v) return fRawBlock[indx_ncalpts_v];
   return 0;
}

//_____________________________________________________________________________
const Int_t* RawQieCalibrationDataBlock::GetDacValues() const
{
   // get the number of calibration points
   int indx_daqvals_v = indx_daqvals;
   if (GetMinorId() <= 0) indx_daqvals_v = indx_daqvals_v0;
   if (fSize > indx_daqvals_v) return (const Int_t*)(fRawBlock+indx_daqvals_v);
   return 0;
}

//_____________________________________________________________________________
Int_t RawQieCalibrationDataBlock::GetDacValue(UInt_t indx) const
{
   // get a daq value point
   UInt_t ncalpts = GetNumCalPoints();
   if (indx >= ncalpts) { // zero based indexing
     MSG("RawData",Msg::kError)
       << "indx " << indx << " out of range: there are only "
       << ncalpts << " dac values " << endl;
     return 0;
   }
   int indx_daqvals_v = indx_daqvals;
   if (GetMinorId() <= 0) indx_daqvals_v = indx_daqvals_v0;
   if ((unsigned long)fSize > indx_daqvals_v+indx) 
     return (Int_t)fRawBlock[indx_daqvals_v+indx];
   return 0;
}

//_____________________________________________________________________________
UInt_t RawQieCalibrationDataBlock::GetNumLocations() const
{
   // calculate how many distinct locations are recorded
   // each might have a different number of points recorded

   UInt_t minor = GetMinorId();
   UInt_t nloc_unpacked = FillLocStart();
   if (minor > 0) {
     UInt_t nloc_stored = fRawBlock[indx_nloc];
     if (nloc_stored != nloc_unpacked)
       MSG("RawData",Msg::kError)
         << " Unpacking found " << nloc_unpacked
         << " 'location', while data claims " << nloc_stored 
         << " were stored" << endl;
   }
   return nloc_unpacked;

}

//_____________________________________________________________________________
UInt_t RawQieCalibrationDataBlock::GetLocation(UInt_t indx) const
{
   // report "location" associated with sub-block index by "indx"

   UInt_t nloc = FillLocStart();
   if ( indx >= nloc) { // zero based indexing
     MSG("RawData",Msg::kError)
       << "indx " << indx << " out of range: there are only "
       << nloc << " entries" << endl;
     return illegalLocation;
   }
   return fLocation[indx];
}

//_____________________________________________________________________________
UInt_t RawQieCalibrationDataBlock::GetNumPoints(UInt_t loc) const
{

   // treat each sub-block as indexed by "location"

   FillLocStart();
   const Int_t* ptr = fLocStart[loc];  // this is "location"
   return *(ptr+1);                    // this is "nPoints"
}

//_____________________________________________________________________________
UInt_t RawQieCalibrationDataBlock::GetNumEntries(UInt_t loc, UInt_t ipt) const
{
   // the number of entries that went into the sub-sub-block
   // related to "location" and point # "ipt"

   const QieCalibPoint* ptr = (const QieCalibPoint*)StartOfLocPoint(loc,ipt);
   if (!ptr) return 0;
   return ptr->nEntries;
}

//_____________________________________________________________________________
Int_t RawQieCalibrationDataBlock::GetRange(UInt_t loc, UInt_t ipt) const
{
   // the "range" that the sub-sub-block corresponds to
   // "location" and point # "ipt"

   const QieCalibPoint* ptr = (const QieCalibPoint*)StartOfLocPoint(loc,ipt);
   if (!ptr) return 0;
   return ptr->range;
}

//_____________________________________________________________________________
Double_t RawQieCalibrationDataBlock::GetMean(UInt_t loc, UInt_t ipt) const
{
   // the "range" that the sub-sub-block corresponds to
   // "location" and point # "ipt"

   const QieCalibPoint* ptr = (const QieCalibPoint*)StartOfLocPoint(loc,ipt);
   if (!ptr) return 0;
   if (!ptr->nEntries) return 0; // don't divide by zero
   return (Double_t)ptr->sum/(Double_t)ptr->nEntries;
}

//_____________________________________________________________________________
Double_t RawQieCalibrationDataBlock::GetRms(UInt_t loc, UInt_t ipt) const
{
   // the RMS that the sub-sub-block corresponds to
   // "location" and point # "ipt"

   const QieCalibPoint* ptr = (const QieCalibPoint*)StartOfLocPoint(loc,ipt);
   if (!ptr) return 0;
   if (!ptr->nEntries) return 0; // don't divide by zero
   Double_t n     = (Double_t)ptr->nEntries; 
   Double_t sumx  = (Double_t)ptr->sum;
   Double_t sumx2 = (Double_t)ptr->sum_sqr;
   Double_t mean  = sumx/n;
   return TMath::Sqrt(sumx2/n - mean*mean);

}

//_____________________________________________________________________________
UInt_t RawQieCalibrationDataBlock::GetSum(UInt_t loc, UInt_t ipt) const
{
   // the sum that the sub-sub-block corresponds to
   // "location" and point # "ipt"

   const QieCalibPoint* ptr = (const QieCalibPoint*)StartOfLocPoint(loc,ipt);
   if (!ptr) return 0;
   return ptr->sum;

}

//_____________________________________________________________________________
UInt_t RawQieCalibrationDataBlock::GetSumSqr(UInt_t loc, UInt_t ipt) const
{
   // the sum^2 that the sub-sub-block corresponds to
   // "location" and point # "ipt"

   const QieCalibPoint* ptr = (const QieCalibPoint*)StartOfLocPoint(loc,ipt);
   if (!ptr) return 0;
   return ptr->sum_sqr;

}

//_____________________________________________________________________________
void RawQieCalibrationDataBlock::FillCrateId() const
{
   // unpack crate info
   if (!fCrateId.IsNull()) return;
   if (GetMinorId() <= 0) {
     fCrateId.SetDetector(GetBlockId().GetDetector());
     MSG("RawData",Msg::kWarning)
       << " No crate info for minor version " << GetMinorId() << endl;
     return;
   }
   fCrateId = RawChannelId(GetBlockId().GetDetector(),GetCrateIdInfo(),0x1fff);
}

//_____________________________________________________________________________
UInt_t RawQieCalibrationDataBlock::FillLocStart() const
{
   // calculate how many distinct locations are recorded
   // each might have a different number of points recorded
   // fill vector of pointers to start of each location's data
   // if already filled just return

   if (!fLocStart.empty()) return fLocStart.size();

   UInt_t ncalpts = GetNumCalPoints();
   int indx_daqvals_v = indx_daqvals;
   if (GetMinorId() <= 0) indx_daqvals_v = indx_daqvals_v0;
   const Int_t *ptr = 
         fRawBlock + indx_daqvals_v + ncalpts; // start of packed data
   const Int_t *end = fRawBlock + fSize;       // one beyond end

   while ( ptr < end ) {
     Int_t loc  = *ptr;
     Int_t npts = *(ptr+1);
     // bitch wildly if already an entry for this "location"
     if (fLocStart[loc]) 
       MSG("RawData",Msg::kError)
         << " Already have an sub-block unit for 'location' 0x"
         << hex << setfill('0') << setw(8) << loc 
         << setfill(' ') << dec << endl
         << " at offset 0x" 
         << hex << setfill('0') << setw(8) << (fLocStart[loc]-fRawBlock) 
         << setfill(' ') << dec
         << " found again at 0x" 
         << hex << setfill('0') << setw(8) << (ptr-fRawBlock) 
         << setfill(' ') << dec
         << endl;
     fLocation.push_back(loc);
     fLocStart[loc] = ptr;
     // skip loc+npts + npts*(entries,range,s,s2)
     Int_t skip = 2 + npts*qieCalibPointIntSize;  
     ptr += skip;
   }

   if ( ptr != end ) 
     MSG("RawData",Msg::kError) << endl
       << "FillLocStart() unpacking did not end evenly at block boundary" 
       << endl;
   
   return fLocStart.size();
}

//_____________________________________________________________________________
const Int_t* RawQieCalibrationDataBlock::StartOfLocPoint(UInt_t loc, UInt_t ipt) const
{

   // treat each sub-block as indexed by "location"
   // sub-sub-structures are indexed by "iptr" and offset by fixed amounts

   FillLocStart();  // make sure we've scanned to find each sub-block
   const Int_t* ptr = fLocStart[loc];
   if (!ptr) {
     MSG("RawData",Msg::kError)
       << " No entry for 'location' 0x" 
       << hex << setfill(' ') << setw(8) << loc 
       << setfill(' ') << dec << endl;
     return 0;
   }
   UInt_t npts = *(ptr+1); // this is "nPoints";
   if ( ipt >= npts ) { // zero based indexing
     MSG("RawData",Msg::kError)
       << "ipt " << ipt << " for 'location' 0x" 
       << hex << setfill(' ') << setw(8) << loc << setfill(' ') << dec
       << " that has only " << npts << " points" << endl;
     return 0;
   }
   // 2 skips loc+npoints, each struct is 4 long 
   ptr += (2 + ipt*qieCalibPointIntSize); 
   return ptr;
}

//_____________________________________________________________________________
std::ostream& RawQieCalibrationDataBlock::FormatToOStream(std::ostream& os, 
                                                          Option_t *option) const
{

   RawDataBlock::FormatToOStream(os,option);
   if (option[0] == 'X') return os;
   
   // additional block specific formatted output is done here

   os << " Run " << GetRun() << " SubRun " << GetSubRun()
      << " RunType " << GetRunType() << endl;
   if (GetMinorId()>0) {
     FillCrateId();
     os << " CrateId " << fCrateId.AsString("C") << ", ";
   }
   UInt_t ndacv = GetNumCalPoints();
   const Int_t* dacv = GetDacValues();
   os << " " << ndacv << " Dac Values" << endl;
   for (UInt_t idacv = 0; idacv < ndacv; ++idacv) {
     os << "   [" << setw(3) << idacv << "] " 
        << setw(5) << dacv[idacv];
     if (idacv%4==3) os << endl;
   }
   if ((ndacv-1)%4!=3) os << endl;

   UInt_t nloc = GetNumLocations();
   os << " " << nloc << " 'locations' "<< endl;

   // xx'location' 
   // xxxx[123] range      entries    mean        RMS
   //   0x12345678 has ?? points
   //     [123] 1234567890 1234567890 1234567890 1234567890 1234567890 1234567890
   os << "            range  entries         mean          RMS        Sum       SumSqr" << endl;
   for (UInt_t indx = 0; indx < nloc; ++indx) {
     UInt_t loc = GetLocation(indx);
     UInt_t npt = GetNumPoints(loc);
     os << "  location 0x" 
        << hex << setfill('0') << setw(8) << loc << setfill(' ') << dec
        << " ( index = " << setw(3) << indx << " )"
        << " has " << npt << " points" << endl;
     for (UInt_t ipt = 0; ipt < npt; ++ipt) {
       os << "   [" << setw(3) << ipt << "] "
          << setw(8)  << GetRange(loc,ipt) << " "
          << setw(8)  << GetNumEntries(loc,ipt) << " "
          << setw(12) << GetMean(loc,ipt) << " "
          << setw(12) << GetRms(loc,ipt) << " "
          << setw(10) << GetSum(loc,ipt) << " "
          << setw(12) << GetSumSqr(loc,ipt)
          << endl;
     }
   }
   return os;
}

//_____________________________________________________________________________

---