RawLinearizedDataBlock.cxx

Go to the documentation of this file.

// $Id: RawLinearizedDataBlock.cxx,v 1.9 2003/07/10 19:36:29 rhatcher Exp $
// 
// RawLinearizedDataBlock 
// 
// RawLinearizedDataBlock holds a block of linearized QIE data
//
// Author:  R. Hatcher 2002.07.15
//

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

UInt_t RawLinearizedDataBlock::fgDebugFlags = 0;

#include "MessageService/MsgService.h"
CVSID("$Id: RawLinearizedDataBlock.cxx,v 1.9 2003/07/10 19:36:29 rhatcher Exp $");
#include "MessageService/MsgFormat.h"

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawLinearizedDataBlock,kMdBlockLinearizedData,0);

ClassImp(RawLinearizedDataBlock)

enum ELinearizedDataBlkPos {
   indx_size      = 0,
   indx_checksum  = 1,
   indx_blockid   = 2,
   indx_run       = 3,
   indx_subrun    = 4,
   indx_runtype   = indx_subrun,
   indx_sec       = 5,
   indx_nsec      = 6,
   indx_tf_v0     = 7,
   zzzz_last_v0   = 8,
   indx_crateid   = 7,
   indx_tf        = 8,
   indx_nloc      = 9,
   zzzz_last      = 10
};

struct LinDataPoint 
{
  long              nEntries;
  long unsigned int sum;
  long unsigned int sum_sqr_high;
  long unsigned int sum_sqr_low;
};
const UInt_t linDataPointIntSize = sizeof(LinDataPoint)/sizeof(Int_t);

const UInt_t illegalLocation = 0xFFFFFFFF;
//_____________________________________________________________________________
RawLinearizedDataBlock::RawLinearizedDataBlock()
  : RawDataBlock()
{
   // Default constructor
}

//_____________________________________________________________________________
RawLinearizedDataBlock::RawLinearizedDataBlock(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   trigger time (sec)    trigger time (sec)    
   //  6   trigger time (nsec)   trigger time (nsec)   
   //  7   timeframe #           crateid
   //  8     --n/a--             timeframe #           
   //  9     --n/a--             nlocations
  /*
   * The data has the following reapeating structure until
   * all channels are completed:
   *           long unsigned int  location;  -- bit packed
   *           long               nPoints;
   * nPoints * struct  {  long             nEntries;
   *                      long unsigned int sum;
   *                      long unsigned int sum_sqr(high word);
   *                      long unsigned int sum_sqr(low word);
   *                   }
   */

}

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

//____________________________________________________________________________
RawLinearizedDataBlock& 
RawLinearizedDataBlock::operator=(const RawLinearizedDataBlock& 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 RawLinearizedDataBlock::GetRun() const
{
   // get the run number
   if (fSize > indx_run) return fRawBlock[indx_run];
   return -1;
}
 
//_____________________________________________________________________________
Short_t RawLinearizedDataBlock::GetSubRun() const
{
   // get the subrun number
   if (fSize > indx_subrun) return (fRawBlock[indx_subrun]>>16)&0xffff;
   return -1;
}
 
//_____________________________________________________________________________
Short_t RawLinearizedDataBlock::GetRunType() const
{
   // get the run type
   if (fSize > indx_runtype) return fRawBlock[indx_runtype]&0xffff;
   return -1;
}
 
//_____________________________________________________________________________
VldTimeStamp RawLinearizedDataBlock::GetTimeStamp() const
{
   // get the trigger time
   if (fSize > indx_nsec)
      return VldTimeStamp(fRawBlock[indx_sec],fRawBlock[indx_nsec]);
 
   return VldTimeStamp((time_t)0,(Int_t)0);
}
 
//_____________________________________________________________________________
Int_t RawLinearizedDataBlock::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;
}

//_____________________________________________________________________________
Int_t RawLinearizedDataBlock::GetTimeFrameNum() const
{
   // get the timeframe number
   int indx_tf_v = indx_tf;
   if (GetMinorId() <= 0) indx_tf_v--; 
   if (fSize > indx_tf_v) return fRawBlock[indx_tf_v];
   return -1;
}

//_____________________________________________________________________________
UInt_t RawLinearizedDataBlock::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 RawLinearizedDataBlock::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 RawLinearizedDataBlock::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 RawLinearizedDataBlock::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 LinDataPoint* ptr = (const LinDataPoint*)StartOfLocPoint(loc,ipt);
   if (!ptr) return 0;
   return ptr->nEntries;
}

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

   const LinDataPoint* ptr = (const LinDataPoint*)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 RawLinearizedDataBlock::GetRms(UInt_t loc, UInt_t ipt) const
{
   // the RMS that the sub-sub-block corresponds to
   // "location" and point # "ipt"

   const LinDataPoint* ptr = (const LinDataPoint*)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;
   unsigned long long isumx2 = GetSumSqr(loc,ipt);
   Double_t sumx2 = (Double_t)isumx2;
   Double_t mean  = sumx/n;
   return TMath::Sqrt(sumx2/n - mean*mean);

}

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

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

}

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

   const LinDataPoint* ptr = (const LinDataPoint*)StartOfLocPoint(loc,ipt);
   if (!ptr) return 0;
   unsigned long long sum2 = 
     ( (unsigned long long)ptr->sum_sqr_high << 32) | ( ptr->sum_sqr_low );
   return sum2;

}

//_____________________________________________________________________________
Double_t RawLinearizedDataBlock::GetMean(UInt_t loc) const
{
   // the "range" that the sub-sub-block corresponds to
   // "location", averaged over all points

   // use 'long long' to accumulate multiple points
   // before conversion to double to avoid potential loss of precision
   unsigned long long sumofentries = 0;
   unsigned long long sumofsums = 0;

   UInt_t npts = GetNumPoints(loc);
   for (UInt_t ipt = 0; ipt < npts; ++ipt) {
     const LinDataPoint* ptr = (const LinDataPoint*)StartOfLocPoint(loc,ipt);
     sumofentries += ptr->nEntries;
     sumofsums    += ptr->sum;
   }
   if (sumofentries) return 0; // don't divide by zero
   return (Double_t)sumofsums/(Double_t)sumofentries;
}

//_____________________________________________________________________________
Double_t RawLinearizedDataBlock::GetRms(UInt_t loc) const
{
   // the RMS that the sub-sub-block corresponds to
   // "location", averaged over all points

   // use 'long long' to accumulate multiple points
   // before conversion to double to avoid potential loss of precision
   unsigned long long sumofentries = 0;
   unsigned long long sumofsums = 0;
   unsigned long long sumofsumsqrs = 0;

   UInt_t npts = GetNumPoints(loc);
   for (UInt_t ipt = 0; ipt < npts; ++ipt) {
     const LinDataPoint* ptr = (const LinDataPoint*)StartOfLocPoint(loc,ipt);
     sumofentries += ptr->nEntries;
     sumofsums    += ptr->sum;
     //sumofsumsqrs += ptr->sum_sqr;
     unsigned long long this_sum_sqr =
       ( (unsigned long long)ptr->sum_sqr_high << 32) | ( ptr->sum_sqr_low );
     sumofsumsqrs += this_sum_sqr;
   }
   if (sumofentries) return 0; // don't divide by zero
   Double_t mean = (Double_t)sumofsums/(Double_t)sumofentries;
   Double_t sumx2byn = (Double_t)sumofsumsqrs/(Double_t)sumofentries;
   return TMath::Sqrt(sumx2byn - mean*mean);

}

//_____________________________________________________________________________
void RawLinearizedDataBlock::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 RawLinearizedDataBlock::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();
   
   int zzzz_last_v = zzzz_last;
   if (GetMinorId() <= 0) zzzz_last_v = zzzz_last_v0;
   const Int_t *ptr = fRawBlock + zzzz_last_v; // 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*linDataPointIntSize;  
     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* RawLinearizedDataBlock::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*linDataPointIntSize); 
   return ptr;
}

//_____________________________________________________________________________
std::ostream& RawLinearizedDataBlock::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() << " TimeFrame " << GetTimeFrameNum()
      << endl
      << " TimeStamp " << GetTimeStamp().AsString("c") << endl;
   if (GetMinorId()>0) {
     FillCrateId();
     os << " CrateId " << fCrateId.AsString("C") << ", ";
   }
   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 << "            -----  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;
}

//_____________________________________________________________________________

---