FillTrack.cxx

Go to the documentation of this file.

// $Id: FillTrack.cxx,v 1.16 2008/02/09 19:15:19 rustem Exp $

// ROOT
#include "TClonesArray.h"

// MINOS
#include "CandNtupleSR/NtpSRTrack.h"
#include "DataUtil/EnergyCorrections.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "Registry/Registry.h"
#include "StandardNtuple/NtpStRecord.h"

// Local
#include "PhysicsNtuple/Default.h"
#include "PhysicsNtuple/Factory.h"

// Local
#include "FillTrack.h"

CVSID("$Id: FillTrack.cxx,v 1.16 2008/02/09 19:15:19 rustem Exp $");

REGISTER_ANP_OBJECT(AlgStore,FillTrack)

namespace EnergyCorrections{}
using namespace EnergyCorrections;
using namespace std;

//-----------------------------------------------------------------------------
Anp::FillTrack::FillTrack()
   :fCorr(true)
{    
}

//-----------------------------------------------------------------------------
Anp::FillTrack::~FillTrack()
{
}

//----------------------------------------------------------------------
bool Anp::FillTrack::Run(Record& record, TObject *ptr)
{
   //
   // Extract data from NtpSRTrack and save to Anp::Track
   //

   NtpStRecord *ntprec = dynamic_cast<NtpStRecord *>(ptr);
   if(!ntprec)
   {
      const MomNavigator *mom = dynamic_cast<const MomNavigator *> (ptr);
      if(mom)
      {
         ntprec = dynamic_cast<NtpStRecord *>(mom -> GetFragment("NtpStRecord")); 
      }
      else
      {
         MSG("FillAlg", Msg::kError) << "Failed to find MomNavigator pointer" << endl;
         return false;
      }      
   }

   if(!ntprec)
   {
      MSG("FillAlg", Msg::kError) << "Failed to get NtpStRecord pointer" << endl;
      return false;
   }

   const TClonesArray *track_array = ntprec -> trk;
   if(!track_array)
   {
      MSG("FillAlg", Msg::kWarning) << "NtpStRecord does not have valid track array." <<endl;
      return true;
   }
   
   const VldContext vldc = ntprec -> GetHeader().GetVldContext();
   const int ntrack = track_array -> GetEntries();

   for(int i = 0; i < ntrack; ++i)
   {
      NtpSRTrack *ntptrk  = dynamic_cast<NtpSRTrack *>(track_array -> At(i));
      if(!ntptrk)
      {
         MSG("FillAlg", Msg::kWarning) << "Failed to find NtpSRTrack at index " << i << endl;
         continue;
      }
      
      if(ntptrk -> index != i)
      {
         MSG("FillAlg", Msg::kWarning) << "Mismatched track index" << endl;
         continue;
      }
      
      if(!fBasic.Fill(*ntprec, *ntptrk))
      {
         MSG("FillAlg", Msg::kWarning) << "Failed to fill basic track information" << endl;
      }

      //
      // Fill variables for PhysicsNtuple/Track.h data class 
      //
      Track track;

      track.index       = ntptrk -> index;
      track.tracen      = ntptrk -> fidend.nplane;
      track.tracet      = ntptrk -> fidend.dr;
      track.fit_qp      = ntptrk -> momentum.qp;
      track.fit_eqp     = ntptrk -> momentum.eqp;
      track.fit_chi2    = ntptrk -> fit.chi2;
      track.fit_ndof    = ntptrk -> fit.ndof;
      track.pass_fit    = ntptrk -> fit.pass;
      track.range       = ntptrk -> range;
      track.p_range_def = ntptrk -> momentum.range;

      if(fCorr)
      {
         track.p_range = FullyCorrectMomentumFromRange(ntptrk -> momentum.range,
                                                       vldc,
                                                       ntprec -> GetRelease());
      }
      else
      {
         track.p_range = ntptrk -> momentum.range;
      }

      //
      // Fill vertex info
      //
      track.fBasic  = fBasic.GetBasic();
      track.fBegVtx = fBasic.GetBegVtx();
      track.fEndVtx = fBasic.GetEndVtx();
      
      //
      // Use default containment cut      
      //
      if(ntptrk -> contained == 1)
      {
         track.stopping = true;
      }
      else
      {
         track.stopping = false;
      }     

      record.Add(track);
   }

   return true;
}

//-----------------------------------------------------------------------------
void Anp::FillTrack::Config(const Registry &reg)
{
   //
   // Configure self
   //
   
   Anp::Read(reg, "FillTrackCorr", fCorr);

   fBasic.Config(reg);

   if(reg.KeyExists("PrintConfig"))
   {
      cout << "FillTrack::Config" << endl
           << "   Corr = " << fCorr << endl;
   }
}

---