RerootFlsDigitToDigiPE.cxx

Go to the documentation of this file.

// $Id: RerootFlsDigitToDigiPE.cxx,v 1.12 2006/12/11 03:08:30 rhatcher Exp $
//
// A JobControl Module for filling RawData from REROOT
//
// Nathaniel Tagg n.tagg1@physics.ox.ac.uk

#include "RerootExodus/RerootFlsDigitToDigiPE.h"
#include "RerootExodus/RerootExodus.h"

#include "MinosObjectMap/MomNavigator.h"
#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.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 "Digitization/DigiList.h"
#include "Digitization/DigiPE.h"
#include "Record/SimSnarlRecord.h"
#include "Record/SimSnarlHeader.h"

#include "TMath.h"

ClassImp(RerootFlsDigitToDigiPE)

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

CVSID("$Id: RerootFlsDigitToDigiPE.cxx,v 1.12 2006/12/11 03:08:30 rhatcher Exp $");
JOBMODULE(RerootFlsDigitToDigiPE, "RerootFlsDigitToDigiPE",
         "Builds RawRecord with RawDigitDataBlock");

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

RerootFlsDigitToDigiPE::RerootFlsDigitToDigiPE() 
{
}

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

RerootFlsDigitToDigiPE::~RerootFlsDigitToDigiPE() 
{
  MSG("DetSim", Msg::kVerbose) << "RerootFlsDigitToDigiPE::Destructor\n";
}

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

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

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

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

  // Make or find the SimSnarl
    
  SimSnarlRecord* simsnarl = 0;

  // See if a SimSnarl already exists. 
  TObject* tobj;
  TIter    fragiter = mom->FragmentIter();
  while( ( tobj = fragiter.Next() ) ) {
    simsnarl = dynamic_cast<SimSnarlRecord*>(tobj);
    if(simsnarl) break;
  }
  
  // If not, make one.
  if(simsnarl == 0) {  
    Int_t   run      = RerootExodus::GetRunNo();
    Short_t subrun   = RerootExodus::GetSubRunNum();
    Int_t   snarl    = RerootExodus::GetSnarlNum(); // tied to tree entry
    Int_t   trigbits = 0;
    Short_t runtype = 0;
    Int_t   errcode = 0;
    Int_t   timeframe = RerootExodus::GetTimeFrame(vldc);
    Int_t   spilltype = -1;

    VldTimeStamp mcGenTime(RerootExodus::GetLastEventHistoryTimeStamp());
    std::string  mcCodename(RerootExodus::GetGminosCodeName().Data());
    std::string  mcHostname(RerootExodus::GetGminosHostName().Data());
    SimSnarlHeader simheader(vldc,run,subrun,runtype,
                             errcode,snarl,trigbits,timeframe,spilltype,
                             mcGenTime,mcCodename,mcHostname);
    
    simsnarl = new SimSnarlRecord(simheader);

    simsnarl->GetTempTags().Set("stream","SimSnarl");  // no idea....
    
    // Give it to mom.
    mom -> AdoptFragment(simsnarl);
  }

  // Find the DigiScintHitList if it exists.
  const TObjArray* scintHitListObj = 
    dynamic_cast<const TObjArray*>(simsnarl->FindComponent(0,"DigiScintHits"));

  std::map<Int_t,const DigiScintHit*> scintMap;
  std::map<Int_t,const DigiScintHit*>::iterator scintMapItr;

  if(scintHitListObj == 0) {
    MSG("Reroot",Msg::kError) << "Cannot find DigiScintHit list in the SimSnarl. (Need to run RerootToTruth Module)" << endl;
  } else {  
    // Build a lookup table for the strip ends. Use it to associate hits and digits.
     TObjArrayIter itr(scintHitListObj);
     const DigiScintHit* scintHit = 0;
     while( (scintHit = dynamic_cast<DigiScintHit*>(itr.Next())) !=0 ){
       PlexStripEndId seid = scintHit->StripEndId();
       scintMap[seid.Build18BitPlnStripKey()] = scintHit;
     }      
  }
  MSG("Reroot",Msg::kDebug) << "ScintHit map has " << scintMap.size() << " entries\n";
  
  // 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;
  PlexPixelSpotId psid;
  Float_t raw;
  Int_t   isAB;
  const DigiScintHit* scintHit=0;
  Int_t totalDigits = 0;
  Int_t mappedDigits = 0;
  
  // 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

  JobCResult result = JobCResult::kPassed;
      
  // Make the list to store the entries in.
  DigiList<DigiPE> peList(0);

  while ( ( flsdigit = (REROOT_FLSDigit*) diter.Next() ) ) {
    // process A side
    raw  = flsdigit->RawA();
    isAB = 0;
    if ( raw > 0.0 && raw < ADAMO_RNULL ) {
      seid = RerootExodus::PECAB2SEId(flsdigit->IPln(),flsdigit->IExtr(),
                                      flsdigit->ICell(),isAB);
      psid = ph.GetPixelSpotId(seid);
      MSG("Reroot",Msg::kVerbose) << "FlsDigit: IPln()==" << flsdigit->IPln()
                                  << "  IExtr()=" << flsdigit->IExtr()
                                  << "  ICell()=" << flsdigit->ICell()
                                  << "  isAB=" << isAB
                                  << "  -> " << seid.AsString() << endl;

      // Strip ID:
      scintMapItr = scintMap.find(seid.Build18BitPlnStripKey());
      if(scintMapItr!=scintMap.end()){
        scintHit = scintMapItr->second;
        mappedDigits++;
      } else {
        scintHit = NULL;
      }

      AddPE(peList,seid,psid,flsdigit->SignalPEA(),flsdigit->TDCA(),scintHit);
      totalDigits++;
    }
    
    // process B side
    raw  = flsdigit->RawB();
    isAB = 1;
    if ( raw > 0.0 && raw < ADAMO_RNULL ) {
      seid = RerootExodus::PECAB2SEId(flsdigit->IPln(),flsdigit->IExtr(),
                                      flsdigit->ICell(),isAB);      
      psid = ph.GetPixelSpotId(seid);

      MSG("Reroot",Msg::kVerbose) << "FlsDigit: IPln()==" << flsdigit->IPln()
                                  << "  IExtr()=" << flsdigit->IExtr()
                                  << "  ICell()=" << flsdigit->ICell()
                                  << "  isAB=" << isAB
                                  << "  -> " << seid.AsString() << endl;

      // Strip ID:
      scintMapItr = scintMap.find(seid.Build18BitPlnStripKey());
      if(scintMapItr!=scintMap.end()){
        scintHit = scintMapItr->second;
        mappedDigits++;
      } else {
        scintHit = NULL;
      }

      AddPE(peList,seid,psid,flsdigit->SignalPEB(),flsdigit->TDCB(),scintHit);
      totalDigits++;
    }
  }

  MSG("Reroot",Msg::kDebug) << totalDigits << " FLSDigits converted to DigiPE. "
                           << mappedDigits << " of them mapped to DigiScintHits.\n";

  // Put list into SimSnarl.


  // Add the DigiPE list to the simsnarl.
  TObjArray* storageArray = peList.CreateObjArray("DigiListPe");
  simsnarl->AdoptTemporary(storageArray);

  return result;
}


void RerootFlsDigitToDigiPE::AddPE( DigiList<DigiPE>& list,
                                    PlexStripEndId&   seid,
                                    PlexPixelSpotId&  psid,
                                    Double_t          pe,
                                    Double_t          time,
                                    const DigiScintHit* scintHit)
{
  //
  // Make a set of PEs from a info given and add them to the list.
  //
  // TODO: Add some sort of realistic time structure to this.
  // As it is, I just add all hits at time t, instead of making
  // my own distribution.
  
  MsgFormat f51("%5.1f");
  MSG("Reroot",Msg::kVerbose) << "FlsDigit: "
                              << f51(pe) << "pe " << f51(time) << "s " 
                              << psid.AsString() << "  " << seid.AsString() << endl;

  

  if(! psid.IsValid() ) {
    // This is a perfectly valid condition: the strip
    // is not attached to an output pixel.
    MSG("Reroot",Msg::kVerbose) << "Ignoring invalid PlexPixelSpotId:" 
                                << psid.AsString() << "  "
                                << seid.AsString() << "  "
                                << f51(pe) << "pe " << endl;
    return;
  }

  int npe = TMath::Nint(pe);
  if(npe>0) {
    for(int ipe=0; ipe<npe; ipe++) {
      DigiPE d(time*1e-9, // convert from ns to Munits.
               psid,      // pixel spot id
               scintHit);     // no hit info
      list.push_back(d);
    }
  }
}
                                   


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


const Registry& RerootFlsDigitToDigiPE::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();
 
  return r;
}

void  RerootFlsDigitToDigiPE::Config(const Registry& )
{
}

---