DetSim.cxx

Go to the documentation of this file.

// $Id: DetSim.cxx,v 1.6 2007/11/10 16:22:40 schubert Exp $
//
// A JobControl Module for filling RawData from REROOT
//
// rhatcher@fnal.gov

#include "DetSim/DetSim.h"
#include "DetSim/SimDetector.h"
#include "Digitization/DigiList.h"
#include "Digitization/DigiPE.h"
#include "Digitization/DigiSignal.h"

#include "MinosObjectMap/MomNavigator.h"

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

#include "Plex/PlexHandle.h"

#include "Conventions/Munits.h"

#include "Calibrator/Calibrator.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/RawDigiDigitMixIn.h"
#include "RawData/RawQieDigit.h"
#include "RawData/RawVaDigit.h"

#include "Record/SimSnarlRecord.h"
#include "Record/SimSnarlHeader.h"
#include <TMath.h>
#include <TObjArray.h>
#include <TRandom3.h>

ClassImp(DetSim)

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

CVSID("$Id: DetSim.cxx,v 1.6 2007/11/10 16:22:40 schubert Exp $");
JOBMODULE(DetSim, "DetSim",
         "Builds RawRecord with DigiPEs");

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

DetSim::DetSim() 
   : fDetector(0),
     fRandomSeed(0),
     fRandom(0), 
     fRunStartSecs(-1),
     ncrates(0), workingcrates(0), cratesizeused(0), workingarray(0),
     fRemoveFalseDigits(1),
     fBiggestSnarlOnly(1),
     fContextSimFlag(SimFlag::kMC)
{
   // construct a new "DetSim" JobControl module

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

   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);

   fDetectorConfiguration.UnLockValues();
   fDetectorConfiguration = SimDetector::DefaultConfig();

   fResultTree = 0;
   fResultTreeFile = 0;
}

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

DetSim::~DetSim() 
{
  MSG("DetSim", Msg::kVerbose) << "DetSim::Destructor\n";
  
  if(fDetector) delete fDetector;
  if (fRandom) delete fRandom;
  fRandom = 0;

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

     delete cratesizeused;
     cratesizeused = 0;

     ncrates = 0;
  }

  if (workingarray) delete workingarray;
  workingarray = 0;

  if(fResultTree) {
    MSG("DetSim",Msg::kInfo) << "Closing DetSim Ana file." << endl;
    fResultTreeFile->cd();
    fResultTree->Write();
    fResultTreeFile->Write();
    fResultTreeFile->Close();
    delete fResultTreeFile;
    fResultTreeFile = 0;
  }
}

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

JobCResult DetSim::Get(MomNavigator *mom)
{
  // Simulate the PMTs and electronics and make a RawRecord.

  // Get the SimSnarl
  SimSnarlRecord* simsnarl = 0;
  TObject* tobj;
  TIter    fragiter = mom->FragmentIter();
  while( ( tobj = fragiter.Next() ) ) {
    simsnarl = dynamic_cast<SimSnarlRecord*>(tobj);
    if(simsnarl) break;
  }

  if(simsnarl ==0){
    MSG("DetSim",Msg::kError) << "Cannot find SimSnarl! Aborting this event!" << endl;
    return JobCResult::kWarning;
  }

   const TObjArray* peListObj = 0;
  peListObj = 
    dynamic_cast<const TObjArray*>(simsnarl->FindTemporary(0,"DigiListPe"));

  if(peListObj == 0) {
    // Not there? See if it's listed as a permanent object.
    MSG("DetSim",Msg::kInfo) << "DigiPE list is not marked as temporary. Try Permanent." << endl;
    peListObj = 
      dynamic_cast<const TObjArray*>(simsnarl->FindComponent(0,"DigiListPe"));
  }

  if(peListObj == 0) {
    MSG("DetSim",Msg::kError) << "Cannot find DigiPE list in the SimSnarl. Aborting." << endl;
    return JobCResult::kWarning;
  }


  const SimSnarlHeader* simHeader = simsnarl->GetSimSnarlHeader();
  if(simHeader ==0){
    MSG("DetSim",Msg::kError) << "Cannot find SimSnarlHeader. Aborting." << endl;
    return JobCResult::kWarning;
  }

  // For a PlexHandle we need a context
  fContext = simHeader->GetVldContext();

  // But we don't like this context.  We want it as an MC context,
  // not Reroot.
  fContext = VldContext(simHeader->GetVldContext().GetDetector(),
                        fContextSimFlag,
                        simHeader->GetVldContext().GetTimeStamp()
                        );

  // Reset the Calibrator.
  Calibrator::Instance().Reset(fContext);

  // Get a PlexHandle for PlexStripEndId to RawChannelId conversions
  PlexHandle ph(fContext);
  
  // Detector configuration. Make a new SimDetector,
  // or configure and reset the old one.
  if(fDetector==0){
    fDetector = new SimDetector(fContext,fRandom);
    fDetector->Config(fDetectorConfiguration);
  }
  fDetector->Reset(fContext);

  // Add all the PEs into the simulation.
  fDetector->AddDigiPEList(peListObj);

  // Set the random seed to match the event.
  // Also add some user-configurable randomness, in case they want to
  // generate the same event with a different outcome.
  fDetector->GetRandom()->SetSeed( simHeader->GetRun() 
                                   + simHeader->GetSnarl() 
                                   + fRandomSeed );

  // The money shot:
  fDetector->Simulate();
  
  // Debugging only:
  //if(MsgService::Instance()->GetStream("DetSim")->IsActive(Msg::kDebug))
  //  fDetector->Print();

  // An array to hold DigiSignals.
  TObjArray* signalArray = new TObjArray(fDetector->GetNumberOfDigits());
  signalArray->SetOwner(true);
  signalArray->SetName("DigiSignal");

  // Copy out all digiSignals.
  for(int i=0;i<fDetector->GetNumberOfDigits();i++) {
    // Get each digitization, whether it made it through a trigger or not.
    const SimDigit* digit = fDetector->GetSimDigit(i);
    if(digit) {
      // This makes a copy of the signal.
      if(digit->GetSignal()) 
        signalArray->AddLast(new DigiSignal(*(digit->GetSignal())));
    }
  }
  // Add the truth data to the simsnarl
  simsnarl->AdoptComponent(signalArray);

  // Make a new RawDigitDataBlock for each SimSnarl

  Int_t snarls_written = 0;

  for(UInt_t iSnarl=0; iSnarl<fDetector->GetNumberOfSnarls(); iSnarl++) { // each snarl

    // Check to see if this is the biggest one. 
    // This removes 'crap' events from the stream. This is a stopgap measure.
    if(fBiggestSnarlOnly) {
      if(iSnarl != fDetector->GetBiggestSnarl()) {
        MSG("DetSim",Msg::kInfo) << "Throwing out a snarl with "
                                 << fDetector->GetSnarl(iSnarl).Size() 
                                 << " digits." << endl;
        continue;
      }
    }

    const SimSnarl& snarl = fDetector->GetSnarl(iSnarl);


    // Prepare to start by getting current REROOT pointers
    // and clearing out the working array
    InitWorkingArray();
    
    
    // Reset context with a slightly different timestamp.
    // This should make no DB change, but correctly gets
    // the trigger time, making this consistent with later
    // analyses.
    
    // rwh: we would actually like to use the ns part of the
    // initial time stamp to offset within the 1 sec time
    // but currently the snarl creation doesn't use this
    // and introducing it here would just confuse things.
    VldTimeStamp trigTime(fContext.GetTimeStamp().GetSec(),
                          (int)(snarl.GetTriggerTime()/Munits::ns));
    VldContext trigContext(fContext.GetDetector(),
                           fContext.GetSimFlag(),
                           trigTime);
    
    Int_t outSnarlHits = 0;
    
    for(UInt_t i=0;i<(snarl.Size());i++) {
      // Get each hit...
      const SimDigit* digit = snarl.GetDigit(i);
      
      // And tack 'em on.
      if(digit) {
        // This test looks for bits that are bad in some way,
        // e.g. failed the 2/36 varc trigger. Some studies
        // may find it useful to keep them. If so, they are flagged
        // with error bits.
        if( (digit->GetErrors()==0) || (fRemoveFalseDigits==0) ) {
          outSnarlHits++;
          AddToCrate( trigContext,
                      digit->GetRawChannelId(),
                      digit->GetADC(),
                      digit->GetTDC(),
                      digit->GetErrors(),
                      digit->GetSignal()->GetId()
                      );
        }
      }
    }
    
    MSG("DetSim",Msg::kDebug) << "Snarl " << iSnarl << " added with " << outSnarlHits << " hits\n";
    
    
    
    // Add the raw data to to the raw record.
    
    // Finalize the working array, produce RawDigitDataBlock
    RawDataBlock *rawblk = FinalizeWorkingArray(trigContext);
    RawDigitDataBlock *rrdb = dynamic_cast<RawDigitDataBlock*>(rawblk);
    
    // produce a RawDaqSnarlHeader (specialized RawHeader)
    // which the RawRecord will adopt
    
    if(fRunStartSecs<0) fRunStartSecs = fContext.GetTimeStamp().GetSec();
    
    Int_t   run      = simHeader->GetRun();
    Short_t subrun   = simHeader->GetSubRun();
    Short_t runtype  = simHeader->GetRunType();
    Int_t   timeframe= simHeader->GetTimeFrame(); // fContext.GetTimeStamp().GetSec() - fRunStartSecs;
    // by using Snarl # stored in SimSnarlHeader we avoid getting out of
    // synch.  drawback is potential for duplicates when triggering
    // splits a SimSnarl's data into two separate triggers
    Int_t   snarlNo  = simHeader->GetSnarl();
    Int_t   trigbits = snarl.GetTriggerSource();
    Int_t   errcode  = simHeader->GetErrorCode();
    Int_t   nrawdigits = (rrdb) ? rrdb->GetNumberOfDigits() : -1;
    Int_t   spilltype  = -1;
    
    RawDaqSnarlHeader *head = 
      new RawDaqSnarlHeader(trigContext,run,subrun,runtype,timeframe,
                            snarlNo,trigbits,errcode,nrawdigits,spilltype);
    
    // produce a RawRecord, have it adopt the header  
    RawRecord *rawrec = new RawRecord(head);

    RecJobHistory& jobhist 
                  = const_cast<RecJobHistory&>(rawrec->GetJobHistory());
    jobhist.Append(simsnarl->GetJobHistory());
    jobhist.CreateJobRecord(RecJobHistory::kRaw);
    
    // 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");
    
    
    // massage the simsnarl so it has the same time.
    SimSnarlHeader* varSimHeader = const_cast<SimSnarlHeader*>(simHeader);
    varSimHeader->SetVldContext(trigContext);
    
    // give the RawRecord to MOM to hold as a "fragment"
    mom->AdoptFragment(rawrec);
    
      snarls_written += 1;
  }

  SimEventResult& eventResult = fDetector->GetEventResult();
  eventResult.run = simHeader->GetRun();
  eventResult.event = simHeader->GetSnarl();

  // Add a copy of the event result to the simsnarl for later bookkeeping.
  simsnarl->AdoptComponent(new SimEventResult(eventResult));

  // Return true if a snarl comes out.
  if(snarls_written==0) return JobCResult::kFailed;
  
  // Return trigger result.
  return JobCResult::kPassed;
}


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

JobCResult DetSim::Ana(const MomNavigator *mom)
{
  // A test job for "reconstruction"


  SimSnarlRecord* simsnarl = 0;
  TObject* tobj;
  TIter    fragiter = mom->FragmentIter();

  // Get the simsnarl.
  while( ( tobj = fragiter.Next() ) ) {
    simsnarl = dynamic_cast<SimSnarlRecord*>(tobj);
    if(simsnarl) break;
  }
  const TObjArray* peListObj = 0;
  peListObj = 
    dynamic_cast<const TObjArray*>(simsnarl->FindTemporary(0,"DigiListPe"));

  if(peListObj == 0) {
    // Not there? See if it's listed as a permanent object.
    MSG("DetSim",Msg::kInfo) << "DigiPE list is not marked as temporary. Try Permanent." << endl;
    peListObj = 
      dynamic_cast<const TObjArray*>(simsnarl->FindComponent(0,"DigiListPe"));
  }

  if(peListObj == 0) {
    MSG("DetSim",Msg::kError) << "Cannot find DigiPE list in the SimSnarl. Aborting." << endl;
    return JobCResult::kWarning;
  }

  const DigiPE* digipe = NULL;
  Double_t earliest = 1e10;

  TObjArrayIter itr(peListObj);
  while( (digipe = dynamic_cast<DigiPE*>(itr.Next()))!=0 ) {
    if(digipe->GetTime() < earliest) earliest = digipe->GetTime();
    fDetector->GetEventResult().npe++;
  };

  // Fill a tree with some summary data.
  static SimEventResult* result_ptr;
  result_ptr = &(fDetector->GetEventResult());
  if( fResultTreeFile==0 ) {
    fResultTreeFile = new TFile("detsim_stats.root","RECREATE");
    fResultTree = new TTree("detsim","detsim");
    
    fResultTree->Branch("result","SimEventResult",&result_ptr,32000,1);
    fResultTree->Write("detsim");
    fResultTree->Print();
  }
  fResultTree->Fill();
  
                                                     
  // The following is example code for 
  // how to look at truth info.
  /*
    

  // Make a table of the DigiSignals if they exist.
  std::map<UInt_t,const DigiSignal*> signalMap;

  const TObjArray* signalArray = 
    dynamic_cast<const TObjArray*>(simsnarl->FindComponent(0,"DigiSignal"));
  if(signalArray) {
    TIter signalIter(signalArray);
    while( (tobj = signalIter.Next()) ) {
      const DigiSignal* signal = dynamic_cast<DigiSignal*>(tobj);
      if(signal) signalMap[signal->GetId()] = signal;
    }
  }  
  MSG("DetSim",Msg::kDebug) << "Got " << signalMap.size() << " signals." << endl;
  
  // Get the RawDigitDataBlock.
  const RawHeader* rawhead =0;
  const RawDigitDataBlock* rddb =0;

  fragiter.Reset();
  while( ( tobj = fragiter.Next() ) ) {
    RawRecord* rawRec = dynamic_cast<RawRecord*>(tobj);
    if(rawRec) {
      rawhead = rawRec->GetRawHeader();
      TIter itr = rawRec->GetRawBlockIter();
      RawDataBlock* rawBlk;
      while ( ( rawBlk = dynamic_cast<RawDataBlock*>(itr.Next()) ) ) {
        rddb = dynamic_cast<RawDigitDataBlock*>(rawBlk);
        if(rddb) break;
      }
    }
  }

  if(rddb) {
    TIter rditer = rddb->GetDatumIter();
    while( ( tobj = rditer.Next() ) ) {
      RawDigit*        rawDigit = dynamic_cast<RawDigit *>(tobj);
      RawDigiDigitMixIn* rawMCDigit = dynamic_cast<RawDigiDigitMixIn*>(tobj);
      
      if(rawDigit) 
        MSG("DetSim",Msg::kDebug) << "Digit: " << *rawDigit << endl;
      if(rawMCDigit) {
        UInt_t id = (UInt_t) rawMCDigit->GetDigiSignalIndex();
        if(signalMap.find(id)!=signalMap.end())
          MSG("DetSim",Msg::kDebug) << "  Signal: " 
               << "(Id: " << id << " ) "
               << "("       << signalMap[id]->GetCharge()/Munits::fC << " fC)\t"
               << "(truth=" << signalMap[id]->GetTruth() << ")\t"
               << "("       << signalMap[id]->GetNumberOfHits() << " hits)\t"
               << "("       << signalMap[id]->GetNumPes() << " PE)"
               << endl;
      }
    }
  }
  */

  return JobCResult::kAOK;
}

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

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

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


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

void DetSim::AddToCrate( VldContext& context,
                                         const RawChannelId&   rcid,
                                         Int_t adc, Int_t tdc,
                                         Bool_t error, 
                                         Int_t truth_info)
{
   // Add this entry into the crate array

   Int_t crate = rcid.GetCrate();
   if (crate>=ncrates) {
      MSG("DetSim",Msg::kFatal) 
         << "DetSim::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("DetSim",Msg::kFatal) 
            << "DetSim::AddToCrate ndigits_indx "
            << ndigits_indx << " != " << used << endl;
      }
      wcrate->AddAt(0,used++);
      // GPS T0 (sec,nsec)
      VldTimeStamp vts = context.GetTimeStamp();
      wcrate->AddAt(vts.GetSec(),used++);
      // The fine time stamp corresponds to the start of the timeframe, not the event.
      wcrate->AddAt(0,used++); 
      // Used to be: wcrate->AddAt(vts.GetNanoSec(),used++);
   }

   // Pack in data words.
   switch( rcid.GetElecType() ) {
   case ElecType::kVA:
     PackVaDigit(used, *wcrate, rcid, adc, tdc, error, truth_info);
     break;
   case ElecType::kQIE:
     PackQieDigit(used, *wcrate, rcid, adc, tdc, error, truth_info);
     break;
   default:
     // This shouldn't happen.
     MSG("DetSim",Msg::kError) << "DetSim: Unknown electronics type! Cannot pack digit!" << endl;
   }

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

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


void 
DetSim::PackVaDigit(Int_t& cptr, 
                                    TArrayI& wcrate,
                                    const RawChannelId&   rcid,
                                    Int_t adc, Int_t tdc,
                                    Bool_t error,
                                    Int_t truth_info
                                    )
{
   // From RawVaDigit:
   //       3         2         1         0
   //      10987654321098765432109876543210
   //  U:  1PWccccccccccccNsaaaaaaaaaaaaaa   X=common mode,c=chan, s=sign a=adc
   //  L:  0Pttttttttttttttttttttttttttttt   P=parity, t=tdc
   //  X:  PlexStripEndId::fEncoded
   // W = fifo or calinject warning condition (0=okay)
   // N = 1 for normal data taking (0=calinject or pedestal data)

  
  const int chaddmask  = 0x1fff;
  const int adcmask    = 0x00003fff;
  const int tdcmask    = 0x3fffffff;
  const int chaddshift = 16;
  const int adcsignbit  = 0x00004000;
  //const int adcsignext  = 0xffffc000;
  //const int adcsignshft = 14;
  const int wordbit    = 0x80000000;
  const int parityb    = 0x40000000;
  const int warnb      = 0x20000000;
  const int stddatab   = 0x00008000;

  // Pack channel address.
  Int_t chadd   = rcid.GetChAdd();
  if (chadd > chaddmask) {
    // this should never happen
    static int nmsg_chadd = 5;
    if (nmsg_chadd) {
         MSG("DetSim",Msg::kFatal) 
           << "DetSim::AddToCrate chadd "
           << hex << chadd << dec << " truncated from " 
           << hex << rcid.GetChAdd() << dec << endl;
         nmsg_chadd--;
         if (nmsg_chadd==0) 
           MSG("DetSim",Msg::kFatal) 
             << " ... last of these messages" << endl;
    }
  }
  chadd &= chaddmask;
  
  Int_t iadc = adc;
  // two's compliment.
  if(adc<0) iadc = (adcmask+1) - abs(adc);

  if (iadc > adcmask ) {
    // this shouldn't happen often.
    static int nmsg_adc = 5;
    if (nmsg_adc) {
      MSG("DetSim",Msg::kWarning) 
        << "DetSim::PackVaDigit() iadc "
        << iadc << " does not fit in field  (max " 
            << adcmask << ")" << endl;
      nmsg_adc--;
      if (nmsg_adc==0)
        MSG("DetSim",Msg::kWarning) 
          << " ... last of these messages" << endl;
    }     
      iadc = TMath::Max(0,TMath::Min(iadc,adcmask));
  }
  iadc &= adcmask;
  
  Int_t itdc = tdc;
  if (itdc < 0 ) { 
    // -ve times are a bugger.
    // Wrap the times around and hope that the reconstruction program can
    // fix it.
    itdc += 640000000; // Number of 16*40MHz ticks in a second.
  }
  else if (itdc > tdcmask ) {
    // this should never happen
    static int nmsg_tdc = 5;
    if (nmsg_tdc) {
      MSG("DetSim",Msg::kWarning) 
        << "DetSim::AddToCrate itdc "
        << itdc << " does not fit in field (max " 
        << tdcmask << ")" << endl;
      nmsg_tdc--;
      if (nmsg_tdc==0)
        MSG("DetSim",Msg::kWarning) 
          << " ... last of these messages" << endl;
    }     
    itdc = TMath::Max(0,TMath::Min(itdc,tdcmask));
  }
  itdc &= tdcmask;
  
  Int_t upper = stddatab | wordbit | (chadd<<chaddshift) | iadc;
  // Add sign bit.
  if(adc<0) upper |= adcsignbit;
  // Add error bit, if appropritate.
  if(error) upper |= warnb;
  
  Int_t lower = itdc;
  Int_t  extra = truth_info;

  // Compute parities.
  int sum1 = 0;
  int sum0 = 0;
  int v1 = upper; // upper word
  int v0 = lower; // lower word
  for (int j=0; j<32; j++) {
    sum1 += (v1&1);
    sum0 += (v0&1);
    v1 = v1 >> 1;
    v0 = v0 >> 1;
  }
  // If parities are odd, add a bit to make them even.
  
  if (sum1&1 !=0 ) upper |= parityb;
  if (sum0&1 !=0 ) lower |= parityb;

  // push the words in
  wcrate.AddAt(upper,cptr++);
  wcrate.AddAt(lower,cptr++);
  wcrate.AddAt(extra,cptr++);
}


void 
DetSim::PackQieDigit(Int_t& cptr, 
                                     TArrayI& wcrate,
                                     const RawChannelId&   rcid,
                                     Int_t adc, Int_t tdc,
                                     Bool_t error,
                                     Int_t truth_info
                                     )
{
   // From RawQieDigit:
   //       3         2         1         0
   //      10987654321098765432109876543210
   //  U:  eeecccccccccccccaaaaaaaaaaaaaaaa   e=err, c=chan, a=adc
   //  L:  dddxxttttttttttttttttttttttttttt   d=datatype x=unused, t=tdc
   //  X:  PlexStripEndId::fEncoded

  const int adcmask    = 0x0000ffff;
  const int tdcmask    = 0x07ffffff;     
  const int chaddmask  = 0x00001fff;
  const int errshift  = 29;
  const int errmask   = 0x00000007;
  const int chanshift = 16;
  const int dtshift   = 29;
  const int dtmask    = 0x00000007;

  Int_t chadd   = rcid.GetChAdd( );
   if (chadd > chaddmask) {
      // this should never happen
      static int nmsg_chadd = 5;
      if (nmsg_chadd) {
         MSG("DetSim",Msg::kFatal) 
            << "DetSim::PackQieDigit chadd "
            << hex << chadd << dec << " truncated from " 
            << hex << rcid.GetChAdd() << dec << endl;
         nmsg_chadd--;
         if (nmsg_chadd==0) 
            MSG("DetSim",Msg::kFatal) 
               << " ... last of these messages" << endl;
      }
   }
   chadd &= chaddmask;

   Int_t iadc = adc;
   if ( (iadc > adcmask) || (iadc<0) ) {
      // this shouldn't happen too often.
      static int nmsg_adc = 5;
      if (nmsg_adc) {
         MSG("DetSim",Msg::kWarning) 
            << "DetSim::PackQieDigit() iadc "
            << iadc << " does not fit in field  (max " 
            << adcmask << ")" << endl;
         nmsg_adc--;
         if (nmsg_adc==0)
            MSG("DetSim",Msg::kWarning) 
               << " ... last of these messages" << endl;
      }     
      iadc = TMath::Max(0,TMath::Min(iadc,adcmask));
   }
   iadc &= adcmask;

   Int_t itdc = tdc;
   if (itdc < 0) {
     // -ve times are a bugger. wrap them to the correct value and hope 
     // the reconstruction can sort it out.
     itdc += 53097844; // The number of QIE ticks in one second.
   }
   if (itdc > tdcmask ) {
      // this should never happen
      static int nmsg_tdc = 5;
      if (nmsg_tdc) {
         MSG("DetSim",Msg::kWarning) 
            << "DetSim::PackQieDigit itdc "
            << itdc << " does not fit in field (max " 
            << tdcmask << ")" << endl;
         nmsg_tdc--;
         if (nmsg_tdc==0)
            MSG("DetSim",Msg::kWarning) 
               << " ... last of these messages" << endl;
      }     
      itdc = TMath::Max(0,TMath::Min(itdc,tdcmask));
   }
   itdc &= tdcmask;
   
   // Pack it up.
   int ierr = 0;
   if(error) ierr =  (RawQieDigit::kParityError) & errmask;
   
   // We assume that all ND data is spill mode.
   // This is the current assumption in the QIE model.
   int dtype = (RawQieDigit::kSGate) & dtmask;
   
   Int_t upper = (ierr<<errshift) | (chadd<<chanshift) | iadc;
   Int_t lower = (dtype<<dtshift) | itdc; 
   Int_t  extra = truth_info;
   
   // push the words in
   wcrate.AddAt(upper,cptr++);
   wcrate.AddAt(lower,cptr++);
   wcrate.AddAt(extra,cptr++);
}



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

RawDataBlock* DetSim::FinalizeWorkingArray(VldContext& context)
{
   // 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 ) MSG("DetSim",Msg::kError) << "RawBlockProxy cross check failed" << endl;

   Int_t  minorId = 0;
   RawBlockId rbid(majorId,minorId,isDCS,context.GetDetector(),context.GetSimFlag());
   MSG("DetSim", Msg::kDebug)
      << " to be stored with RawBlockId " 
      << " 0x" << hex << rbid.GetEncoded() << dec
      << " == " << rbid.AsString() << endl
      << " majorId " << majorId << " minorId " << minorId
      << ((isDCS) ? " DCS " : " DAQ ")
      << " " << Detector::AsString(context.GetDetector()) << 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());

}

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


const Registry& DetSim::DefaultConfig() const
{
  static Registry r;

  // Set name of config
  std::string name = this->GetName();
  name += ".config.default";
  r.SetName(name.c_str());
  
  // Set values in configuration
  r.UnLockValues();
  
  r.Set("removeFalseDigits",1);
  r.Set("biggestSnarlOnly",1);
  r.Set("contextSimFlag",SimFlag::AsString(SimFlag::kMC));
  r.Set("randomSeed",fRandomSeed);

  const Registry& r_simdet = SimDetector::DefaultConfig();
  r.Merge(r_simdet);

  return r;
}

void  DetSim::Config(const Registry& r)
{
  fDetectorConfiguration.Merge(r);
  
  r.Get("removeFalseDigits",fRemoveFalseDigits);
  r.Get("biggestSnarlOnly",fBiggestSnarlOnly);
  r.Get("randomSeed",fRandomSeed);
  const char* tmps;
  if(r.Get("contextSimFlag",tmps)) { 
    SimFlag::SimFlag_t tsimflag = SimFlag::StringToEnum(tmps);
    if(tsimflag!=SimFlag::kUnknown) fContextSimFlag = tsimflag;
  }

  if(fDetector) fDetector->Config(fDetectorConfiguration);
}

void  DetSim::Report()
{
  if(fDetector) fDetector->Print();
  else JobCModule::Report();
}

---