RawSpillServerMonitorBlock.cxx

Go to the documentation of this file.

// $Id: RawSpillServerMonitorBlock.cxx,v 1.2 2005/01/26 20:29:21 rhatcher Exp $
// 
// RawSpillServerMonitorBlock 
// 
// RawSpillServerMonitorBlock holds the information about spill
//    timing (and estimates thereof).
//
// Author:  R. Hatcher 2004.10.13
//

#include "RawData/RawSpillServerMonitorBlock.h"
#include "TString.h"

UInt_t RawSpillServerMonitorBlock::fgDebugFlags = 0;

#include "MessageService/MsgService.h"
//CVSID("$Id: RawSpillServerMonitorBlock.cxx,v 1.2 2005/01/26 20:29:21 rhatcher Exp $");
//#include "MessageService/MsgStream.h"

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawSpillServerMonitorBlock,kMdBlockSpillServerMonitor,0);

ClassImp(RawSpillServerMonitorBlock)

enum EDaqHeaderBlkPos {
   indx_size       =  0,
   indx_checksum   =  1,
   indx_blockid    =  2,
   indx_run        =  3,
   indx_subrun     =  4,
   indx_runtype    =  indx_subrun,
   indx_start_sec  =  5,
   indx_start_nsec =  6,
   indx_tf         =  7,
   indx_end_sec    =  8,
   indx_end_nsec   =  9,
   indx_response   = 10,
   indx_spilldata  = 11, // start of structure
   indx_request    = 11,
   indx_isknown    = 12,
   indx_spilltype  = 13,
   indx_spillid    = 14,
   indx_near_sec   = 15,
   indx_near_nsec  = 16,
   indx_far_sec    = 17,
   indx_far_nsec   = 18,
   indx_esterr_ns  = 19,
   indx_open_ns    = 20,
   indx_close_ns   = 21,
   zzzz_last       = 22
};

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

//_____________________________________________________________________________
RawSpillServerMonitorBlock::RawSpillServerMonitorBlock(const Int_t *block)
   : RawDataBlock(block)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   run #
   //  4   {subrun #| run type}
   //  5   timeframe start timestamp (sec)
   //  6   timeframe start timestamp (nsec)
   //  7   timeframe #
   //  8   timeframe end timestamp (sec)
   //  9   timeframe end timestamp (nsec)
   // 10   query response time (usec if >=0; error code if <0)
   // 11   request sec
   // 12   isKnown
   // 13   spill type
   // 14   spill id (unique 'DAQ' id for spill)
   // 15   near spill timestamp (sec)
   // 16   near spill timestamp (nsec)
   // 17   far spill timestamp (sec)
   // 18   far spill timestamp (nsec)
   // 19   estimated worst case error (nsec)
   // 20   suggested window open time (nsec)
   // 21   suggested window close time (nsec)
}
//_____________________________________________________________________________
RawSpillServerMonitorBlock::RawSpillServerMonitorBlock(const VldContext& vldc, Int_t run, 
                                     Short_t subrun, Short_t runtype,
                                     Int_t timeframe)
   : RawDataBlock()
{
   // Component ctor

   fSize = zzzz_last;
   if (fRawBlock) delete [] fRawBlock;
   fRawBlock = new Int_t [fSize];

   fRawBlock[0] = fSize;
// fRawBlock[1] = checksum... see below

   RawBlockRegistry& rbr = RawBlockRegistry::Instance();
   RawBlockProxy*    rbp = rbr.LookUp("RawSpillServerMonitorBlock");

   Bool_t isDCS   = rbp->IsDCS();
   Int_t  majorId = rbp->GetMajorId();
   Int_t  minorId = 1;  // latest and greatest minor version #
   RawBlockId rbid(majorId,minorId,isDCS,
                   vldc.GetDetector(),vldc.GetSimFlag());
   fRawBlock[2] = rbid.GetEncoded();

   fRawBlock[indx_run]         = run;
   fRawBlock[indx_subrun]      = (subrun&0xffff)<<16 | (runtype&0xffff);
   fRawBlock[indx_start_sec]   = vldc.GetTimeStamp().GetSec();
   fRawBlock[indx_start_nsec]  = vldc.GetTimeStamp().GetNanoSec();
   fRawBlock[indx_tf]          = timeframe;
   fRawBlock[indx_end_sec]     = fRawBlock[indx_start_sec] + 1;
   fRawBlock[indx_end_nsec]    = fRawBlock[indx_start_nsec];
   fRawBlock[indx_response]    = -1;
   fRawBlock[indx_request]     = 0;
   fRawBlock[indx_isknown]     = 0;
   fRawBlock[indx_spilltype]   = -1;
   fRawBlock[indx_spillid]     = 0;
   fRawBlock[indx_near_sec]    = 0;
   fRawBlock[indx_near_sec]    = 0;
   fRawBlock[indx_near_nsec]   = 0;
   fRawBlock[indx_far_sec]     = 0;
   fRawBlock[indx_far_nsec]    = 0;
   fRawBlock[indx_esterr_ns]   = 0;
   fRawBlock[indx_open_ns]     = 0;
   fRawBlock[indx_close_ns]    = 0;

   // fill checksum
   rdxsum_fill((long*)fRawBlock,0); 

}

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

//_____________________________________________________________________________
VldTimeStamp RawSpillServerMonitorBlock::GetFrameStartTime() const
{
   // get the timestamp for the start of the timeframe
   if (fSize > indx_start_nsec) 
      return VldTimeStamp(fRawBlock[indx_start_sec],
                          fRawBlock[indx_start_nsec]);

   return VldTimeStamp((time_t)0,(Int_t)0);
}

//_____________________________________________________________________________
VldTimeStamp RawSpillServerMonitorBlock::GetFrameEndTime() const
{
   // get the timestamp for the end of the timeframe

   if (fSize > indx_end_nsec) 
      return VldTimeStamp(fRawBlock[indx_end_sec],
                          fRawBlock[indx_end_nsec]);

   return VldTimeStamp((time_t)0,(Int_t)0);
}

//_____________________________________________________________________________
Int_t RawSpillServerMonitorBlock::GetRun() const
{
   // get the run number
   if (fSize > indx_run) return fRawBlock[indx_run];
   return -1;
}

//_____________________________________________________________________________
Short_t RawSpillServerMonitorBlock::GetSubRun() const
{
   // get the subrun number
   if (fSize > indx_subrun) return (fRawBlock[indx_subrun]>>16)&0xffff;
   return -1;
}

//_____________________________________________________________________________
Short_t RawSpillServerMonitorBlock::GetRunType() const
{
   // get the run type
   if (fSize > indx_runtype) return fRawBlock[indx_runtype]&0xffff;
   return -1;
}

//_____________________________________________________________________________
Int_t RawSpillServerMonitorBlock::GetTimeFrameNum() const
{
   // get the timeframe number
   if (fSize > indx_tf) return fRawBlock[indx_tf];
   return -1;
}

//_____________________________________________________________________________
Int_t RawSpillServerMonitorBlock::GetResponse() const
{
   // get the time taken to obtain data from server (in usec)
   if (fSize > indx_response) return fRawBlock[indx_response];
   return -1;
}

//_____________________________________________________________________________
const mdSpillData_t& RawSpillServerMonitorBlock::GetSpillData() const
{
   // get the mdSpillData_t structure
  static mdSpillData_t dummySpillData; // = {0,0,0,0,0,0,0,0,0,0,0};

  if ((unsigned int)fSize > indx_response+sizeof(mdSpillRequest_t)) {
    return *(mdSpillData_t*)(fRawBlock+indx_spilldata);
  }
  else return dummySpillData;
}

//_____________________________________________________________________________
VldContext RawSpillServerMonitorBlock::GetVldContext() const
{
   // build validity context
   RawBlockId rbid = GetBlockId();
   return VldContext(rbid.GetDetector(),rbid.GetSimFlag(),GetTimeStamp());
}

//_____________________________________________________________________________
std::ostream& RawSpillServerMonitorBlock::FormatToOStream(ostream& os, 
                                                 Option_t *option) const
{
   RawDataBlock::FormatToOStream(os,option);
   if (option[0] == 'X') return os;

   //Int_t minor = GetMinorId();

   os << " [ " 
      << GetFrameStartTime().AsString("c") 
      << " : "
      << GetFrameEndTime().AsString("c") 
      << " ]"
      << endl;
   os << " Run " << GetRun()
      << " SubRun " << GetSubRun() 
      << " RunType " << GetRunType()
      << " TimeFrame " << GetTimeFrameNum()
      << endl; 

   Int_t response = GetResponse();
   os << " Response";
   if (response >= 0) os << " in " << response << "usec" << endl;
   else               os << ": " << ResponseAsString(response) << endl;
  
   // interpret mdSpillData_t info

   const mdSpillData_t& spillData = GetSpillData();
   long request_sec = spillData.request_sec;
   VldTimeStamp requestTimeStamp((time_t)request_sec,0);
   os << " Queried time: " << request_sec 
      << " [ " << requestTimeStamp.AsString("s") << "]" << endl;
   os << " isKnown " << spillData.isKnown
      << " " << SpillTypeAsString(spillData.isSpill)
      << " DAQ-ID " << spillData.spillId
      << endl;
   VldTimeStamp nearTimeStamp(spillData.spillTimeND.sec,
                              spillData.spillTimeND.nsec);
   VldTimeStamp farTimeStamp(spillData.spillTimeFD.sec,
                             spillData.spillTimeFD.nsec);
   os << " Near " << nearTimeStamp.AsString("c")
      << " Far " << farTimeStamp.AsString("c")
      << endl;
   os << " Est. worst error " 
      << spillData.spillTimeError_nsec << " ns"
      << endl;
   os << " Window open " << spillData.windowOpen_nsec
      << " close " << spillData.windowClose_nsec << " ns"
      << endl;
 
   return os;
}

//_____________________________________________________________________________
const Char_t* RawSpillServerMonitorBlock::ResponseAsString(Int_t response)
{
  // interpret response error codes -- tpSpillServerQueryErrors
 
  if (response>=0) return Form("in %d usec",response);

  switch (response) {
  case kSpillServerNotAsked:       return "No query to Spill Server ";                  break;
  case kSpillServerNoConnect:      return "Connection to Spill Server failed";          break;
  case kSpillServerCommsFailure:   return "Spill Server socket communications failure"; break;
  case kSpillServerHangUp:         return "Spill Server hung up before response";       break;
  case kSpillServerTimeout:        return "Timeout before Spill Server responded";      break;
  case kSpillServerIncompleteData: return "Incomplete Data received from Spill Server"; break;
  default: return "unknown tpSpillServerQueryError"; break;
  }
}

//_____________________________________________________________________________
const Char_t* RawSpillServerMonitorBlock::SpillTypeAsString(Int_t spillType)
{
  // interpret spill types -- mdSpillTypeEnum

  switch (spillType) {
  case kSpillType_None:      return "None";              break;
  case kSpillType_Reported:  return "Reported";          break;
  case kSpillType_Predicted: return "Predicted";         break;
  case kSpillType_Fake:      return "Fake";              break;
  case kSpillType_Local:     return "Local";             break;
  default:                   return "Unknown mdSpillTypeEnum"; break;
  }
}

//_____________________________________________________________________________

---