CDTrackerModule.cxx

Go to the documentation of this file.

// Program name: CDTrackerModule.cxx
//
// Package: CalDetTracker
//
// Purpose: 
//
// Contact: Chris Smith, Ryan Nichol, Leo Jenner or Jeff Hartnell

#include <fstream>

#include "TClonesArray.h"
#include "TFile.h"
#include "TTree.h"

#include "CalDetPID/CalDetBeamMomentum.h"
#include "CalDetPID/CalDetParticleType.h"
#include "Calibrator/Calibrator.h"
#include "CalDetPID/CandCalDetPIDHandle.h"
#include "CalDetSI/CandCalDetSIHandle.h"
#include "CandData/CandRecord.h"
#include "CandDigit/CandDigitListHandle.h"
#include "RecoBase/CandStripListHandle.h"
#include "DatabaseInterface/DbiResultPtr.h"
#include "DatabaseUpdater/DbuSubRunSummary.h"
#include "JobControl/JobCommand.h"
#include "JobControl/JobCModuleRegistry.h"
#include "MinosObjectMap/MomNavigator.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawDeadChipBlock.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawVaDigit.h"
#include "Validity/VldContext.h"
#include "Validity/VldTimeStamp.h"
#include "MessageService/MsgService.h"

#include "CalDetTracker/CDTrackerModule.h"
#include "CalDetTracker/CDMapMaker.h"
#include "CalDetTracker/CDCrossTalker.h"
#include "CalDetTracker/CDBeamMuTracker.h"
#include "CalDetTracker/CDCosmicTracker.h"
#include "CalDetTracker/CDTrackedHits.h"
#include "CalDetTracker/CDUnidentifiedHits.h"
#include "CalDetTracker/CDTrackInfo.h"
#include "CalDetTracker/CDTrackedHitInfo.h"
#include "CalDetTracker/CDXTalkHitInfo.h"
#include "CalDetTracker/CDPIDInfo.h"
#include "CalDetTracker/CDTruthifier.h"
#include "CalDetTracker/CDTrackedHitInfo.h"
#include "CalDetTracker/CDTrackInfo.h"
#include "CalDetTracker/CDTrackerOptions.h"
#include "CalDetTracker/CDPIDInfo.h"

using std::endl;
using std::cout;

CVSID("$Id: CDTrackerModule.cxx,v 1.25 2005/08/28 01:41:37 rhatcher Exp $");

JOBMODULE(CDTrackerModule,"CDTrackerModule",
          "Track Muons in CalDet");

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

CDTrackerModule::CDTrackerModule()
{
  ffirstrecord=true;

  fBeamMomentum=0;
  fNumDeadChips=-1;
  fTemperature=-1;
  fSimFlag=SimFlag::kUnknown;
  frun=0;
  fsubrun=0;
  fsnarl=0;
  fSec=-1;
  fStartSnarl=0;
  fEndSnarl=0;
  fStartTime=0;
  fEndTime=0;
  fsavefile=0;
  fJustWriteTracks=0;
  fOverwriteFile=0;
  fWritePID=0;
  sprintf(ftag,"SetFileIDToMakeThisShorter");
  fWriteTruth=0;

  //initialise pointers
  fTrkInfo=0;
  ftree=0;
  fPID=0;

  //"beam" tracked hits
  fTrkHits=new TClonesArray("CDTrackedHitInfo",1000);
  //cosmic counter hits
  fCCHits=new TClonesArray("CDTrackedHitInfo",1000); 
  //"cosmic" tracked hits
  fStTrkHits=new TClonesArray("CDTrackedHitInfo",1000);
  //xtalk hits 
  fXTalkHits=new TClonesArray("CDXTalkHitInfo",1000);
  //unidentified hits
  fUnTrkHits=new TClonesArray("CDTrackedHitInfo",1000);
  //the truth of the hits
  fTruthHits=new TClonesArray("CDTruthHitInfo",1000);

  //tracker options
  fTrkOpt=new CDTrackerOptions();
}

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

JobCResult CDTrackerModule::Ana(const MomNavigator *mom) 
{
  //set the default result to passed
  JobCResult result(JobCResult::kPassed);

  CandRecord* candrec=dynamic_cast<CandRecord*>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (candrec==0) {
    MSG("CDTrackerModule",Msg::kWarning) 
      <<"No PrimaryCandidateRecord in MOM." << endl;
    result.SetFailed();
    return result;
  }

  RawRecord *rr=dynamic_cast<RawRecord *>
    (mom->GetFragment("RawRecord"));
  if (rr==0) {
    MSG("CDTrackerModule",Msg::kWarning) 
      <<"No RawRecord in MOM." << endl;
    result.SetFailed();
    return result;
  }

  const RawDeadChipBlock* dcb=dynamic_cast<const RawDeadChipBlock*>
    (rr->FindRawBlock("RawDeadChipBlock"));
  if(dcb) {
    fNumDeadChips=dcb->GetNumberOfEntries();
    if (fNumDeadChips>0) {
      MAXMSG("CDTrackerModule",Msg::kDebug,100)
        <<"Found dead chips="<<fNumDeadChips<<endl;
    }
  }
  else {
    MAXMSG("CDTrackerModule",Msg::kWarning,10)
      <<"No RawDeadChipBlock present"<<endl;
  }

  const RawDaqSnarlHeader* snarlHdr =
    dynamic_cast<const RawDaqSnarlHeader*>(rr->GetRawHeader());
  if(snarlHdr){
    fsnarl=snarlHdr->GetSnarl();
    fSec=snarlHdr->GetVldContext().GetTimeStamp().GetSec();
    fEndSnarl=fsnarl;
    fEndTime=fSec;

    if(ffirstrecord) {
      fSimFlag=snarlHdr->GetVldContext().GetSimFlag();
      fStartTime=snarlHdr->GetVldContext().GetTimeStamp().GetSec();
      fStartSnarl=snarlHdr->GetSnarl();
      frun=snarlHdr->GetRun();
      fsubrun=snarlHdr->GetSubRun();//this isn't always right!

      /*
      DbiResultPtr<DbuSubRunSummary> dsrs(snarlHdr->GetVldContext(),
                                          Dbi::kDefaultTask,
                                          Dbi::kDisabled);
      MSG("CDTrackerModule",Msg::kInfo)
        <<"Number of rows in DbuSubRunSummary="<<dsrs.GetNumRows()
        <<endl;
      
      //get the database row
      if(dsrs.GetNumRows()==1) {
        fsubrun=dsrs.GetRow(0)->fSubRun;
        MSG("CDTrackerModule",Msg::kInfo)
          <<"Found subrun in database="<<fsubrun
          <<", run="<<dsrs.GetRow(0)->fRun<<endl
          <<"Start time="<<dsrs.GetRow(0)->fStartTime.GetSec()<<endl
          <<"End time  ="<<dsrs.GetRow(0)->fEndTime.GetSec()<<endl;
      }
      else{
        MSG("CDTrackerModule",Msg::kWarning)
          <<"Can't find subrun in database, #rows="<<dsrs.GetNumRows()
          <<", fsubrun="<<fsubrun<<endl;
      }
      */
      MSG("CDTrackerModule",Msg::kVerbose)<<"Subrun="<<fsubrun<<endl;
    }
  }
  else{
    MSG("CDTrackerModule",Msg::kWarning) 
      <<"No RawDaqSnarlHeader in MOM."<<endl;
    result.SetFailed();
    return result;
  }

  //get the temperature from the calibrator
  Calibrator& cal=Calibrator::Instance();
  cal.Reset(snarlHdr->GetVldContext());
  fTemperature=cal.GetTemperature();
  MAXMSG("CDTrackerModule",Msg::kDebug,20) 
    <<"Used Calibrator to get temperature="<<fTemperature<<" C"<<endl;

  int ExtTrigTime=0;//stores external trigger time of specific channel
  const RawDigitDataBlock *rddb=dynamic_cast<const RawDigitDataBlock *>
    (rr->FindRawBlock("RawDigitDataBlock"));

  //looping to find particular channel
  if (rddb) {
    RawChannelId id(Detector::kCalDet,ElecType::kVA,0,0x1602);
    id.SetModeBits(true,true,true);
    TIter it=rddb->GetDatumIter();
    while (TObject *obj=it.Next()) {
      RawVaDigit *rvd=dynamic_cast<RawVaDigit *>(obj);
      if (rvd) {
        RawChannelId rcid=rvd->GetChannel();
        if (rcid.IsSameChannel(id)) ExtTrigTime=rvd->GetTDC();
      }
    }
  }
    
  //work out the directory to write to
  if(ffirstrecord) {
    MSG("CDTrackerModule",Msg::kDebug)
      <<"Opening file..."<<endl;
    //open the output file
    fsavefile=this->OpenFile(frun,fsubrun);
    
    //create tree and initialise branches
    this->InitialiseTree();
    ffirstrecord=false;
    MSG("CDTrackerModule",Msg::kDebug) 
      <<"... file opened and tree initialised"<<endl;

    if (fSimFlag==SimFlag::kData){
      //note that only beam momentum for data is set here
      //for MC it is the largest stdhep TParticle momentum
      DbiResultPtr<CalDetBeamMomentum> cdbm(snarlHdr->GetVldContext(),
                                            Dbi::kDefaultTask,
                                            Dbi::kDisabled);
      
      MSG("CDTrackerModule",Msg::kDebug)
        <<"Number of rows in CalDetBeamMomentum="<<cdbm.GetNumRows()
        <<endl;
      
      //get the database row
      if(cdbm.GetNumRows()==1) {
        fBeamMomentum=cdbm.GetRow(0)->GetMomentum();
        MSG("CDTrackerModule",Msg::kInfo)
          <<"Found beam momentum in database="<<fBeamMomentum<<endl;
      }
      else{
        MSG("CDTrackerModule",Msg::kInfo)
          <<"Problem with beam momentum in database"
          <<", #rows="<<cdbm.GetNumRows()
          <<", beamMomentum="<<fBeamMomentum<<endl;
      }
    }
  }
  static Bool_t firstSnarl=true;
  if (firstSnarl){
    MSG("CDTrackerModule",Msg::kInfo)
      <<"Started tracking... (first snarl number="<<fsnarl
      <<", second="<<fSec<<")"<<endl;
    firstSnarl=false;
  }

  if (fWritePID){
    //make PID Info object
    fPID=new CDPIDInfo();

    //Get CandCalDetSIHandle and pass it to CDPIDInfo constructor
    CandCalDetSIHandle* cdsi=dynamic_cast<CandCalDetSIHandle*>
      (candrec->FindCandHandle("CandCalDetSIHandle"));
    
    //now fill CDPIDInfo with SI info object
    if(cdsi) {
      this->FillPID(cdsi);
    }
    else{      
      if (fSimFlag==SimFlag::kData){
        MSG("CDTrackerModule",Msg::kError)
          <<"No caldet SI handle; not filling CDPIDInfo!"<<endl;
      }
      //else simflag=MC and you don't expect to find such a handle
    }

    CandCalDetPIDHandle* cdpid=dynamic_cast<CandCalDetPIDHandle*>
      (candrec->FindCandHandle("CandCalDetPIDHandle"));

    //now fill CDPIDInfo object from cdpid
    if (cdpid){
      MSG("CalDetPID",Msg::kDebug) 
        <<"Tracker::particle="<<cdpid->GetPIDType()
        <<", nooverlap="<<cdpid->NoOverlap()
        <<", inckvtime="<<cdpid->InCERTime()
        <<", ol chi2="<<cdpid->GetOLChi2()
        <<endl;
      this->FillPID(cdpid);
    }
    else{
      if (fSimFlag==SimFlag::kData){
      MAXMSG("CDTrackerModule",Msg::kWarning,5) 
        <<"No caldet pid handle; not filling CDPIDInfo!"<<endl;
      }
      //else simflag=MC and you don't expect to find such a handle
    }
  }

  //Get CandDigitList
  CandDigitListHandle *digitlist=dynamic_cast<CandDigitListHandle*>
    (candrec->FindCandHandle("CandDigitListHandle"));
  if(digitlist==0) {
    MSG("CDTrackerModule", Msg::kFatal) 
      << "No CandDigitList in MOM." << endl;
    result.SetFailed();
    return result;
  }

  //Get CandStripList
  CandStripListHandle *striplist=dynamic_cast<CandStripListHandle*>
    (candrec->FindCandHandle("CandStripListHandle"));
  if(striplist==0) {
    MSG("CDTrackerModule", Msg::kFatal) 
      << "No CandStripList in MOM." << endl;
    result.SetFailed();
    return result;
  }

  //Write the truth information
  if (fWriteTruth){
    //check if the input file is not data
    if (fSimFlag!=SimFlag::kData){
      MAXMSG("CDTrackerModule", Msg::kVerbose,5)
        <<"fSimFlag="<<SimFlag::AsString(fSimFlag)
        <<". Accessing truth info..."<<endl; 
      //create a CDTruthifier
      CDTruthifier cdTruthifier;
      cdTruthifier.GetTruthHitInfo(mom,fTruthHits);

      Float_t beamP=0;

      //get the particle momentum
      //note that for kData the beam momentum is obtained 
      //from the caldet database table
      if (fWritePID && fPID){
        cdTruthifier.RecoStdHep(mom,fPID);
        beamP=fPID->GetTrueParticleMomentum();
      }
      else if (!fPID){
        //still want to get the beam momentum
        //even if not writing the whole CDPIDInfo object
        beamP=cdTruthifier.ParticleMomentum(mom);
      }

      //calculate the average beam momentum
      static Float_t count=0;
      MAXMSG("CDTrackerModule",Msg::kVerbose,200)
        <<"beamP="<<beamP<<", fBeamMomentum="<<fBeamMomentum
        <<", count="<<count<<endl;
      fBeamMomentum=fBeamMomentum*(count/(count+1))+beamP*(1/(count+1));
      count++;
    }
  }

  //make a map of the strips
  CDMapMaker *mpmkrStrips = new CDMapMaker(striplist);

  //cross talk removal code:
  CDCrossTalker xtalker(mpmkrStrips->GetStripMap(),0.9,
                        fTrkOpt->Cosmic());
  xtalker.GetXTalkStripInfo(fXTalkHits);

  //create tracker object
  CDTracker *tracker;

  //pass crosstalk removed map to the tracker:
  //if cosmic option set, use cosmic tracker otherwise beam tracker
  if(fTrkOpt->Cosmic()){
    tracker=new CDCosmicTracker(xtalker.GetCleanStripMap(),fTrkOpt);
  }
  else{
    tracker=new CDBeamMuTracker(xtalker.GetCleanStripMap(),fTrkOpt);
  }
  
  //Get track info from the tracker
  fTrkInfo=tracker->GetTrackInfo();
  
  //Set a few things that can't be set in the CDTracker objects:
  fTrkInfo->SetAbsTime(digitlist->GetAbsTime());//leave as digit
  fTrkInfo->SetTriggerTime(ExtTrigTime);
  
  //calculate pathlengths etc. for each hit in a track:
  CDTrackedHits trkHits(tracker->GetTrackedStripMap(PlaneView::kX),
                        tracker->GetTrackedStripMap(PlaneView::kY),
                        tracker->GetCCStripMap());
  
  //Use angles from the track info class to calculate track quantities:
  trkHits.GetTrackedStripInfo(fStTrkHits,fTrkInfo->GetAngle(0),
                              fTrkInfo->GetAngle(1));
  
  //Get Cosmic counter hit info
  trkHits.GetCCStripInfo(fCCHits);
  
  //Set trk range in TrackInfo object
  fTrkInfo->SetRange(trkHits.GetTrkRange());
  
  //alternative way to calculate pathlengths
  //only necessary for beam muons
  if(!fTrkOpt->Cosmic()){
    trkHits.GetTrackedStripInfo(fTrkHits);  
    //overwrite trk range if BeamTracker used
    fTrkInfo->SetRange(trkHits.GetTrkRange());
  }

  //Find unidentified hits in event
  //need to change the cross talker
  CDUnidentifiedHits uihStrips
    (mpmkrStrips->GetStripMap(),
     tracker->GetTrackedStripMap(PlaneView::kX),
     tracker->GetTrackedStripMap(PlaneView::kY),
     tracker->GetCCStripMap(),
     xtalker.GetXTalkStripMap());

  //get the unidentified strips
  uihStrips.GetUnidentifiedStripInfo(fUnTrkHits);
  
  //fill tree with info:
  if(fTrkInfo->GetResult(0)==1 && fTrkInfo->GetResult(1)==1){
    ftree->Fill();
  }
  else {
    result.SetFailed();
    if(!fJustWriteTracks)
      ftree->Fill();
  }
  
  //delete objects pointed to by local pointers
  delete tracker;
  delete mpmkrStrips;

  //clear the TClonesArrays and delete objects
  this->CleanDataMembers();

  return result;
}
//......................................................................

void CDTrackerModule::CleanDataMembers()
{
  //Clear TClonesArrays for next event
  //Note: This used to use Delete but that is slower and only 
  //necessary for objects (stored in the TClonesArray) that 
  //allocate their own memory
  fTrkHits->Clear();
  fStTrkHits->Clear();
  fCCHits->Clear();
  fXTalkHits->Clear();
  fUnTrkHits->Clear();
  fTruthHits->Clear();
  
  //delete objects 
  if (fTrkInfo) delete fTrkInfo;
  if (fPID) delete fPID;

  //reinitialise pointers
  fTrkInfo=0;
  fPID=0;

  //Note: Don't delete the fTrkOpt, it is only created once
}

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

void CDTrackerModule::HandleCommand(JobCommand* cmd)
{

  if (cmd->HaveCmd()) {                      // If we have a command...
    string sc = cmd->PopCmd();               // Get the command
    
    if (sc == "TrackOpt") {
      string st(cmd->PopOpt());
      fTrkOpt->SetTrackerOptions(st);
      return;
    }

    else if (sc == "ADCThreshold") {
      fTrkOpt->SetThresh(cmd->PopFloatOpt());
      return;
    }

    else if (sc == "MinNHits") {
      fTrkOpt->SetMinHit(cmd->PopIntOpt());
      return;
    }
    
    else if (sc == "MinTrkLen") {
      fTrkOpt->SetTrkLenCut(cmd->PopIntOpt());
      return;
    }
    
    else if (sc == "MaxAngle") {
      fTrkOpt->SetAngleLimit(cmd->PopFloatOpt());
      return;
    }
    
    else if (sc == "MinAngle") {
      fTrkOpt->SetMinAngle(cmd->PopFloatOpt());
      return;
    }

    else if (sc == "MinVertAngle") {
      fTrkOpt->SetMinVertAngle(cmd->PopFloatOpt());
      return;
    }

    else if (sc == "SearchRange") {
      fTrkOpt->SetAcceptance(cmd->PopIntOpt());
      return;
    }

    else if (sc == "HitsPerPlane") {
      fTrkOpt->SetHitsPerPlane(cmd->PopIntOpt());
      return;
    }

    else if (sc == "MaxHotPlanes") {
      fTrkOpt->SetMaxHotPlanes(cmd->PopIntOpt());
      return;
    }

    else if (sc == "FileID") {
      sprintf(ftag,"%s",cmd->PopOpt());
      return;      
    }

    else if (sc == "JustWriteTracks") {
      int tempNum=cmd->PopIntOpt();
      if(tempNum==0)
        fJustWriteTracks=0;
      if(tempNum>0) 
        fJustWriteTracks=1;
      return;      
    }

    else if (sc == "OverwriteFile") {
      int tempNum=cmd->PopIntOpt();
      if(tempNum==0)
        fOverwriteFile=0;
      if(tempNum>0) 
        fOverwriteFile=1;
      return;      
    }

    else if (sc == "WritePID") {
      int tempNum=cmd->PopIntOpt();
      if(tempNum==0)
        fWritePID=0;
      if(tempNum>0) 
        fWritePID=1;
      return;      
    }
    else if (sc == "WriteTruth") {
      int tempNum=cmd->PopIntOpt();
      if(tempNum==0)
        fWriteTruth=0;
      if(tempNum>0) 
        fWriteTruth=1;
      return; 
    }
    else MSG("CDTrackerModule",Msg::kWarning) 
      << "Don't understand '" << sc.c_str() << "'\n";
  }
}

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

void CDTrackerModule::EndJob()
{
  MSG("CDTrackerModule",Msg::kDebug)<<"Running EndJob()"<<endl;  
  
  if (fsavefile!=0 && fsavefile->IsWritable()){
    fsavefile->cd();
    
    MSG("CDTrackerModule",Msg::kInfo)
      <<"Writing to file... "<<endl;
    //print where tree will be written
    fsavefile->pwd();
    ftree->Write();
    
    MSG("CDTrackerModule",Msg::kDebug)
      <<"Creating options tree..."<<endl;
    TTree opt_tree("TrackerOptions","Tracker Options");
    opt_tree.Branch("SimFlag",&fSimFlag,"SimFlag/I",32000);
    opt_tree.Branch("StartTime",&fStartTime,"StartTime/I",32000);
    opt_tree.Branch("EndTime",&fEndTime,"EndTime/I",32000);
    opt_tree.Branch("StartSnarl",&fStartSnarl,"StartSnarl/I",32000);
    opt_tree.Branch("EndSnarl",&fEndSnarl,"EndSnarl/I",32000);
    opt_tree.Branch("BeamMomentum",&fBeamMomentum,
                    "BeamMomentum/F",32000);
    opt_tree.Branch("Run",&frun,"run/I",32000);
    opt_tree.Branch("SubRun",&fsubrun,"subrun/I",32000);
    opt_tree.Branch("TrackerOptions","CDTrackerOptions",
                     &fTrkOpt,8000,1);
    
    MSG("CDTrackerModule",Msg::kInfo)
      <<"Time="<<fStartTime<<"->"<<fEndTime<<endl
      <<"Snarl="<<fStartSnarl<<"->"<<fEndSnarl<<endl;

    MSG("CDTrackerModule",Msg::kDebug)<<"Filling tree..."<<endl;
    opt_tree.Fill();
    opt_tree.Write();
    MSG("CDTrackerModule",Msg::kInfo)<<"Closing file..."<<endl;
    fsavefile->Close();
  }
  else {
    MSG("CDTrackerModule",Msg::kWarning)
      <<"File not writable!"<<endl;
  }

  delete fTrkHits;
  delete fCCHits;
  delete fStTrkHits;
  delete fXTalkHits;
  delete fUnTrkHits;
  delete fTruthHits;

  MSG("CDTrackerModule",Msg::kDebug)
    <<"End of CDTrackerModule::EndJob() reached"<<endl;
}

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

TFile* CDTrackerModule::OpenFile(Int_t runNumber,
                                       Int_t runNumberSub)
{
  //create the tfile pointer to be returned
  TFile* outputFile=0;
  
  //get the environmental variable
  char *trackerdir=getenv("TRACKER_DIR");
  
  //use a string to hold env instead 
  string sTrackerDir="";
  
  if (trackerdir!=NULL) {
    sTrackerDir=trackerdir;
  }
  else {
    MSG("CDTrackerModule",Msg::kInfo) 
      <<"Environmental variable $TRACKER_DIR not set." 
      <<" Writing file(s) to current directory"<<endl;
    sTrackerDir=".";
  }
  
  //convert varaibles to string
  string sRunNumber=Form("%d",runNumber);
  string sRunNumberSub=Form("%d",runNumberSub);
  MSG("CDTrackerModule",Msg::kVerbose) 
    <<"srunnumbersub="<<sRunNumberSub<<endl;
  //string sDetector="";
  string sTag=ftag;
  string sBase=sTrackerDir+"/Tracker"+sRunNumber+"_"+
    sRunNumberSub+"_"+sTag;
  string sFileName=sBase+".root";
  
  //test if file already exists
  ifstream Test(sFileName.c_str());
  
  //open the appropriate file
  if(!Test || fOverwriteFile){
    outputFile=new TFile(sFileName.c_str(),"RECREATE");
    if(fOverwriteFile) {
       if(Test) Test.close();
    }
  }
  else {
    //Need new filename
    Int_t fred=1;
    while(Test) {
      Test.close();
      string sAppendage=Form("%d",fred);
      sFileName=sBase+"_"+sAppendage+".root";
      Test.open(sFileName.c_str());
      fred++;
    }
    outputFile = new TFile(sFileName.c_str(),"NEW");
    outputFile->SetCompressionLevel(9);
  }
  
  MSG("CDTrackerModule",Msg::kInfo) 
    <<"Output file opened: "<<sFileName<<endl;
  return outputFile;
}

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

void CDTrackerModule::InitialiseTree()
{
  //create the tree
  ftree=new TTree("TrackerTree","Tracker Tree");
  
  //set tree branches  
  ftree->Branch("Snarl",&fsnarl,"snarl/I",32000);
  ftree->Branch("NumDeadChips",&fNumDeadChips,"NumDeadChips/I",32000);
  ftree->Branch("Sec",&fSec,"Sec/I",32000);
  ftree->Branch("Temperature",&fTemperature,"Temperature/F",32000);
  if(fWritePID==1) ftree->Branch("PIDInfo","CDPIDInfo",&fPID,8000,1);
  ftree->Branch("TrackInfo","CDTrackInfo",&fTrkInfo,8000,1);
  ftree->Branch("TrackedHitInfo","TClonesArray",&fTrkHits,8000,1);
  ftree->Branch("StraightTrackedHitInfo","TClonesArray",
                &fStTrkHits,8000,1);
  ftree->Branch("CCHitInfo","TClonesArray",&fCCHits,8000,1);
  ftree->Branch("XTalkHitInfo","TClonesArray",&fXTalkHits,8000,1);
  ftree->Branch("UnTrackedHitInfo","TClonesArray",&fUnTrkHits,8000,1);
  if (fWriteTruth) ftree->Branch("TruthHitInfo","TClonesArray",
                                 &fTruthHits,8000,1);
}

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

void CDTrackerModule::FillPID(const CandCalDetPIDHandle* cdpid)
{
  //check handle exists and fill
  if(cdpid) {
    MSG("CDTrackerModule",Msg::kVerbose)
      <<"Filling CDPIDInfo object with CalDetPID info"<<endl;
    fPID->SetPIDType(cdpid->GetPIDType());
    fPID->SetNoOverlap(cdpid->NoOverlap());
    fPID->SetInCERTime(cdpid->InCERTime());
    fPID->SetNoOverlapBits(cdpid->GetNoOverlapBits());
    fPID->SetInCERTimeBits(cdpid->GetInCERTimeBits());
    fPID->SetOLChi2(cdpid->GetOLChi2());
  }
}

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

void CDTrackerModule::FillPID(CandCalDetSIHandle *cdsi)
{
  //check handle exists and fill
  if(cdsi) {
    fPID->SetIsEmpty(true);
    fPID->SetTriggerPMT(cdsi->GetTriggerPMT());
    fPID->SetFafErr(cdsi->GetFafErr());
    fPID->SetSparseErr(cdsi->GetSparseErr());
    fPID->SetTrigSource(cdsi->GetTrigSource());
    fPID->SetKovADC1(cdsi->GetKovADC1());
    fPID->SetKovADC2(cdsi->GetKovADC2());
    fPID->SetKovADC3(cdsi->GetKovADC3());
    fPID->SetKovTimeStamp1(cdsi->GetKovTimeStamp1());
    fPID->SetKovTimeStamp2(cdsi->GetKovTimeStamp2());
    fPID->SetKovTimeStamp3(cdsi->GetKovTimeStamp3());
    fPID->SetSnarlTimeFrame(cdsi->GetSnarlTimeFrame());
    fPID->SetSnarlMinTimeStamp(cdsi->GetSnarlMinTimeStamp());
    fPID->SetSnarlMaxTimeStamp(cdsi->GetSnarlMaxTimeStamp());
    fPID->SetTofTDC0(cdsi->GetTofTDC0());
    fPID->SetTofTDC1(cdsi->GetTofTDC1());
    fPID->SetTofTDC2(cdsi->GetTofTDC2());    
    fPID->SetTofADC0(cdsi->GetTofADC0());
    fPID->SetTofADC1(cdsi->GetTofADC1());
    fPID->SetTofADC2(cdsi->GetTofADC2());
    fPID->SetTofADCTimeStamp0(cdsi->GetTofADCTimeStamp0());
    fPID->SetTofADCTimeStamp1(cdsi->GetTofADCTimeStamp1());
    fPID->SetTofADCTimeStamp2(cdsi->GetTofADCTimeStamp2());
    fPID->SetTofTimeStamp(cdsi->GetTofTimeStamp());
    fPID->SetTickSinceLast(cdsi->GetTickSinceLast());
  }
}

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

---