SRMom.cxx

Go to the documentation of this file.

// $Id: SRMom.cxx,v 1.8 2009/02/28 21:46:14 gmieg Exp $
//
// Wrapper to the MomNavigator to provide a simple interface.
//
// Justin Evans
// j.evans2@physics.ox.ac.uk
//
// $Log: SRMom.cxx,v $
// Revision 1.8  2009/02/28 21:46:14  gmieg
// Update for GCC 4.4.0.  Mostly add #includes
// for reorganized C++ headers, such as -
// algorithm for: sort, find
// cassert for:   assert, abort
// climits for:   SHRT_MAX, INT_MAX
// cstdlib for:   abs, getenv, atoi, atof, strtod, exit
// cstring for:   strcmp
//
// Revision 1.7  2008/05/02 15:46:25  rhatcher
// Remove #include level circular dependency that P. Rodrigues discovered.
//
// Revision 1.6  2007/11/11 06:42:06  rhatcher
// Part of the ongoing purge of "DetectorType" in favor of "Detector"
// (the former is a synonym of the latter ...)
//
// Revision 1.5  2007/04/06 21:12:39  evans
// Code to get at shower vertices.
//
// Revision 1.4  2007/03/27 13:31:20  evans
// New code to calculate my charge PID (requires pdfs in /data).
// Also includes code to calculate track jitter given an NtpSRTrack object.
//
// Revision 1.3  2007/02/07 20:42:41  evans
// Removing the Mad dependency from SRMom.
//
// Revision 1.2  2007/02/05 22:03:30  rhatcher
// #ifdef away the #include "NuMuBar/NuMadAnalysis.h" and most of the code
// in SRMom::PID().  These introduce a dependency on the NuMuBar package
// which *isn't* currently part of the base release (and thus breaks building
// NtupleUtils on most sites).
//
// Revision 1.1  2007/02/05 14:45:51  evans
// Adding the code to calculate the majority curvature for a track.
//
// To calculate the majority curvature for an NtpSRTrack object, pass it to the function MajorityCurvature::Curvature(const NtpSRTrack* track) const.
// The return value is the majority curvature of the track.
//
// The class SRMom is a wrapper to the MomNavigator that has been submitted as MajorityCurvature uses some of its methods.
//
//
//

#include "TClonesArray.h"

#include "BeamDataNtuple/NtpBDLiteRecord.h"
#include "CandNtupleSR/NtpSREvent.h"
#include "CandNtupleSR/NtpSRMomentum.h"
#include "CandNtupleSR/NtpSRShower.h"
#include "CandNtupleSR/NtpSRTrack.h"
#include "CandNtupleSR/NtpSRVertex.h"
#include "Conventions/Munits.h"
#include "DataUtil/GetDetector.h"
#include "DataUtil/PlaneOutline.h"
// for now code that needs MadDpID is commented out
//#include "Mad/MadDpID.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "NtupleUtils/NuCuts.h"
#include "Plex/PlexPlaneId.h"
#include "StandardNtuple/NtpStRecord.h"
#include "Validity/VldContext.h"

#include "NtupleUtils/SRMom.h"
//#include "NuMuBar/NuMadAnalysis.h"

#include <cmath>
#include <cstdlib>

using std::multimap;

ClassImp(SRMom)

CVSID("$Id: SRMom.cxx,v 1.8 2009/02/28 21:46:14 gmieg Exp $");

//____________________________________________________________________72
SRMom::SRMom()
  : fbeamType(BeamType::kLE)
{
  fmom = 0;
  fstRecord = 0;
  fbdLiteRec = 0;
  /*
  fbuffSREvt = 0;
  fbuffEvtNum = -1;
  fbuffSRTrk = 0;
  fbuffTrkNum = -1;
  */
}

//____________________________________________________________________72
SRMom::SRMom(const MomNavigator* mom)
  : fbeamType(BeamType::kLE)
{
  fmom = mom;
  if (!fmom){
    MSG("SRMom",Msg::kWarning) 
      << "No Mom in this snarl" << endl;
    fstRecord = 0;
    fbdLiteRec = 0;
  }

  else{
    fstRecord = dynamic_cast<NtpStRecord*>
      (fmom->GetFragment("NtpStRecord"));
    if (!fstRecord){
      MSG("SRMom",Msg::kWarning) 
        << "No NtpStRecord in Mom" << endl;
    }

    fbdLiteRec = dynamic_cast<NtpBDLiteRecord*>
      (fmom->GetFragment("NtpBDLiteRecord"));
    if (!fbdLiteRec){
      MAXMSG("SRMom",Msg::kWarning, 10)
        << "No NtpBDLiteRecord in Mom" << endl;
    }
  }

  /*
  fbuffSREvt = 0;
  fbuffEvtNum = -1;
  fbuffSRTrk = 0;
  fbuffTrkNum = -1;
  */
}

//____________________________________________________________________72
SRMom::~SRMom()
{
  fbdLiteRec = 0;
  fstRecord = 0;
  fmom = 0;
  /*
  fbuffSREvt = 0;
  fbuffEvtNum = -1;
  fbuffSRTrk = 0;
  fbuffTrkNum = -1;
  */
}

//____________________________________________________________________72
const multimap<Float_t, Float_t>  SRMom::ArrayRAlongTrack(const Int_t eventNum,
                                                          const Int_t trackNum) const
{
  multimap<Float_t, Float_t> md;
  md.clear();
  const NtpSRTrack* srTrack = SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return md;
  }
  for (Int_t k=0; k<srTrack->nstrip; ++k){
//     if(!srTrack->stpfit[k]){continue;}
    Float_t x = srTrack->stpx[k];
    Float_t y = srTrack->stpy[k];
    md.insert(pair<Float_t,Float_t>(srTrack->stpz[k],
                                    sqrt(x*x + y*y)));
  }
  return md;
}

//____________________________________________________________________72
const multimap<Float_t, Float_t>  SRMom::ArrayUAlongTrack(const Int_t eventNum,
                                                          const Int_t trackNum) const
{
  multimap<Float_t, Float_t> md;
  md.clear();
  const NtpSRTrack* srTrack = SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return md;
  }
  for (Int_t k=0; k<srTrack->nstrip; ++k){
//     if(!srTrack->stpfit[k]){continue;}
    md.insert(pair<Float_t,Float_t>(srTrack->stpz[k],
                                    srTrack->stpu[k]));
  }
  return md;
}

//____________________________________________________________________72
const multimap<Float_t, Float_t>  SRMom::ArrayVAlongTrack(const Int_t eventNum,
                                                          const Int_t trackNum) const
{
  multimap<Float_t, Float_t> md;
  md.clear();
  const NtpSRTrack* srTrack = SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return md;
  }
  for (Int_t k=0; k<srTrack->nstrip; ++k){
//     if(!srTrack->stpfit[k]){continue;}
    md.insert(pair<Float_t,Float_t>(srTrack->stpz[k],
                                    srTrack->stpv[k]));
  }
  return md;
}

//____________________________________________________________________72
const multimap<Float_t, Float_t>  SRMom::ArrayXAlongTrack(const Int_t eventNum,
                                                          const Int_t trackNum) const
{
  multimap<Float_t, Float_t> md;
  md.clear();
  const NtpSRTrack* srTrack = SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return md;
  }
  
  for (Int_t k=0; k<srTrack->nstrip; ++k){
//     if(!srTrack->stpfit[k]){continue;}
    // cout<<k<<"  "<<srTrack->stpx[k]<<"  "<<srTrack->stpz[k]<<endl;
    md.insert(pair<Float_t,Float_t>(srTrack->stpz[k],
                                    srTrack->stpx[k]));
  }/*
  multimap<Float_t,Float_t>::const_iterator it = md.begin();
  
  for(int k=0;k<srTrack->nstrip; ++k){
    cout<<"from SR MOM  "<<it->first<<"  "<<it->second<<endl;
    it++;
  }
   */
  return md;
}

//____________________________________________________________________72
const multimap<Float_t, Float_t> 
SRMom::ArrayXAlongTrack(const NtpSRTrack* srTrack) const
{
  multimap<Float_t, Float_t> md;
  md.clear();
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack passed to SRMom::ArrayXAlongTrack" << endl;
    return md;
  }
  
  for (Int_t k=0; k<srTrack->nstrip; ++k){
    md.insert(pair<Float_t,Float_t>(srTrack->stpz[k],
                                    srTrack->stpx[k]));
  }
  return md;
}

//____________________________________________________________________72
const multimap<Float_t, Float_t>  SRMom::ArrayYAlongTrack(const Int_t eventNum,
                                                          const Int_t trackNum) const
{
  multimap<Float_t, Float_t> md;
  md.clear();
  const NtpSRTrack* srTrack = SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return md;
  }
  for (Int_t k=0; k<srTrack->nstrip; ++k){
//     if(!srTrack->stpfit[k]){continue;}
    md.insert(pair<Float_t,Float_t>(srTrack->stpz[k],
                                    srTrack->stpy[k]));
  }
  return md;
}

//____________________________________________________________________72
const multimap<Float_t, Float_t>
SRMom::ArrayYAlongTrack(const NtpSRTrack* srTrack) const
{
  multimap<Float_t, Float_t> md;
  md.clear();
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack passed to SRMom::ArrayYAlongTrack" << endl;
    return md;
  }
  for (Int_t k=0; k<srTrack->nstrip; ++k){
    md.insert(pair<Float_t,Float_t>(srTrack->stpz[k],
                                    srTrack->stpy[k]));
  }
  return md;
}

//____________________________________________________________________72
const Int_t SRMom::BiggestShwIndex(const Int_t eventNum) const
{
  Float_t highestPH = 0.0;
  Int_t biggestShwIndex = -1;
  Int_t numShowers = this->NumShowers(eventNum);
  if (numShowers < 1){return -1;}

  for (Int_t j=0; j<numShowers; ++j){
    Float_t ph = this->ShwPHGeV(eventNum,j);
    if (ph > highestPH){
      highestPH = ph;
      biggestShwIndex = j;
    }
  }
  if (-1 == biggestShwIndex){
    MSG("SRMom",Msg::kWarning) 
      << "Showers in event " << eventNum << " have -ve energy." << endl;
  }
  return biggestShwIndex;
}

//____________________________________________________________________72
const Float_t SRMom::ChiSq(const Int_t eventNum,
                           const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1.0;
  }
  if (!srTrack->fit.pass) return -1.0;
  
  return srTrack->fit.chi2;
}

//____________________________________________________________________72
const Float_t SRMom::ChiSqPerNDoF(const Int_t eventNum,
                                  const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1.0;
  }
  if (!srTrack->fit.pass) return -1.0;
  if (!srTrack->fit.ndof) return -1.0;

  return srTrack->fit.chi2/srTrack->fit.ndof;
}

//____________________________________________________________________72
const Detector::Detector_t SRMom::Detector() const
{
  const VldContext* vc = this->VldCntxt();
  if (!vc){return Detector::kUnknown;}
  return vc->GetDetector();
}

//____________________________________________________________________72
const Int_t SRMom::EvtLthPln(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return abs((Int_t) (srEvent->vtx.plane) -
              (Int_t) (srEvent->end.plane));
}

//____________________________________________________________________72
const NtpSRVertex* SRMom::EvtVtx(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return 0;
  }

  return &(srEvent->vtx);
}

//____________________________________________________________________72
const Int_t SRMom::EventVtxPlane(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return srEvent->vtx.plane;
}

//____________________________________________________________________72
const Float_t SRMom::EventVtxU(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return srEvent->vtx.u;
}

//____________________________________________________________________72
const Float_t SRMom::EventVtxV(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return srEvent->vtx.v;
}

//____________________________________________________________________72
const Float_t SRMom::EventVtxX(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return srEvent->vtx.x;
}

//____________________________________________________________________72
const Float_t SRMom::EventVtxY(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return srEvent->vtx.y;
}

//____________________________________________________________________72
const Float_t SRMom::EventVtxZ(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return srEvent->vtx.z;
}

//____________________________________________________________________72
const Bool_t SRMom::LISnarl() const
{
  if (!fstRecord){return false;}
  if (-1.0 == fstRecord->evthdr.litime){return false;}
  else {return true;}
}

//____________________________________________________________________72
const Int_t SRMom::LongestTrackIndex(const Int_t eventNum) const
{
  Float_t longestLength = 0.0;
  Int_t longestIndex = -1;
  Int_t numTracks = this->NumTracks(eventNum);
  if (numTracks < 1){return -1;}

  for (Int_t j=0; j<numTracks; ++j){
    Float_t length = this->TrackLength(eventNum,j);
    if (length > longestLength){
      longestLength = length;
      longestIndex = j;
    }
  }
  if (-1 == longestIndex){
    MSG("SRMom",Msg::kWarning) 
      << "Tracks in event " << eventNum << " have -ve length." << endl;
  }
  return longestIndex;
}

//____________________________________________________________________72
const NtpSRTrack* SRMom::LongestTrackInEvent(const Int_t eventNum) const
{
  Float_t longestLength = 0.0;
  Int_t longestIndex = -1;
  Int_t numTracks = this->NumTracks(eventNum);
  if (numTracks < 1){return 0;}

  for (Int_t j=0; j<numTracks; ++j){
    Float_t length = this->TrackLength(eventNum,j);
    if (length > longestLength){
      longestLength = length;
      longestIndex = j;
    }
  }
  if (-1 == longestIndex){
    MSG("SRMom",Msg::kWarning) 
      << "Tracks in event " << eventNum << " have -ve length." << endl;
    return 0;
  }
  return this->SRTrack(eventNum, longestIndex);
}

//____________________________________________________________________72
const Int_t SRMom::NDoF(const Int_t eventNum,
                        const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1;
  }
  if (!srTrack->fit.pass) return -1;

  return srTrack->fit.ndof;
}

//____________________________________________________________________72
const Int_t SRMom::NumEvents() const
{
  if (!fstRecord){return -1;}

  TClonesArray* srArray = fstRecord->evt;

  TIter digitIter(srArray);
  NtpSREvent* srEvent;
  Int_t numEvents = 0;
  while ( (srEvent = dynamic_cast<NtpSREvent*> (digitIter.Next()) ) ){
    numEvents++;
  }

  return numEvents;
}

//____________________________________________________________________72
const Int_t SRMom::NumShowers(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return srEvent->nshower;
}

//____________________________________________________________________72
const Int_t SRMom::NumTracks(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return -1;
  }

  return srEvent->ntrack;
}
/*
//____________________________________________________________________72
const Float_t SRMom::PID(const Int_t eventNum) const
{
  if (!fstRecord){return -9999.9;}
  
  NuMadAnalysis madAnal;
  madAnal.SetEntry(fstRecord);

  MadDpID dpid;
  dpid.ChoosePDFs(fstRecord->GetHeader().GetVldContext().GetDetector(),
                  BeamType::kLE);
  Float_t pid = dpid.CalcPID(&madAnal,eventNum,0);
  return pid;
}
*/
//____________________________________________________________________72
const Int_t SRMom::RunNumber() const
{
  return fstRecord->GetHeader().GetRun();
}

//____________________________________________________________________72
const Int_t SRMom::SnarlNumber() const
{
  return fstRecord->GetHeader().GetSnarl();
}

//____________________________________________________________________72
const Float_t SRMom::SnarlPoT() const
{
  if (!fbdLiteRec){return 0;}
  return fbdLiteRec->tortgt;
}

//____________________________________________________________________72
const Int_t SRMom::ShwEndPln(const Int_t eventNum,
                             const Int_t shwNum) const
{
  const NtpSRShower* srShower = this->SRShower(eventNum,shwNum);
  if (!srShower){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRShower number " << shwNum
      << " in event number " << eventNum<< endl;
    return 0;
  }
  return (Int_t) srShower->plane.end;
}

//____________________________________________________________________72
const Int_t SRMom::ShwLthPlanes(const Int_t eventNum,
                                const Int_t shwNum) const
{
  const NtpSRShower* srShower = this->SRShower(eventNum,shwNum);
  if (!srShower){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRShower number " << shwNum
      << " in event number " << eventNum<< endl;
    return 0;
  }
  return abs(((Int_t) srShower->plane.end)
             - ((Int_t) srShower->plane.beg));
}

//____________________________________________________________________72
const Float_t SRMom::ShwPHGeV(const Int_t eventNum,
                              const Int_t shwNum) const
{
  const NtpSRShower* srShower = this->SRShower(eventNum,shwNum);
  if (!srShower){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRShower number " << shwNum
      << " in event number " << eventNum<< endl;
    return 0.0;
  }
  return srShower->ph.gev;
}

//____________________________________________________________________72
const NtpSRVertex* SRMom::ShwStartVtx(const Int_t eventNum,
                                      const Int_t shwNum) const
{
  const NtpSRShower* srShower = this->SRShower(eventNum,shwNum);
  if (!srShower){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRShower number " << shwNum
      << " in event number " << eventNum<< endl;
    return 0;
  }
  return &(srShower->vtx);
}

//____________________________________________________________________72
const NtpSREvent* SRMom::SREvent(const Int_t eventNum) const
{
  /*
  if (fbuffEvtNum == eventNum){
    return fbuffSREvt;
  }
  */
  if (!fstRecord){
    /*
    fbuffSREvt = 0;
    fbuffEvtNum = eventNum;
    fbuffTrkNum = -1;
    fbuffSRTrk = 0;
    */
    return 0;
  }
  TClonesArray& srArray = *(fstRecord->evt);
  NtpSREvent* srEvent = dynamic_cast<NtpSREvent*> (srArray[eventNum]);
  /*
  fbuffSREvt = srEvent;
  fbuffEvtNum = eventNum;
  fbuffTrkNum = -1;
  fbuffSRTrk = 0;
  */
  return srEvent;
}

//____________________________________________________________________72
const NtpSRShower* SRMom::SRShower(const Int_t eventNum,
                                   const Int_t shwNum) const
{
  if (shwNum < 0){return 0;}
  if (shwNum >= this->NumShowers(eventNum)){return 0;}

  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if (!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return 0;
  }
 
  Int_t shwIndex = srEvent->shw[shwNum];
  TClonesArray& shwArray = *(fstRecord->shw);
  NtpSRShower* shower = dynamic_cast<NtpSRShower*>
    (shwArray[shwIndex]); 
  return shower;
}

//____________________________________________________________________72
const NtpSRTrack* SRMom::SRTrack(const Int_t eventNum,
                                 const Int_t trackNum) const
{
  /*
  if ((fbuffTrkNum == trackNum) && (fbuffEvtNum == eventNum)){
    //    cout << "Returning bufferred track " << SnarlNumber() << ", " << eventNum << ", " << trackNum << endl;
    return fbuffSRTrk;
  }
  */
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if (!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    /*
    fbuffSRTrk = 0;
    fbuffTrkNum = trackNum;
    //   cout << "Returning 0 for track " << SnarlNumber() << ", " << eventNum << ", " << trackNum << endl;
    */
    return 0;
  }

  Int_t trackIndex = srEvent->trk[trackNum];
  TClonesArray& trackArray = *(fstRecord->trk);
  NtpSRTrack* track = dynamic_cast<NtpSRTrack*>
    (trackArray[trackIndex]);
  /*
  fbuffSRTrk = track;
  fbuffTrkNum = trackNum;
  //  cout << "Returning non-buferred track " << SnarlNumber() << ", " << eventNum << ", " << trackNum << endl;
  */
  return track;
}

//____________________________________________________________________72
const Int_t SRMom::TrkContained(const Int_t eventNum,
                                const Int_t trackNum) const
{
  Float_t dOut = this->TrackEndDistOuterTransEdge(eventNum,trackNum);
  Float_t dz = this->TrackEndDistZEnd(eventNum,trackNum);
  if (dOut < -999990){return -1;}
  if (dz < -999990){return -1;}
  if (dOut < 0.2){return 0;}
  if (dz < 0.2){return 0;}
  return 1;
  /*
  //Will only work with newer versions of the code
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1;
  }
  return srTrack->contained;
  */
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndDistOuterTransEdge(const Int_t eventNum,
                                                const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }

  const Int_t endPln = this->TrackEndPlane(srTrack);
  if (endPln < 0){
    MSG("SRMom",Msg::kWarning)
      << "Trying to find TrackEndDistOuterTransEdge for a plane "
      << "before the start of the detector."
      << endl;
    return -999999.9;
  }
  PlexPlaneId planeID(DataUtil::GetDetector(*fmom),
                      (UInt_t) endPln);

  Float_t distance = 0;
  Float_t xdist = 0;
  Float_t ydist = 0;
  PlaneOutline plnout;
  plnout.DistanceToOuterEdge(this->TrackEndX(srTrack),
                             this->TrackEndY(srTrack),
                             planeID.GetPlaneView(),
                             planeID.GetPlaneCoverage(),
                             distance,
                             xdist,
                             ydist);    
  return distance;
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndDistZEnd(const Int_t eventNum,
                                      const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }

  Detector::Detector_t det = DataUtil::GetDetector(*fmom);
  Float_t detLength = 282*5.94*Munits::cm;
  if (Detector::kFar == det){
    detLength = 484*5.94*Munits::cm;
  }
  else{
    if (Detector::kNear != det){
      MSG("SRMom",Msg::kWarning)
        << "Trying to find TrkEndDistZEnd for non-existant detector."
        << endl;
      return -999999.9;
    }
  }
  return detLength - srTrack->end.z;
}

//____________________________________________________________________72
const Int_t SRMom::TrackEndPlane(const Int_t eventNum,
                                   const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1;
  }
  return srTrack->end.plane;
}

//____________________________________________________________________72
const Int_t SRMom::TrackEndPlane(const NtpSRTrack* srTrack) const
{
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "Trying to find TrackEndPlane for a null track." << endl;
    return -1;
  }
  return srTrack->end.plane;
}

//____________________________________________________________________72
const Float_t SRMom::TrkEndR(const Int_t eventNum,
                               const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  Float_t x = srTrack->end.x;
  Float_t y = srTrack->end.y;
  Float_t r = sqrt(x*x + y*y);
  return r;
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndU(const Int_t eventNum,
                                   const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->end.u;
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndV(const Int_t eventNum,
                                   const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->end.v;
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndX(const Int_t eventNum,
                                   const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->end.x;
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndX(const NtpSRTrack* srTrack) const
{
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "Trying to find TrackEndX for a null track." << endl;
    return -999999.9;
  }
  return srTrack->end.x;
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndY(const Int_t eventNum,
                               const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->end.y;
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndY(const NtpSRTrack* srTrack) const
{
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "Trying to find TrackEndY for a null track." << endl;
    return -999999.9;
  }
  return srTrack->end.y;
}

//____________________________________________________________________72
const Float_t SRMom::TrackEndZ(const Int_t eventNum,
                               const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->end.z;
}

//____________________________________________________________________72
const Float_t SRMom::TrkEnergySimple(const Int_t eventNum,
                                     const Int_t trackNum) const
{
  //Simple function that uses the SR's opinion on containment.
  Int_t contained = this->TrkContained(eventNum,trackNum);
  if (-1.0 == contained){
    return -999999.9;
  }
  if (!contained){
    return this->TrkMomCurv(eventNum,trackNum);
  }
  return TrkMomRange(eventNum,trackNum);
}

//____________________________________________________________________72
const Int_t SRMom::TrkFitPass(const Int_t eventNum,
                              const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1;
  }
  return (Int_t) srTrack->fit.pass;
}

//____________________________________________________________________72
const Float_t SRMom::TrackLength(const Int_t eventNum,
                                 const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1.0;
  }
  Float_t trackLength = srTrack->ds;
  return trackLength;
}

//____________________________________________________________________72
const Int_t SRMom::TrackLengthPlanes(const Int_t eventNum,
                                     const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1;
  }
  Int_t vtxPlane = TrackVtxPlane(srTrack);
  Int_t endPlane = TrackEndPlane(srTrack);
  if (-1 == endPlane || -1 == vtxPlane){return -1;}
  Int_t trackLength = endPlane - vtxPlane;
  return trackLength;
}

//____________________________________________________________________72
const Int_t SRMom::TrackLengthPlanes(const NtpSRTrack* srTrack) const
{
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack given to SRMom::TrkLthPln" << endl;
    return -1;
  }
  Int_t vtxPlane = TrackVtxPlane(srTrack);
  Int_t endPlane = TrackEndPlane(srTrack);
  if (-1 == endPlane || -1 == vtxPlane){return -1;}
  Int_t trackLength = endPlane - vtxPlane;
  return trackLength;
}

//____________________________________________________________________72
const Float_t SRMom::TrkMomCurv(const Int_t eventNum,
                                const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  Float_t qOvp = srTrack->momentum.qp;
  if (!qOvp) return -999999.9;
  return fabs(1.0/qOvp);
}

//____________________________________________________________________72
const Float_t SRMom::TrkMomRange(const Int_t eventNum,
                                 const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->momentum.range;
}

//____________________________________________________________________72
const Int_t SRMom::TrkNumPln(const Int_t eventNum,
                             const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1;
  }
  return srTrack->plane.n;
}

//____________________________________________________________________72
const Int_t SRMom::TrackNumStrips(const Int_t eventNum,
                                  const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1;
  }
  return srTrack->nstrip;
}

//____________________________________________________________________72
const NtpSRVertex* SRMom::TrkStartVtx(const Int_t eventNum,
                                     const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return 0;
  }
  return &(srTrack->vtx);
}

//____________________________________________________________________72
const Int_t SRMom::TrackVtxPlane(const Int_t eventNum,
                                 const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -1;
  }
  return srTrack->vtx.plane;
}

//____________________________________________________________________72
const Int_t SRMom::TrackVtxPlane(const NtpSRTrack* srTrack) const
{
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "Trying to find TrackEndX for a null track." << endl;
    return -1;
  }
  return srTrack->vtx.plane;
}

//____________________________________________________________________72
const Float_t SRMom::TrackVtxQOvP(const Int_t eventNum,
                                  const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->momentum.qp;
}

//____________________________________________________________________72
const Float_t SRMom::TrackVtxQOvP(const NtpSRTrack* srTrack) const
{
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack given to SRMom::TrackVtxQOvP" << endl;
    return -999999.9;
  }
  return srTrack->momentum.qp;
}

//____________________________________________________________________72
const Float_t SRMom::TrackVtxQOvPError(const Int_t eventNum,
                                       const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->momentum.eqp;
}

//____________________________________________________________________72
const Float_t SRMom::TrkVtxR(const Int_t eventNum,
                             const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  Float_t x = srTrack->vtx.x;
  Float_t y = srTrack->vtx.y;
  Float_t r = sqrt(x*x + y*y);
  return r;
}

//____________________________________________________________________72
const Float_t SRMom::TrackVtxX(const Int_t eventNum,
                               const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->vtx.x;
}

//____________________________________________________________________72
const Float_t SRMom::TrackVtxY(const Int_t eventNum,
                               const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->vtx.y;
}

//____________________________________________________________________72
const Float_t SRMom::TrackVtxZ(const Int_t eventNum,
                               const Int_t trackNum) const
{
  const NtpSRTrack* srTrack = this->SRTrack(eventNum, trackNum);
  if (!srTrack){
    MSG("SRMom",Msg::kWarning)
      << "No NtpSRTrack number " << trackNum
      << " in event number " << eventNum << endl;
    return -999999.9;
  }
  return srTrack->vtx.z;
}

//____________________________________________________________________72
const VldContext* SRMom::VldCntxt() const
{
  if (!fstRecord){
    return 0;
  }
  return fstRecord->GetVldContext();
}

//Jeff's Cuts:
/*
//____________________________________________________________________72
const Bool_t SRMom::VtxInPittFidVol(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return false;
  }
  const NuCuts cuts;
  return cuts.IsInPittFidVol(EventVtxX(eventNum),
                             EventVtxY(eventNum),
                             EventVtxZ(eventNum),
                             EventVtxU(eventNum),
                             EventVtxV(eventNum));
}

//____________________________________________________________________72
const Bool_t SRMom::GoodBeyondTrackEnd(const Int_t eventNum) const
{
  const NtpSREvent* srEvent = this->SREvent(eventNum);
  if(!srEvent){
    MSG("SRMom",Msg::kWarning) 
      << "No NtpSREvent with event number " << eventNum << endl;
    return false;
  }
  const NuCuts cuts;
  return cuts.IsGoodBeyondTrkEnd(*fstRecord,
                                 *srEvent);
}

//____________________________________________________________________72
const Bool_t SRMom::GoodUVVtx(const Int_t eventNum,
                              const Int_t trackNum) const
{
  if (!fstRecord){return 0;}
  const NuCuts cuts;
  return cuts.IsGoodUVVtx(*fstRecord,
                          *SREvent(eventNum),
                          *SRTrack(eventNum,trackNum));
}
*/

---