ComparisonHints.h

Go to the documentation of this file.

#include "CAFAna/Core/Binning.h"
#include "CAFAna/Core/Var.h"

#include "3FlavorAna/Vars/NumuVars.h"

#include "StandardRecord/Proxy/SRProxy.h"
#include "3FlavorAna/Vars/NumuVars.h"

// --- Define the height / widht of the detector.
const float XMinEx = -758.;
const float XMaxEx =  765.;
const float YMinEx = -749.;
const float YMaxEx =  765.;
// --- Center pos.
const float XCent = XMinEx + ((XMaxEx-XMinEx)/2);
const float YCent = YMinEx + ((YMaxEx-YMinEx)/2);

namespace ana {

  // ******* Define some bin sets which I want to use *******
  const unsigned int NumBins = 100;
  const Binning NumHitBins = Binning::Simple(NumBins, 0    , 1000 );
  const Binning RatioBins  = Binning::Simple(NumBins, 0    , 1.01 );
  const Binning CompBins   = Binning::Simple(NumBins, -1.01, 1.01 );
  const Binning CompZBins  = Binning::Simple(NumBins, -0.5 , 0.5  );
  // Energy bins
  const Binning EnergyBins = Binning::Simple(NumBins, 0    , 5    );
  const Binning LowEnBins  = Binning::Simple(NumBins, 0    , 3    );
  const Binning EnPHitBins = Binning::Simple(NumBins, 0    , 0.1  );
  const Binning RangeBins  = Binning::Simple(NumBins, -0.2 , 0.2  );
  const Binning SmallBins  = Binning::Simple(NumBins, 0    , 0.02 );
  const Binning TinyBins   = Binning::Simple(NumBins, 0    , 0.002);
  // Length / hit bins
  const Binning NumTrkBins = Binning::Simple(11     , -0.5 , 10   );
  const Binning YRangeBins = Binning::Simple(NumBins, -8   , 8    );
  const Binning ZRangeBins = Binning::Simple(NumBins, -0.1 , 60.1 );
  const Binning LengthBins = Binning::Simple(NumBins, 0    , 20   );
  const Binning CellsBins  = Binning::Simple(NumBins, 0    , 1000 );
  // Time bins
  const Binning TimeFBins  = Binning::Simple(NumBins, 0  , 550 );
  const Binning TimeZBins  = Binning::Simple(NumBins, 200, 250 );

  // ********** Define my Positional cuts **********

  // Y inc
  // ^
  // | TL   TR  
  // |
  // | BL   BR
  //   ------> X inc
  // If Y is positive and X is negative.
  const Cut kW_TL( [](const caf::SRProxy* sr) {
      bool IsTrue = ( sr->trk.kalman.tracks[0].start.X() < XCent &&
                      sr->trk.kalman.tracks[0].start.Y() > YCent );
      /*
      std::cout << "\nStartX is " << sr->trk.kalman.tracks[0].start.X() << " StartY is " << sr->trk.kalman.tracks[0].start.Y() 
                << "\t...\tXCent is " << XCent << " && YCent is " << YCent << "\n"
                << "\tInkW_TL ==> IsTrue " << IsTrue << std::endl;
      */
      return IsTrue;
    });
  // If Y is positive and X is positive.
  const Cut kW_TR( [](const caf::SRProxy* sr) {
      bool IsTrue ( sr->trk.kalman.tracks[0].start.X() > XCent &&
                    sr->trk.kalman.tracks[0].start.Y() > YCent );
      //std::cout << "\tIn kW_TR ==> IsTrue " << IsTrue << std::endl;
      return IsTrue;
    });
  // If Y is negative and X is negative.
  const Cut kW_BL( [](const caf::SRProxy* sr) {
      bool IsTrue ( sr->trk.kalman.tracks[0].start.X() < XCent &&
                    sr->trk.kalman.tracks[0].start.Y() < YCent );
      //std::cout << "\tIn kW_BL ==> IsTrue " << IsTrue << std::endl;
      return IsTrue;
    });
  // If Y is negative and X is positive.
  const Cut kW_BR( [](const caf::SRProxy* sr) {
      bool IsTrue ( sr->trk.kalman.tracks[0].start.X() > XCent &&
                    sr->trk.kalman.tracks[0].start.Y() < YCent );
      //std::cout << "\tIn kW_BR ==> IsTrue " << IsTrue << std::endl;
      return IsTrue;
    });

  // ************** Define my additional Vars **************
  // --- The Reco - True / True neutrino energy
  const Var kRTOvTNuE = ( (kCCE-kTrueE)/kTrueE );
  // --- The most forward Kalman track hit cell.
  const Var kKalFwdCell( [](const caf::SRProxy* sr) { return sr->sel.contain.kalfwdcell; });
  // --- The most backward Kalman track hit cell.
  const Var kKalBakCell( [](const caf::SRProxy* sr) { return sr->sel.contain.kalbakcell; });
  // --- The highest Y vertex of Kalman track.
  const Var kMaxKalYPos( [](const caf::SRProxy* sr) {
      if(sr->trk.kalman.ntracks < 1) return -10.0f;
      return std::max( sr->trk.kalman.tracks[0].start.Y()/100, 
                       sr->trk.kalman.tracks[0].stop.Y()/100 );
    });
  // --- The highest Z vertex of Kalman track.
  const Var kMaxKalZPos( [](const caf::SRProxy* sr) {
      if(sr->trk.kalman.ntracks < 1) return -10.0f;
      return std::max( sr->trk.kalman.tracks[0].start.Z()/100, 
                       sr->trk.kalman.tracks[0].stop.Z()/100 );
    });
  // --- Scattering over track length
  const Var kScattTrLen( [](const caf::SRProxy* sr) {
      if(sr->trk.kalman.ntracks < 1) return -10.0f;
      return (float)((float)sr->sel.cosrej.scatt / (float)sr->trk.kalman.tracks[0].len);
    });
  // --- Min Proj cells to edge
  const Var kMinCellEdg( [](const caf::SRProxy* sr) {
      return std::min((sr->sel.contain.kalfwdcell + sr->sel.contain.kalbakcell),
                      (sr->sel.contain.cosfwdcell + sr->sel.contain.cosbakcell));
    });
  // --- Ratio of kalman hits in slice.
  const Var kRatOfKalHi( [](const caf::SRProxy* sr) {
      if(sr->trk.kalman.ntracks < 1) return -10.0f;
      return (float)((float)sr->trk.kalman.tracks[0].nhit / (float)sr->slc.nhit);
    });
  // --- The Second analysis BDT result
  const Var kSANumuContPID( [](const caf::SRProxy* sr) { return sr->sel.cosrej.numuSAcontpid; });
  // --- The first hit cell.
  const Var kFirstCell( [](const caf::SRProxy* sr) { return sr->slc.firstcell; });  
  // --- The last hit cell.
  const Var kLastCell ( [](const caf::SRProxy* sr) { return sr->slc.lastcell;  });

  // *** Some more plots from Alex
  // Slice.
  // --- The Vis En in the slice
  const Var kVisESlc( [](const caf::SRProxy* sr) { return sr->slc.calE; });
  // --- The Num.Hits in the slic
  const Var kNHitSlc( [](const caf::SRProxy* sr) { return sr->slc.nhit; });
  // --- Visibile E per hit in sl
  const Var kEnPHSlc( [](const caf::SRProxy* sr) { if(sr->slc.nhit < 1) return -10.0f; return (float)(sr->slc.calE) / (float)(1.78*sr->slc.nhit); });
  // Track.
  // --- The Vis En of the track
  const Var kVisETrk( [](const caf::SRProxy* sr) { if(sr->trk.kalman.ntracks < 1) return -10.0f; return (float)sr->trk.kalman.tracks[0].calE; });
  // --- The NumHits in the track
  const Var kNHitTrk( [](const caf::SRProxy* sr) { if(sr->trk.kalman.ntracks < 1) return -10.0f; return (float)sr->trk.kalman.tracks[0].nhit; });
  // --- Visibile E PerHit in trk
  const Var kEnPHTrk( [](const caf::SRProxy* sr) { 
      if(sr->trk.kalman.ntracks < 1) return -10.0f; 
      return (float)(sr->trk.kalman.tracks[0].calE) / (float)(1.78 * sr->trk.kalman.tracks[0].nhit); });
  // Hadronic energy
  // --- The Hadronic Vis Energy
  const Var kVisEHad( [](const caf::SRProxy* sr) { if(sr->trk.kalman.ntracks < 1) return -10.0f; return (float)(sr->slc.calE - sr->trk.kalman.tracks[0].calE); });
  // --- The Num.Hits in the slic
  const Var kNHitHad( [](const caf::SRProxy* sr) { if(sr->trk.kalman.ntracks < 1) return -10.0f; return (float)(sr->slc.nhit - sr->trk.kalman.tracks[0].nhit); });
  // --- Visibile E per hit in sl
  const Var kEnPHHad( [](const caf::SRProxy* sr) { 
      if(sr->trk.kalman.ntracks < 1) return -10.0f;
      return (float)(sr->slc.calE - sr->trk.kalman.tracks[0].calE) / (float)(1.78 * (sr->slc.nhit - sr->trk.kalman.tracks[0].nhit) );
    });

  // --- The difference in XY Track Length
  const Var kTrkLenXY( [](const caf::SRProxy* sr) {
      if(sr->trk.kalman.ntracks < 1) return -10.0f;
      float XLen = ( sr->trk.kalman.tracks[0].start.X() - sr->trk.kalman.tracks[0].stop.X() ) /100;
      float YLen = ( sr->trk.kalman.tracks[0].start.Y() - sr->trk.kalman.tracks[0].stop.Y() ) /100;
      return XLen - YLen;
    });

  // --- The True Hadronic Energy
  const Var kTrueHadE = ( kTrueE - kTrueMuonE );
  // --- The True Hadronic Energy Fraction
  const Var kTrueHFrE( [](const caf::SRProxy* sr) {
      float HadE = kTrueHadE(sr);
      float TruE = kTrueE(sr);
      return ( HadE / TruE );
    });
}