RawConfigFilesBlock.cxx

Go to the documentation of this file.

// $Id: RawConfigFilesBlock.cxx,v 1.9 2005/06/07 23:12:21 rhatcher Exp $
// 
// RawConfigFilesBlock 
// 
// RawConfigFilesBlock holds the ConfigFile info (for archival purposes)
//
// Author:  R. Hatcher 2002.05.07
//

#include "RawData/RawConfigFilesBlock.h"

UInt_t RawConfigFilesBlock::fgDebugFlags = 0;

#include "MessageService/MsgService.h"
//CVSID("$Id: RawConfigFilesBlock.cxx,v 1.9 2005/06/07 23:12:21 rhatcher Exp $");
#include "MessageService/MsgFormat.h"

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawConfigFilesBlock,kMdBlockConfigFiles,0);

#include "RawData/littleendian_strings.h"
#include <string.h>

ClassImp(RawConfigFilesBlock)

enum ERunStartBlkPos {
   indx_size      = 0,
   indx_checksum  = 1,
   indx_blockid   = 2,
   zzzz_last_v1   = indx_blockid+1,
   indx_run       = 3,
   indx_subrun    = 4,
   indx_runtype   = indx_subrun,
   indx_startsec  = 5,
   indx_startnsec = 6,
   zzzz_last      = 7
};

//____________________________________________________________________________
RawConfigFilesBlock::RawConfigFilesBlock()
   : RawDataBlock(), fConfigFile(0)
{
   // Default constructor
}

//____________________________________________________________________________
RawConfigFilesBlock::RawConfigFilesBlock(const Int_t *block)
   : RawDataBlock(block), fConfigFile(0)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   //  3   run #
   //  4   {subrun#| run type}
   //  5   time (sec)
   //  6   time (nsec)
   //  7   comment string (padded to 4 char)

}

//____________________________________________________________________________
RawConfigFilesBlock::RawConfigFilesBlock(const VldContext& vldc, Int_t run,
                                       Short_t subrun, Short_t runtype,
                                       const Char_t* comment)
   : RawDataBlock(), fConfigFile(0)
{
   // Component ctor 

   UInt_t nwdc  = nwords_in_string(comment);
   fSize = zzzz_last + nwdc;
   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("RawConfigFilesBlock");
 
   Bool_t isDCS   = rbp->IsDCS();
   Int_t  majorId = rbp->GetMajorId();
   Int_t  minorId = 2;
   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_startsec]     = vldc.GetTimeStamp().GetSec();
   fRawBlock[indx_startnsec]    = vldc.GetTimeStamp().GetNanoSec();
 
   fRawBlock[fSize-1] = 0; // ensure final '\0'
   pack_string_in_lel(fRawBlock+zzzz_last,comment);

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

//____________________________________________________________________________
RawConfigFilesBlock::~RawConfigFilesBlock()
{
   // dtor
   if (fConfigFile) {
      delete [] fConfigFile;
      fConfigFile = 0;
   }
}

//____________________________________________________________________________
RawConfigFilesBlock& RawConfigFilesBlock::operator=(const RawConfigFilesBlock& rhs)
{
   // deep copy assignment 
  if (this != &rhs) {
    RawDataBlock::operator=(rhs);
    if (fConfigFile) { delete [] fConfigFile; fConfigFile = 0; }
  }
  return *this;
}

//____________________________________________________________________________
VldTimeStamp RawConfigFilesBlock::GetTime() const
{
   // get the trigger time

   if ( fSize >= zzzz_last )
      return VldTimeStamp(fRawBlock[indx_startsec],fRawBlock[indx_startnsec]);
 
   return VldTimeStamp((time_t)0,(Int_t)0);
}
 
//____________________________________________________________________________
Int_t RawConfigFilesBlock::GetRun() const
{
   // get the run number

   if ( fSize >= zzzz_last ) return fRawBlock[indx_run];
   return -1;
}
 
//____________________________________________________________________________
Short_t RawConfigFilesBlock::GetSubRun() const
{
   // get the subrun number

   if ( fSize >= zzzz_last ) 
      return (fRawBlock[indx_subrun]>>16)&0xffff;
   return -1;
}
 
//____________________________________________________________________________
Short_t RawConfigFilesBlock::GetRunType() const
{
   // get the run type

   if ( fSize >= zzzz_last ) 
      return fRawBlock[indx_runtype]&0xffff;
   return -1;
}

//____________________________________________________________________________
VldContext RawConfigFilesBlock::GetVldContext() const
{
   // build validity context
   RawBlockId rbid = GetBlockId();
   return VldContext(rbid.GetDetector(),rbid.GetSimFlag(),GetTime());
}

//____________________________________________________________________________
const Char_t* RawConfigFilesBlock::GetConfigFile() const
{
   // return the run config string

   if (!fConfigFile) {

      Int_t*       insitu = fRawBlock+zzzz_last;

      UInt_t nwd = (fRawBlock+fSize) - insitu;
      fConfigFile = unpack_lel_to_string(insitu,nwd);

      // replace non-printable, non-newline characters with blanks
      // leave final null (which should be there ... but make sure it is).
      int nchar = nwd*sizeof(Int_t)/sizeof(Char_t) - 1;
      fConfigFile[nchar] = '\0';
      for (int i=0; i<nchar; ++i) {
        Char_t c = fConfigFile[i];
        if ( !isprint(c) && '\n'!=c ) fConfigFile[i] = ' ';
      }

   }
   return fConfigFile;
}

//____________________________________________________________________________
std::string RawConfigFilesBlock::GuessFileType() const
{
   // guess the type of config file this might be
   // current version don't have this in any explicit form

  const Char_t* haystack = GetConfigFile();
  
  // newer blocks actually are tagged as to what file they are
  const Char_t* starttag = "<config name=\"";
  const Char_t* beginname = strstr(haystack,starttag);
  if (beginname) {
      beginname += strlen(starttag);  // move to after the opening double-quote
      const Char_t* endquote = strstr(beginname,"\""); // closing double-quotes
      if (endquote) {
          std::string configName = "";
          for (const Char_t* iptr = beginname; iptr<endquote; ++iptr)
              configName += *iptr;
          return configName;
      }
  }

  // didn't find the new indicator of the config name
  // resort to guessing ... bleh!

  // strstr returns 0 if substring is not found
  
  // these are empirically determined correlations between the
  // actual file type and some string uniquely found in them
  // NOTE: angerous because the files are subject to change, new ones
  // may need to be added.

  if (strstr(haystack,"dcp.config file"))             return "dcp.config";
  if (strstr(haystack,"vaClockPeriod"))               return "varc.config";
  if (strstr(haystack,"VME Access ModuleId"))         return "master.config";
  if (strstr(haystack,"Trigger Processor Config"))    return "tp.config";
  if (strstr(haystack,"config file for LI control"))  return "li.config";
  if (strstr(haystack,"<branches>"))                  return "daq.config";
  if (strstr(haystack,"ropConfig"))                   return "rop.config";
  if (strstr(haystack,"<timemaster>"))                return "tpc.config";
  if (strstr(haystack,"pvicBrpNode"))                 return "pvic.config";
  if (strstr(haystack,"planemap>"))                   return "detector.config";
  if (strstr(haystack,"brpHost"))                     return "brp.config";
  if (strstr(haystack,"<Pedestal>"))                  return "runType.config";
  if (strstr(haystack,"<runstats>"))                  return "runtimes.config";
  if (strstr(haystack,"<fileConfig>"))                return "dcp.config";
  if (strstr(haystack,"<startTimes>"))                return "liStartTimes.config";

  return "undetermined.config";
  
}

//____________________________________________________________________________
std::ostream& RawConfigFilesBlock::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 << "Time " << GetTime().AsString("c") << endl;
   os << " Run " << GetRun()
      << " SubRun " << GetSubRun()
      << " RunType " << GetRunType() << endl;
   os << " GuessFileType: '" << GuessFileType() << "'" << endl;
   const Char_t* cfg = GetConfigFile();
   const Char_t* linestart = " | ";
   os << linestart;
   while (*cfg != '\0') {
      os << *cfg;
      if (*cfg == '\n' && *(cfg+1) != '\0') os << linestart;
      ++cfg;
   }
   os << endl;

   return os;
}

//____________________________________________________________________________

---