RawRecord.cxx

Go to the documentation of this file.

// $Id: RawRecord.cxx,v 1.19 2007/11/11 20:44:34 schubert Exp $
//
// RawRecord
//
// RawRecord is the top level object for raw MINOS data from the online
// This is the primary key for I/O of records of raw data
//
// Author:  R. Hatcher 2000.04.19
//

#include "RawData/RawRecord.h"
#include "RawData/RawHeader.h"
#include "RawData/RawDataBlock.h"

#include "RawData/RawBlockRegistry.h"
#include "RawData/RawBlockProxy.h"

#include <iostream>
#include <cassert>
#include <string>
#include <map>

#include "MessageService/MsgService.h"
CVSID("$Id: RawRecord.cxx,v 1.19 2007/11/11 20:44:34 schubert Exp $");

ClassImp(RawRecord)

//_____________________________________________________________________________

// No one record should keep track of how many times generic blocks
// have been promoted, so this shouldn't be a data memeber of an object.
// Not having it as a data member of the class (but rather simply
// in the implementation file) avoids exposing it in the header.
static std::map<std::string,unsigned long int> fgPromoteCount;

//_____________________________________________________________________________
RawRecord::RawRecord() : promotionChecked(false)
{
   // Default constructor
}

//_____________________________________________________________________________
RawRecord::RawRecord(RawHeader *rh) : RecMinos(rh), promotionChecked(false)
{
   // normal ctor, adopt the RawHeader for ownership
}


//_____________________________________________________________________________
RawRecord::~RawRecord()
{
   // dtor, no explicit deletion of header -- done by RecMinos
}

//_____________________________________________________________________________
const RawHeader *RawRecord::GetRawHeader() const
{

   // Return the RawHeader

   const RawHeader* rawHeader =
     dynamic_cast<const RawHeader *>(RecMinos::GetHeader());
   
   if (!rawHeader) {
     const RecMinosHdr* recHeader = RecMinos::GetHeader();
     MSG("RawData",Msg::kWarning)
       << "RawRecord::GetRawHeader found no RawHeader*, "
       << "RecMinosHdr* was " << recHeader << endl;
   }
   return rawHeader;
}
//_____________________________________________________________________________
const RawDataBlock *RawRecord::FindRawBlock(const char *classname,
                                            const char *objname) const
{

// Returns the *last* selected RawDataBlock.  If classname is a null ptr
// or blank string, no class selection is done.  If classname is
// provided, the qualifying object must InheritFrom() or be a classname.
// The objname is optional, but, if filled, will further qualify the
// selection by requiring agreement with the GetName() method of the
// selected object.

// RecMinos::FindComponent() returns a "const TObject *".  This gets
// converted to a "RawDataBlock *" using dynamic_cast to make sure the
// original is a "RawDataBlock *". 

  PromoteRawDataBlocks();  // make sure that blocks are specialized

  return dynamic_cast<const RawDataBlock *>
     (RecMinos::FindComponent(classname, objname));
}

//_____________________________________________________________________________
TIter RawRecord::GetRawBlockIter(Bool_t dir) const
{

   // Get an iterator over the raw blocks

   PromoteRawDataBlocks();  // make sure that blocks are specialized

   return TIter(&RecMinos::GetComponents(),dir);
}

//_____________________________________________________________________________
void RawRecord::AdoptRawBlock(RawDataBlock *rawblock)
{
   // Adopt (to own) a RawDataBlock derived object

   RecMinos::AdoptComponent(rawblock);
}

//_____________________________________________________________________________
void RawRecord::Print(Option_t *option) const
{
   // Print header, loop over raw blocks, print those
   // unless passed "l" option, then just list the blocks.

   if (fHeader) fHeader->Print();
   else cout << "RawRecord: has no header";
   cout << endl;  // header doesn't terminate the line
   GetJobHistory().Print();
   
   string opt = option;
   if ( opt.find("l") != string::npos ) ListBlocks();
   else {
     TIter iter = this->GetRawBlockIter();
     TObject *tobj = 0;
     while ((tobj = iter())) tobj->Print(option);
   }
}

//_____________________________________________________________________________
void RawRecord::AdoptComponent(TObject* component)
{
   // Adopt (to own) a random TObject derived object
   // RawRecord should only be adopting RawDataBlocks
   // so this will assert before actually adopting.

   MSG("Raw",Msg::kFatal)
      << "RawRecord::AdoptComponent(TObject*) was called"
      << endl;
   assert(0);

   RecMinos::AdoptComponent(component);
}

//_____________________________________________________________________________
void RawRecord::PromoteRawDataBlocks() const
{
   // Look through list of blocks for generic 'RawDataBlock' objects;
   // convert these to specialized blocks based on block id.

  if (promotionChecked) return;

  const TString generic = "RawDataBlock";
  RawBlockRegistry& rbr = RawBlockRegistry::Instance();

  Int_t last = fComponents.GetLast();
  for (Int_t idx=0; idx <= last; ++idx) {

    TObject* tobj = fComponents[idx];
    if ( ! tobj ) continue;

    RawDataBlock* rdb = dynamic_cast<RawDataBlock*>(tobj);
    if ( ! rdb ) {
      // protect against serious suprises
      MSG("Raw",Msg::kWarning)
        << "Element " << idx << " in fComponents was not a RawDataBlock!"
        << endl;
      continue; 
    }

    if (generic != rdb->ClassName()) continue;

    // if we're here then the block is unspecialized

    RawBlockId rbid    = rdb->GetBlockId();
    RawBlockProxy* rbp = rbr.LookUp(rbid.IsDCS(),rbid.GetMajor());

    if (rbp) {
      // create a block of the right type
      RawDataBlock *specialBlk = rbp->CreateRawDataBlock(rdb->GetData());
      
      // a bit of nasty code so that this method can be considered
      // logical const even though it changes fComponents
      // we do it by index so that no ordering is changed in any way
      
      TObjArray& writable = const_cast<TObjArray&>(fComponents);
      
      writable.RemoveAt(idx);          // remove generic version
      writable.AddAt(specialBlk,idx);  // replace with specialized copy
      delete rdb;                      // delete generic version

      std::string finalClass = specialBlk->ClassName();
      unsigned long int curcount = (++fgPromoteCount[finalClass]);

      const unsigned long int maxmsg = 10;
      if (curcount <= maxmsg)
        MSG("Raw",Msg::kInfo)
          << "RawRecord promoted generic 'RawDataBlock'"
          << " to '" << finalClass << "'"
          << endl;
      if (curcount == maxmsg)
        MSG("Raw",Msg::kInfo) << "... last message for " << finalClass << endl;
    }
    else {
      // couldn't find an appropriate block id in the registry
      MSG("Raw",Msg::kWarning) 
        << "No proxy for RawBlockId "
        << "0x" << hex << rbid.GetMajor() << dec
        << ", can not promote to specialized block."
        << endl;
    }
    
  }  // loop over entries

  promotionChecked = true;
}
//_____________________________________________________________________________
const char* RawRecord::GetName() const
{
  // Return the "name"
  // If the TNamed value has been set use that otherwise see if
  // one can determine a useful name from the stream recorded in
  // the registry.

  string recUserName = TNamed::GetName();
  if (recUserName != "") return recUserName.c_str();
  else{
    //MSG("Raw",Msg::kInfo) << "Record has no name" << endl;
    const char* unknownStream = "?stream?";
    const char* tmp = 0;
    string recStream(unknownStream);

    const Registry& reg = GetTempTags();
    if (reg.Get("stream",tmp)) recStream = tmp;
    if (recStream != unknownStream) {
      // this method is logical "const" but it does modify the object
      RawRecord* writeableSelf = const_cast<RawRecord*>(this);
      writeableSelf->SetName(recStream.c_str());
      //MSG("Raw",Msg::kInfo) << "Record has is now named \"" 
      //                      << TNamed::GetName() << "\"" << endl;
    }
  }
  return TNamed::GetName();
}

//_____________________________________________________________________________
void RawRecord::ListBlocks() const
{
  // Lump the classname and block id for all the elements in fComponents.
  // Avoid anything that would promote generic blocks.

  MSG("Raw",Msg::kInfo)
    << "   index ClassName                 RawBlockId" 
    << endl;

   Int_t last = fComponents.GetLast();
   for (Int_t idx=0; idx <= last; ++idx) {
     TObject* tobj = fComponents[idx];
     if ( ! tobj ) continue;
     RawDataBlock* rdb = dynamic_cast<RawDataBlock*>(tobj);
     if (rdb) {
       RawBlockId rbid = rdb->GetBlockId();
       MSG("Raw",Msg::kInfo)
         << "    [" << setw(2) << idx << "] " 
         << left << setw(25) << tobj->ClassName()
         << resetiosflags(ios::adjustfield) // reset "left"
         << " " << rbid
         << endl;
     }
     else {
       MSG("Raw",Msg::kInfo)
         << "    [" << setw(2) << idx << "] " 
         << left << setw(25) << tobj->ClassName()
         << resetiosflags(ios::adjustfield) // reset "left"
         << " is not a RawDataBlock."
         << endl;
     }
   }
   
   MSG("Raw",Msg::kInfo) << endl;
}

//_____________________________________________________________________________
void RawRecord::PrintPromotionCount()
{
  // Print the number of times each type of RawDataBlock had to
  // be promoted to the non-generic class type

  if (fgPromoteCount.empty()) {
    MSG("Raw",Msg::kInfo)
      << "RawRecord promoted no RawDataBlocks to derived types"
      << endl;
  }
  else {
    MSG("Raw",Msg::kInfo)
      << "RawRecord promoted RawDataBlocks to derived types:"
      << endl;

    std::map<std::string,unsigned long int>::const_iterator pc_itr = 
      fgPromoteCount.begin();
    while (pc_itr != fgPromoteCount.end()) {
      MSG("Raw",Msg::kInfo)
        << "   " << pc_itr->first << " " 
        << pc_itr->second << " times "
        << endl;
      pc_itr++;
    }
  }
}

//_____________________________________________________________________________

---