TrackEff2Selector.C

Go to the documentation of this file.

#define TrackEff2Selector_cxx
// The class definition in TrackEff2Selector.h has been generated automatically
// by the ROOT utility TTree::MakeSelector(). This class is derived
// from the ROOT class TSelector. For more information on the TSelector
// framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.

// The following methods are defined in this file:
//    Begin():        called every time a loop on the tree starts,
//                    a convenient place to create your histograms.
//    SlaveBegin():   called after Begin(), when on PROOF called only on the
//                    slave servers.
//    Process():      called for each event, in this function you decide what
//                    to read and fill your histograms.
//    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
//                    called only on the slave servers.
//    Terminate():    called at the end of the loop on the tree,
//                    a convenient place to draw/fit your histograms.
//
// To use this file, try the following session on your Tree T:
//
// Root > T->Process("TrackEff2Selector.C")
// Root > T->Process("TrackEff2Selector.C","some options")
// Root > T->Process("TrackEff2Selector.C+")
//

#include "TrackEff2Selector.h"
#include <TH2.h>
#include <TStyle.h>


void TrackEff2Selector::Begin(TTree * /*tree*/)
{
   // The Begin() function is called at the start of the query.
   // When running with PROOF Begin() is only called on the client.
   // The tree argument is deprecated (on PROOF 0 is passed).

   TString option = GetOption();

   dOutputFile = new TFile("dh_TrackEff2Hists.root", "RECREATE");

   unsigned int locNumPBins = 100;
   unsigned int locNumThetaBins = 140;
   unsigned int locNumDeltaPOverPBins = 1000;
   unsigned int locNumDeltaPtOverPtBins = 1000;
   unsigned int locNumDeltaThetaBins = 480;
   unsigned int locNumDeltaPhiBins = 800;
   unsigned int locNumConLevBins = 500;

   double locMinP = 0.0, locMaxP = 2.0;
   double locMinTheta = 0.0, locMaxTheta = 140.0;
   double locMinConLev = 0.0, locMaxConLev = 1.0;

   double locMinDeltaPOverP = -0.4, locMaxDeltaPOverP = 0.4; //more for wrong charge!
   double locMinDeltaPtOverPt = -0.4, locMaxDeltaPtOverPt = 0.4;
   double locMinDeltaTheta = -12.0, locMaxDeltaTheta = 12.0;
   double locMinDeltaPhi = -40.0, locMaxDeltaPhi = 40.0;

   double locMinDeltaPOverP_WrongCharge = -50.0, locMaxDeltaPOverP_WrongCharge = 50.0;
   double locMinDeltaPtOverPt_WrongCharge = -50.0, locMaxDeltaPtOverPt_WrongCharge = 50.0;
   double locMinDeltaTheta_WrongCharge = -360.0, locMaxDeltaTheta_WrongCharge = 360.0;
   double locMinDeltaPhi_WrongCharge = -360.0, locMaxDeltaPhi_WrongCharge = 360.0;

   //EFFICIENCIES
   dSelectorHist_TrackEff2_CandidateReconstructed = new TH2F("dSelectorHist_TrackEff2_CandidateReconstructed", "Reconstructed Track Candidates;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_CandidateMissing = new TH2F("dSelectorHist_TrackEff2_CandidateMissing", "Missing Track Candidates;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_WireBasedReconstructed = new TH2F("dSelectorHist_TrackEff2_WireBasedReconstructed", "Reconstructed Wire Based Tracks;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_WireBasedMissing = new TH2F("dSelectorHist_TrackEff2_WireBasedMissing", "Missing Wire Based Tracks;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_TimeBasedReconstructed = new TH2F("dSelectorHist_TrackEff2_TimeBasedReconstructed", "Reconstructed Time Based Tracks;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_TimeBasedMissing = new TH2F("dSelectorHist_TrackEff2_TimeBasedMissing", "Missing Time Based Tracks;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);

   dSelectorHist_TrackEff2_CandidateChargeCorrect = new TH2F("dSelectorHist_TrackEff2_CandidateChargeCorrect", "Correct Charge Track Candidates;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_CandidateChargeWrong = new TH2F("dSelectorHist_TrackEff2_CandidateChargeWrong", "Incorrect Charge Track Candidates;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_WireBasedChargeCorrect = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeCorrect", "Correct Charge Wire Based Tracks;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_WireBasedChargeWrong = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeWrong", "Incorrect Charge Wire Based Tracks;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_TimeBasedChargeCorrect = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeCorrect", "Correct Charge Time Based Tracks;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_TimeBasedChargeWrong = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeWrong", "Incorrect Charge Time Based Tracks;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);

   //CONFIDENCE LEVEL
   dSelectorHist_TrackEff2_WireBasedConLev = new TH1F("dSelectorHist_TrackEff2_WireBasedConLev", "Correct Charge Wire Based Tracks;Wire Based Track Reconstruction Confidence Level", locNumConLevBins, locMinConLev, locMaxConLev);
   dSelectorHist_TrackEff2_TimeBasedConLev = new TH1F("dSelectorHist_TrackEff2_TimeBasedConLev", "Correct Charge Time Based Tracks;Time Based Track Reconstruction Confidence Level", locNumConLevBins, locMinConLev, locMaxConLev);
   dSelectorHist_TrackEff2_WireBasedLowConLev = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeCorrectLowConLev", "Correct Charge Wire Based Tracks, Confidence Level <= 0.01;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_WireBasedNonLowConLev = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeCorrectNonLowConLev", "Correct Charge Wire Based Tracks, Confidence Level > 0.01;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_TimeBasedLowConLev = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeCorrectLowConLev", "Correct Charge Time Based Tracks, Confidence Level <= 0.01;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   dSelectorHist_TrackEff2_TimeBasedNonLowConLev = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeCorrectNonLowConLev", "Correct Charge Time Based Tracks, Confidence Level > 0.01;#theta#circ;p (GeV/c)", locNumThetaBins, locMinTheta, locMaxTheta, locNumPBins, locMinP, locMaxP);
   

   //CHARGE RECONSTRUCTION DETAIL
   dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPOverPVsTheta = new TH2F("dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPOverPVsTheta", "Correct Charge Track Candidates;#theta#circ;#Deltap/p", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPOverPBins, locMinDeltaPOverP, locMaxDeltaPOverP);
   dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPOverPVsTheta = new TH2F("dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPOverPVsTheta", "Incorrect Charge Track Candidates;#theta#circ;#Deltap/p", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPOverPBins, locMinDeltaPOverP_WrongCharge, locMaxDeltaPOverP_WrongCharge);
   dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPOverPVsTheta = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPOverPVsTheta", "Correct Charge Wire Based Tracks;#theta#circ;#Deltap/p", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPOverPBins, locMinDeltaPOverP, locMaxDeltaPOverP);
   dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPOverPVsTheta = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPOverPVsTheta", "Incorrect Charge Wire Based Tracks;#theta#circ;#Deltap/p", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPOverPBins, locMinDeltaPOverP_WrongCharge, locMaxDeltaPOverP_WrongCharge);
   dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPOverPVsTheta = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPOverPVsTheta", "Correct Charge Time Based Tracks;#theta#circ;#Deltap/p", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPOverPBins, locMinDeltaPOverP, locMaxDeltaPOverP);
   dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPOverPVsTheta = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPOverPVsTheta", "Incorrect Charge Time Based Tracks;#theta#circ;#Deltap/p", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPOverPBins, locMinDeltaPOverP_WrongCharge, locMaxDeltaPOverP_WrongCharge);

   dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPtOverPtVsTheta = new TH2F("dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPtOverPtVsTheta", "Correct Charge Track Candidates;#theta#circ;#Deltap_{T}/p_{T}", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPtOverPtBins, locMinDeltaPtOverPt, locMaxDeltaPtOverPt);
   dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPtOverPtVsTheta = new TH2F("dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPtOverPtVsTheta", "Incorrect Charge Track Candidates;#theta#circ;#Deltap_{T}/p_{T}", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPtOverPtBins, locMinDeltaPtOverPt_WrongCharge, locMaxDeltaPtOverPt_WrongCharge);
   dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPtOverPtVsTheta = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPtOverPtVsTheta", "Correct Charge Wire Based Tracks;#theta#circ;#Deltap_{T}/p_{T}", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPtOverPtBins, locMinDeltaPtOverPt, locMaxDeltaPtOverPt);
   dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPtOverPtVsTheta = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPtOverPtVsTheta", "Incorrect Charge Wire Based Tracks;#theta#circ;#Deltap_{T}/p_{T}", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPtOverPtBins, locMinDeltaPtOverPt_WrongCharge, locMaxDeltaPtOverPt_WrongCharge);
   dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPtOverPtVsTheta = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPtOverPtVsTheta", "Correct Charge Time Based Tracks;#theta#circ;#Deltap_{T}/p_{T}", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPtOverPtBins, locMinDeltaPtOverPt, locMaxDeltaPtOverPt);
   dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPtOverPtVsTheta = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPtOverPtVsTheta", "Incorrect Charge Time Based Tracks;#theta#circ;#Deltap_{T}/p_{T}", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPtOverPtBins, locMinDeltaPtOverPt_WrongCharge, locMaxDeltaPtOverPt_WrongCharge);

   dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaThetaVsTheta = new TH2F("dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaThetaVsTheta", "Correct Charge Track Candidates;#theta#circ;#Delta#theta#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaThetaBins, locMinDeltaTheta, locMaxDeltaTheta);
   dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaThetaVsTheta = new TH2F("dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaThetaVsTheta", "Incorrect Charge Track Candidates;#theta#circ;#Delta#theta#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaThetaBins, locMinDeltaTheta_WrongCharge, locMaxDeltaTheta_WrongCharge);
   dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaThetaVsTheta = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaThetaVsTheta", "Correct Charge Wire Based Tracks;#theta#circ;#Delta#theta#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaThetaBins, locMinDeltaTheta, locMaxDeltaTheta);
   dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaThetaVsTheta = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaThetaVsTheta", "Incorrect Charge Wire Based Tracks;#theta#circ;#Delta#theta#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaThetaBins, locMinDeltaTheta_WrongCharge, locMaxDeltaTheta_WrongCharge);
   dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaThetaVsTheta = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaThetaVsTheta", "Correct Charge Time Based Tracks;#theta#circ;#Delta#theta#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaThetaBins, locMinDeltaTheta, locMaxDeltaTheta);
   dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaThetaVsTheta = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaThetaVsTheta", "Incorrect Charge Time Based Tracks;#theta#circ;#Delta#theta#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaThetaBins, locMinDeltaTheta_WrongCharge, locMaxDeltaTheta_WrongCharge);

   dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPhiVsTheta = new TH2F("dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPhiVsTheta", "Correct Charge Track Candidates;#theta#circ;#Delta#phi#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPhiBins, locMinDeltaPhi, locMaxDeltaPhi);
   dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPhiVsTheta = new TH2F("dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPhiVsTheta", "Incorrect Charge Track Candidates;#theta#circ;#Delta#phi#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPhiBins, locMinDeltaPhi_WrongCharge, locMaxDeltaPhi_WrongCharge);
   dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPhiVsTheta = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPhiVsTheta", "Correct Charge Wire Based Tracks;#theta#circ;#Delta#phi#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPhiBins, locMinDeltaPhi, locMaxDeltaPhi);
   dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPhiVsTheta = new TH2F("dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPhiVsTheta", "Incorrect Charge Wire Based Tracks;#theta#circ;#Delta#phi#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPhiBins, locMinDeltaPhi_WrongCharge, locMaxDeltaPhi_WrongCharge);
   dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPhiVsTheta = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPhiVsTheta", "Correct Charge Time Based Tracks;#theta#circ;#Delta#phi#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPhiBins, locMinDeltaPhi, locMaxDeltaPhi);
   dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPhiVsTheta = new TH2F("dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPhiVsTheta", "Incorrect Charge Time Based Tracks;#theta#circ;#Delta#phi#circ", locNumThetaBins, locMinTheta, locMaxTheta, locNumDeltaPhiBins, locMinDeltaPhi_WrongCharge, locMaxDeltaPhi_WrongCharge);
}

void TrackEff2Selector::SlaveBegin(TTree * /*tree*/)
{
   // The SlaveBegin() function is called after the Begin() function.
   // When running with PROOF SlaveBegin() is called on each slave server.
   // The tree argument is deprecated (on PROOF 0 is passed).

   TString option = GetOption();

}

Bool_t TrackEff2Selector::Process(Long64_t entry)
{
   // The Process() function is called for each entry in the tree (or possibly
   // keyed object in the case of PROOF) to be processed. The entry argument
   // specifies which entry in the currently loaded tree is to be processed.
   // It can be passed to either TrackEff2Selector::GetEntry() or TBranch::GetEntry()
   // to read either all or the required parts of the data. When processing
   // keyed objects with PROOF, the object is already loaded and is available
   // via the fObject pointer.
   //
   // This function should contain the "body" of the analysis. It can contain
   // simple or elaborate selection criteria, run algorithms on the data
   // of the event and typically fill histograms.
   //
   // The processing can be stopped by calling Abort().
   //
   // Use fStatus to set the return value of TTree::Process().
   //
   // The return value is currently not used.


/*
   if(isreconstructable == false)
      return kTRUE; //not interested...
*/

   GetEntry(entry);
   if((entry % 1000) == 0)
      cout << "entry = " << entry << endl;

   TVector3 locP3_Thrown(pthrown_fX, pthrown_fY, pthrown_fZ);
   TVector3 locP3_TimeBased(pfit_fX, pfit_fY, pfit_fZ);
   TVector3 locP3_WireBased(pfit_wire_fX, pfit_wire_fY, pfit_wire_fZ);
   TVector3 locP3_Candidate(pcan_fX, pcan_fY, pcan_fZ);
   double locThrownTheta_Degrees = locP3_Thrown.Theta()*180.0/TMath::Pi();
   double locThrownMomentum = locP3_Thrown.Mag();
   double delta_p_over_p_can = (locP3_Candidate.Mag() - locThrownMomentum)/locThrownMomentum;
   double delta_p_over_p_wire = (locP3_WireBased.Mag() - locThrownMomentum)/locThrownMomentum;
   double delta_p_over_p = (locP3_TimeBased.Mag() - locThrownMomentum)/locThrownMomentum;
   double locFOM_WireBased = TMath::Prob(trk_chisq_wb, trk_Ndof_wb);
   double locFOM_TimeBased = TMath::Prob(trk_chisq, trk_Ndof);
   double locFOM_Cutoff = 0.01;
   double delta_phi_can_deg = delta_phi_can*180.0/(1000.0*TMath::Pi());
   double delta_phi_wire_deg = delta_phi_wire*180.0/(1000.0*TMath::Pi());
   double delta_phi_deg = delta_phi*180.0/(1000.0*TMath::Pi());
   double delta_theta_can_deg = delta_theta_can*180.0/(1000.0*TMath::Pi());
   double delta_theta_wire_deg = delta_theta_wire*180.0/(1000.0*TMath::Pi());
   double delta_theta_deg = delta_theta*180.0/(1000.0*TMath::Pi());

   //TRACK RECONSTRUCTION EFFICIENCIES
   if(dTrackReconstructedFlag_Candidate == true)
      dSelectorHist_TrackEff2_CandidateReconstructed->Fill(locThrownTheta_Degrees, locThrownMomentum);
   else
      dSelectorHist_TrackEff2_CandidateMissing->Fill(locThrownTheta_Degrees, locThrownMomentum);
   if(dTrackReconstructedFlag_Candidate == true){
      if(dTrackReconstructedFlag_WireBased == true)
         dSelectorHist_TrackEff2_WireBasedReconstructed->Fill(locThrownTheta_Degrees, locThrownMomentum);
      else
         dSelectorHist_TrackEff2_WireBasedMissing->Fill(locThrownTheta_Degrees, locThrownMomentum);
   }
   if(dTrackReconstructedFlag_WireBased == true){
      if(dTrackReconstructedFlag_TimeBased == true)
         dSelectorHist_TrackEff2_TimeBasedReconstructed->Fill(locThrownTheta_Degrees, locThrownMomentum);
      else
         dSelectorHist_TrackEff2_TimeBasedMissing->Fill(locThrownTheta_Degrees, locThrownMomentum);
   }

   //CHARGE RECONSTRUCTION EFFICIENCIES
   if(dTrackReconstructedFlag_Candidate == true){
      if(fabs(q_thrown - q_candidate) < 0.1)
         dSelectorHist_TrackEff2_CandidateChargeCorrect->Fill(locThrownTheta_Degrees, locThrownMomentum);
      else
         dSelectorHist_TrackEff2_CandidateChargeWrong->Fill(locThrownTheta_Degrees, locThrownMomentum);
   }
   if(dTrackReconstructedFlag_WireBased == true){
      if(fabs(q_thrown - q_wirebased) < 0.1)
         dSelectorHist_TrackEff2_WireBasedChargeCorrect->Fill(locThrownTheta_Degrees, locThrownMomentum);
      else
         dSelectorHist_TrackEff2_WireBasedChargeWrong->Fill(locThrownTheta_Degrees, locThrownMomentum);
   }
   if(dTrackReconstructedFlag_TimeBased == true){
      if(fabs(q_thrown - q_timebased) < 0.1)
         dSelectorHist_TrackEff2_TimeBasedChargeCorrect->Fill(locThrownTheta_Degrees, locThrownMomentum);
      else
         dSelectorHist_TrackEff2_TimeBasedChargeWrong->Fill(locThrownTheta_Degrees, locThrownMomentum);
   }

   //CONFIDENCE LEVEL
   if((dTrackReconstructedFlag_WireBased == true) && (fabs(q_thrown - q_wirebased) < 0.1)){
      dSelectorHist_TrackEff2_WireBasedConLev->Fill(locFOM_WireBased);
      if(locFOM_WireBased <= locFOM_Cutoff)
         dSelectorHist_TrackEff2_WireBasedLowConLev->Fill(locThrownTheta_Degrees, locThrownMomentum);
      else
         dSelectorHist_TrackEff2_WireBasedNonLowConLev->Fill(locThrownTheta_Degrees, locThrownMomentum);
   }
   if((dTrackReconstructedFlag_TimeBased == true) && (fabs(q_thrown - q_timebased) < 0.1)){
      dSelectorHist_TrackEff2_TimeBasedConLev->Fill(locFOM_TimeBased);
      if(locFOM_TimeBased <= locFOM_Cutoff)
         dSelectorHist_TrackEff2_TimeBasedLowConLev->Fill(locThrownTheta_Degrees, locThrownMomentum);
      else
         dSelectorHist_TrackEff2_TimeBasedNonLowConLev->Fill(locThrownTheta_Degrees, locThrownMomentum);
   }

   //CHARGE MIS-RECONSTRUCTION DELTAS
   if(dTrackReconstructedFlag_Candidate == true){
      if(fabs(q_thrown - q_candidate) < 0.1){
         dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPOverPVsTheta->Fill(locThrownTheta_Degrees, delta_p_over_p_can);
         dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPtOverPtVsTheta->Fill(locThrownTheta_Degrees, delta_pt_over_pt_can);
         dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaThetaVsTheta->Fill(locThrownTheta_Degrees, delta_theta_can_deg);
         dSelectorHist_TrackEff2_CandidateChargeCorrect_DeltaPhiVsTheta->Fill(locThrownTheta_Degrees, delta_phi_can_deg);
      }else{
         dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPOverPVsTheta->Fill(locThrownTheta_Degrees, delta_p_over_p_can);
         dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPtOverPtVsTheta->Fill(locThrownTheta_Degrees, delta_pt_over_pt_can);
         dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaThetaVsTheta->Fill(locThrownTheta_Degrees, delta_theta_can_deg);
         dSelectorHist_TrackEff2_CandidateChargeWrong_DeltaPhiVsTheta->Fill(locThrownTheta_Degrees, delta_phi_can_deg);
      }
   }
   if(dTrackReconstructedFlag_WireBased == true){
      if(fabs(q_thrown - q_wirebased) < 0.1){
         dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPOverPVsTheta->Fill(locThrownTheta_Degrees, delta_p_over_p_wire);
         dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPtOverPtVsTheta->Fill(locThrownTheta_Degrees, delta_pt_over_pt_wire);
         dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaThetaVsTheta->Fill(locThrownTheta_Degrees, delta_theta_wire_deg);
         dSelectorHist_TrackEff2_WireBasedChargeCorrect_DeltaPhiVsTheta->Fill(locThrownTheta_Degrees, delta_phi_wire_deg);
      }else{
         dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPOverPVsTheta->Fill(locThrownTheta_Degrees, delta_p_over_p_wire);
         dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPtOverPtVsTheta->Fill(locThrownTheta_Degrees, delta_pt_over_pt_wire);
         dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaThetaVsTheta->Fill(locThrownTheta_Degrees, delta_theta_wire_deg);
         dSelectorHist_TrackEff2_WireBasedChargeWrong_DeltaPhiVsTheta->Fill(locThrownTheta_Degrees, delta_phi_wire_deg);
      }
   }
   if(dTrackReconstructedFlag_TimeBased == true){
      if(fabs(q_thrown - q_timebased) < 0.1){
         dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPOverPVsTheta->Fill(locThrownTheta_Degrees, delta_p_over_p);
         dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPtOverPtVsTheta->Fill(locThrownTheta_Degrees, delta_pt_over_pt);
         dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaThetaVsTheta->Fill(locThrownTheta_Degrees, delta_theta_deg);
         dSelectorHist_TrackEff2_TimeBasedChargeCorrect_DeltaPhiVsTheta->Fill(locThrownTheta_Degrees, delta_phi_deg);
      }else{
         dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPOverPVsTheta->Fill(locThrownTheta_Degrees, delta_p_over_p);
         dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPtOverPtVsTheta->Fill(locThrownTheta_Degrees, delta_pt_over_pt);
         dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaThetaVsTheta->Fill(locThrownTheta_Degrees, delta_theta_deg);
         dSelectorHist_TrackEff2_TimeBasedChargeWrong_DeltaPhiVsTheta->Fill(locThrownTheta_Degrees, delta_phi_deg);
      }
   }


/*
   //hist: deviation of measured values from true values at each level (in )

      bool dTrackReconstructedFlag_TimeBased;
      TVector3 pfit;
      double trk_chisq;
      int trk_Ndof;
      double delta_pt_over_pt;
      double delta_theta;  // mrad
      double delta_phi;    // mrad
      int num_timebased;


   Float_t         q_thrown;
   Int_t           PID_thrown;
   UInt_t          pthrown_fUniqueID;
   UInt_t          pthrown_fBits;
   Bool_t          isreconstructable;
   Int_t           Nstereo;
   Int_t           Ncdc;
   Int_t           Nfdc;
   Int_t           NLR_bad_stereo;
   Int_t           NLR_bad;
   Int_t           PID_hypothesized;
   Float_t         q_hypothesized;
   Float_t         FOM_hypothesized;
   Float_t         q_timebased;
   Int_t           PID_timebased;
   Bool_t          dTrackReconstructedFlag_TimeBased;
   Double_t        trk_chisq;
   Int_t           trk_Ndof;
   Double_t        delta_pt_over_pt;
   Double_t        delta_theta;
   Double_t        delta_phi;
   Int_t           num_timebased;
   Float_t         q_wirebased;
   Int_t           PID_wirebased;
   Bool_t          dTrackReconstructedFlag_WireBased;
   Double_t        trk_chisq_wb;
   Int_t           trk_Ndof_wb;
   Double_t        delta_pt_over_pt_wire;
   Double_t        delta_theta_wire;
   Double_t        delta_phi_wire;
   Int_t           num_wirebased;
   Float_t         q_candidate;
   Int_t           PID_candidate;
   Bool_t          dTrackReconstructedFlag_Candidate;
   Double_t        delta_pt_over_pt_can;
   Double_t        delta_theta_can;
   Double_t        delta_phi_can;
   Int_t           num_candidates;
*/
   return kTRUE;
}

void TrackEff2Selector::SlaveTerminate()
{
   // The SlaveTerminate() function is called after all entries or objects
   // have been processed. When running with PROOF SlaveTerminate() is called
   // on each slave server.

}

void TrackEff2Selector::Terminate()
{
   // The Terminate() function is the last function to be called during
   // a query. It always runs on the client, it can be used to present
   // the results graphically or save the results to file.

   dOutputFile->Write();
}