RerootToRawDataModule.cxx

Go to the documentation of this file.

// $Id: RerootToRawDataModule.cxx,v 1.49 2005/08/26 19:07:29 rhatcher Exp $
//
// A JobControl Module for filling RawData from REROOT
//
// rhatcher@fnal.gov

#include "RerootExodus/RerootToRawDataModule.h"
#include "RerootExodus/RerootExodus.h"

#include "MinosObjectMap/MomNavigator.h"

#include "MessageService/MsgService.h"
#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"

#include "MINF_Classes/MINFast.h"
#include "REROOT_Classes/REROOT_GeomMisc.h"
#include "REROOT_Classes/REROOT_PlanePos.h"
#include "REROOT_Classes/REROOT_PlaneSpec.h"
#include "REROOT_Classes/REROOT_CellPos.h"

#include "Plex/PlexHandle.h"

#include "RawData/RawRecord.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawBlockRegistry.h"
#include "RawData/RawBlockId.h"
#include "RawData/RawDigit.h"
#include "RawData/RawMCDigitMixIn.h"

#include "TMath.h"

const UInt_t dbg_DumpAddToCrate         = 0x0001;
const UInt_t dbg_DumpNewCrate           = 0x0002;
const UInt_t dbg_PrintRawDigitDataBlock = 0x0004;
const UInt_t dbg_WarnAllMissingRCId     = 0x0008;

ClassImp(RerootToRawDataModule)


//......................................................................

CVSID("$Id: RerootToRawDataModule.cxx,v 1.49 2005/08/26 19:07:29 rhatcher Exp $");
JOBMODULE(RerootToRawDataModule, "RerootToRawDataModule",
         "Builds RawRecord with RawDigitDataBlock");

//......................................................................


RerootToRawDataModule::RerootToRawDataModule() 
   : random(0), fDebugFlags(0), fRawPeCut(0.2999), 
   ncrates(0), workingcrates(0), cratesizeused(0),
   workingarray(0), display(0),
   Nplaneshit(0), ofMplanes(0)
{
   // construct a new "RerootToRawDataModule" JobControl module

   // we'll use a random # generator to set fake "trigbits"
   // the generator can live as long as the module
   random = new TRandom();

   // initialize detector to non-legal value
   detector = Detector::kUnknown;

   ncrates = 128;
   cratesizeused  = new TArrayI(ncrates);
   workingcrates  = new TArrayI [ncrates];

   Int_t init_alloc = 5 + 100*3;
   for (Int_t i=0; i<ncrates; i++) {
      cratesizeused->AddAt(0,i);
      workingcrates[i].Set(init_alloc);
   }

   nwordsblock = 0;
   workingarray = new TArrayI(2);


}

//......................................................................

RerootToRawDataModule::~RerootToRawDataModule() 
{
  MSG("Exodus", Msg::kVerbose) << "RerootToRawDataModule::Destructor\n";

  if (random) delete random;
  random = 0;

  if (ncrates) {
     delete [] workingcrates;
     workingcrates = 0;

     delete cratesizeused;
     cratesizeused = 0;

     ncrates = 0;
  }

  if (workingarray) delete workingarray;
  workingarray = 0;

  if (display) delete display;
  display = 0;

}

//......................................................................

JobCResult RerootToRawDataModule::Get(MomNavigator *mom)
{
   // Create RawRecord from the current REROOT event
   // available via gMINFast.

  if (!gMINFast) {
    static int nmsg = 10;
    if (nmsg) {
      MSG("Exodus",Msg::kFatal) 
        << "RerootToRawDataModule lacked gMINFast" << endl
        << "   perhaps the input isn't a REROOT file"
        << endl;
      nmsg--;
      if (!nmsg) MSG("Exodus",Msg::kFatal) 
        << " ... last such message" << endl;
    }
    return JobCResult::kError;
  }

  // Prepare to start by getting current REROOT pointers
  // and clearing out the working array
  InitWorkingArray();

  ndigitsPerPlane.Reset();

  // For a PlexHandle we need a context
  VldContext vldc = RerootExodus::BuildVldContext();

  // Get a PlexHandle for PlexStripEndId to RawChannelId conversions
  PlexHandle ph(vldc);

  // Prepare to loop over REROOT digits
  const TClonesArray *flsdigits   = RerootExodus::GetFLSDigitList();
  REROOT_FLSDigit    *flsdigit = 0;
  TIter diter(flsdigits);

  PlexStripEndId seid;
  RawChannelId   rcid;
  Float_t raw, tdc;
  Int_t   isAB;

  // Keep track of earliest time.
  Float_t tearly = 2e9; // Set to something not crazy, so (int)tearly isn't a fpe.

  // ADAMO unfilled entries have special values
  // but exact testing doesn't seem to work...
  Float_t ADAMO_RNULL =  699050. * (Float_t) (16<<26); // 699050*16.0**26

  // loop over all digits
  while ( ( flsdigit = (REROOT_FLSDigit*) diter.Next() ) ) {

     static int nmsgIsNull = 20; // default, limit to 20 messages

     // process A side
     raw  = flsdigit->RawA();
     tdc  = flsdigit->TDCA();
     isAB = 0;
     if ( raw > 0.0 && raw < ADAMO_RNULL ) {
        seid = RerootExodus::PECAB2SEId(flsdigit->IPln(),flsdigit->IExtr(),
                                        flsdigit->ICell(),isAB);
        // make an entry
        rcid = ph.GetRawChannelId(seid);
        if (rcid.IsNull()) {
           if (( fDebugFlags & dbg_WarnAllMissingRCId) || nmsgIsNull>0)
              MSG("Exodus",Msg::kWarning) 
                 << "rcid.IsNull() on A side " << seid.AsString() << endl;
           if (nmsgIsNull==1 & !(fDebugFlags&dbg_WarnAllMissingRCId)) 
              MSG("Exodus",Msg::kWarning)
                 << " ... last IsNull message" << endl;
           nmsgIsNull--;
        }
        // add no matter if rcid.IsNull, so we see MC truth
        AddToCrate(seid,rcid,raw,tdc);
        if(tdc < tearly) tearly = tdc;
     }

     // process B side
     raw  = flsdigit->RawB();
     tdc  = flsdigit->TDCB();
     isAB = 1;
     if ( raw > 0.0 && raw < ADAMO_RNULL ) {
        seid = RerootExodus::PECAB2SEId(flsdigit->IPln(),flsdigit->IExtr(),
                                        flsdigit->ICell(),isAB);
        // make an entry
        rcid = ph.GetRawChannelId(seid);
        if (rcid.IsNull()) {
           if (( fDebugFlags & dbg_WarnAllMissingRCId) || nmsgIsNull>0)
              MSG("Exodus",Msg::kWarning) 
                 << "rcid.IsNull() on B side " << seid.AsString() << endl;
           if (nmsgIsNull==1 & !(fDebugFlags&dbg_WarnAllMissingRCId)) 
              MSG("Exodus",Msg::kWarning)
                 << " ... last IsNull message" << endl;
           nmsgIsNull--;
        }
        // add no matter if rcid.IsNull, so we see MC truth
        AddToCrate(seid,rcid,raw,tdc);
        if(tdc < tearly) tearly = tdc;
     }
  }

  // Finalize the working array, produce RawDigitDataBlock
  RawDataBlock *rawblk = FinalizeWorkingArray();
  RawDigitDataBlock *rrdb = dynamic_cast<RawDigitDataBlock*>(rawblk);

  if (fDebugFlags & dbg_PrintRawDigitDataBlock) rawblk->Print();

  // produce a RawDaqSnarlHeader (specialized RawHeader)
  // which the RawRecord will adopt

  Int_t   run      = RerootExodus::GetRunNo();
  Int_t   snarl    = RerootExodus::GetEventNo();
  Int_t   trigbits = random->Integer(0x0fffffff);
  Short_t subrun = 0;
  Short_t runtype = 0;
  Int_t   errcode = 0;
  static Int_t tf = 0;
  Int_t   nrawdigits = (rrdb) ? rrdb->GetNumberOfDigits() : -1;
  Int_t   spilltype = -1;

  // Convert tearly to trigger time.
  VldTimeStamp trigTime(vldc.GetTimeStamp().GetSec(),
                        (int)(tearly));
  // Build a new, slightly different context:
  VldContext trigContext(vldc.GetDetector(),
                         vldc.GetSimFlag(),
                         trigTime);

  RawDaqSnarlHeader *head = 
     new RawDaqSnarlHeader(trigContext,run,subrun,runtype,++tf,
                           snarl,trigbits,errcode,nrawdigits,spilltype);

  // produce a RawRecord, have it adopt the header
  
  RawRecord *rawrec = new RawRecord(head);

  // give the block to the RawRecord

  rawrec->AdoptRawBlock(rawblk);

  // tag this RawRecord AS IF it had come from the DaqSnarl stream

  rawrec->GetTempTags().Set("stream","DaqSnarl");

  // give the RawRecord to MOM to hold as a "fragment"
  
  mom->AdoptFragment(rawrec);

  // 

  return ApplyTrigger(); // result depends on trigger
}

//......................................................................

JobCResult RerootToRawDataModule::ApplyTrigger()
{
  // Apply the N of M trigger for the Far Eetector
  // Should also work for CalDet
  // Simply punt for Near Detector

  if (Detector::kNear == detector) return JobCResult::kPassed;

  // if no test then always pass
  if (Nplaneshit<=0) return JobCResult::kPassed;

  // find first & last plane with digits
  Int_t first = 0;
  Int_t last  = ndigitsPerPlane.GetSize()-1;
  for ( ; last>first; last-- ) if (ndigitsPerPlane[last]>0) break;
  for ( ; first<last; first++) if (ndigitsPerPlane[first]>0) break;

  // if impossibly short then don't bother further, it fails
  if (last-first+1<Nplaneshit) return JobCResult::kFailed;  

  Int_t running_total = 0;
  Int_t excluded_plns = 0;
  for (Int_t plane = first; plane<=last; plane++) {

    // check for uninstrumented plane
    PlexPlaneId pid(detector,plane);
    if (pid.GetPlaneCoverage() == PlaneCoverage::kNoActive) {
      excluded_plns++;
      if (ndigitsPerPlane[plane]>0)
        MSG("Exodus",Msg::kWarning)
          << "saw " << ndigitsPerPlane[plane]
          << " digits in uninstrumented plane "
          << pid << endl;
      else
        ndigitsPerPlane[plane] = -1; // mark it as to be excluded
    }
    
    // if appropriate, add this plane into total
    if (ndigitsPerPlane[plane]>0) running_total++;

    // start subtracting
    Int_t window = ofMplanes + excluded_plns;
    if (plane>=window-1 && plane-window>=0) { // -1 for zero based indexing
      Int_t ngoingout = ndigitsPerPlane[plane-window];
      if      (ngoingout < 0) excluded_plns--;
      else if (ngoingout > 0) running_total--;
    }

    // test if valid
    if ( running_total >= Nplaneshit ) return JobCResult::kPassed;

  }
  // fell through without passing?  failed!
  return JobCResult::kFailed;
}

//......................................................................

JobCResult RerootToRawDataModule::Reco(MomNavigator *mom)
{
  // A test job for "reconstruction"
  // This example code unpacks the RawDataBlocks in the RawRecord
  // and displays them on a CheezyDisplay using the Plex
  // to convert from RawRecordId into PlexStripEndId's
  
  //  MSG("Exodus", Msg::kVerbose) << "RerootToRawDataModule::Reco\n";

  TObject   *obj;

  // Get the RawRecord from Mom
  RawRecord *rawrec = dynamic_cast<RawRecord *>
                                        (mom->GetFragment("RawRecord"));
  if ( ! rawrec ) {
     MSG("Exodus",Msg::kFatal) << "RerootToRawDataModule::Reco" <<
        " failed to fin a \"RawRecord\"" << endl;
     return JobCResult::kError;
  }
  
  // For a PlexHandle we need a context
  VldContext vldc = rawrec->GetRawHeader()->GetVldContext();

  // Get a PlexHandle for PlexStripEndId to RawChannelId conversions
  PlexHandle ph(vldc);

  // Create (if necessary) a display
  if ( ! display ) display = 
                      new CheezyDisplay("RerootToRawDataModule",
                                        "RerootToRawDataModule display");
  display->ClearLists();
  display->SetVldContext(vldc);


  // from the RawRecord loop over the RawDataBlocks
  RawDigitDataBlock     *digitblk  = 0;
  TIter blkiter = rawrec->GetRawBlockIter();
  while ( ( obj = blkiter.Next() ) ) {
     digitblk  = dynamic_cast<RawDigitDataBlock*>(obj);
     if (digitblk) {

        // Loop over the digits make counts
        RawDigit       *digit = 0;
        TIter diter = digitblk->GetDatumIter();

        while ( ( digit = (RawDigit*) diter.Next() ) ) {
           
           // if it came from a Raw{Qie,Va}MCDigit then there
           // is Truth(TM) info available
           // cast the digit correctly and retrieve it
           RawMCDigitMixIn *truthDigit = dynamic_cast<RawMCDigitMixIn*>(digit);
           if (truthDigit) {
              PlexStripEndId seid(truthDigit->GetTrueSEIdEncoded());
              display->AddStripEndId(seid,kTRUE);
           }           

           // ALT LIST
           RawChannelId rcid = digit->GetChannel();
           PlexSEIdAltL altlist = ph.GetSEIdAltL(rcid);
           altlist.SetFirst();
           while ( altlist.IsValid() ) {
              PlexStripEndId seid = altlist.GetCurrentSEId();
              display->AddStripEndId(seid,kFALSE);
              altlist.Next();
           }
        }

     }
  }
     
  // Now actually draw these things
  display->Draw();

  return JobCResult::kAOK;

}

//......................................................................

void RerootToRawDataModule::InitWorkingArray(void)
{
   // Initialize for new "Get"

   // zero out used sizes ...
   for (Int_t i=0; i<ncrates; i++) {
      cratesizeused->AddAt(0,i);
   }
   nwordsblock = 0;

   detector = RerootExodus::GetDetector();
}

//......................................................................

void RerootToRawDataModule::AddToCrate(const PlexStripEndId& seid,
                                       const RawChannelId&   rcid,
                                       Float_t raw, Float_t tdc)
{
   // Add this entry into the crate array

   // apply the cut if necessary
   if (raw < fRawPeCut ) {
      static Float_t last_cut_msg = -1;
      if (last_cut_msg != fRawPeCut) {
         // one warning for any given cut level
         last_cut_msg = fRawPeCut;
         MSG("Exodus",Msg::kInfo)
            << "::AddToCrate cutting all raw values < "
            << fRawPeCut << endl;
      }
      return;
   }

   // keep track of # of digits in each plane (above threshold)
   Int_t plane = seid.GetPlane();
   if (ndigitsPerPlane.GetSize()<plane+1) ndigitsPerPlane.Set(plane+1);
   ndigitsPerPlane[plane]++;

   Int_t crate = rcid.GetCrate();
   if (crate>=ncrates) {
      MSG("Exodus",Msg::kFatal) 
         << "RerootToRawDataModule::AddToCrate "
         << crate << " larger than allocated " << ncrates << endl;
      return;
   }

   TArrayI *wcrate = &workingcrates[crate];

   //  Crate block format is:
   //-------------------------
   //   0: Crate #
   //   1: # ndigits in crate (N)
   //   2: GPS T0 sec
   //   3: GPS T0 nsec
   //   4: readout 1 word 1
   //   5: readout 1 word 2
   //   6: PlexStripEndId.fEncoded truth
   //   7: readout 2 word 1
   //   8: readout 2 word 2
   //   9: PlexStripEndId.fEncoded truth

   const Int_t hsize        = 4; // header size
   const Int_t ndigits_indx = 1; // index for pair count
   const Int_t nw_digit     = 3; // 3 words per digit

   // if allocated size is too small make it bigger
   Int_t used = cratesizeused->At(crate);
   Int_t need = used + nw_digit;  // each new entry adds three words
   if (0 == used) need += hsize;

   const Int_t slop = 100; // min extra allocation

   if (wcrate->GetSize() < need) {
      wcrate->Set(need+slop);
   }

   // add in header stuff if necessary
   if (0 == used) {
      // crate # + ped/common modes + electronics flag
      const Int_t modes = 0x07;
      Int_t etype = rcid.GetElecType();
      Int_t packedCrate = (modes << 8) |
         (etype << 6) | (crate & 0x0000003f);
      wcrate->AddAt(packedCrate,used++);
      // # digits
      if (used != ndigits_indx) {
         // this should never happen
         MSG("Exodus",Msg::kFatal) 
            << "RerootToRawDataModule::AddToCrate ndigits_indx "
            << ndigits_indx << " != " << used << endl;
      }
      wcrate->AddAt(0,used++);
      // GPS T0 (sec,nsec)
      VldTimeStamp vts = RerootExodus::BuildVldContext().GetTimeStamp();
      wcrate->AddAt(vts.GetSec(),used++);
      // NT 08/03 The crate T0 measures the time time of the start of the timeframe,
      // NOT the time of the event.
      //wcrate->AddAt(vts.GetNanoSec(),used++);
      wcrate->AddAt(0,used++);

      // if flag is set dump what we just did
      if (fDebugFlags & dbg_DumpNewCrate) {
         printf("new header for crate %3d %#8.8x\n",crate,packedCrate);
      }
   }

   //       3         2         1         0
   //      10987654321098765432109876543210
   //  U:  1PXcccccccccccchhaaaaaaaaaaaaaa   X=common mode,c=chan, h=hdr a=adc
   //  L:  0Pttttttttttttttttttttttttttttt   P=parity, t=tdc
   //  X:  PlexStripEndId::fEncoded

   const int signbit    = 0x80000000;
//rwh:not_used_yet   const int hdrmask    = 0x0000c000;
//rwh:not_used_yet   const int parityb    = 0x40000000;
//rwh:not_used_yet   const int cmodeb     = 0x20000000;
   const int chaddmask  = 0x1fff;
   const int chaddshift = 16;
   const int adcmask    = 0x00003fff;
   const int tdcmask    = 0x3fffffff;

   // ADC = FLSDigit.RawA|B *  60  :  max RawX = (2^17-1)/60  = 2184.5pe
   // TDC = FLSDigit.TdcA|B *  10  :  max TdcX = (2^28-1)/10  = 26.8msec

   // create the three words we'll be putting in
//rwh:not_used_yet   Int_t err     = 0;
   Int_t chadd   = rcid.GetChAdd();
   if (chadd > chaddmask) {
      // this should never happen
      static int nmsg_chadd = 5;
      if (nmsg_chadd) {
         MSG("Exodus",Msg::kFatal) 
            << "RerootToRawDataModule::AddToCrate chadd "
            << hex << chadd << dec << " truncated from " 
            << hex << rcid.GetChAdd() << dec << endl;
         nmsg_chadd--;
         if (nmsg_chadd==0) 
            MSG("Exodus",Msg::kFatal) 
               << " ... last of these messages" << endl;
      }
   }
   chadd &= chaddmask;

   Int_t iadc     = TMath::Nint( raw * 60.0 );
   if(rcid.GetElecType()==ElecType::kQIE) iadc+=50; // Add 50 count pedestal to ND data.
   if (iadc > adcmask ) {
      // this should never happen
      static int nmsg_adc = 5;
      if (nmsg_adc) {
         MSG("Exodus",Msg::kWarning) 
            << "RerootToRawDataModule::AddToCrate iadc "
            << iadc << " does not fit in field  (max " 
            << adcmask << ")" << endl;
         nmsg_adc--;
         if (nmsg_adc==0)
            MSG("Exodus",Msg::kWarning) 
               << " ... last of these messages" << endl;
      }     
      iadc = TMath::Max(0,TMath::Min(iadc,adcmask));
   }
   iadc &= adcmask;

// Convert from 0.1*Munits:ns to standard Munits base time units (sec).
   Float_t tdc_convert = 0.1; // REROOT, non-VA, non-QIE scale factor
   switch (rcid.GetElecType()) {
   case (ElecType::kVA):  
     // VA electronics, tick = 1.5625 ns (640MHz)
     tdc_convert = 1.5625;
     break;
   case (ElecType::kQIE):
     // QIE electronics, tick = 18.832 ns (RF clock)
     tdc_convert =  1000./53.1;  // clock is 53.1MHz
     // CalDet has yet a different clock frequency
     if (rcid.GetDetector() == Detector::kCalDet)
       tdc_convert = 1.5625*16.0*58.0/77.0;
     break;
   default: // handle non-VA, non-QIE by original initialization
      break;
   }
   Int_t itdc     = TMath::Nint( tdc / tdc_convert );

   if (itdc > tdcmask ) {
      // this should never happen
      static int nmsg_tdc = 5;
      if (nmsg_tdc) {
         MSG("Exodus",Msg::kWarning) 
            << "RerootToRawDataModule::AddToCrate itdc "
            << itdc << " does not fit in field (max " 
            << tdcmask << ")" << endl;
         nmsg_tdc--;
         if (nmsg_tdc==0)
            MSG("Exodus",Msg::kWarning) 
               << " ... last of these messages" << endl;
      }     
      itdc = TMath::Max(0,TMath::Min(itdc,tdcmask));
   }
   itdc &= tdcmask;

   // if flag is set dump what we're about to do
   if (fDebugFlags & dbg_DumpAddToCrate) {
      MSG("Exodus",Msg::kInfo) 
         << "AddToCrate " << rcid.AsString() 
         << " seid " << seid.AsString("c") 
         << " raw " << raw << " time " << tdc 
         << endl
         << hex << setfill('0')
         << " stored as adc 0x" << setw(8) << iadc
         << " tdc 0x" << setw(8) << itdc
         << setfill(' ') << dec
         << endl;
   }


   // missing parity bits and "hrd"
   Int_t upper = signbit | (chadd<<chaddshift) | iadc;
   Int_t lower = itdc;
   Int_t extra = seid.GetEncoded();
      
   // push the words in
   wcrate->AddAt(upper,used++);
   wcrate->AddAt(lower,used++);
   wcrate->AddAt(extra,used++);

   // update pair count
   Int_t npairs = (used-hsize)/nw_digit;
   wcrate->AddAt(npairs,ndigits_indx);

   // update used size
   cratesizeused->AddAt(used,crate);

}

//......................................................................

RawDataBlock* RerootToRawDataModule::FinalizeWorkingArray(void)
{
   // Build final array from crate arrays

   //  Block format is:
   //---------------------
   //  # words in block
   //  checksum
   //  Block Id
   //  Crate #
   //  GPS T0 sec
   //  GPS T0 nsec
   //  Crate status
   //  # pairs in crate (N)
   //  readout 1 word 1
   //  readout 1 word 2
   //   < truth PlexStripEndId if Reroot data>
   //  readout 2 word 1
   //  readout 2 word 2
   //  ...
   //  readout N word 1
   //  readout N word 2
   //  Crate #
   //  GPS T0 sec
   //  GPS T0 nsec
   //  Crate status
   //  # pairs in crate (N)
   //  readout 1 word 1

   Int_t need = 3;  // #words, checksum, blockid
   for (Int_t crate=0; crate < ncrates; crate++) {
      need += cratesizeused->At(crate);
   }

   // float to highwater mark without copying contents
   if (workingarray->GetSize() < need) {
      workingarray->Set(0);    // deletes old array
      workingarray->Set(need); // set to necessary size
   }

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

   Bool_t isDCS   = rbp->IsDCS();
   Int_t  majorId = rbp->GetMajorId();

   RawBlockProxy*    rbp2 = rbr.LookUp(isDCS,majorId);
   if ( rbp2 != rbp ) cout << "RawBlockProxy cross check failed" << endl;

   Int_t  minorId = 0;
   RawBlockId rbid(majorId,minorId,isDCS,detector,SimFlag::kReroot);
   MSG("Exodus", Msg::kDebug)
      << " to be stored with RawBlockId " 
      << " 0x" << hex << rbid.GetEncoded() << dec
      << " == " << rbid.AsString() << endl
      << " majorId " << majorId << " minorId " << minorId
      << ((isDCS) ? " DCS " : " DAQ ")
      << " " << Detector::AsString(detector) << endl;

   Int_t checksum = 0xdeadbeef;

   Int_t& indx = nwordsblock;  // set "next" index to # words in block
   indx = 0;
   workingarray->AddAt(need,indx++);
   workingarray->AddAt(checksum,indx++);
   workingarray->AddAt(rbid.GetEncoded(),indx++);
   for (Int_t crate=0; crate<ncrates; crate++) {
      Int_t csize = cratesizeused->At(crate);
      TArrayI *wcrate = &workingcrates[crate];
      Int_t   *array  = wcrate->GetArray();  // gawd, it's guts are public
      for (Int_t i=0; i<csize; i++) {
         workingarray->AddAt(array[i],indx++);
      }
   }     
   
   // fill in the true checksum
   int xsum_version = 0;
   rdxsum_fill((long*)workingarray->GetArray(),xsum_version);
   
   // use the proxy to actually create a block
   return rbp->CreateRawDataBlock(workingarray->GetArray());

}

//......................................................................

void RerootToRawDataModule::HandleCommand(JobCommand *command) 
{
//
// Process configuration commands
//
  TString cmd = command->PopCmd();
  if (cmd == "Set") {
     TString opt = command->PopOpt();
     if      (opt == "fRawPeCut")   fRawPeCut   = command->PopFloatOpt();
     else if (opt ==  "RawPeCut")   fRawPeCut   = command->PopFloatOpt();
     else if (opt == "fDebugFlags") fDebugFlags = command->PopIntOpt();
     else if (opt == "Trigger") {
       Nplaneshit = command->PopIntOpt();
       ofMplanes  = command->PopIntOpt();
       MSG("Exodus", Msg::kInfo)
           << "RerootToRawDataModule: Trigger is " 
           << Nplaneshit << " of " << ofMplanes << endl;
     }
     else {
        MSG("Exodus", Msg::kWarning)
           << "RerootToRawDataModule: Unrecognized option " << opt << endl;
     }
  } else {
     MSG("Exodus", Msg::kWarning)
        << "RerootToRawDataModule: Unrecognized command " << cmd << endl;
  }
}

//......................................................................

---