MadBase.h

Go to the documentation of this file.

#ifndef madbase_h
#define madbase_h
#include <iostream>
#include <string>
#include "TROOT.h"
#include "TChain.h"
#include "TFile.h"
#include "CandNtupleSR/NtpSRRecord.h"
#include "CandNtupleSR/NtpSREvent.h"
#include "CandNtupleSR/NtpSRTrack.h"
#include "CandNtupleSR/NtpSRShower.h"
#include "CandNtupleSR/NtpSRCluster.h"
#include "CandNtupleSR/NtpSRSlice.h"
#include "CandNtupleSR/NtpSRShieldStrip.h"
#include "CandNtupleSR/NtpSRStrip.h"
#include "CandNtupleSR/NtpSRDmxStatus.h"
#include "CandNtupleSR/NtpSRDetStatus.h"
#include "StandardNtuple/NtpStRecord.h"
#include "MCNtuple/NtpMCRecord.h"
#include "MCNtuple/NtpMCSummary.h"
#include "MCNtuple/NtpMCTruth.h"
#include "MCNtuple/NtpMCStdHep.h"
#include "TruthHelperNtuple/NtpTHRecord.h"
#include "TruthHelperNtuple/NtpTHSlice.h"
#include "TruthHelperNtuple/NtpTHShower.h"
#include "TruthHelperNtuple/NtpTHTrack.h"
#include "TruthHelperNtuple/NtpTHEvent.h"
#include "CandNtupleSR/NtpSRShieldSummary.h"
#include "CandNtupleSR/NtpSREventSummary.h"
#include "Record/RecCandHeader.h"
#include "CandNtupleEM/NtpEMShower.h"
#include "CandNtupleEM/NtpEMRecord.h"
#include "CandNtupleEM/NtpEMSummary.h"
#include "JobControl/JobC.h"
#include "JobControl/JobCInput.h"
#include "JobControl/JobCPath.h"
#include "MinosObjectMap/MomNavigator.h"
#include "MadChain.h"

class MadBase 
{
  protected :

  MadChain *fChain;  //allows for either ntuple or candidate file
  JobC *fJC;          //access to data members
  string jcPath;     //path name
  int fCurRun;       //current run
  int lastEntry;     //last entry from tree/snarl form Cand file accessed

  int whichSource;  // 0==> chain, 1==> candidate file, -1==> problem

  NtpStRecord *strecord;
  NtpSRRecord *record;
  const RecCandHeader *ntpHeader;
  NtpSRShieldSummary *shieldSummary;
  NtpSREventSummary *eventSummary;
  NtpSRDmxStatus *dmxStatus;
  NtpSRDetStatus *detStatus;

  NtpSREvent *ntpEvent;
  NtpSRTrack *ntpTrack;
  NtpSRShower *ntpShower;
  NtpSRCluster *ntpCluster;
  NtpSRSlice *ntpSlice;
  NtpSRShieldStrip *ntpShieldStrip;
  NtpSRStrip *ntpStrip;
  
  NtpMCRecord *mcrecord;
  NtpMCSummary *mcHeader;
  NtpMCTruth *ntpTruth;
  NtpMCStdHep *ntpStdHep;

  NtpTHRecord *threcord;
  NtpTHSlice *ntpTHSlice;
  NtpTHEvent *ntpTHEvent;
  NtpTHTrack *ntpTHTrack;
  NtpTHShower *ntpTHShower;

  NtpEMRecord *emrecord;
  NtpEMSummary *ntpEMSummary;
  NtpEMShower *ntpEMShower;

  Bool_t isMC;
  Bool_t isTH;
  Bool_t isEM;
  Bool_t isST;
  Int_t Nentries; //number of entries for fChainSR

  //
  // Usage examples. Code not inheriting from MadBase should substitute 
  // Get<-->Load in function names and pickup the pointer the Get routines
  // give back rather than using the pointers here in MadBase. The Get 
  // routines call the Load routines when they operate.
  //
  //
  // To loop over all events in the record, you do:
  //
  // for(int i=0; i<eventSummary->nevent; i++){
  //    LoadEvent(i);
  //    ntpEvent->.....
  // }
  //
  //
  // To loop over all tracks in an event you do:
  //
  // LoadEvent(event);
  // for(int i=0; i<ntpEvent->ntrack; i++){
  //     int trkidx=ntpEvent->trk[i]; // get track index in track array
  //     LoadTrack(trkidx); // pull track from track array
  //     ntpTrack->.....
  // }
  //
  // To loop over all *MC* events you do:
  //
  // for(int i=0; i<mcHeader->nmc; i++){
  //     LoadTruth(i);
  //     ntpTruth->....;
  // }
  //
  // To loop over all particles in an mc event you do:
  //
  // LoadTruth(mcevent);
  // for(int i=ntpTruth->stdhep[0]; i<=ntpTruth->stdhep[1]; i++){
  //     LoadStdHep(i);
  //     ntpStdHep->....;
  // }
  //
  // To loop over all particles in the stdhep block most closely associated
  // with a given reconstructed event, you do:
  //
  // LoadTruthForRecoTH(event, mcevent);//point ntpTruth at best mc event
  // for(int i=ntpTruth->stdhep[0]; i<=ntpTruth->stdhep[1]; i++){
  //     LoadStdHep(i);
  //     ntpStdHep->.....;
  // }
  //



  //
  // these routines load the reconstructed object stored at index position 
  // in the arrays contained in this record(i.e. snarl, i.e. spill)
  //
  // !!NOTE!!: ONE IS ACCESSING ALL THE RECONSTRUCTED OBJECTS, 
  //           NOT JUST THOSE IN THE LOADED EVENT!!!! 
  //

  //load one track from the "trk" array
  Bool_t LoadTrack(Int_t idx); 
  //load one shower from the "shw" array
  Bool_t LoadShower(Int_t idx); 
  //load one cluster from the "clu" array
  Bool_t LoadCluster(Int_t idx);
  //load one event from the event array "evt"
  Bool_t LoadEvent(Int_t idx); // here idx==event
  //load one slice from the slice array "slc"
  Bool_t LoadSlice(Int_t idx); 
  //load one strip from the shield strip array "vetostp"
  Bool_t LoadShieldStrip(Int_t idx);
  //load one strip from the strip array "stp"
  Bool_t LoadStrip(Int_t idx); 
  //load one entry from the mc array "mc"
  Bool_t LoadTruth(Int_t idx);//here idx==mcevent 
  //load one entry from the stdhep array "stdhep"
  Bool_t LoadStdHep(Int_t idx); 
  // load one entry from the 
  Bool_t LoadTHTrack(Int_t); //load a thtrack
  Bool_t LoadTHEvent(Int_t); //load a thevent
  Bool_t LoadTHShower(Int_t); //load a thshower
  Bool_t LoadTHSlice(Int_t); //load a thslice

  Bool_t LoadEMShower(Int_t); //load an EM shower



  // load largest trk or shower associated with event
  // return the index postion or -1 if no track or shower was found
  Bool_t LoadLargestTrackFromEvent(Int_t event, Int_t& trkidx);
  Bool_t LoadShower_Jim(Int_t event, Int_t& shwidx, Int_t detector);
  Bool_t LoadLargestShowerFromEvent(Int_t event, Int_t& shwidx);
  //load the shower in this event that is nearest track vertex
  Bool_t LoadShowerAtTrackVertex(Int_t event, Int_t track, Int_t& shwidx);

  // load one mc entry (i.e. event) corresponding to specified reco event
  // mc<-->reco association is done by event vertices
  // !!NOTE:!! PREFER LoadTruthForRecoTH() OVER THIS ROUTINE
  Bool_t LoadTruthForReco(Int_t,Int_t&); 

  // load one mc entry (i.e. event) corresponding to specified reco event
  // mc<-->reco association is done by truth helper
  // !!NOTE!!: PREFER THIS ROUTINE OVER LoadTruthForReco()
  Bool_t LoadTruthForRecoTH(Int_t,Int_t&);
  Bool_t LoadSliceForRecoTH(Int_t,Int_t&); 
  Float_t RecoShwEnergy(Int_t ishw=0,Int_t opt=-1, Int_t det=1); //from SR



 
 public:
  MadBase(TChain *chainSR=0,TChain *chainMC=0,
          TChain *chainTH=0,TChain *chainEM=0);
  MadBase(JobC *,string,int);
  ~MadBase();
  Int_t  GetEntry(Int_t run,Int_t snarl);
  Int_t  GetEntry(Int_t entry);
  void   InitChain(TChain *chainSR,TChain *chainMC,
                   TChain *chainTH,TChain *chainEM, bool build_index=false);
  void   Clear();  


 public:
  // functions allowing external manipulation of this object
  // motivation:  algorithms can look like : MyAlg(MadBase*)
  //              and be called like:  myobj.MyAlg(this)
  //              from inside a MadBase derived class (e.g. in a MadAnalysis)
  //
  const NtpSREventSummary* GetEventSummary(){return eventSummary;}
  const RecCandHeader* GetHeader() {return ntpHeader;}
  const NtpSRTrack* GetTrack(Int_t); 
  const NtpSRTrack* GetLargestTrackFromEvent(Int_t,Int_t&);
  const NtpSRShower* GetShower(Int_t);
  const NtpSRCluster* GetCluster(Int_t);
  const NtpSRShower* GetLargestShowerFromEvent(Int_t,Int_t&);
  const NtpSRShower* GetShowerAtTrackVertex(Int_t,Int_t,Int_t&);
  const NtpSREvent* GetEvent(Int_t);
  const NtpSRSlice* GetSlice(Int_t);
  const NtpSRShieldStrip* GetShieldStrip(Int_t);
  const NtpSRStrip* GetStrip(Int_t);
  
  const NtpMCTruth* GetTruth(Int_t);
  const NtpMCStdHep* GetStdHep(Int_t);
  const NtpMCTruth* GetTruthForReco(Int_t,Int_t&);
  const NtpTHSlice* GetSliceForRecoTH(Int_t,Int_t&);
  const NtpMCTruth* GetTruthForRecoTH(Int_t,Int_t&);
  const NtpTHTrack* GetTHTrack(Int_t);
  const NtpTHEvent* GetTHEvent(Int_t);
  const NtpTHShower* GetTHShower(Int_t);
  const NtpTHSlice* GetTHSlice(Int_t);

  const NtpEMShower* GetEMShower(Int_t);
 

};

#endif // #ifdef madbase_h

---