DemoCandNtpModule.cxx

Go to the documentation of this file.

//
// DemoCandNtpModule.cc
//
// A JobControl Module for demonstrating ntuple construction.
//
#include <map>
#include <iostream>
#include <cassert>
using std::endl;

#include "TClonesArray.h"

#include "CandData/CandRecord.h"
#include "CandData/CandHeader.h"
#include "MessageService/MsgService.h"
#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"
#include "MinosObjectMap/MomNavigator.h"
#include "RawData/RawRecord.h"
#include "RawData/RawHeader.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RecoBase/CandSliceHandle.h"
#include "RecoBase/CandStripHandle.h"
#include "RecoBase/CandTrackHandle.h"
#include "CandTrackSR/CandTrackSRHandle.h"
#include "RecoBase/CandShowerHandle.h"
#include "RecoBase/CandEventHandle.h"
#include "RecoBase/CandSliceListHandle.h"
#include "RecoBase/CandStripListHandle.h"
#include "RecoBase/CandTrackListHandle.h"
#include "CandTrackSR/CandTrackSRListHandle.h"
#include "RecoBase/CandShowerListHandle.h"
#include "RecoBase/CandEventListHandle.h"
#include "NtupleBase/test/DemoCandNtpModule.h"
#include "NtupleBase/test/CandRecordSRNtuple.h"
#include "NtupleBase/test/CandTrackSRNtuple.h"
#include "NtupleBase/NtpCandEvent.h"
#include "NtupleBase/NtpCandTrack.h"
#include "NtupleBase/NtpCandShower.h"
#include "NtupleBase/NtpCandSlice.h"
#include "NtupleBase/NtpCandStrip.h"
#include "Record/RecCandHeader.h"

ClassImp(DemoCandNtpModule)

//   Definition of static data members
//   *********************************

CVSID("$Id: DemoCandNtpModule.cxx,v 1.4 2005/05/18 06:18:13 west Exp $");
JOBMODULE(DemoCandNtpModule, "DemoCandNtpModule",
         "A module for demonstrating ntuple construction.");


// Definition of methods (alphabetical order)
// ***************************************************

JobCResult DemoCandNtpModule::Reco(MomNavigator *mom) {
  //
  //  Purpose:  Create ntuple record if not present on input
  //            stream.
  //
  //  Arguments: none.
  //  
  //  Return: none.
  //
  //  Contact:   S. Kasahara
  // 


  JobCResult result(JobCResult::kPassed);  
  MSG("DemoNtuple",Msg::kVerbose) << "DemoCandNtpModule::Get" << endl;

  // Check that mom exists.
  assert(mom);
    
  // Check for existing NtpCand fragment in MOM.
  CandRecordSRNtuple *candNtp = dynamic_cast<CandRecordSRNtuple*>
     (mom->GetFragment("CandRecordSRNtuple","PrimaryCandidateRecord"));

  if ( candNtp ) return result;

  // Otherwise, create a new one 
  CandRecord *candRec = dynamic_cast<CandRecord*>
    (mom->GetFragment("CandRecord","PrimaryCandidateRecord"));
  if ( !candRec ) {
    MSG("DemoNtuple",Msg::kWarning) << "No PrimaryCandidateRecord in MOM"<<endl;
    result.SetWarning().SetFailed();
    return result;
  }

  // Need to convert from old CandHeader format to new.
  // This ugliness will go away if the CandRecord adopts the new header class.
  // Need rawrecord to properly construct new header
  RawRecord *rawRec = dynamic_cast<RawRecord*>
    (mom->GetFragment("RawRecord")); // should iterate but this is just a demo
  if ( !rawRec ) {
    MSG("DemoNtuple",Msg::kWarning) << "No RawRecord in MOM"<<endl;
    result.SetWarning().SetFailed();
    return result;
  }
  const CandHeader* cndHdr = candRec -> GetCandHeader();
  const RawDaqSnarlHeader* rawHdr = dynamic_cast<const RawDaqSnarlHeader*>
                              (rawRec -> GetHeader());
  rawHdr->GetVldContext().Print();
  RecCandHeader* newHdr = new RecCandHeader(rawHdr->GetVldContext(),
        cndHdr->GetRun(),rawHdr->GetSubRun(),rawHdr->GetRunType(),
        rawHdr->GetErrorCode(),cndHdr->GetSnarl(),rawHdr->GetTrigSrc(),
        rawHdr->GetTimeFrameNum(),rawHdr->GetRemoteSpillType(),cndHdr->GetEvent());

  // Create new record
  CandRecordSRNtuple* ntpRec = new CandRecordSRNtuple(*newHdr);

  ntpRec->SetName("PrimaryCandidateRecord"); //associate with parent CandRecord
  // And pass it to Mom, mom now has memory management responsibility
  mom->AdoptFragment(ntpRec);
  
  // An option will be provided to not write out strip data as in 
  // EventSRListModule
  std::map<Int_t,Int_t> stripmap; // uid, stripindex
  CandStripListHandle* strips = dynamic_cast<CandStripListHandle*>
    (candRec -> FindCandHandle("CandStripListHandle"));
  if ( !strips ) return result;  // but warn first
  TIter stItr(strips->GetDaughterIterator());
  Int_t nstrip=0;
  while ( CandStripHandle *strip = dynamic_cast<CandStripHandle*>(stItr()) ) {
    // For each new strip, an ntuple object is created and added to the TClones
    Int_t uid = strip->GetUidInt();
    stripmap.insert(std::make_pair(uid,nstrip));
    new((ntpRec->GetStrips())[nstrip++]) NtpCandStrip(*strip);
  }

  // Slices
  CandSliceListHandle* slices = dynamic_cast<CandSliceListHandle*>
    (candRec -> FindCandHandle("CandSliceListHandle"));
  if ( slices ) {
    TIter slitr(slices->GetDaughterIterator());
    Int_t nslice=0;
    while (CandSliceHandle *slice = dynamic_cast<CandSliceHandle*>(slitr())) {
      // For each new slice, an ntp object is created and added to the TClones
      NtpCandSlice* slicentp = 
          new((ntpRec->GetSlices())[nslice++]) NtpCandSlice(*slice);
      TIter stripitr(slice->GetDaughterIterator());
      Int_t nslicestrip=0;
      while (CandStripHandle* strip
                            = dynamic_cast<CandStripHandle*>(stripitr())) {
        Int_t uid = strip->GetUidInt();
        Int_t stripindex = stripmap[uid];
        slicentp->AddStripAt(stripindex,nslicestrip); // add index to strip
        nslicestrip++;
      } 
    }
  }

  CandTrackListHandle* tracks = dynamic_cast<CandTrackListHandle*>
    (candRec -> FindCandHandle("CandTrackListHandle"));
  Int_t ntrack=0;
  std::map<Int_t,Int_t> trackmap; // uid,index
  if ( tracks ) {
    TIter tritr(tracks->GetDaughterIterator());
    while (CandTrackSRHandle *track=dynamic_cast<CandTrackSRHandle*>(tritr()))
    {
      trackmap.insert(std::make_pair(track->GetUidInt(),ntrack));
      // For each new track, an ntp object is created and added to the TClones
      CandTrackSRNtuple* trackntp = 
           new((ntpRec->GetTracks())[ntrack++]) CandTrackSRNtuple(*track);
      TIter stripitr(track->GetDaughterIterator());
      Int_t ntrackstrip = 0;
      while (CandStripHandle* strip
             =dynamic_cast<CandStripHandle*>(stripitr())) {
        Int_t stripindex = stripmap[strip->GetUidInt()];
        trackntp->AddStripAt(stripindex,ntrackstrip); // add reference to strip
        ntrackstrip++;
      } 
    }
  }

  CandShowerListHandle* showers = dynamic_cast<CandShowerListHandle*>
    (candRec -> FindCandHandle("CandShowerListHandle"));
  Int_t nshower=0;
  std::map<Int_t,Int_t> showermap;
  if ( showers ) {
    TIter shitr(showers->GetDaughterIterator());
    while (CandShowerHandle *shower 
           = dynamic_cast<CandShowerHandle*>(shitr())) {
      showermap.insert(std::make_pair(shower->GetUidInt(),nshower));
      // For each new shower,an ntp object is created and added to the TClones
      NtpCandShower* showerntp = 
           new((ntpRec->GetShowers())[nshower++]) NtpCandShower(*shower);
      Int_t nshowerstrip=0;
      TIter stripitr(shower->GetDaughterIterator());
      while(CandStripHandle* strip=dynamic_cast<CandStripHandle*>(stripitr())){
        Int_t stripindex = stripmap[strip->GetUidInt()];
        showerntp->AddStripAt(stripindex,nshowerstrip); // add ref to strip
        nshowerstrip++;
      } 
    }
  }

  CandEventListHandle* events = dynamic_cast<CandEventListHandle*>
    (candRec -> FindCandHandle("CandEventListHandle"));
  if ( events ) {
    TIter evitr(events->GetDaughterIterator());
    Int_t nevent=0;
    while (CandEventHandle *event = dynamic_cast<CandEventHandle*>(evitr())) {
      // For each new strip, an ntp object is created and added to the TClones
      NtpCandEvent* eventntp = 
           new((ntpRec->GetEvents())[nevent++]) NtpCandEvent(*event);
      // An iterator over the tracks&showers is not provided, why?
      for ( Int_t i = 0; i <= event->GetLastTrack(); i++ ) {
        CandTrackHandle* track 
                       = const_cast<CandTrackHandle*>(event->GetTrack(i));
        Int_t trackindex = trackmap[track->GetUidInt()];
        eventntp->AddTrackAt(trackindex,i);
      }
      for ( Int_t i = 0; i <= event->GetLastShower(); i++ ) {
        CandShowerHandle* shower 
                      = const_cast<CandShowerHandle*>(event->GetShower(i));
        Int_t showerindex = showermap[shower->GetUidInt()];
        eventntp->AddShowerAt(showerindex,i);
      }
    }
  }

  return result;

}

void DemoCandNtpModule::BeginJob() {
  //
  //  Purpose:  Configure module at beginning of job.
  //
  //  Arguments: none.
  //  
  //  Return: none.
  //
  //  Contact:   S. Kasahara
  // 

  MSG("DemoNtuple", Msg::kVerbose) << "DemoCandNtpModule::BeginJob" << endl;

  // Configure module
 
}

void DemoCandNtpModule::Config(const Registry& r) {
  //
  //  Purpose:  Configure the module based on the contents of the registry.
  //
  //  Arguments: none.
  //  
  //  Return: none.
  //
  //  Contact:   S. Kasahara
  // 

  MSG("DemoNtuple",Msg::kDebug) << "Config DemoCandNtpModule with r=" << r << endl;

}

const Registry& DemoCandNtpModule::DefaultConfig() const {
  //
  //  Purpose:  Load default values into configuration registry.
  //
  //  Arguments: none.
  //  
  //  Return: registry of default configuration values.
  //
  //  Contact:   S. Kasahara
  // 

  static Registry r;
  r.SetName("DemoNtuple.config");

  r.UnLockValues();

  MSG("DemoNtuple",Msg::kDebug) << "Loading default config.\n" << endl;

  // r.Set("variable","argument");

  r.LockValues();
  return r;

}

DemoCandNtpModule::DemoCandNtpModule() { 
  //
  //  Purpose:  Default constructor.
  //
  //  Arguments: none.
  //
  //  Return:    n/a.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes: none.
  // 

  MSG("DemoNtuple", Msg::kVerbose) << "DemoCandNtpModule::Constructor" << endl;

}

DemoCandNtpModule::~DemoCandNtpModule() {
  //
  //  Purpose:  Destructor.  
  //
  //  Contact:   S. Kasahara
  // 

  MSG("DemoNtuple", Msg::kVerbose) << "DemoCandNtpModule::Destructor" << endl;

}

---