NumuCCIncBins.h

Go to the documentation of this file.

#pragma once

#include "CAFAna/Core/Binning.h"

namespace ana
{

  // binning for scattering LL in remid
  const Binning scatbins = Binning::Simple(100,-0.45, 0.45);
  
  // binning for dedx LL in remid
  const Binning dEdXbins = Binning::Simple(100,-3.0, 1.0);

  // binning for energy per length
  const Binning ebylbins = Binning::Simple(100,0,0.006);

  // binning for x or y coordinate
  const Binning xybins   = Binning::Simple(20,-200,200);

  // binning for z coordinate
  const Binning zbins    = Binning::Simple(80,0 ,1600);

  // binning for energy
  const Binning ebins    = Binning::Simple(50,0,5);

  // binning for muon transverse momentum
  const Binning ptbins   = Binning::Simple(30,0,1.5);


  // binning for resolution
  const Binning resbins  = Binning::Simple(101,-1.005,1.005);

  // binning for zoom costheta
  const Binning angzoombins  = Binning::Simple(101,0.895,1.005);

  // binning for costheta
  const Binning angbins  = Binning::Simple(101,-1.005,1.005);

  // binning for efficiency
  const Binning effbins  = Binning::Simple(101,-0.005,1.005);

  // binning for energy resolution vs energy, 2d
  const Binning resebins = Binning::Simple(ebins.NBins()*resbins.NBins(),
                                     0,
                                     ebins.NBins()*resbins.NBins());

  // binning for costheta resolution vs costheta, 2d
  const Binning rescosthetabins = Binning::Simple(angzoombins.NBins()*resbins.NBins(),
                                            0,
                                            angzoombins.NBins()*resbins.NBins());

  // binning for remid
  const Binning remidbins       = Binning::Simple(81, -1/160., 1+1/160.);

  // binning for momentum vs costheta, 2d
  const Binning pvsthetabins    = Binning::Simple(ebins.NBins()*angbins.NBins(),
                                            0, ebins.NBins()*angbins.NBins());

  // binning for pt vs pz, 2d
  const Binning ptvspzbins      = Binning::Simple(ebins.NBins()*ebins.NBins(),
                                            0, ebins.NBins()*ebins.NBins());


  //-----------------------------------------------------------------------------------
  // Standard analysis binning

  // bin edges for custom binning in costheta, allowing unphysical and outside our phasespace
  const std::vector<double> angedges {-1.0, 0.5, 0.56, 0.62, 0.68, 0.74, 0.80, 0.85, 0.88, 0.91, 0.94, 0.96, 0.98, 0.99, 1.0};
  const std::vector<double> angedges_display {0.5, 0.56, 0.62, 0.68, 0.74, 0.80, 0.85, 0.88, 0.91, 0.94, 0.96, 0.98, 0.99, 1.0};

  // custom binning for costheta
  const Binning angbinsCustom = Binning::Custom(angedges);
  const Binning angbinsDisplay = Binning::Custom(angedges_display);

  // bin edges for custom binning in muon KE, allowing unphysical and outside our phasespace
  const std::vector<double> mukeedges {-10.0,
                                        0.5, 0.6, 0.7, 0.8, 0.9,
                                        1.0, 1.1, 1.2, 1.3, 1.4,
                                        1.5, 1.6, 1.7, 1.8, 1.9,
                                        2.0, 2.1, 2.2, 2.3, 2.4,
                                        2.5, 120};
  const std::vector<double> mukeedges_display {
                                        0.5, 0.6, 0.7, 0.8, 0.9,
                                        1.0, 1.1, 1.2, 1.3, 1.4,
                                        1.5, 1.6, 1.7, 1.8, 1.9,
                                        2.0, 2.1, 2.2, 2.3, 2.4,
                                        2.5};

  // Custom binning for muon Kinetic Energy
  const Binning mukebins   = Binning::Custom(mukeedges);
  const Binning mukebinsDisplay   = Binning::Custom(mukeedges_display);

  // bin edges for custom binning in neutrino energy
  const std::vector<double> enuedges { -10,
                                        0.0, 0.25, 0.50, 0.75,
                                        1.0, 1.25, 1.50, 1.75,
                                        2.0, 2.25, 2.50, 2.75,
                                        3.0, 3.25, 3.50, 3.75,
                                        4.0, 4.25, 4.50, 4.75,
                                        5.0, 120};
  const std::vector<double> enuedges_display {
                                        0.0, 0.25, 0.50, 0.75,
                                        1.0, 1.25, 1.50, 1.75,
                                        2.0, 2.25, 2.50, 2.75,
                                        3.0, 3.25, 3.50, 3.75,
                                        4.0, 4.25, 4.50, 4.75,
                                        5.0};
  // Custom binning for Neutrino Energy
  const Binning enubins   = Binning::Custom(enuedges);
  const Binning enubinsDisplay   = Binning::Custom(enuedges_display);


  // bin edges for custom binning in neutrino energy
  const std::vector<double> eavailedges {
                                        0.0, 0.25, 0.50, 0.75,
                                        1.0, 1.25, 1.50, 1.75,
                                        2.0, 2.25, 2.50, 120};
  const std::vector<double> eavailedges_display {
                                        0.0, 0.25, 0.50, 0.75,
                                        1.0, 1.25, 1.50, 1.75,
                                        2.0, 2.25, 2.50};
  // Custom binning for Neutrino Energy
  const Binning eavailbins   = Binning::Custom(eavailedges);
  const Binning eavailbinsDisplay   = Binning::Custom(eavailedges_display);

  // custom binning for costheta vs momentum, 2d
  const Binning angvsmukebins = Binning::Simple(mukebins.NBins()*
                                                angbinsCustom.NBins(),
                                                0,
                                                mukebins.NBins()*
                                                angbinsCustom.NBins());  
  
  const Binning angvsmukevsebins = Binning::Simple(mukebins.NBins()*
                                                   angbinsCustom.NBins()*
                                                   enubins.NBins(),
                                                   0,
                                                   mukebins.NBins()*
                                                   angbinsCustom.NBins()*
                                                   enubins.NBins());

  const Binning angvsmukevseavailbins = Binning::Simple(mukebins.NBins()*
               angbinsCustom.NBins()*
               eavailbins.NBins(),
               0,
               mukebins.NBins()*
               angbinsCustom.NBins()*
               eavailbins.NBins());

  const std::vector<double> q2edges {
    0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.40, 0.50, 0.60, 0.75, 0.90, 1.10, 1.40, 1.80, 2.8, 120.
  };

  const Binning q2bins = Binning::Custom(q2edges);

  // Binning for Energy Estimation
  const Binning kMuonEActBinning  = Binning::Simple(150, 0,  5);
  const Binning kHadEnergyBinning = Binning::Simple(150, 0,  5);
  const Binning kTrkLenActBinning = Binning::Simple(160, 0, 16);
  const Binning kTrkLenCatBinning = Binning::Simple(150, 0,  4);
  const Binning kMuonECatBinning  = Binning::Simple(150, 0,  3);
  const Binning kVisHadEBinning   = Binning::Simple(150., 0.,2.);
}