Oscillation analysis framework, runs over CAF files outside of ART. More...

Namespaces
	CosmicIdUtils

	Current
	Enumeration for interaction currents (CC/NC)

	ExampleAnalysis

	Flavors
	Enumeration of neutrino transition modes.

	SBNOsc

	Sign
	Enumeration for neutrino sign (neutrino/antineutrino)

Classes
class	TPCPurityInfoAna

class	NuFitPenalizer

class	Penalizer_GlbLike

class	NuFitPenalizerCDR

class	Penalizer_GlbLikeCDR

class	Fitter
	Perform MINUIT fits in one or two dimensions. More...

class	FitAxis
	Collect information describing the axis of a fit variable. More...

class	GradientDescent

class	MedianSurface

class	OscCalcNoHash
	Helper for Surface::FillSurfacePoint. More...

class	Surface
	Log-likelihood scan across two parameters. More...

class	Binning
	Represent the binning of a Spectrum's x-axis. More...

class	_Cut
	Template for Cut and SpillCut. More...

class	InstallHandlers

class	EnsembleRatio

class	EnsembleSpectrum

class	FileListSource
	Simple file source based on an explicit list provided by the user. More...

class	FileReducer
	Create smaller CAFs. More...

class	_HistAxis
	Collect information describing the x-axis of an analysis histogram. More...

class	HistCache
	Helper for Spectrum. More...

class	IFileSource
	Interface class for accessing ROOT files in sequence. More...

class	IFitVar
	Interface definition for fittable variables. More...

class	IConstrainedFitVar
	Base class for variables with constraints. Apply penalty outside range. More...

class	ISyst
	Encapsulate code to systematically shift a caf::StandardRecord. More...

class	Loaders
	Collection of SpectrumLoaders for many configurations. More...

class	MultiVar2DFunc
	Helper for MultiVar2D. More...

class	_MultiVar

class	OscCalcSterileApprox

class	OscCalcSterileApproxAdjustable

class	OscCurve
	Transition probability for any one channel as a function of energy. More...

class	OscillatableSpectrum
	Spectrum with true energy information, allowing it to be oscillated More...

class	ProfilerSupport
	Support for the –prof commandline option. More...

class	Progress
	A simple ascii-art progress bar. More...

class	Ratio
	Represent the ratio between two spectra. More...

class	ReweightableSpectrum
	Spectrum with the value of a second variable, allowing for reweighting More...

class	SAMProjectSource
	Fetch files from a pre-existing SAM project. More...

class	SAMQuerySource
	File source based on a SAM query or dataset (definition) More...

class	Spectrum
	Representation of a spectrum in any variable, with associated POT. More...

struct	CompareByID

class	CutVarCache
	Helper for HandleRecord. More...

class	SpectrumLoader
	Collaborates with Spectrum and OscillatableSpectrum to fill spectra from CAF files. More...

class	SpectrumLoaderBase
	Base class for the various types of spectrum loader. More...

class	NullLoader
	Dummy loader that doesn't load any files. More...

class	SystRegistry

class	SystShifts
	Simple record of shifts applied to systematic parameters. More...

class	ThreadPool
	A very simple thread pool for use by Surface. More...

class	DontAddDirectory
	Prevent histograms being added to the current directory. More...

class	IFDHSilent
	ifdh calls between construction and destruction produce no output More...

class	FloatingExceptionOnNaN
	Alter floating-point exception flag. More...

class	LLPerBinFracSystErr

class	Var2DFunc
	Helper for Var2D. More...

class	Var3DFunc
	Helper for Var3D. More...

class	_Var
	Most useful for combining weights. More...

class	WildcardSource
	File source based on a wildcard (glob) More...

class	CCFlavSel
	Helper for defining true CC event cuts. More...

class	NCFlavOrig
	Helper for defining true CC event cuts. More...

class	CountingExperiment
	Compare a data spectrum to MC expectation using only the event count. More...

class	GaussianConstraint
	A simple Gaussian constraint on an arbitrary IFitVar. More...

class	IExperiment
	Base class defining interface for experiments. More...

class	MultiExperiment
	Combine multiple component experiments. More...

class	MultiExperimentSBN
	Combine multiple component experiments. More...

class	RatioExperiment

class	ReactorExperiment
	Very simple model allowing inclusion of reactor constraints. More...

class	SingleSampleExperiment
	Compare a single data spectrum to the MC + cosmics expectation. More...

class	SolarConstraints
	Constraints on the parameters $\Delta m^2_{21}$ and $\sin^22\theta_{12}$ from solar experiments. More...

class	IExtrap
	Interface to extrapolation procedures. More...

class	TrivialExtrap
	"Extrapolation" that simply returns the MC prediction More...

class	IncrementalCholeskyDecomp

class	IPrediction
	Standard interface to all prediction techniques. More...

class	PredictionExtrap
	Take the output of an extrapolation and oscillate it as required. More...

class	IPredictionGenerator
	Given loaders and an MC shift, Generate() generates an IPrediction. More...

class	PredictionIncDirt
	Prediction summing detector and dirt components. More...

class	PredictionInterp
	Implements systematic errors by interpolation between shifted templates. More...

class	PredictionLinFit
	Parameterize a collection of universes as a function of the syst knobs. More...

class	PredictionNoExtrap
	Prediction that just uses one detector's MC, with no extrapolation. More...

class	NoExtrapPredictionGenerator

class	PredictionNoOsc
	Prediction that wraps a simple Spectrum. More...

class	NoOscPredictionGenerator

class	PredictionSBNExtrap
	TODO comment. More...

class	SBNExtrapGenerator

class	PredictionScaleComp
	Prediction broken down into arbitrary components whose scales can be varied independently. More...

class	BoosterFluxHadronSyst

struct	BoosterFluxHadronSystVector

class	EnergyScaleSyst

class	NuMIFluxSyst

class	UniverseWeight

class	SBNWeightSyst

class	SystComponentScale
	Uncertainty in the scale of a single component of the spectrum. More...

class	UniverseOracle

class	FitTheta13
	$\theta_{13}$ More...

class	FitSinSq2Theta13
	$\sin^22\theta_{13}$ More...

class	FitDeltaInPiUnits
	$\delta_{CP}/\pi$ More...

class	FitTheta23
	$\theta_{13}$ More...

class	FitSinSqTheta23
	$\sin^2\theta_{23}$ More...

class	FitSinSq2Theta23
	$\sin^22\theta_{23}$ More...

class	FitDmSq32
	$\Delta m^2_{32}$ More...

class	FitDmSq32Scaled
	$\Delta m^2_{32}\times10^3{\rm eV}^2$ More...

class	FitTanSqTheta12
	$\tan^2\theta_{12}$ More...

class	FitSinSq2Theta12
	$\sin^22\theta_{12}$ More...

class	FitDmSq21
	$\Delta m^2_{21}$ More...

class	FitRho
	$\rho$ More...

class	FitDmSq32Sterile
	$\Delta m^2_{32}$ More...

class	FitDmSq41Sterile
	$\Delta m^2_{41}$ More...

class	FitDmSq43Sterile
	$\Delta m^2_{43}$ More...

class	FitDelta13InPiUnitsSterile
	$\delta_{13}/\pi$ More...

class	FitDelta14InPiUnitsSterile
	$\delta_{13}/\pi$ More...

class	FitDelta24InPiUnitsSterile
	$\delta_{24}/\pi$ More...

class	FitTheta13Sterile
	$\theta_{13}$ More...

class	FitSinSqTheta13Sterile
	$\sin^2\theta_{13}$ More...

class	FitTheta23Sterile
	$\theta_{23}$ More...

class	FitSinSqTheta23Sterile
	$\sin^2\theta_{23}$ More...

class	FitTheta14Sterile
	$\theta_{14}$ More...

class	FitSinSqTheta14Sterile
	$\sin^2\theta_{14}$ More...

class	FitSinSq2Theta14Sterile
	$\sin^22\theta_{14}$ More...

class	FitTheta24Sterile
	$\theta_{24}$ More...

class	FitSinSqTheta24Sterile
	$\sin^2\theta_{24}$ More...

class	FitSinSq2Theta24Sterile
	$\sin^22\theta_{24}$ More...

class	FitTheta34Sterile
	$\theta_{34}$ More...

class	FitSinSqTheta34Sterile
	$\sin^2\theta_{34}$ More...

class	FitSinSq2Theta34Sterile
	$\sin^22\theta_{34}$ More...

class	FitTheta13InDegreesSterile
	$\theta_{13}$ More...

class	FitTheta23InDegreesSterile
	$\theta_{23}$ More...

class	FitTheta14InDegreesSterile
	$\theta_{14}$ More...

class	FitTheta24InDegreesSterile
	$\theta_{24}$ More...

class	FitTheta34InDegreesSterile
	$\theta_{34}$ More...

class	FitDmSqSterile
	$\Delta m^2$ More...

class	FluxTimesNuclei

class	ApaCrossCosmicIdAlg

class	CosmicIdAlg

class	CpaCrossCosmicIdAlg

class	CrtHitCosmicIdAlg

class	CrtTrackCosmicIdAlg

class	FiducialVolumeCosmicIdAlg

class	GeometryCosmicIdAlg

class	PandoraT0CosmicIdAlg

class	StoppingParticleCosmicIdAlg

class	PFPSliceValidation

Typedefs
typedef double(	ExposureFunc_t )(const caf::SRSpill *spill)

typedef _Cut< caf::SRSliceProxy >	SliceCut
	Representation of a cut (selection) to be applied to a caf::StandardRecord object. More...

typedef _Cut< caf::SRSliceProxy >	Cut

typedef _Cut< caf::SRSpillProxy >	SpillCut
	Equivalent of Cut acting on caf::SRSpill. For use in spill-by-spill data quality cuts. More...

typedef _Cut < caf::SRSpillTruthBranch >	SpillTruthCut
	Cut designed to be used over the nuTree, ie all neutrinos, not just those that got slices. More...

typedef _HistAxis< Var >	HistAxis

typedef _HistAxis< SpillVar >	SpillHistAxis

typedef _MultiVar < caf::SRSliceProxy >	MultiVar

typedef _MultiVar < caf::SRSpillProxy >	SpillMultiVar

typedef _Var< caf::SRSliceProxy >	Var
	Representation of a variable to be retrieved from a caf::StandardRecord object. More...

typedef _Var< caf::SRSpillProxy >	SpillVar
	Equivalent of Var acting on caf::SRSpill. More...

Enumerations
enum	SterileOscAngles { SterileOscAngles::kNone = 0, SterileOscAngles::kSinSq2ThetaMuMu = 1, SterileOscAngles::kSinSq2ThetaMuE = (1 << 1), SterileOscAngles::kSinSq2ThetaEE = (1 << 2) }

enum	DataSource { kBeam, kCosmic }
	Is this data-file representing beam spills or cosmic spills? More...

enum	EBinType { kBinContent, kBinDensity }

enum	EExposureType { kPOT, kLivetime }
	For use as an argument to Spectrum::ToTH1. More...

enum	EnergyScaleSystTerm { EnergyScaleSystTerm::kConstant, EnergyScaleSystTerm::kSqrt, EnergyScaleSystTerm::kInverseSqrt }

enum	EnergyScaleSystParticle { EnergyScaleSystParticle::kMuon, EnergyScaleSystParticle::kHadron, EnergyScaleSystParticle::kNeutron, EnergyScaleSystParticle::kEM, EnergyScaleSystParticle::kChargedHadron }

enum	EnergyScaleSystDetector { EnergyScaleSystDetector::kSBND, EnergyScaleSystDetector::kMicroBooNE, EnergyScaleSystDetector::kICARUS, EnergyScaleSystDetector::kAll }

enum	ESide { ESide::kAbove, ESide::kBelow, ESide::kEither }
	Desired match type in UniverseOracle::ClosestShiftIndex. More...

Functions
void	ResetOscCalcToDefault (osc::IOscCalcAdjustable *calc)
	Reset calc to default assumptions for all parameters. More...

osc::IOscCalcAdjustable *	DefaultOscCalc ()
	Create a new calc with default assumptions for all parameters. More...

void	ResetOscCalcToDefaultIH (osc::IOscCalcAdjustable *calc)

osc::IOscCalcAdjustable *	DefaultOscCalcIH ()

void	ResetSterileCalcToDefault (osc::OscCalcSterile *calc)
	Reset calc to default assumptions for all parameters. More...

osc::OscCalcSterile *	DefaultSterileCalc (int nflavors)
	Create a sterile calc with default assumptions for all parameters. More...

osc::IOscCalcAdjustable *	NuFitOscCalc (int hie)

bool	HasVar (std::vector< const IFitVar * > oscVars, std::string name)

osc::IOscCalcAdjustable *	ThrownNuFitOscCalc (int hie, std::vector< const IFitVar * > oscVars)

osc::IOscCalcAdjustable *	NuFitOscCalcPlusOneSigma (int hie)

osc::IOscCalcAdjustable *	NuFitOscCalcCDR (int hie)

osc::IOscCalcAdjustable *	ThrownNuFitOscCalcCDR (int hie)

osc::IOscCalcAdjustable *	NuFitOscCalcCDRPlusOneSigma (int hie)

void	MakeNMinusOneSpectra (SpectrumLoader &loader, const Cut &sigcut, const Cut &presel, const std::vector< HistAxis > &axes, const std::vector< double > &cut_pos, std::vector< Spectrum > &sigs, std::vector< Spectrum > &bkgs)
	Make a series of spectra leaving out one cut in turn. More...

double	FindOptimumCut (TH1 hsig, TH1 hbkg, double &best_fom)
	Search for optimum cut position given signal and background histograms. More...

double	OptimizeOneCut (const std::string &wildcard, double pot, const Cut &sigcut, const Cut &presel, const std::vector< HistAxis > &axes, std::vector< double > &cut_pos)
	Scan all cuts and update the one giving the largest FOM gain. More...

void	OptimizeCuts (const std::string &wildcard, double pot, const Cut &sigcut, const Cut &presel, const std::vector< HistAxis > &axes, std::vector< double > &cut_pos)
	Repeatedly invoke OptimizeOneCut until the FOM increase becomes small. More...

double	SimpleFOM (const Spectrum &obs, const Spectrum &unosc, double pot=0)
	Figure-of-merit with no systematics, for binned data. More...

TH1 *	Profile (const IExperiment expt, osc::IOscCalcAdjustable calc, const IFitVar v, int nbinsx, double minx, double maxx, double minchi=-1, const std::vector< const IFitVar > &profVars={}, const std::vector< const ISyst * > &profSysts={}, const std::map< const IFitVar , std::vector< double >> &seedPts={}, const std::vector< SystShifts > &systsSeedPts={}, std::map< const IFitVar , TGraph * > &profVarsMap=empty_vars_map, std::map< const ISyst , TGraph > &systsMap=empty_syst_map)
	$\chi^2$ scan in one variable, profiling over all others More...

TH1 *	Profile (const IExperiment expt, osc::IOscCalcAdjustable calc, const ISyst s, int nbinsx, double minx, double maxx, double input_minchi, const std::vector< const IFitVar > &profVars, const std::vector< const ISyst * > &profSysts, const std::map< const IFitVar , std::vector< double >> &seedPts, const std::vector< SystShifts > &systSeedPts, std::map< const IFitVar , TGraph * > &profVarsMap, std::map< const ISyst , TGraph > &profSystsMap)

TH1 *	SqrtProfile (const IExperiment expt, osc::IOscCalcAdjustable calc, const IFitVar v, int nbinsx, double minx, double maxx, double minchi=-1, std::vector< const IFitVar > profVars={}, std::vector< const ISyst * > profSysts={}, const std::map< const IFitVar , std::vector< double >> &seedPts={}, const std::vector< SystShifts > &systsSeedPts={}, std::map< const IFitVar , TGraph * > &profVarsMap=empty_vars_map, std::map< const ISyst , TGraph > &systsMap=empty_syst_map)
	Forward to Profile but sqrt the result for a crude significance. More...

TH1 *	SqrtProfile (const IExperiment expt, osc::IOscCalcAdjustable calc, const ISyst s, int nbinsx, double minx, double maxx, double minchi, std::vector< const IFitVar > profVars, std::vector< const ISyst * > profSysts, const std::map< const IFitVar , std::vector< double >> &seedPts, const std::vector< SystShifts > &systSeedPts, std::map< const IFitVar , TGraph * > &profVarsMap, std::map< const ISyst , TGraph > &systsMap)

TH1 *	Slice (const IExperiment expt, osc::IOscCalcAdjustable calc, const IFitVar *v, int nbinsx, double minx, double maxx, double minchi=-1)
	$\chi^2$ scan in one variable, holding all others constant More...

TH1 *	Slice (const IExperiment expt, osc::IOscCalcAdjustable calc, const ISyst *s, int nbinsx, double minx, double maxx, double minchi)

TH1 *	SqrtSlice (const IExperiment expt, osc::IOscCalcAdjustable calc, const IFitVar *v, int nbinsx, double minx, double maxx, double minchi=-1)
	Forward to Slice but sqrt the result for a crude significance. More...

TH1 *	SqrtSlice (const IExperiment expt, osc::IOscCalcAdjustable calc, const ISyst *s, int nbinsx, double minx, double maxx, double minchi)

TGraph *	FindValley (const IExperiment expt, osc::IOscCalcAdjustable calc, const IFitVar &scanVar, const IFitVar &fitVar, int nbinsx, double xmin, double xmax, const std::vector< const IFitVar * > &profVars={}, const std::vector< const ISyst * > &profSysts={}, const std::map< const IFitVar *, std::vector< double >> &seedPts={}, const std::vector< SystShifts > &systsSeedPts={}, bool transpose=false)
	Find the minimum in one variable as a function of another. More...

std::vector< double >	FindCurveCrossings (TH1 *h, double critVal)
	Intended for use on the output of Profile. More...

Fitter::Precision	operator\| (Fitter::Precision a, Fitter::Precision b)

TH1 *	DataMCComparison (const Spectrum &data, const Spectrum &mc)

TH1 *	DataMCComparisonAreaNormalized (const Spectrum &data, const Spectrum &mc)

TH1 *	DataMCComparisonComponents (const Spectrum &data, const IPrediction mc, osc::IOscCalc calc)
	Plot MC broken down into flavour components, overlayed with data. More...

TH1 *	GetMCSystTotal (const IPrediction mc, osc::IOscCalc calc, const SystShifts &shift, std::string hist_name, double pot, bool force1D)

TH1 *	GetMCTotal (const IPrediction mc, osc::IOscCalc calc, std::string hist_name, double pot, bool force1D)

std::vector< TH1 * >	GetMCComponents (const IPrediction mc, osc::IOscCalc calc, std::string hist_name, double pot, bool force1D)

std::vector< TH1 * >	GetMCSystComponents (const IPrediction mc, osc::IOscCalc calc, const SystShifts &shift, std::string hist_name, double pot, bool force1D)

std::vector< TH1 * >	GetMCTotalForSystShifts (const IPrediction mc, osc::IOscCalc calc, const ISyst *syst, std::string hist_base_name, double pot, bool force1D)

void	DataMCRatio (const Spectrum &data, const IPrediction mc, osc::IOscCalc calc, double miny=0, double maxy=3)
	Plot data/MC ratio for the given spectrum. Normalize MC to Data by POT. More...

void	DataMCRatio (const Spectrum &data, const Spectrum &mc, double miny=0, double maxy=3)
	Plot data/MC ratio for the given spectrum. Normalize MC to Data by POT. More...

void	DataMCAreaNormalizedRatio (const Spectrum &data, const IPrediction mc, osc::IOscCalc calc, double miny=0, double maxy=3)
	Plot data/MC ratio for the given spectrum. Normalize MC to Data by area. More...

void	DataMCAreaNormalizedRatio (const Spectrum &data, const Spectrum &mc, double miny=0, double maxy=3)
	Plot data/MC ratio for the given spectrum. Normalize MC to Data by area. More...

void	RatioPlot (const Spectrum &data, const Spectrum &expected, const Spectrum &fit, double miny=0, double maxy=1.2)
	Plot data/expected, compared with fit/expected. More...

void	PlotWithSystErrorBand (IPrediction pred, const std::vector< const ISyst > &systs, osc::IOscCalc *calc, double pot, int col=-1, int errCol=-1, float headroom=1.3, bool newaxis=true)
	Plot prediction with +/-1sigma error band. More...

void	PlotWithSystErrorBand (const Spectrum &nominal, const std::vector< Spectrum > &upShifts, const std::vector< Spectrum > &downShifts, double pot, int col=-1, int errCol=-1, float headroom=1.3, bool newaxis=true)
	Plot prediction with error band. More...

THStack *	ToTHStack (const std::vector< std::pair< Spectrum, Color_t >> &s, double pot)
	Can call like ToTHStack({{h1, kRed}, {h2, kBlue}}, pot) More...

double	PointDistanceToBox (double x, double y, double x0, double y0, double x1, double y1)
	Helper for AutoPlaceLegend. More...

TLegend *	AutoPlaceLegend (double dx, double dy, double yPin=-1)
	Create a legend, maximizing distance from all histograms. More...

TGraphAsymmErrors *	GraphWithPoissonErrors (const TH1 *h, bool noErrorsXaxis=false, bool drawEmptyBins=true)
	Calculate statistical errors appropriate for small Poisson numbers. More...

TGraph *	ShadeBetweenHistograms (TH1 hmin, TH1 hmax)

TGraphAsymmErrors *	ProfileQuantile (const TH2 *hist, const std::string &axis_name, const std::string &graph_name="", const std::pair< double, double > &quantile_divisions={0.159, 0.841})
	Calculate profile with error bars corresponding to specified quantiles of a 2D distribution (by default, 68% coverage) More...

void	CountingExperimentErrorBarChart (const std::map< std::string, double > &systs, double statErr=0, bool bkgdOrSig=false, bool shortchart=false)
	Make a simple plot of relative size of different errors. More...

double	BinCenter (const TAxis *ax, int bin, bool islog)

TH2 *	Flat (double level, const Surface &s)
	Helper function for the gaussian approximation surfaces. More...

TH2 *	Gaussian68Percent2D (const Surface &s)
	Up-value surface for 68% confidence in 2D in gaussian approximation. More...

TH2 *	Gaussian90Percent2D (const Surface &s)
	Up-value surface for 90% confidence in 2D in gaussian approximation. More...

TH2 *	Gaussian95Percent2D (const Surface &s)
	Up-value surface for 95% confidence in 2D in gaussian approximation. More...

TH2 *	Gaussian2Sigma2D (const Surface &s)
	Up-value surface for 2 sigma confidence in 2D in gaussian approximation. More...

TH2 *	Gaussian99Percent2D (const Surface &s)
	Up-value surface for 99% confidence in 2D in gaussian approximation. More...

TH2 *	Gaussian3Sigma2D (const Surface &s)
	Up-value surface for 3 sigma confidence in 2D in gaussian approximation. More...

TH2 *	Gaussian5Sigma2D (const Surface &s)
	Up-value surface for 5 sigma confidence in 2D in gaussian approximation. More...

TH2 *	Gaussian68Percent1D (const Surface &s)
	Up-value surface for 68% confidence in 1D in gaussian approximation. More...

TH2 *	Gaussian90Percent1D (const Surface &s)
	Up-value surface for 90% confidence in 1D in gaussian approximation. More...

TH2 *	Gaussian95Percent1D (const Surface &s)
	Up-value surface for 95% confidence in 1D in gaussian approximation. More...

TH2 *	Gaussian2Sigma1D (const Surface &s)
	Up-value surface for 2 sigma confidence in 1D in gaussian approximation. More...

TH2 *	Gaussian99Percent1D (const Surface &s)
	Up-value surface for 99% confidence in 1D in gaussian approximation. More...

TH2 *	Gaussian3Sigma1D (const Surface &s)
	Up-value surface for 3 sigma confidence in 1D in gaussian approximation. More...

TH2 *	Gaussian90Percent1D1Sided (const Surface &s)
	Up-value surface for 90% confidence in 1D in 1-sided gaussian approximation. More...

TH2 *	Gaussian95Percent1D1Sided (const Surface &s)
	Up-value surface for 95% confidence in 1D in 1-sided gaussian approximation. More...

TH2 *	Gaussian99Percent1D1Sided (const Surface &s)
	Up-value surface for 99% confidence in 1D in 1-sided gaussian approxiamtion. More...

TH2 *	Gaussian3Sigma1D1Sided (const Surface &s)
	Up-value surface for 3 sigma confidence in 1D in 1-sided gaussian approximation. More...

TH2 *	Gaussian5Sigma1D1Sided (const Surface &s)
	Up-value surface for 5 sigma confidence in 1D in 1-sided gaussian approximation. More...

Binning	TrueEnergyBins ()
	Default true-energy bin edges. More...

Binning	TrueLOverTrueEBins ()

std::function< ExposureFunc_t >	CombineExposures (const std::function< ExposureFunc_t > &a, const std::function< ExposureFunc_t > &b)

template<class T >
_Cut< T >	operator&& (const _Cut< T > &a, const _Cut< T > &b)

template Cut	operator&&< caf::SRSliceProxy > (const Cut &a, const Cut &b)

template SpillCut	operator&&< caf::SRSpillProxy > (const SpillCut &a, const SpillCut &b)

template<class T >
_Cut< T >	operator\|\| (const _Cut< T > &a, const _Cut< T > &b)

template Cut	operator\|\|< caf::SRSliceProxy > (const Cut &a, const Cut &b)

template SpillCut	operator\|\|< caf::SRSpillProxy > (const SpillCut &a, const SpillCut &b)

template<class T >
_Cut< T >	operator! (const _Cut< T > &a)

template Cut	operator!< caf::SRSliceProxy > (const Cut &a)

template SpillCut	operator!< caf::SRSpillProxy > (const SpillCut &a)

template<class T >
_Cut< T >	operator> (const _Var< T > &v, double c)

template<class T >
_Cut< T >	operator>= (const _Var< T > &v, double c)

template<class T >
_Cut< T >	operator< (const _Var< T > &v, double c)

template<class T >
_Cut< T >	operator<= (const _Var< T > &v, double c)

template<class T >
_Cut< T >	operator== (const _Var< T > &v, double c)

template<class T >
_Cut< T >	operator!= (const _Var< T > &v, double c)

template<class T >
_Cut< T >	operator> (const _Var< T > &a, const _Var< T > &b)

template<class T >
_Cut< T >	operator>= (const _Var< T > &a, const _Var< T > &b)

template<class T >
_Cut< T >	operator== (const _Var< T > &a, const _Var< T > &b)

template<class T >
_Cut< T >	operator> (double c, const _Var< T > &v)

template<class T >
_Cut< T >	operator< (double c, const _Var< T > &v)

template<class T >
_Cut< T >	operator>= (double c, const _Var< T > &v)

template<class T >
_Cut< T >	operator<= (double c, const _Var< T > &v)

template<class T >
_Cut< T >	operator!= (double c, const _Var< T > &v)

template<class T >
_Cut< T >	operator< (const _Var< T > &a, const _Var< T > &b)

template<class T >
_Cut< T >	operator<= (const _Var< T > &a, const _Var< T > &b)

template<class T >
_Cut< T >	operator!= (const _Var< T > &a, const _Var< T > &b)

template Cut	operator> (const Var &, double)

template Cut	operator< (const Var &, double)

template Cut	operator>= (const Var &, double)

template Cut	operator<= (const Var &, double)

template Cut	operator== (const Var &, double)

template Cut	operator!= (const Var &, double)

template Cut	operator> (const Var &, const Var &)

template Cut	operator< (const Var &, const Var &)

template Cut	operator>= (const Var &, const Var &)

template Cut	operator<= (const Var &, const Var &)

template Cut	operator== (const Var &, const Var &)

template Cut	operator!= (const Var &, const Var &)

template Cut	operator> (double, const Var &)

template Cut	operator< (double, const Var &)

template Cut	operator>= (double, const Var &)

template Cut	operator<= (double, const Var &)

const Cut	kNoCut ([](const caf::SRSliceProxy *){return true;})
	The simplest possible cut: pass everything, used as a default. More...

const SpillCut	kNoSpillCut ([](const caf::SRSpillProxy *){return true;})
	The simplest possible cut: pass everything, used as a default. More...

void	gdb_backtrace ()

void	handle_terminate ()

void	handle_signal (int sig, siginfo_t , void )

EnsembleRatio	operator/ (const EnsembleSpectrum &lhs, const EnsembleSpectrum &rhs)

void	DrawErrorBand (TH1 nom, TGraphAsymmErrors band, int bandCol, double alpha)

EnsembleSpectrum	operator* (const EnsembleRatio &lhs, const EnsembleSpectrum &rhs)

EnsembleSpectrum	operator/ (const EnsembleRatio &lhs, const EnsembleSpectrum &rhs)

void	ClearTrueParticles (caf::StandardRecord *sr)

std::vector< std::string >	GetGenieWeightNames ()

std::pair< double, double >	GetGenieDialLimits (const std::string &name)

int	GetGenieIndex (const std::string &name, bool quiet)

std::string	GetGenieWeightName (int index)

double	GetGenieMin (int index)

double	GetGenieMax (int index)

	fBins ({binsX, binsY})

	fVars ({varX, varY})

template<>
std::unique_ptr< osc::IOscCalc >	LoadFrom< osc::IOscCalc > (TDirectory *dir)

template<>
void	SaveTo (const osc::IOscCalc &x, TDirectory *dir)

template<class T >
std::unique_ptr< T >	LoadFrom (TDirectory *dir)

template<>
std::unique_ptr< IDecomp >	LoadFrom< IDecomp > (TDirectory *dir)

template<>
std::unique_ptr< IExtrap >	LoadFrom< IExtrap > (TDirectory *dir)

template<>
std::unique_ptr< IPrediction >	LoadFrom< IPrediction > (TDirectory *dir)

template<>
std::unique_ptr< IExperiment >	LoadFrom< IExperiment > (TDirectory *dir)

template<>
std::unique_ptr < ModularExtrapComponent >	LoadFrom< ModularExtrapComponent > (TDirectory *dir)

template<>
std::unique_ptr< IBkgdEstimator >	LoadFrom< IBkgdEstimator > (TDirectory *dir)

template<class T >
void	SaveTo (const T &x, TDirectory *dir)

template<class T >
std::unique_ptr< T >	LoadFromFile (const std::string &fname, const std::string &label)

template<class T >
void	SaveToFile (const T &x, const std::string &fname, const std::string &label)

template<class T >
_MultiVar< T >	MultiVar2D (const _MultiVar< T > &a, const Binning &binsa, const _MultiVar< T > &b, const Binning &binsb)

template MultiVar	MultiVar2D (const MultiVar &, const Binning &, const MultiVar &, const Binning &)

double	Si (double x)

double	AvgSinSq (double k, double a, double b)

OscCalcSterileApproxAdjustable *	DefaultSterileApproxCalc (SterileOscAngles angles)

const OscCalcSterileApprox *	DowncastToSterileApprox (const osc::IOscCalc *calc, bool allowFail)

OscCalcSterileApprox *	DowncastToSterileApprox (osc::IOscCalc *calc, bool allowFail)

SterileOscAngles	operator\| (const SterileOscAngles a, const SterileOscAngles b)

SterileOscAngles	operator& (const SterileOscAngles a, const SterileOscAngles b)

const Var	kBaseline ([](const caf::SRSliceProxy slc) -> double{return slc->truth.baseline 1e-3;})

	fCachedHash (0)

Ratio	operator/ (const Spectrum &lhs, const Spectrum &rhs)

void	ProjectionX (TH2D from, TH1D to)
	Helper for Unweighted. More...

void	ProjectionY (TH2D from, TH1D to)
	Helper for WeightingVariable. More...

Spectrum	operator* (const Ratio &lhs, const Spectrum &rhs)

Spectrum	operator/ (const Ratio &lhs, const Spectrum &rhs)

std::string	UniqueName ()
	Return a different string each time, for creating histograms. More...

std::string	Experiment ()
	$EXPERIMENT or a nice error message and abort More...

std::string	SAMExperiment ()
	$SAM_EXPERIMENT or a nice error message and abort More...

std::unique_ptr< TMatrixD >	CalcCovMx (const std::vector< TArrayD * > &binSets, int firstBin=0, int lastBin=-1)
	Compute bin-to-bin covariance matrix from a collection of sets of bin contents. More...

double	LogLikelihood (double exp, double obs)
	The log-likelihood formula for a single bin. More...

double	LogLikelihood (const TH1 exp, const TH1 obs, bool useOverflow=false)
	The log-likelihood formula from the PDG. More...

double	Chi2CovMx (const TVectorD e, const TVectorD o, const TMatrixD *covmxinv)

double	Chi2CovMx (const TH1 e, const TH1 o, const TMatrixD *covmxinv)

TH2F *	ExpandedHistogram (const std::string &title, int nbinsx, double xmin, double xmax, bool xlog, int nbinsy, double ymin, double ymax, bool ylog)

std::unique_ptr< TMatrixD >	SymmMxInverse (const TMatrixD &mx)

TH1D *	MakeTH1D (const char name, const char title, const Binning &bins)

TH2D *	MakeTH2D (const char name, const char title, const Binning &binsx, const Binning &binsy)

TH2 *	ToTH2 (const Spectrum &s, double exposure, ana::EExposureType expotype, const Binning &binsx, const Binning &binsy, ana::EBinType bintype)

TH2 *	ToTH2 (const Ratio &r, const Binning &binsx, const Binning &binsy)

TH2 *	ToTH2Helper (std::unique_ptr< TH1 > h1, const Binning &binsx, const Binning &binsy, ana::EBinType bintype)

TH3 *	ToTH3 (const Spectrum &s, double exposure, ana::EExposureType expotype, const Binning &binsx, const Binning &binsy, const Binning &binsz, ana::EBinType bintype)

TH3 *	ToTH3 (const Ratio &r, const Binning &binsx, const Binning &binsy, const Binning &binsz)

TH3 *	ToTH3Helper (std::unique_ptr< TH1 > h1, const Binning &binsx, const Binning &binsy, const Binning &binsz, ana::EBinType bintype)

std::vector< std::string >	Wildcard (const std::string &wildcardString)

std::string	FindCAFAnaDir ()

std::vector< std::string >	LoadFileList (const std::string &listfile)

std::map< std::string, std::string >	GetCAFMetadata (TDirectory *dir)

void	CombineMetadata (std::map< std::string, std::string > &base, const std::map< std::string, std::string > &add, std::set< std::string > &mask)

void	WriteCAFMetadata (TDirectory *dir, const std::map< std::string, std::string > &meta)

bool	RunningOnGrid ()

size_t	Stride (bool allow_default)

size_t	Offset (bool allow_default)

int	Limit ()

size_t	JobNumber ()

size_t	NumJobs ()

bool	AlmostEqual (double a, double b)

std::string	pnfs2xrootd (std::string loc, bool unauth)

void	EnsurePositiveDefinite (TH2 *mat)

TH1 *	GetMaskHist (const Spectrum &s, double xmin, double xmax, double ymin, double ymax)

double	FindQuantile (double frac, std::vector< double > &xs)

template<class T >
_Var< T >	Var2D (const _Var< T > &a, const Binning &binsa, const _Var< T > &b, const Binning &binsb)
	Variable formed from two input variables. More...

template<class T >
_Var< T >	Var2D (const _Var< T > &a, int na, double a0, double a1, const _Var< T > &b, int nb, double b0, double b1)
	Variable formed from two input variables. More...

template Var	Var2D (const Var &, const Binning &, const Var &, const Binning &)

template Var	Var2D (const Var &, int, double, double, const Var &, int, double, double)

template<class T >
_Var< T >	Var3D (const _Var< T > &a, const Binning &binsa, const _Var< T > &b, const Binning &binsb, const _Var< T > &c, const Binning &binsc)
	This is just like a Var2D, but useful for 3D Spectra. More...

template<class T >
_Var< T >	Var3D (const _Var< T > &a, int na, double a0, double a1, const _Var< T > &b, int nb, double b0, double b1, const _Var< T > &c, int nc, double c0, double c1)
	This is just like a Var2D, but useful for 3D Spectra. More...

template Var	Var3D (const Var &, const Binning &, const Var &, const Binning &, const Var &, const Binning &)

template Var	Var3D (const Var &, int, double, double, const Var &, int, double, double, const Var &, int, double, double)

Var	Scaled (const Var &v, double s)
	Use to rescale another variable. More...

Var	Constant (double c)
	Use to weight events up and down by some factor. More...

Var	Sqrt (const Var &v)
	Use to take sqrt of a var. More...

template<class T >
_Var< T >	operator* (const _Var< T > &a, const _Var< T > &b)

template<class T >
_Var< T >	operator/ (const _Var< T > &a, const _Var< T > &b)

template<class T >
_Var< T >	operator+ (const _Var< T > &a, const _Var< T > &b)

template<class T >
_Var< T >	operator- (const _Var< T > &a, const _Var< T > &b)

template Var	operator* (const Var &, const Var &)

template Var	operator/ (const Var &, const Var &)

template Var	operator+ (const Var &, const Var &)

template Var	operator- (const Var &, const Var &)

const Var	kUnweighted ([](const caf::SRSliceProxy *){return 1;})
	The simplest possible Var, always 1. Used as a default weight. More...

const SpillVar	kSpillUnweighted ([](const caf::SRSpillProxy *){return 1;})

const Cut	kIsNueApp (CCFlavSel(12, 14))
	Select CC $\nu_\mu\to\nu_e$ . More...

const Cut	kIsNumuCC (CCFlavSel(14, 14))
	Select CC $\nu_\mu\to\nu_\mu$ . More...

const Cut	kIsBeamNue (CCFlavSel(12, 12))
	Select CC $\nu_e\to\nu_e$ . More...

const Cut	kIsNumuApp (CCFlavSel(14, 12))
	Select CC $\nu_e\to\nu_\mu$ . More...

const Cut	kIsTauFromMu (CCFlavSel(16, 14))
	Select CC $\nu_\mu\to\nu_\tau$ . More...

const Cut	kIsTauFromE (CCFlavSel(16, 12))
	Select CC $\nu_e\to\nu_\tau$ . More...

const Cut	kIsNCFromNumu (NCFlavOrig(14))

const Cut	kIsNCFromNue (NCFlavOrig(12))

const ReactorExperiment *	DayaBayConstraint2014 ()
	A ReactorExperiment initialized with the Nu2014 Daya Bay constraints. More...

const ReactorExperiment *	WorldReactorConstraint2015 ()
	Weighted average of all experiments as of first nue paper writing. More...

const ReactorExperiment *	WorldReactorConstraint2016 ()
	Updated value for SecondAna based on the latest PDG. More...

const ReactorExperiment *	WorldReactorConstraint2017 ()
	Reactor constraint from PDG 2017 update. More...

const SolarConstraints	kSolarConstraintsPDG2017 (7.53e-5, 0.18e-5, 0.851, 0.020)

	fSplitBySign (mode==kSplitBySign)

const BoosterFluxHadronSyst *	GetBoosterFluxHadronSyst (unsigned int i)

BoosterFluxHadronSystVector	GetBoosterFluxHadronSysts (unsigned int N)

std::vector< const ISyst * >	GetEnergySysts ()

std::vector< const ISyst * >	GetBigEnergySysts ()

const NuMIFluxSyst *	GetNuMIFluxSyst (const std::string &dir, const std::string &prefix, const std::string &name)

std::vector< const ISyst * >	GetNuMIHadronProductionFluxSysts ()
	These are envelopes not real systs. TODO make clearer in naming. More...

std::vector< const ISyst * >	GetNuMIBeamlineFluxSysts ()

std::vector< const ISyst * >	GetNuMIPCAFluxSysts (unsigned int Npcs)

std::vector< const ISyst * >	GetAllNuMIFluxSysts (unsigned int Npcs)
	Combination of all beamline systs plus Npcs hadron production components. More...

std::vector< std::string >	GetSBNGenieWeightNames ()

const std::vector< const ISyst * > &	GetSBNGenieWeightSysts ()

std::vector< std::string >	GetSBNBoosterFluxWeightNames ()

const std::vector< const ISyst * > &	GetSBNBoosterFluxWeightSysts ()

const std::vector< const ISyst * > &	GetSBNWeightSysts ()

Var	GetUniverseWeight (const std::string &psetName, int univIdx)

caf::SRGlobal	GetSRGlobal ()

void	PrintSRGlobal (const caf::SRGlobal &global)

Spectrum	UnfoldIterative (const Spectrum &reco, const ReweightableSpectrum &recoVsTrue, unsigned int nIterations)

Spectrum	UnfoldSVD (const Spectrum &reco, const ReweightableSpectrum &recoVsTrue, unsigned int reg)
	Singular value decomposition unfolding using ROOT's TSVDDecomp. More...

Spectrum	UnfoldTikhonov (const Spectrum &reco, const ReweightableSpectrum &recoVsTrue, double regStrength)
	Unfolding using Tikhonov regularization (penalizing true spectra with large second derivatives) More...

bool	IsCCQEOnArgon (const caf::SRTrueInteractionProxy *nu, int pdg)

bool	IsNCQEOnArgon (const caf::SRTrueInteractionProxy *nu, int pdg)

Cut	IsCCQEOnArgonCut (int pdg)

TString	thisCellColor (double weird)

TString	fixLatexName (TString mystring)

void	printTableHeader (int quantId=0)

void	printTableFooter ()

void	printEventsLine (std::string cutname, float nue, float numu, float nc, float cos, float other, float eff, float pur)

void	SplitCanvas2 (TCanvas &c1, TPad &pad1, TPad *&pad2)

float	GetHistMax (std::vector< TH1 * > histos)

void	PimpHist (TH1 *histo, Color_t color, Style_t linestyle, int linewidth, Style_t markerstyle=8, double markersize=8)

void	FillWithDimColor (TH1 *h, bool usealpha=false, float dim=0.8)

void	DrawComponentsLegend (TH1 hnue, TH1 hnumu, TH1 hnc, TH1 hcos, TH1 *hother)

void	DrawSigBkgLegend (TH1 h1, char name1, TH1 h2, char name2)

void	DrawSigBkgIntLegend (TH1 h1, char name1, double iSig, TH1 h2, char name2, double iBkg)

void	DrawIntEffPurLegend (TH1D g1, char name1, TH1D g2, char name2)

void	DrawPurLegend (TH1D g1, char name1)

void	DrawEffPurLegend (TH1D g1, char name1, TH1D g2, char name2)

void	DrawSigBkgIntText (TH1 hsig, TH1 hbkg, float textsize)

TH1D *	EffOrPurHistogram (TH1 hSelSignal, TH1 hSelBack, TH1 *hSignal, bool geteff)

TGraph *	EffOrPurGraph (TH1 hSelSignal, TH1 hSelBack, TH1 *hSignal, bool geteff)

static bool	Icarus202208contained (const caf::SRTrackProxy &trk)

bool	IsPrimary (const caf::SRTrueParticleProxy &p)
	Whether this is a primary particle or generated by a secondary interaction. More...

bool	HasBraggPeak (const caf::SRTrueParticleProxy &p)
	Whether this particle should have a bragg peak in the detector. More...

bool	IsGenie (const caf::SRTrueParticleProxy &p)
	Whether this particle was generated by genie (as opposed to geant or corsika) More...

bool	IsStable (const caf::SRTrueParticleProxy &p)
	Whether this is a stable particle as generated by genie. More...

const Cut	kIsAntiNu ([](const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return false;return slc->truth.pdg< 0;})

const Cut	kIsCC ([](const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return false;return(slc->truth.iscc==1);})

const Cut	kIsNC ([](const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return false;return(slc->truth.isnc==1);})

const caf::SRShowerProxy *	LargestRecoShower (const caf::SRSliceProxy *slc)
	Pointer to largest reconstructed shower, or null pointer if none exists. More...

const caf::SRTrackProxy *	LongestRecoTrack (const caf::SRSliceProxy *slc)
	Pointer to longest reconstructed shower, or null pointer if none exists. More...

const caf::SRTrkChi2PIDProxy *	BestPlaneChi2PID (const caf::SRTrackProxy *trk)

const caf::SRTrkChi2PIDProxy *	LongestTrackBestPlaneChi2PID (const caf::SRSliceProxy *slc)

static bool	Icarus202208_proton_cut (const caf::SRTrackProxy &trk)

const Var	kNuScore ([](const caf::SRSliceProxy *slc) -> double{return slc->nu_score;})

const Var	kSlcIsRecoNu ([](const caf::SRSliceProxy *slc) -> double{return!slc->is_clear_cosmic;})

Variables
const double	kNuFitDmsq21CV = 7.39e-5

const double	kNuFitTh12CV = 33.82 * TMath::Pi()/180

const double	kNuFitDmsq32CVNH = +2.525e-3 - kNuFitDmsq21CV

const double	kNuFitTh23CVNH = 49.6 * TMath::Pi()/180

const double	kNuFitTh13CVNH = 8.61 * TMath::Pi()/180

const double	kNuFitdCPCVNH = 215 * TMath::Pi()/180

const double	kNuFitDmsq32CVIH = -2.512e-3

const double	kNuFitTh23CVIH = 49.8 * TMath::Pi()/180

const double	kNuFitTh13CVIH = 8.65 * TMath::Pi()/180

const double	kNuFitdCPCVIH = 284 * TMath::Pi()/180

const double	kNuFitDmsq21Err = ((8.01-6.79)/6)*1e-5

const double	kNuFitTh12Err = ((36.27-31.61)/6) * TMath::Pi()/180

const double	kNuFitDmsq32ErrNH = ((2.625-2.427)/6)*1e-3

const double	kNuFitTh23ErrNH = ((52.4-40.3)/6) * TMath::Pi()/180

const double	kNuFitTh13ErrNH = ((8.99-8.22)/6) * TMath::Pi()/180

const double	kNuFitDmsq32ErrIH = ((2.611-2.412)/6)*1e-3

const double	kNuFitTh23ErrIH = ((52.5-40.6)/6) * TMath::Pi()/180

const double	kNuFitTh13ErrIH = ((9.03-8.27)/6) * TMath::Pi()/180

const double	kBaseline = 1284.9

const double	kEarthDensity = 2.848

const double	kPOTnominal = 6.6e20

const double	kPOTuBoone = 1.3e21

const double	kBaselineSBND = 0.11

const double	kBaselineMicroBoone = 0.47

const double	kBaselineIcarus = 0.6

const int	kSBND = 0

const int	kMicroBoone = 1

const int	kICARUS = 2

const std::vector< double >	kBLs = {kBaselineSBND, kBaselineMicroBoone, kBaselineIcarus}

static std::map< const IFitVar , TGraph >	empty_vars_map

static std::map< const ISyst , TGraph >	empty_syst_map

const Color_t	kTotalMCColor = kRed

const Color_t	kTotalMCErrorBandColor = kRed-10

const Color_t	kNueSignalColor = kViolet-5

const Color_t	kTotalBackgroundColor = kAzure+2

const Color_t	kNCBackgroundColor = kAzure

const Color_t	kBeamNueBackgroundColor = kPink+9

const Color_t	kCosmicBackgroundColor = kAzure+1

const Color_t	kNumuBackgroundColor = kGreen+2

const Color_t	kNormalHierarchyColor = kAzure+3

const Color_t	kInvertedHierarchyColor = kOrange+9

const Style_t	k90PercentConfidenceStyle = 9

const Style_t	k68PercentConfidenceStyle = 7
	Dashed. More...

const Color_t	kPrimColorNH = kAzure+2

const Color_t	kSecoColorNH = kAzure+1

const Color_t	kPrimColorIH = kOrange+9

const Color_t	kSecoColorIH = kOrange+10

const Style_t	kFillStyleNH = 3013

const Style_t	kFillStyleIH = 3003

const Style_t	k1SigmaConfidenceStyle = 7

const Style_t	k2SigmaConfidenceStyle = 9

const Style_t	k3SigmaConfidenceStyle = 10

const Color_t	kCentralValueColorNH = kAzure+3

const Color_t	k1SigmaConfidenceColorNH = kAzure+3

const Color_t	k90PercConfidenceColorNH = kAzure+2

const Color_t	k2SigmaConfidenceColorNH = kAzure+2

const Color_t	k3SigmaConfidenceColorNH = kAzure+1

const Color_t	kCentralValueColorIH = kOrange+9

const Color_t	k1SigmaConfidenceColorIH = kOrange+9

const Color_t	k2SigmaConfidenceColorIH = kOrange+10

const Color_t	k3SigmaConfidenceColorIH = kOrange+8

const Color_t	k90PercConfidenceColorIH = kOrange+10

const Color_t	kCentralValueColor = kGray+2

const Style_t	kCentralValueStyle = kSolid

const Float_t	kBlessedTitleFontSize = 0.08

const Float_t	kBlessedLabelFontSize = 0.06

const Binning	kTrueEnergyBins = TrueEnergyBins()
	Default true-energy bin edges. More...

const Binning	kTrueLOverEBins = Binning::Simple(100, 0, 2)

bool	gIsException = false

static InstallHandlers	gHandlerInstaller

const Var	kTrueE ([](const caf::SRSliceProxy *slc) -> double{return slc->truth.E;})

const Var	kTrueLOverE = kBaseline / kTrueE

static NullLoader	kNullLoader
	Dummy loader that doesn't load any files. More...

const SystShifts	kNoShift = SystShifts::Nominal()

const Cut	kHasMatchedNu ([](const caf::SRSliceProxy *slc){return slc->truth.index >=0;})

const Cut	kIsNC ([](const caf::SRSliceProxy *slc){return kHasMatchedNu(slc)&&slc->truth.isnc;})
	Is this a Neutral Current event? More...

const Cut	kIsCC ([](const caf::SRSliceProxy *slc){return kHasMatchedNu(slc)&&slc->truth.iscc;})

const Cut	kIsAntiNu ([](const caf::SRSliceProxy *slc){return kHasMatchedNu(slc)&&slc->truth.pdg< 0;})
	Is this truly an antineutrino? More...

const EnergyScaleSyst	kEnergyScaleMuon (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kAll, 0.02,"EnergyScaleMuon","Correlated linear E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonSqrt (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kAll, 0.02,"EnergyScaleMuonSqrt","Correlated sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonInvSqrt (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kAll, 0.02,"EnergyScaleMuonInvSqrt","Correlated inv sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonND (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kSBND, 0.02,"EnergyScaleMuonND","Uncorrelated SBND linear E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonSqrtND (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kSBND, 0.02,"EnergyScaleMuonSqrtND","Uncorrelated SBND sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonInvSqrtND (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kSBND, 0.02,"EnergyScaleMuonInvSqrtND","Uncorrelated SBND inv sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonUB (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kMicroBooNE, 0.02,"EnergyScaleMuonUB","Uncorrelated MicroBooNE linear E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonSqrtUB (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kMicroBooNE, 0.02,"EnergyScaleMuonSqrtUB","Uncorrelated MicroBooNE sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonInvSqrtUB (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kMicroBooNE, 0.02,"EnergyScaleMuonInvSqrtUB","Uncorrelated MicroBooNE inv sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonFD (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kICARUS, 0.02,"EnergyScaleMuonFD","Uncorrelated ICARUS linear E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonSqrtFD (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kICARUS, 0.02,"EnergyScaleMuonSqrtFD","Uncorrelated ICARUS sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonInvSqrtFD (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kICARUS, 0.02,"EnergyScaleMuonInvSqrtFD","Uncorrelated ICARUS inv sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleHadron (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kAll, 0.05,"EnergyScaleHadron","Correlated linear E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronSqrt (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kAll, 0.05,"EnergyScaleHadronSqrt","Correlated sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronInvSqrt (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kAll, 0.05,"EnergyScaleHadronInvSqrt","Correlated inv sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronND (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kSBND, 0.05,"EnergyScaleHadronND","Uncorrelated SBND linear E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronSqrtND (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kSBND, 0.05,"EnergyScaleHadronSqrtND","Uncorrelated SBND sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronInvSqrtND (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kSBND, 0.05,"EnergyScaleHadronInvSqrtND","Uncorrelated SBND inv sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronUB (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kMicroBooNE, 0.05,"EnergyScaleHadronUB","Uncorrelated MicroBooNE linear E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronSqrtUB (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kMicroBooNE, 0.05,"EnergyScaleHadronSqrtUB","Uncorrelated MicroBooNE sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronInvSqrtUB (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kMicroBooNE, 0.05,"EnergyScaleHadronInvSqrtUB","Uncorrelated MicroBooNE inv sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronFD (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kICARUS, 0.05,"EnergyScaleHadronFD","Uncorrelated ICARUS linear E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronSqrtFD (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kICARUS, 0.05,"EnergyScaleHadronSqrtFD","Uncorrelated ICARUS sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronInvSqrtFD (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kICARUS, 0.05,"EnergyScaleHadronInvSqrtFD","Uncorrelated ICARUS inv sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleMuonBig (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kAll, 0.05,"EnergyScaleMuonBig","Correlated linear E_{#mu} scale ")

const EnergyScaleSyst	kEnergyScaleMuonSqrtBig (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kAll, 0.05,"EnergyScaleMuonSqrtBig","Correlated sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonInvSqrtBig (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kAll, 0.05,"EnergyScaleMuonInvSqrtBig","Correlated inv sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonNDBig (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kSBND, 0.05,"EnergyScaleMuonNDBig","Uncorrelated SBND linear E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonSqrtNDBig (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kSBND, 0.05,"EnergyScaleMuonSqrtNDBig","Uncorrelated SBND sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonInvSqrtNDBig (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kSBND, 0.05,"EnergyScaleMuonInvSqrtNDBig","Uncorrelated SBND inv sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonUBBig (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kMicroBooNE, 0.05,"EnergyScaleMuonUBBig","Uncorrelated MicroBooNE linear E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonSqrtUBBig (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kMicroBooNE, 0.05,"EnergyScaleMuonSqrtUBBig","Uncorrelated MicroBooNE sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonInvSqrtUBBig (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kMicroBooNE, 0.05,"EnergyScaleMuonInvSqrtUBBig","Uncorrelated MicroBooNE inv sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonFDBig (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kICARUS, 0.05,"EnergyScaleMuonFDBig","Uncorrelated ICARUS linear E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonSqrtFDBig (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kICARUS, 0.05,"EnergyScaleMuonSqrtFDBig","Uncorrelated ICARUS sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleMuonInvSqrtFDBig (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kMuon, EnergyScaleSystDetector::kICARUS, 0.05,"EnergyScaleMuonInvSqrtFDBig","Uncorrelated ICARUS inv sqrt E_{#mu} scale")

const EnergyScaleSyst	kEnergyScaleHadronBig (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kAll, 0.10,"EnergyScaleHadronBig","Correlated linear E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronSqrtBig (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kAll, 0.10,"EnergyScaleHadronSqrtBig","Correlated sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronInvSqrtBig (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kAll, 0.10,"EnergyScaleHadronInvSqrtBig","Correlated inv sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronNDBig (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kSBND, 0.10,"EnergyScaleHadronNDBig","Uncorrelated SBND linear E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronSqrtNDBig (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kSBND, 0.10,"EnergyScaleHadronSqrtNDBig","Uncorrelated SBND sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronInvSqrtNDBig (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kSBND, 0.10,"EnergyScaleHadronInvSqrtNDBig","Uncorrelated SBND inv sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronUBBig (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kMicroBooNE, 0.10,"EnergyScaleHadronUBBig","Uncorrelated MicroBooNE linear E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronSqrtUBBig (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kMicroBooNE, 0.10,"EnergyScaleHadronSqrtUBBig","Uncorrelated MicroBooNE sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronInvSqrtUBBig (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kMicroBooNE, 0.10,"EnergyScaleHadronInvSqrtUBBig","Uncorrelated MicroBooNE inv sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronFDBig (EnergyScaleSystTerm::kConstant, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kICARUS, 0.10,"EnergyScaleHadronFDBig","Uncorrelated ICARUS linear E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronSqrtFDBig (EnergyScaleSystTerm::kSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kICARUS, 0.10,"EnergyScaleHadronSqrtFDBig","Uncorrelated ICARUS sqrt E_{had} scale")

const EnergyScaleSyst	kEnergyScaleHadronInvSqrtFDBig (EnergyScaleSystTerm::kInverseSqrt, EnergyScaleSystParticle::kHadron, EnergyScaleSystDetector::kICARUS, 0.10,"EnergyScaleHadronInvSqrtFDBig","Uncorrelated ICARUS inv sqrt E_{had} scale")

const FitTheta13	kFitTheta13 = FitTheta13()
	$\theta_{13}$ More...

const FitSinSq2Theta13	kFitSinSq2Theta13 = FitSinSq2Theta13()
	$\sin^22\theta_{13}$ More...

const FitDeltaInPiUnits	kFitDeltaInPiUnits = FitDeltaInPiUnits()
	$\delta_{CP}/\pi$ More...

const FitTheta23	kFitTheta23 = FitTheta23()
	$\theta_{13}$ More...

const FitSinSqTheta23	kFitSinSqTheta23 = FitSinSqTheta23()
	$\sin^2\theta_{23}$ More...

const FitSinSq2Theta23	kFitSinSq2Theta23 = FitSinSq2Theta23()
	$\sin^22\theta_{23}$ More...

const FitDmSq32	kFitDmSq32 = FitDmSq32()
	$\Delta m^2_{32}$ More...

const FitDmSq32Scaled	kFitDmSq32Scaled = FitDmSq32Scaled()
	$\Delta m^2_{32}\times10^3{\rm eV}^2$ More...

const FitTanSqTheta12	kFitTanSqTheta12 = FitTanSqTheta12()
	$\tan^2\theta_{12}$ More...

const FitSinSq2Theta12	kFitSinSq2Theta12 = FitSinSq2Theta12()
	$\sin^22\theta_{12}$ More...

const FitDmSq21	kFitDmSq21 = FitDmSq21()
	$\Delta m^2_{21}$ More...

const FitRho	kFitRho = FitRho()
	$\rho$ More...

const FitDmSq32Sterile	kFitDmSq32Sterile = FitDmSq32Sterile()
	$\Delta m^2_{32}$ More...

const FitDmSq41Sterile	kFitDmSq41Sterile = FitDmSq41Sterile()
	$\Delta m^2_{41}$ More...

const FitDmSq43Sterile	kFitDmSq43Sterile = FitDmSq43Sterile()
	$\Delta m^2_{43}$ More...

const FitDelta13InPiUnitsSterile	kFitDelta13InPiUnitsSterile = FitDelta13InPiUnitsSterile()
	$\delta_{CP}/\pi$ More...

const FitDelta14InPiUnitsSterile	kFitDelta14InPiUnitsSterile = FitDelta14InPiUnitsSterile()
	$\delta_{14}/\pi$ More...

const FitDelta24InPiUnitsSterile	kFitDelta24InPiUnitsSterile = FitDelta24InPiUnitsSterile()
	$\delta_{24}/\pi$ More...

const FitTheta13Sterile	kFitTheta13Sterile = FitTheta13Sterile()
	$\theta_{13}$ More...

const FitSinSqTheta13Sterile	kFitSinSqTheta13Sterile = FitSinSqTheta13Sterile()
	$\sin^2\theta_{13}$ More...

const FitTheta23Sterile	kFitTheta23Sterile = FitTheta23Sterile()
	$\theta_{23}$ More...

const FitSinSqTheta23Sterile	kFitSinSqTheta23Sterile = FitSinSqTheta23Sterile()
	$\sin^2\theta_{23}$ More...

const FitTheta14Sterile	kFitTheta14Sterile = FitTheta14Sterile()
	$\theta_{14}$ More...

const FitSinSqTheta14Sterile	kFitSinSqTheta14Sterile = FitSinSqTheta14Sterile()
	$\sin^2\theta_{14}$ More...

const FitSinSq2Theta14Sterile	kFitSinSq2Theta14Sterile = FitSinSq2Theta14Sterile()
	$\sin^22\theta_{14}$ More...

const FitTheta24Sterile	kFitTheta24Sterile = FitTheta24Sterile()
	$\theta_{24}$ More...

const FitSinSqTheta24Sterile	kFitSinSqTheta24Sterile = FitSinSqTheta24Sterile()
	$\sin^2\theta_{24}$ More...

const FitSinSq2Theta24Sterile	kFitSinSq2Theta24Sterile = FitSinSq2Theta24Sterile()
	$\sin^22\theta_{24}$ More...

const FitTheta34Sterile	kFitTheta34Sterile = FitTheta34Sterile()
	$\theta_{34}$ More...

const FitSinSqTheta34Sterile	kFitSinSqTheta34Sterile = FitSinSqTheta34Sterile()
	$\sin^2\theta_{34}$ More...

const FitSinSq2Theta34Sterile	kFitSinSq2Theta34Sterile = FitSinSq2Theta34Sterile()
	$\sin^22\theta_{34}$ More...

const FitTheta13InDegreesSterile	kFitTheta13InDegreesSterile = FitTheta13InDegreesSterile()
	$\theta_{13}$ More...

const FitTheta23InDegreesSterile	kFitTheta23InDegreesSterile = FitTheta23InDegreesSterile()
	$\theta_{23}$ More...

const FitTheta14InDegreesSterile	kFitTheta14InDegreesSterile = FitTheta14InDegreesSterile()
	$\theta_{14}$ More...

const FitTheta24InDegreesSterile	kFitTheta24InDegreesSterile = FitTheta24InDegreesSterile()
	$\theta_{24}$ More...

const FitTheta34InDegreesSterile	kFitTheta34InDegreesSterile = FitTheta34InDegreesSterile()
	$\theta_{34}$ More...

const FitDmSqSterile	kFitDmSqSterile = FitDmSqSterile()
	m^2 More...

f sin	theta_

const Var	kInvXSec ([](const caf::SRSliceProxy *sr){const double GeV2perm2=2.56819e31;return GeV2perm2/sr->truth.xsec;})

const SpillCut	kFirstEvents = kEvt < 10

const SpillCut	kFlashTrigger ([](const caf::SRSpillProxy *sr){return(sr->pass_flashtrig);})

const SpillCut	kCRTHitVetoND ([](const caf::SRSpillProxy *sr){for(auto const &crtHit:sr->crt_hits){return false;}return true;})

const SpillCut	kCRTHitVetoFD ([](const caf::SRSpillProxy *sr){for(auto const &crtHit:sr->crt_hits){auto thistime=crtHit.time-1600.;return false;}return true;})

const Cut	kFiducialVolumeND ([](const caf::SRSliceProxy *slc){return PtInVolAbsX(slc->vertex, fvndAbs);})

const Cut	kActiveVolumeND ([](const caf::SRSliceProxy *slc){return PtInVolAbsX(slc->vertex, avnd);})

const Cut	kFiducialVolumeFDCryo1 ([](const caf::SRSliceProxy *slc){return PtInVol(slc->vertex, fvfd_cryo1);})

const Cut	kFiducialVolumeFDCryo2 ([](const caf::SRSliceProxy *slc){return PtInVol(slc->vertex, fvfd_cryo2);})

const Cut	kActiveVolumeFDCryo1 ([](const caf::SRSliceProxy *slc){return PtInVol(slc->vertex, avfd_cryo1);})

const Cut	kActiveVolumeFDCryo2 ([](const caf::SRSliceProxy *slc){return PtInVol(slc->vertex, avfd_cryo2);})

const Cut	kSlcIsRecoNu ([](const caf::SRSliceProxy *slc){return!slc->is_clear_cosmic;})

const Cut	kSlcNuScoreCut ([](const caf::SRSliceProxy *slc){return(kSlcIsRecoNu(slc)&&slc->nu_score >0.4);})

const Cut	kSlcHasFlashMatch ([](const caf::SRSliceProxy *slc){return slc->fmatch.present;})

const Cut	kSlcFlashMatchCut ([](const caf::SRSliceProxy *slc){return(kSlcHasFlashMatch(slc)&&slc->fmatch.score >0 &&slc->fmatch.score< 6);})

const Cut	kContainedFD = kFiducialVolumeFDCryo1 \|\| kFiducialVolumeFDCryo2

const Cut	kRecoShower ([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].bestplane_energy > 0.f &&slc->reco.shw[largestShwIdx].bestplane_dEdx > 0.f &&slc->reco.shw[largestShwIdx].conversion_gap > 0.f);})

const Cut	kNueBasicCut ([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].bestplane_energy > 0.2f &&slc->reco.shw[largestShwIdx].bestplane_dEdx< 3 &&slc->reco.shw[largestShwIdx].conversion_gap< 3);})

const Cut	kShowerEnergyCut ([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].bestplane_energy > 0.2f);})

const Cut	kShowerdEdxCut ([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].bestplane_dEdx< 3.625f);})

const Cut	kShowerConvGapCut ([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].conversion_gap< 3.25f);})

const Cut	kNueNumShowersCut ([](const caf::SRSliceProxy *slc){return((unsigned int) kRecoShowers_EnergyCut(slc)==1);})

const Cut	kNueHasTrackCut ([](const caf::SRSliceProxy *slc){return slc->reco.ntrk > 0;})

const Cut	kNueTrackContainmentCut ([](const caf::SRSliceProxy *slc){const int longestTrackIdx(kLongestTrackIdx(slc));return true;return PtInVol(slc->reco.trk[longestTrackIdx].end, fvndExit);})

const Cut	kNueTrackLenCut ([](const caf::SRSliceProxy *slc){return kLongestTrackLength(slc)< 110.f;})

const Cut	kNueMuonCut ([](const caf::SRSliceProxy *slc){return(kLongestTrackLength(slc)< 80.f\|\|kLongestTrackChi2Muon(slc) > 30.f\|\|kLongestTrackChi2Proton(slc)< 60.f);})

const Cut	kShowerDensityCut ([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].density > 4.5);})

const Cut	kShowerOpenAngleCut ([](const caf::SRSliceProxy *slc){return kRecoShower_OpenAngle(slc)< 12.f;})

const Cut	kShowerRazzleElectronCut = kRecoShowerRazzlePID == 11

const Cut	kShowerRazzleElectronScoreCut = kRecoShowerRazzleElectronScore > 0.8

const Cut	kNueLongestTrackDazzleMuonCut = kLongestTrackDazzlePID != 13

const Cut	kNueLongestTrackDazzleMuonScoreCut = kLongestTrackDazzleMuonScore < 0.8

const Cut	kNueAllTrackDazzleMuonCut ([](const caf::SRSliceProxy *slc){for(auto const &trk:slc->reco.trk){return false;}return true;})

const Cut	kNueAllTrackDazzleMuonScoreCut ([](const caf::SRSliceProxy *slc){for(auto const &trk:slc->reco.trk){return false;}return true;})

const Cut	kNueContainedND ([](const caf::SRSliceProxy slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;double this_endx=slc->reco.shw[largestShwIdx].start.x+(slc->reco.shw[largestShwIdx].dir.x slc->reco.shw[largestShwIdx].len);double this_endy=slc->reco.shw[largestShwIdx].start.y+(slc->reco.shw[largestShwIdx].dir.y slc->reco.shw[largestShwIdx].len);double this_endz=slc->reco.shw[largestShwIdx].start.z+(slc->reco.shw[largestShwIdx].dir.z slc->reco.shw[largestShwIdx].len);bool startx=(fvndAbs.xmin< std::abs(slc->reco.shw[largestShwIdx].start.x))&&(std::abs(slc->reco.shw[largestShwIdx].start.x)< fvndAbs.xmax);bool endx=(fvndAbs.xmin< std::abs(this_endx))&&(std::abs(this_endx)< fvndAbs.xmax);bool starty=(fvndAbs.ymin< slc->reco.shw[largestShwIdx].start.y)&&(slc->reco.shw[largestShwIdx].start.y< fvndAbs.ymax);bool endy=(fvndAbs.ymin< this_endy)&&(this_endy< fvndAbs.ymax);bool startz=(fvndAbs.zmin< slc->reco.shw[largestShwIdx].start.z)&&(slc->reco.shw[largestShwIdx].start.z< fvndAbs.zmax);bool endz=(fvndAbs.zmin< this_endz)&&(this_endz< fvndAbs.zmax);return(startx &&endx &&starty &&endy &&startz &&endz);})

const Cut	kNueContainedFD ([](const caf::SRSliceProxy slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;double this_endx=slc->reco.shw[largestShwIdx].start.x+(slc->reco.shw[largestShwIdx].dir.x slc->reco.shw[largestShwIdx].len);double this_endy=slc->reco.shw[largestShwIdx].start.y+(slc->reco.shw[largestShwIdx].dir.y slc->reco.shw[largestShwIdx].len);double this_endz=slc->reco.shw[largestShwIdx].start.z+(slc->reco.shw[largestShwIdx].dir.z slc->reco.shw[largestShwIdx].len);bool startx=(fvfd_cryo1.xmin< slc->reco.shw[largestShwIdx].start.x)&&(slc->reco.shw[largestShwIdx].start.x< fvfd_cryo1.xmax);bool endx=(fvfd_cryo1.xmin< this_endx)&&(this_endx< fvfd_cryo1.xmax);bool starty=(fvfd_cryo1.ymin< slc->reco.shw[largestShwIdx].start.y)&&(slc->reco.shw[largestShwIdx].start.y< fvfd_cryo1.ymax);bool endy=(fvfd_cryo1.ymin< this_endy)&&(this_endy< fvfd_cryo1.ymax);bool startz=(fvfd_cryo1.zmin< slc->reco.shw[largestShwIdx].start.z)&&(slc->reco.shw[largestShwIdx].start.z< fvfd_cryo1.zmax);bool endz=(fvfd_cryo1.zmin< this_endz)&&(this_endz< fvfd_cryo1.zmax);return(startx &&endx &&starty &&endy &&startz &&endz);})

const Cut	kNueMuonCutOLD

const Cut	kNueMuonCutNEW

const Cut	kPreNueSelND = kFiducialVolumeND && kSlcNuScoreCut && kSlcFlashMatchCut

const Cut	kRecoNueSel = kRecoShower && kShowerEnergyCut

const Cut	kFullNueSel = kNueTrackLenCut && kShowerConvGapCut && kShowerdEdxCut && kShowerDensityCut

const Cut	kRazzleDazzleNueSel = kNueAllTrackDazzleMuonCut && kShowerRazzleElectronScoreCut

const Cut	kNueFlashScoreFDCut = kSlcFlashMatchCut

const Cut	kNuePandoraScoreFDCut = kSlcNuScoreCut

const Cut	kRecoShowerFD = kRecoShower && kNueNumShowersCut && kShowerdEdxCut && kShowerConvGapCut && kNueTrackLenCut && kShowerDensityCut && kShowerEnergyCut

const Cut	kNueFD = kContainedFD && kNueFlashScoreFDCut && kNuePandoraScoreFDCut && kRecoShowerFD

const Cut	kNumuBasicQual ([](const caf::SRSliceProxy *slc){bool hastrk=(slc->reco.ntrk > 0);if(!hastrk) return hastrk;unsigned int muIdx=(unsigned int) kPrimMuonIdx(slc);double len=slc->reco.trk[muIdx].len;return(len > 0);})

const Cut	kHasFlashMatch ([](const caf::SRSliceProxy *slc){return(slc->fmatch.present);})

const Cut	kFlashMatchScore ([](const caf::SRSliceProxy *slc){return(slc->fmatch.time > 0 &&slc->fmatch.score > 6);})

const Cut	kFlashMatchNumuCut = kHasFlashMatch && kFlashMatchScore

const Cut	kNumuTrkLen ([](const caf::SRSliceProxy *slc){bool hastrk=(slc->reco.ntrk > 0);if(!hastrk) return hastrk;unsigned int muIdx=(unsigned int) kPrimMuonIdx(slc);double len=slc->reco.trk[muIdx].len;return(len > 50);})

const Cut	kIsNuSlice = ( kTruthIndex >= 0.f )

const Cut	kIsCosmic = ( !kIsNuSlice )

const Cut	kIsNuMuCC ([](const caf::SRSliceProxy *slc){return(kIsNuSlice(slc)&&slc->truth.iscc &&(slc->truth.pdg==14\|\|slc->truth.pdg==-14));})

const Cut	kIsNuOther = ( kIsNuSlice && !kIsNuMuCC )

const Cut	kCryo0 ([](const caf::SRSliceProxy *slc){return(!isnan(slc->vertex.x)&&slc->vertex.x< 0);})

const Cut	kTFiducial ([](const caf::SRSliceProxy *slc){return(!isnan(slc->truth.position.x)&&((slc->truth.position.x< -71.1-25 &&slc->truth.position.x >-369.33+25)\|\|(slc->truth.position.x > 71.1+25 &&slc->truth.position.x< 369.33-25))&&!isnan(slc->truth.position.y)&&(slc->truth.position.y >-181.7+25 &&slc->truth.position.y< 134.8-25)&&!isnan(slc->truth.position.z)&&(slc->truth.position.z >-895.95+30 &&slc->truth.position.z< 895.95-50));})

const Cut	kRFiducial ([](const caf::SRSliceProxy *slc){return(!isnan(slc->vertex.x)&&((slc->vertex.x< -71.1-25 &&slc->vertex.x >-369.33+25)\|\|(slc->vertex.x > 71.1+25 &&slc->vertex.x< 369.33-25))&&!isnan(slc->vertex.y)&&(slc->vertex.y >-181.7+25 &&slc->vertex.y< 134.8-25)&&!isnan(slc->vertex.z)&&(slc->vertex.z >-895.95+30 &&slc->vertex.z< 895.95-50));})

const Cut	kNotClearCosmic ([](const caf::SRSliceProxy *slc){return!slc->is_clear_cosmic;})

const Cut	kNuScore ([](const caf::SRSliceProxy *slc){return(!isnan(slc->nu_score)&&slc->nu_score > 0.4);})

const Cut	kFMScore ([](const caf::SRSliceProxy *slc){return(!isnan(slc->fmatch.score)&&slc->fmatch.score< 7.0);})

const Cut	kPTrack ([](const caf::SRSliceProxy *slc){return(kPTrackInd(slc) >=0);})

const Cut	kPTrackContained ([](const caf::SRSliceProxy *slc){int Ind=kPTrackInd(slc);bool Contained(false);if(Ind >=0){auto const &trk=slc->reco.trk.at(Ind);Contained=(!isnan(trk.end.x)&&(trk.end.x< -71.1-25 &&trk.end.x >-369.33+25)&&!isnan(trk.end.y)&&(trk.end.y >-181.7+25 &&trk.end.y< 134.8-25)&&!isnan(trk.end.z)&&(trk.end.z >-895.95+30 &&trk.end.z< 895.95-50));}return Contained;})

const Cut	kPTrackExiting ([](const caf::SRSliceProxy *slc){int Ind=kPTrackInd(slc);bool Exiting(false);if(Ind >=0){auto const &trk=slc->reco.trk.at(Ind);Exiting=!(!isnan(trk.end.x)&&(trk.end.x< -71.1-25 &&trk.end.x >-369.33+25)&&!isnan(trk.end.y)&&(trk.end.y >-181.7+25 &&trk.end.y< 134.8-25)&&!isnan(trk.end.z)&&(trk.end.z >-895.95+30 &&trk.end.z< 895.95-50));}return Exiting;})

const Cut	kNuMuCC_Cryo0 = ( kIsNuMuCC && kCryo0 )

const Cut	kCosmic_Cryo0 = ( kIsCosmic && kCryo0 )

const Cut	kNuOther_Cryo0 = ( kIsNuOther && kCryo0 )

const Cut	kNuMuCC_TFiducial = ( kNuMuCC_Cryo0 && kTFiducial )

const Cut	kNuMuCC_RFiducial = ( kNuMuCC_Cryo0 && kRFiducial )

const Cut	kCosmic_TFiducial = ( kCosmic_Cryo0 && kTFiducial )

const Cut	kCosmic_RFiducial = ( kCosmic_Cryo0 && kRFiducial )

const Cut	kNuOther_TFiducial = ( kNuOther_Cryo0 && kTFiducial )

const Cut	kNuOther_RFiducial = ( kNuOther_Cryo0 && kRFiducial )

const Cut	kNuMuCC_ClearCos = ( kNuMuCC_TFiducial && kNotClearCosmic )

const Cut	kCosmic_ClearCos = ( kCosmic_RFiducial && kNotClearCosmic )

const Cut	kNuOther_ClearCos = ( kNuOther_TFiducial && kNotClearCosmic )

const Cut	kNuMuCC_NuScore = ( kNuMuCC_ClearCos && kNuScore )

const Cut	kCosmic_NuScore = ( kCosmic_ClearCos && kNuScore )

const Cut	kNuOther_NuScore = ( kNuOther_ClearCos && kNuScore )

const Cut	kNuMuCC_FMScore = ( kNuMuCC_NuScore && kFMScore )

const Cut	kCosmic_FMScore = ( kCosmic_NuScore && kFMScore )

const Cut	kNuOther_FMScore = ( kNuOther_NuScore && kFMScore )

const Cut	kNuMuCC_PTrack = ( kNuMuCC_FMScore && kPTrack )

const Cut	kCosmic_PTrack = ( kCosmic_FMScore && kPTrack )

const Cut	kNuOther_PTrack = ( kNuOther_FMScore && kPTrack )

const Cut	kNuMuCC_FullSelection = ( kCryo0 && kRFiducial && kNotClearCosmic && kNuScore && kFMScore && kPTrack )

const SpillCut	kLongTrack ([](const caf::SRSpillProxy *sr){bool ProgCut=false;bool NuIsNuMuCC, IsMuon, Contained;for(auto const &nu:sr->mc.nu){NuIsNuMuCC=nu.iscc &&(nu.pdg==14\|\|nu.pdg==-14);for(auto const &prim:nu.prim){IsMuon=(prim.pdg==13\|\|prim.pdg==-13);Contained=(prim.contained==1);ProgCut=ProgCut\|\|(NuIsNuMuCC &&IsMuon &&((Contained &&prim.length > 50.0)\|\|(!Contained &&prim.length > 100.0)));}}return ProgCut;})

const Cut	kIcarus202208FMTimeCut = kFMTimeVar > 0 && kFMTimeVar < 1.8

const Cut	kIcarus202208FMScoreCut = kFMScoreVar < 9

const Cut	kIcarus202208LongTrackDirCut = kCRLongestTrackDirY > -0.91

const Cut	kIcarus202208FoundMuon = kIcarus202208MuonIdx >= 0

const Cut	kIcarus202208RecoFiducial ([](const caf::SRSliceProxy *slc){return(!isnan(slc->vertex.x)&&((slc->vertex.x< -71.1-25 &&slc->vertex.x >-369.33+25)\|\|(slc->vertex.x > 71.1+25 &&slc->vertex.x< 369.33-25))&&!isnan(slc->vertex.y)&&(slc->vertex.y >-181.7+25 &&slc->vertex.y< 134.8-25)&&!isnan(slc->vertex.z)&&(slc->vertex.z >-895.95+30 &&slc->vertex.z< 895.95-50));})

const Cut	kIcarus202208NumuSelection = kIcarus202208RecoFiducial && kIcarus202208FMScoreCut && kIcarus202208FMTimeCut && kIcarus202208LongTrackDirCut && kIcarus202208FoundMuon

const Cut	kIcarus202208NoPion = kIcarus202208NumPions == 0

const Cut	kIcarus202208ContainedHadrons ([](const caf::SRSliceProxy *slc){auto idx=kIcarus202208MuonIdx(slc);int muID=-1;if(idx >=0) muID=slc->reco.trk.at(idx).pfp.id;for(auto &trk:slc->reco.trk){if(!Icarus202208contained(trk)) return false;}return true;})

const Cut	kIcarus202208ContainedMuon ([](const caf::SRSliceProxy *slc){return kIcarus202208FoundMuon(slc)&&Icarus202208contained(slc->reco.trk.at(kIcarus202208MuonIdx(slc)));})

const Cut	kIcarus202208ContainedMuonAndHadrons = kIcarus202208ContainedMuon && kIcarus202208ContainedHadrons

const Cut	kIcarus202208QELike = kIcarus202208NumuSelection && kIcarus202208NoPion && kIcarus202208ContainedHadrons

const Cut	kIcarus202208QELikeContainedMuon = kIcarus202208QELike && kIcarus202208ContainedMuon

const Cut	kInFV ([](const caf::SRSliceProxy *slc){return(slc->vertex.x >(-199.15+10)&&slc->vertex.x< (199.15-10)&&slc->vertex.y >(-200.+10)&&slc->vertex.y< (200.-10)&&slc->vertex.z >(0.0+10)&&slc->vertex.z< (500.-50));})

const Cut	kSlcFlashMatchTimeCut ([](const caf::SRSliceProxy *slc){if(std::isnan(slc->fmatch.time)) return false;bool InBeam=(slc->fmatch.time > 0.&&slc->fmatch.time< 1.800);return(InBeam);})

const Cut	kSlcFlashMatchScoreCut ([](const caf::SRSliceProxy *slc){return(slc->fmatch.score< 7);})

const Cut	kHasPrimaryMuonTrk ([](const caf::SRSliceProxy *slc){int ptrkid=kPrimaryMuonTrkIdx(slc);double ptrkrecop=kPrimaryMuonTrkP(slc);return(ptrkid!=-1 &&!isnan(ptrkrecop)&&ptrkrecop > 0.&&ptrkrecop< 7.5);})

const Cut	kCRTTrackAngleCut ([](const caf::SRSliceProxy *slc){int ptrkid=kPrimaryMuonTrkIdx(slc);const caf::SRTrackProxy &ptrk=slc->reco.trk[ptrkid];return(isnan(ptrk.crttrack.angle)\|\|ptrk.crttrack.angle > 0.05);})

const Cut	kCRTHitDistanceCut ([](const caf::SRSliceProxy *slc){int ptrkid=kPrimaryMuonTrkIdx(slc);const caf::SRCRTHitMatchProxy &crthit=slc->reco.trk[ptrkid].crthit;if(std::isnan(crthit.hit.time)\|\|std::isnan(crthit.distance)) return true;return crthit.distance > 5\|\|(crthit.hit.time > 0.&&crthit.hit.time< 1.800);})

const Cut	kInBeamSpill
	Does the event fall inside the beam spill window. More...

const Cut	kInTimingSideband
	Is the event far from the start and end of the spill window. More...

const Cut	kTrueActiveVolumeND ([](const caf::SRSliceProxy *slc){return kHasNu(slc)&&PtInVolAbsX(slc->truth.position, avnd);})

const Cut	kTrueFiducialVolumeND ([](const caf::SRSliceProxy *slc){return kHasNu(slc)&&PtInVolAbsX(slc->truth.position, fvndAbs);})

const Cut	kTrueActiveVolumeFDCryo1 ([](const caf::SRSliceProxy *slc){return kHasNu(slc)&&PtInVol(slc->truth.position, avfd_cryo1);})

const Cut	kTrueActiveVolumeFDCryo2 ([](const caf::SRSliceProxy *slc){return kHasNu(slc)&&PtInVol(slc->truth.position, avfd_cryo2);})

const Cut	kTrueFiducialVolumeFDCryo1 ([](const caf::SRSliceProxy *slc){return kHasNu(slc)&&PtInVol(slc->truth.position, fvfd_cryo1);})

const Cut	kTrueFiducialVolumeFDCryo2 ([](const caf::SRSliceProxy *slc){return kHasNu(slc)&&PtInVol(slc->truth.position, fvfd_cryo2);})

const Cut	kIsNu ([](const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return false;return slc->truth.pdg > 0;})

const Cut	kHasNu ([](const caf::SRSliceProxy *slc){return slc->truth.index >=0;})

const Cut	kIsNue ([](const caf::SRSliceProxy *slc){return slc->truth.index >=0 &&abs(slc->truth.pdg)==12;})

const Cut	kIsNumu ([](const caf::SRSliceProxy *slc){return slc->truth.index >=0 &&abs(slc->truth.pdg)==14;})

const Cut	kIsNutau ([](const caf::SRSliceProxy *slc){return slc->truth.index >=0 &&abs(slc->truth.pdg)==16;})

const Cut	kVtxDistMagCut ([](const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return true;return(kTruthVtxDistMag(slc)< 1);})

const Cut	kSlcCompletenessCut ([](const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return false;return(kCompletness(slc) > 0.5);})

const SpillCut	kIsCosmicSpill ([](const caf::SRSpillProxy *sr){return(sr->mc.nnu==0);})

const SpillCut	kIsSingleNuSpill ([](const caf::SRSpillProxy *sr){return(sr->mc.nnu< 2);})

const SpillCut	kIsNueSpill ([](const caf::SRSpillProxy *sr){if(kIsCosmicSpill(sr)\|\|!kIsSingleNuSpill(sr)) return false;return(std::abs(sr->mc.nu[0].pdg)==12);})

const SpillCut	kIsNumuSpill ([](const caf::SRSpillProxy *sr){if(kIsCosmicSpill(sr)\|\|!kIsSingleNuSpill(sr)) return false;return(std::abs(sr->mc.nu[0].pdg)==14);})

const SpillCut	kIsNutauSpill ([](const caf::SRSpillProxy *sr){if(kIsCosmicSpill(sr)\|\|!kIsSingleNuSpill(sr)) return false;return(std::abs(sr->mc.nu[0].pdg)==16);})

const SpillCut	kIsCCSpill ([](const caf::SRSpillProxy *sr){if(kIsCosmicSpill(sr)\|\|!kIsSingleNuSpill(sr)) return false;return((bool) sr->mc.nu[0].iscc);})

const SpillCut	kIsNCSpill ([](const caf::SRSpillProxy *sr){if(kIsCosmicSpill(sr)\|\|!kIsSingleNuSpill(sr)) return false;return((bool) sr->mc.nu[0].isnc);})

const std::vector< double >	kLowEnergyEdges

const std::vector< double >	kLowEnergyGeVEdges

const Binning	kNueEnergyBinning = Binning::Simple( 20, 0., 5000.)

const Binning	kNumuEnergyBinning = Binning::Simple( 20, 0., 5000.)

const Binning	kLowEnergyBinning = Binning::Custom( kLowEnergyEdges )

const Binning	kLowEnergyGeVBinning = Binning::Custom( kLowEnergyGeVEdges )

const Binning	kPositionXNDBinning = Binning::Simple(40, avnd.xmin, avnd.xmax)

const Binning	kPositionYNDBinning = Binning::Simple(40, avnd.ymin, avnd.ymax)

const Binning	kPositionZNDBinning = Binning::Simple(50, avnd.zmin, avnd.zmax)

const Binning	kPositionXFDBinning = Binning::Simple(47, avfd_cryo1.xmin, avfd_cryo1.xmax)

const Binning	kPositionYFDBinning = Binning::Simple(35, avfd_cryo1.ymin, avfd_cryo1.ymax)

const Binning	kPositionZFDBinning = Binning::Simple(90, avfd_cryo1.zmin, avfd_cryo1.zmax)

const Binning	kCRTXFDBinning = Binning::Simple(60, crtfd.xmin, crtfd.xmax)

const Binning	kCRTYFDBinning = Binning::Simple(100, crtfd.ymin, crtfd.ymax)

const Binning	kCRTZFDBinning = Binning::Simple(130, crtfd.zmin, crtfd.zmax)

const Binning	kBDTBinning = Binning::Simple(50,0, 1.0)

const Var	kLargestRecoShowerIdx ([](const caf::SRSliceProxy *slc) -> int{int bestIdx(-1);double maxEnergy(-1);for(unsigned int i=0;i< slc->reco.nshw;i++){auto const &shw=slc->reco.shw[i];continue;if(shw.bestplane_energy > maxEnergy){bestIdx=i;maxEnergy=shw.bestplane_energy;}}return bestIdx;})

const Var	kRecoShower_BestEnergy ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->bestplane_energy):-5;})

const Var	kRecoShower_TruePdg ([](const caf::SRSliceProxy slc) -> int{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?int(shw->truth.p.pdg):-5;})

const Var	kRecoShower_BestdEdx ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);if(!shw\|\|shw->bestplane_dEdx< 0) return-5.;return shw->bestplane_dEdx;})

const Var	kRecoShower_ConversionGap ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->conversion_gap):-5.;})

const Var	kRecoShower_Density ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->density):-5.;})

const Var	kRecoShower_Energy ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->plane[1].energy):-5.;})

const Var	kRecoShower_Length ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->len):-5.;})

const Var	kRecoShower_OpenAngle ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?180.*shw->open_angle/M_PI:-5.;})

const Var	kRecoShower_StartX ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->start.x):-9999.;})

const Var	kRecoShower_StartY ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->start.y):-9999.;})

const Var	kRecoShower_StartZ ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->start.z):-9999.;})

const Var	kRecoShower_EndX ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->start.x+shw->dir.x *shw->len):-9999.;})

const Var	kRecoShower_EndY ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->start.y+shw->dir.y *shw->len):-9999.;})

const Var	kRecoShower_EndZ ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->start.z+shw->dir.z *shw->len):-9999.;})

const Var	kRecoShower_densityGradient ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->selVars.densityGradient):-5.;})

const Var	kRecoShower_densityGradientPower ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->selVars.densityGradientPower):-5.;})

const Var	kRecoShower_trackLength ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->selVars.trackLength):-5.;})

const Var	kRecoShower_trackWidth ([](const caf::SRSliceProxy slc) -> double{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?double(shw->selVars.trackWidth):-5.;})

const Var	kRecoShowers_EnergyCut ([](const caf::SRSliceProxy *slc) -> unsigned{unsigned int counter(0);for(auto const &shw:slc->reco.shw){++counter;}return counter;})

const Var	kLongestTrackIdx ([](const caf::SRSliceProxy *slc) -> int{int bestIdx(-1);double maxLength(-1);for(unsigned int i=0;i< slc->reco.ntrk;i++){auto const &trk=slc->reco.trk[i];continue;if(trk.len > maxLength){bestIdx=i;maxLength=trk.len;}}return bestIdx;})

const Var	kLongestTrackTruePdg ([](const caf::SRSliceProxy slc) -> int{const caf::SRTrackProxy trk=LongestRecoTrack(slc);return trk?int(trk->truth.p.pdg):-5;})

const Var	kLongestTrackLength ([](const caf::SRSliceProxy slc) -> double{const caf::SRTrackProxy trk=LongestRecoTrack(slc);return trk?double(trk->len):-5.;})

const Var	kLongestTrackChi2Muon ([](const caf::SRSliceProxy slc) -> double{const caf::SRTrkChi2PIDProxy chi2=LongestTrackBestPlaneChi2PID(slc);return chi2?double(chi2->chi2_muon):-5.;})

const Var	kLongestTrackChi2Pion ([](const caf::SRSliceProxy slc) -> double{const caf::SRTrkChi2PIDProxy chi2=LongestTrackBestPlaneChi2PID(slc);return chi2?double(chi2->chi2_pion):-5.;})

const Var	kLongestTrackChi2Kaon ([](const caf::SRSliceProxy slc) -> double{const caf::SRTrkChi2PIDProxy chi2=LongestTrackBestPlaneChi2PID(slc);return chi2?double(chi2->chi2_kaon):-5.;})

const Var	kLongestTrackChi2Proton ([](const caf::SRSliceProxy slc) -> double{const caf::SRTrkChi2PIDProxy chi2=LongestTrackBestPlaneChi2PID(slc);return chi2?double(chi2->chi2_proton):-5.;})

const Var	kMuonTrackLength ([](const caf::SRSliceProxy slc) -> double{const caf::SRTrackProxy trk=LongestRecoTrack(slc);if(!trk) return-5;if(trk &&(kLongestTrackChi2Muon(slc)< 30.f &&kLongestTrackChi2Proton(slc) > 60.f)){return trk->len;}return-5;})

const Var	kLongestTrackDazzlePID ([](const caf::SRSliceProxy slc) -> int{const caf::SRTrackProxy trk=LongestRecoTrack(slc);return trk?(int) trk->dazzle.pdg:-5;})

const Var	kLongestTrackDazzleMuonScore ([](const caf::SRSliceProxy slc) -> float{const caf::SRTrackProxy trk=LongestRecoTrack(slc);return trk?(float) trk->dazzle.muonScore:-5.f;})

const Var	kRecoShowerRazzlePID ([](const caf::SRSliceProxy slc) -> int{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?(int) shw->razzle.pdg:-5;})

const Var	kRecoShowerRazzleElectronScore ([](const caf::SRSliceProxy slc) -> float{const caf::SRShowerProxy shw=LargestRecoShower(slc);return shw?(float) shw->razzle.electronScore:-5.f;})

const Var	kPrimMuonIdx ([](const caf::SRSliceProxy *slc) -> double{if((int) slc->reco.ntrk==0) return-5.0;double best_idx=0;double best_len=-5.0;for(unsigned int trkIdx=0;trkIdx< slc->reco.ntrk;trkIdx++){auto &trk=slc->reco.trk[trkIdx];if(trk.chi2pid[2].pid_ndof< 0) return-5.0;bool isMuonLike=trk.chi2pid[2].chi2_pion > trk.chi2pid[2].chi2_muon;if(isMuonLike &&trk.len > best_len){best_len=trk.len;best_idx=trkIdx;}}return best_idx;})

const Var	kPrimTrkLen ([](const caf::SRSliceProxy *slc) -> double{double len=-5.0;if(slc->reco.ntrk > 0){int muIdx=(int) kPrimMuonIdx(slc);if(muIdx >=0){len=slc->reco.trk[muIdx].len;}}return len;})

const Var	kTruthIndex = SIMPLEVAR(truth.index)

const Var	kPrimaryEnergy = SIMPLEVAR(truth.E)

const Var	kMuMaxTrack ([](const caf::SRSliceProxy *slc) -> float{float len(-5.f);for(auto const &trk:slc->reco.trk){if((trk.truth.p.pdg==13\|\|trk.truth.p.pdg==-13)&&trk.truth.p.length > len) len=trk.truth.p.length;}return len;})

const Var	kPTrackInd ([](const caf::SRSliceProxy *slc) -> int{float Longest(0);int PTrackInd(-1);for(std::size_t i(0);i< slc->reco.trk.size();++i){auto const &trk=slc->reco.trk.at(i);if(trk.bestplane==-1) continue;const float Atslc=std::hypot(slc->vertex.x-trk.start.x, slc->vertex.y-trk.start.y, slc->vertex.z-trk.start.z);const bool AtSlice=(Atslc< 10.0 &&trk.pfp.parent_is_primary);const float Chi2Proton=trk.chi2pid[trk.bestplane].chi2_proton;const float Chi2Muon=trk.chi2pid[trk.bestplane].chi2_muon;const bool Contained=(!isnan(trk.end.x)&&(trk.end.x< -71.1-25 &&trk.end.x >-369.33+25)&&!isnan(trk.end.y)&&(trk.end.y >-181.7+25 &&trk.end.y< 134.8-25)&&!isnan(trk.end.z)&&(trk.end.z >-895.95+30 &&trk.end.z< 895.95-50));const bool MaybeMuonExiting=(!Contained &&trk.len > 100);const bool MaybeMuonContained=(Contained &&Chi2Proton > 60 &&Chi2Muon< 30 &&trk.len > 50);{Longest=trk.len;PTrackInd=i;}}return PTrackInd;})

const Var	kRecoMuonP ([](const caf::SRSliceProxy *slc) -> float{float p(-5.f);{auto const &trk=slc->reco.trk.at(kPTrackInd(slc));const bool Contained=(!isnan(trk.end.x)&&(trk.end.x< -71.1-25 &&trk.end.x >-369.33+25)&&!isnan(trk.end.y)&&(trk.end.y >-181.7+25 &&trk.end.y< 134.8-25)&&!isnan(trk.end.z)&&(trk.end.z >-895.95+30 &&trk.end.z< 895.95-50));if(Contained) p=trk.rangeP.p_muon;else p=trk.mcsP.fwdP_muon;}return p;})

const Var	kTrueMuonP ([](const caf::SRSliceProxy *slc) -> float{float p(-5.f);{auto const &trk=slc->reco.trk.at(kPTrackInd(slc));p=std::hypot(trk.truth.p.genp.x, trk.truth.p.genp.y, trk.truth.p.genp.z);}return p;})

const Var	kCRLongestTrackDirY = SIMPLEVAR(nuid.crlongtrkdiry)

const Var	kFMTimeVar = SIMPLEVAR(fmatch.time)

const Var	kFMScoreVar = SIMPLEVAR(fmatch.score)

const Var	kIcarus202208MuonIdx ([](const caf::SRSliceProxy *slc) -> int{float Longest(0);int PTrackInd(-1);for(std::size_t i(0);i< slc->reco.trk.size();++i){auto const &trk=slc->reco.trk.at(i);if(trk.bestplane==-1) continue;const float Atslc=std::hypot(slc->vertex.x-trk.start.x, slc->vertex.y-trk.start.y, slc->vertex.z-trk.start.z);const bool AtSlice=(Atslc< 10.0 &&trk.pfp.parent_is_primary);const float Chi2Proton=trk.chi2pid[trk.bestplane].chi2_proton;const float Chi2Muon=trk.chi2pid[trk.bestplane].chi2_muon;const bool Contained=(!isnan(trk.end.x)&&((trk.end.x< -71.1-5 &&trk.end.x >-369.33+5)\|\|(trk.end.x< 71.1+5 &&trk.end.x >+369.33-5))&&!isnan(trk.end.y)&&(trk.end.y >-181.7+5 &&trk.end.y< 134.8-5)&&!isnan(trk.end.z)&&(trk.end.z >-895.95+5 &&trk.end.z< 895.95-5));const bool MaybeMuonExiting=(!Contained &&trk.len > 100);const bool MaybeMuonContained=(Contained &&Chi2Proton > 60 &&Chi2Muon< 30 &&trk.len > 50);if(AtSlice &&(MaybeMuonExiting\|\|MaybeMuonContained)&&trk.len > Longest){Longest=trk.len;PTrackInd=i;}}return PTrackInd;})

const Var	kIcarus202208NumPions ([](const caf::SRSliceProxy *slc){int count=0;auto idx=kIcarus202208MuonIdx(slc);int muID=-1;if(idx >=0) muID=slc->reco.trk.at(idx).pfp.id;for(auto &trk:slc->reco.trk){++count;}return count;})

const Var	kPrimaryMuonTrkIdx ([](const caf::SRSliceProxy *slc){double longest=-1;int best_idx=-1;double dist=-1;bool atslc, contained, maybe_muon_exiting, maybe_muon_contained;float chi2_proton, chi2_muon;for(unsigned int trkidx=0;trkidx< slc->reco.trk.size();++trkidx){const caf::SRTrackProxy &trk=slc->reco.trk[trkidx];if(trk.bestplane==-1) continue;dist=sqrt((pow(trk.start.x-slc->vertex.x, 2))+(pow(trk.start.y-slc->vertex.y, 2))+(pow(trk.start.z-slc->vertex.z, 2)));atslc=dist< 10;if(!atslc\|\|!trk.pfp.parent_is_primary) continue;contained=((-199.15+10)< trk.end.x &&trk.end.x< (199.15-10)&&(-200.+10)< trk.end.y &&trk.end.y< (200.-10)&&(0.0+10)< trk.end.z &&trk.end.z< (500.-50));chi2_proton=trk.chi2pid[trk.bestplane].chi2_proton;chi2_muon=trk.chi2pid[trk.bestplane].chi2_muon;maybe_muon_exiting=!contained &&trk.len > 100;maybe_muon_contained=contained &&chi2_proton > 60 &&chi2_muon< 30 &&trk.len > 50;if(!maybe_muon_contained &&!maybe_muon_exiting) continue;if(trk.len > longest){longest=trk.len;best_idx=trkidx;}}return best_idx;})

const Var	kPrimaryMuonTrkP ([](const caf::SRSliceProxy *slc){float recop(-5.f);bool contained(false);if(kPrimaryMuonTrkIdx(slc) >=0){auto const &ptrk=slc->reco.trk.at(kPrimaryMuonTrkIdx(slc));contained=((-199.15+10)< ptrk.end.x &&ptrk.end.x< (199.15-10)&&(-200.+10)< ptrk.end.y &&ptrk.end.y< (200.-10)&&(0.0+10)< ptrk.end.z &&ptrk.end.z< (500.-50));if(contained) recop=ptrk.rangeP.p_muon;else recop=ptrk.mcsP.fwdP_muon;}return recop;})

const Var	kCRTTrkTime ([](const caf::SRSliceProxy *slc) -> double{float crttrktime(-5.f);if(kPrimaryMuonTrkIdx(slc) >=0){int ptrkid=kPrimaryMuonTrkIdx(slc);const caf::SRTrackProxy &ptrk=slc->reco.trk[ptrkid];crttrktime=ptrk.crthit.hit.time;}return crttrktime;})

const Var	kCRTTrkAngle ([](const caf::SRSliceProxy *slc) -> double{float crttrkangle(-5.f);if(kPrimaryMuonTrkIdx(slc) >=0){int ptrkid=kPrimaryMuonTrkIdx(slc);const caf::SRTrackProxy &ptrk=slc->reco.trk[ptrkid];crttrkangle=ptrk.crttrack.angle;}return crttrkangle;})

const Var	kCRTHitDist ([](const caf::SRSliceProxy *slc) -> double{float crttrkdist(-5.f);if(kPrimaryMuonTrkIdx(slc) >=0){int ptrkid=kPrimaryMuonTrkIdx(slc);const caf::SRTrackProxy &ptrk=slc->reco.trk[ptrkid];crttrkdist=ptrk.crthit.distance;}return crttrkdist;})

const Var	kPrimaryMuonTrkLen ([](const caf::SRSliceProxy *slc) -> double{float ptrklen(-5.f);if(kPrimaryMuonTrkIdx(slc) >=0){int ptrkid=kPrimaryMuonTrkIdx(slc);const caf::SRTrackProxy &ptrk=slc->reco.trk[ptrkid];ptrklen=ptrk.len;}return ptrklen;})

const Var	kHasTruthMatch ([](const caf::SRSliceProxy *slc) -> double{return(slc->truth.index!=-1);})

const Var	kCompletness ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) slc->tmatch.eff:-5.f);})

const Var	kTruthEnergy ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) slc->truth.E:-5.f);})

const Var	kTruthVtxX ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) slc->truth.position.x:-999.f);})

const Var	kTruthVtxY ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) slc->truth.position.y:-999.f);})

const Var	kTruthVtxZ ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) slc->truth.position.z:-999.f);})

const Var	kTruthVtxDistX ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) std::abs(slc->truth.position.x-kSlcVtxX(slc)):-999.f);})

const Var	kTruthVtxDistY ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) std::abs(slc->truth.position.y-kSlcVtxY(slc)):-999.f);})

const Var	kTruthVtxDistZ ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) std::abs(slc->truth.position.z-kSlcVtxZ(slc)):-999.f);})

const Var	kTruthVtxDistMag ([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) std::hypot(kTruthVtxDistX(slc), kTruthVtxDistY(slc), kTruthVtxDistZ(slc)):-5.f);})

const SpillVar	kTruthNuEnergy ([](const caf::SRSpillProxy *sr) -> double{return(sr->mc.nnu!=1?-5.f:(float) sr->mc.nu[0].E);})

const SpillVar	kTruthLeptonEnergy ([](const caf::SRSpillProxy *sr) -> double{if(sr->mc.nnu!=1) return-5.f;for(auto const &prim:sr->mc.nu[0].prim){if(std::abs(prim.pdg)!=11 &&std::abs(prim.pdg)!=13) continue;return prim.startE;}return-5.f;})

const SpillVar	kRun = SIMPLESPILLVAR(hdr.run)

const SpillVar	kEvt = SIMPLESPILLVAR(hdr.evt)

const Var	kCounting = kUnweighted

const SpillVar	kSpillCounting = kSpillUnweighted

const SpillMultiVar	kCRTHitX ([](const caf::SRSpillProxy *sr){std::vector< double > positions;for(const auto &hit:sr->crt_hits){positions.push_back(hit.position.x);}return positions;})

const SpillMultiVar	kCRTHitY ([](const caf::SRSpillProxy *sr){std::vector< double > positions;for(const auto &hit:sr->crt_hits){positions.push_back(hit.position.y);}return positions;})

const SpillMultiVar	kCRTHitZ ([](const caf::SRSpillProxy *sr){std::vector< double > positions;for(const auto &hit:sr->crt_hits){positions.push_back(hit.position.z);}return positions;})

const SpillMultiVar	kCRTHitPE ([](const caf::SRSpillProxy *sr){std::vector< double > pes;for(const auto &hit:sr->crt_hits){pes.push_back(hit.pe);}return pes;})

const SpillMultiVar	kCRTHitTime ([](const caf::SRSpillProxy *sr){std::vector< double > times;for(const auto &hit:sr->crt_hits){times.push_back(hit.time);}return times;})

const SpillMultiVar	kCRTHitTimeFD ([](const caf::SRSpillProxy *sr){std::vector< double > times;for(const auto &hit:sr->crt_hits){auto thistime=hit.time-1600.;times.push_back(thistime);}return times;})

const Var	kSlcVtxX ([](const caf::SRSliceProxy *slc) -> double{return slc->vertex.x;})

const Var	kSlcVtxY ([](const caf::SRSliceProxy *slc) -> double{return slc->vertex.y;})

const Var	kSlcVtxZ ([](const caf::SRSliceProxy *slc) -> double{return slc->vertex.z;})

const Var	kSlcNuScore ([](const caf::SRSliceProxy *slc) -> double{return slc->nu_score;})

const Var	kSlcHasFlash ([](const caf::SRSliceProxy *slc) -> double{return slc->fmatch.present;})

const Var	kSlcFlashScore ([](const caf::SRSliceProxy *slc) -> double{return((bool) kSlcHasFlash(slc)?(float) slc->fmatch.score:-5.f);})

Detailed Description

Oscillation analysis framework, runs over CAF files outside of ART.

Beam spill duration is 1.6 microseconds TO DO: Change numbers to reflect reality: Where the beam spill actually starts after the beam trigger?

All analysis code is defined in namespace "ana"

Typedef Documentation

typedef _Cut<caf::SRSliceProxy> ana::Cut

Definition at line 95 of file Cut.h.

typedef double( ana::ExposureFunc_t)(const caf::SRSpill *spill)

Definition at line 24 of file Cut.h.

typedef _HistAxis<Var> ana::HistAxis

Definition at line 62 of file HistAxis.h.

typedef _MultiVar<caf::SRSliceProxy> ana::MultiVar

Definition at line 48 of file MultiVar.h.

typedef _Cut<caf::SRSliceProxy> ana::SliceCut

Representation of a cut (selection) to be applied to a caf::StandardRecord object.

A Cut consists of a function, taking a StandardRecord and returning a boolean indicating if that event passes the cut.

Cut objects may be combined with the standard boolean operations && || and !

Definition at line 94 of file Cut.h.

typedef _Cut<caf::SRSpillProxy> ana::SpillCut

Equivalent of Cut acting on caf::SRSpill. For use in spill-by-spill data quality cuts.

Definition at line 99 of file Cut.h.

typedef _HistAxis<SpillVar> ana::SpillHistAxis

Definition at line 63 of file HistAxis.h.

typedef _MultiVar<caf::SRSpillProxy> ana::SpillMultiVar

Definition at line 49 of file MultiVar.h.

typedef _Cut<caf::SRSpillTruthBranch> ana::SpillTruthCut

Cut designed to be used over the nuTree, ie all neutrinos, not just those that got slices.

Definition at line 103 of file Cut.h.

typedef _Var<caf::SRSpillProxy> ana::SpillVar

Equivalent of Var acting on caf::SRSpill.

Definition at line 76 of file Var.h.

typedef _Var<caf::SRSliceProxy> ana::Var

Representation of a variable to be retrieved from a caf::StandardRecord object.

A Var consists of a function, taking a StandardRecord and returning the value of the variable (which may be some complicated function).

Definition at line 73 of file Var.h.

Enumeration Type Documentation

enum ana::DataSource

Is this data-file representing beam spills or cosmic spills?

Enumerator
kBeam
kCosmic

Definition at line 28 of file SpectrumLoaderBase.h.

                  {
     // TODO there are no longer any actions taken as a result of this
     // distinction. Remove after SA.
     kBeam,
     kCosmic
   };

enum ana::EBinType

Enumerator
kBinContent	Regular histogram.
kBinDensity	Divide bin contents by bin widths.

Definition at line 36 of file sbnana/sbnana/CAFAna/Core/Utilities.h.

   {
     kBinContent, ///< Regular histogram
     kBinDensity  ///< Divide bin contents by bin widths
   };

enum ana::EExposureType

For use as an argument to Spectrum::ToTH1.

Enumerator
kPOT
kLivetime

Definition at line 44 of file sbnana/sbnana/CAFAna/Core/Utilities.h.

                     {
     kPOT,
     kLivetime
   };

enum ana::EnergyScaleSystDetector

strong

Enumerator
kSBND
kMicroBooNE
kICARUS
kAll

Definition at line 26 of file EnergySysts.h.

                                      {
     kSBND,
     kMicroBooNE,
     kICARUS,
     kAll
   };

enum ana::EnergyScaleSystParticle

strong

Enumerator
kMuon
kHadron
kNeutron
kEM
kChargedHadron

Definition at line 18 of file EnergySysts.h.

                                      {
     kMuon,
     kHadron,
     kNeutron,
     kEM,
     kChargedHadron
   };

enum ana::EnergyScaleSystTerm

strong

Enumerator
kConstant
kSqrt
kInverseSqrt

Definition at line 12 of file EnergySysts.h.

                                  {
     kConstant,
     kSqrt,
     kInverseSqrt
   };

enum ana::ESide

strong

Desired match type in UniverseOracle::ClosestShiftIndex.

Enumerator
kAbove
kBelow
kEither

Definition at line 12 of file UniverseOracle.h.

                   {
     kAbove, kBelow, kEither
   };

enum ana::SterileOscAngles

strong

Enumerator
kNone
kSinSq2ThetaMuMu
kSinSq2ThetaMuE
kSinSq2ThetaEE

Definition at line 7 of file OscCalcSterileApprox.h.

                               {
     kNone = 0,
     kSinSq2ThetaMuMu = 1,
     kSinSq2ThetaMuE  = (1 << 1),
     kSinSq2ThetaEE   = (1 << 2)
   };

Function Documentation

bool ana::AlmostEqual	(	double	a,
		double	b
	)

Definition at line 799 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     if(a == 0 && b == 0) return true;
 
     return fabs(a-b)/std::max(a, b) < .0001; // allow 0.01% error
   }

TLegend * ana::AutoPlaceLegend	(	double	dx,
		double	dy,
		double	yPin = `-1`
	)

Create a legend, maximizing distance from all histograms.

Parameters

dx	Width of the legend, fraction of pad width
dy	Height of the legend, fraction of pad height
yPin,height	in NDC (frac) to pin center of legend, i.e only move x

Definition at line 510 of file Plots.cxx.

   {
     gPad->Update();
 
     // Convert requested width and height into physics coordinates
     dx *= (gPad->GetX2()-gPad->GetX1());
     dy *= (gPad->GetY2()-gPad->GetY1());
 
     // Range of axes in physics units
     const double x0 = gPad->GetUxmin();
     const double x1 = gPad->GetUxmax();
     const double y0 = gPad->GetUymin();
     const double y1 = gPad->GetUymax();
 
     const double X = x1-x0;
     const double Y = y1-y0;
 
     double bestd = 0;
     double bestx = 0;
     double besty = 0;
     // If we want to pin Y pos, set it to that now.
     if(yPin >= 0) besty = yPin * (gPad->GetY2()-gPad->GetY1());
 
     for(bool fallback: {false, true}){
       for(double x = x0+dx/2; x < x1-dx/2; x += X/50){
         for(double y = y0+dy/2; y < y1-dy/2; y += Y/50){
           double d = 999999;
 
           // Repel from edges
           d = std::min(d, util::sqr((x-dx/2-x0)/X));
           d = std::min(d, util::sqr((x+dx/2-x1)/X));
           d = std::min(d, util::sqr((y-dy/2-y0)/Y));
           d = std::min(d, util::sqr((y+dy/2-y1)/Y));
           if(d < bestd) continue;
 
           TIter next(gPad->GetListOfPrimitives());
           while(TObject* obj = next()){
 
             if(!obj->InheritsFrom(TH1::Class())) continue;
             if( obj->InheritsFrom(TH2::Class())) continue;
 
             TH1* h = (TH1*)obj;
 
             for(int n = 1; n <= h->GetNbinsX(); ++n){
               const double px = h->GetBinCenter(n);
               const double py = h->GetBinContent(n);
 
               if(fallback){
                 d = std::min(d, util::sqr((px-x)/X)+util::sqr((py-y)/Y));
               }
               else{
                 d = std::min(d, PointDistanceToBox(px/X, py/Y,
                                                    (x-dx/2)/X, (y-dy/2)/Y,
                                                    (x+dx/2)/X, (y+dy/2)/Y));
               }
               if(d < bestd) break;
             }
             if(d < bestd) break;
           } // end while
 
           if(d > bestd){
             bestd = d;
             bestx = x;
             // Update Y if we're not pinning it.
             if (yPin < 0) besty = y;
           }
         } // end for y
       } // end for x
 
       if(bestd != 0) break; // If we always collide, have to do fallback
     } // end for fallback
 
     // Convert to pad coordinates
     const double nx = (bestx-gPad->GetX1())/(gPad->GetX2()-gPad->GetX1());
     const double ny = (besty-gPad->GetY1())/(gPad->GetY2()-gPad->GetY1());
 
     const double ndx = dx/(gPad->GetX2()-gPad->GetX1());
     const double ndy = dy/(gPad->GetY2()-gPad->GetY1());
 
     return new TLegend(nx-ndx/2, ny-ndy/2, nx+ndx/2, ny+ndy/2);
   }

double ana::AvgSinSq	(	double	k,
		double	a,
		double	b
	)

Definition at line 145 of file OscCalcSterileApprox.cxx.

   {
     // This function shows up high in profiles, and is often called with the same masses/baselines/energies
     static std::map<std::tuple<double, double, double>, double> cache;
     const std::tuple<double, double, double> key = {k, a, b};
 
     // energies times masses times baselines plus some slack
     if(cache.size() > 100*100*10) cache.clear();
 
     auto it = cache.find(key);
     if(it != cache.end()) return it->second;
 
     double ret = 0;
     if(a == b){
       ret = util::sqr(sin(k/a));
     }
     else{
       // https://www.wolframalpha.com/input/?i=integral+sin%5E2(k%2Fx)+from+a+to+b
       ret = k*(Si(2*k/a)-Si(2*k/b));
       assert(!isnan(ret));
       if(a) ret -= a * util::sqr(sin(k/a));
       assert(!isnan(ret));
       if(b) ret += b * util::sqr(sin(k/b));
       assert(!isnan(ret));
 
       ret /= (b-a);
     }
 
     cache[key] = ret;
     return ret;
   }

const caf::SRTrkChi2PIDProxy* ana::BestPlaneChi2PID ( const caf::SRTrackProxy * trk )

Definition at line 193 of file NueVars.cxx.

 {
   if(trk->bestplane == -1) return 0;
   return &trk->chi2pid[trk->bestplane];
 }

double ana::BinCenter	(	const TAxis *	ax,
		int	bin,
		bool	islog
	)

inline

Definition at line 32 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

   {
     return islog ? ax->GetBinCenterLog(bin) : ax->GetBinCenter(bin);
   }

std::unique_ptr< TMatrixD > ana::CalcCovMx	(	const std::vector< TArrayD * > &	binSets,
		int	firstBin = `0`,
		int	lastBin = `-1`
	)

Compute bin-to-bin covariance matrix from a collection of sets of bin contents.

Parameters

binSets	Collection of sets of bins from which covariances should be calculated
firstBin	The first bin that should be considered (inclusive)
lastBin	The last bin that should be considered (inclusive). -1 means "last in set"

Returns: unique_ptr to TMatrixD containing computed covariance matrix unless binSets.size() < 2, in which case the unique_ptr's target is nullptr.

Note TH1D is a child class of TArrayD – so you can pass a vector of TH1D* to this method.

Definition at line 118 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     if (binSets.size() < 2)
       return std::unique_ptr<TMatrixD>(nullptr);
 
     if (lastBin < 0)
       lastBin = binSets[0]->GetSize() - 1;  // indexed from 0
 
     int nBins = lastBin - firstBin + 1;  // firstBin and lastBin are inclusive
 
     std::vector<double> binMeans(nBins);
     for( const auto & binSet : binSets )
     {
       for ( decltype(lastBin) binIdx = firstBin; binIdx <= lastBin; binIdx++ )
         binMeans[binIdx] += (*binSet)[binIdx];
     }
     for (decltype(lastBin) binIdx = firstBin; binIdx <= lastBin; binIdx++)
       binMeans[binIdx] /= binSets.size();
 
 
     auto covmx = std::make_unique<TMatrixD>(nBins, nBins);
 
     for( unsigned int hist_idx = 0; hist_idx < binSets.size(); ++hist_idx )
     {
       // first calculate the weighted sum of squares of the deviations
       for( decltype(nBins) i = 0; i < nBins; i++ )
       {
         double xi = (*(binSets[hist_idx]))[i];
         for( decltype(nBins) k = i; k < nBins; k++ )
         {
           double xk = (*(binSets[hist_idx]))[k];
           (*covmx)[i][k] += (xi - binMeans[i]) * (xk - binMeans[k]);
           if (i != k)
             (*covmx)[k][i] = (*covmx)[i][k];  // covariance matrices are always symmetric
         }
       }
     } // for (hist_idx)
 
     // now divide by N-1 to get sample covariance
     (*covmx) *= 1./(binSets.size()-1);
 
     return covmx;
   }

double ana::Chi2CovMx	(	const TVectorD *	e,
		const TVectorD *	o,
		const TMatrixD *	covmxinv
	)

Definition at line 221 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     assert (e->GetNrows() == o->GetNrows());
 
     TVectorD diff = *o - *e;
     return diff * ((*covmxinv) * diff);  // operator* for two TVectorDs is the "dot product" (i.e., v1 * v2 = v1^{trans}v1)
   }

double ana::Chi2CovMx	(	const TH1 *	e,
		const TH1 *	o,
		const TMatrixD *	covmxinv
	)

Definition at line 230 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     TVectorD eVec(e->GetNbinsX());
     TVectorD oVec(o->GetNbinsX());
     for (int bin = 1; bin <= e->GetNbinsX(); bin++)
       eVec[bin-1] = e->GetBinContent(bin);
     for (int bin = 1; bin <= o->GetNbinsX(); bin++)
       oVec[bin-1] = o->GetBinContent(bin);
 
     return Chi2CovMx(&eVec, &oVec, covmxinv);
   }

void ana::ClearTrueParticles ( caf::StandardRecord * sr )

Definition at line 25 of file FileReducer.cxx.

   {
     sr->true_particles.clear();
     sr->ntrue_particles = 0;
   }

std::function<ExposureFunc_t> ana::CombineExposures	(	const std::function< ExposureFunc_t > &	a,
		const std::function< ExposureFunc_t > &	b
	)

Definition at line 26 of file Cut.cxx.

   {
     if(!a && !b) return 0;
     if(!a) return b;
     if(!b) return a;
 
     return [a, b](const caf::SRSpill* spill){
       const double va = a(spill);
       const double vb = b(spill);
 
       if(va >= 0 && vb >= 0){
         std::cout << "Inconsistent pot/livetime values of "
                   << va << " and " << vb
                   << " from two cuts being combined." << std::endl;
         abort();
       }
 
       return std::max(va, vb);
     };
   }

void ana::CombineMetadata	(	std::map< std::string, std::string > &	base,
		const std::map< std::string, std::string > &	add,
		std::set< std::string > &	mask
	)

Definition at line 612 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     for(auto it: add){
       const std::string& key = it.first;
 
       // Needs special handling anyway, skip it
       if(key == "parents") continue;
 
       // Accumulate the runs list
       if(key == "runs"){
         const std::string& r1 = base[key];
         const std::string& r2 = it.second;
 
         assert(!r2.empty());
 
         // Strip the outermost enclosing []
         const std::string& r2tmp = r2.substr(1, r2.length()-2);
 
         // Check that the run/subrun is not already present
         if (r1.find(r2tmp) != std::string::npos){
           std::cout << "Found files with duplicate run/subrun metadata: " << r2tmp << std::endl;
 
           abort();
         } 
 
         if(r1.empty()){
           base[key] = r2;
           continue;
         }
 
         // "[foo]" + "[bar]"
         std::string sum = r1+&r2[1]; // "[foo]bar]"
         sum[r1.size()-1] = ',';      // "[foo,bar]"
         base[key] = sum;
         continue;
       }
 
       if(base.find(key) == base.end()){
         // If it's new, add it
         base[key] = it.second;
       }
       else{
         if(key == "simulated.number_of_spills" ||
            key == "event_count" ||
            key == "online.totalevents"){
           // These two fields should be accumulated
           base[key] = TString::Format("%d",
                                       atoi(base[key].c_str()) +
                                       atoi(it.second.c_str())).Data();
         }
         else{
           // If it's a clash, record it
           if(base[key] != it.second) mask.insert(key);
         }
       }
     }
   }

Var ana::Constant ( double c )

Use to weight events up and down by some factor.

Definition at line 165 of file Var.cxx.

   {
     return Var([c](const caf::SRSliceProxy*){return c;});
   }

void ana::CountingExperimentErrorBarChart	(	const std::map< std::string, double > &	systs,
		double	statErr = `0`,
		bool	bkgdOrSig = `false`,
		bool	shortchart = `false`
	)

Make a simple plot of relative size of different errors.

Parameters

systs	Map from error label to size in percent
statErr	Percentage statistical error. Optional.
bkgdOrSig	Label axis for background or signal. Default (false) = bkgd

void ana::DataMCAreaNormalizedRatio	(	const Spectrum &	data,
		const IPrediction *	mc,
		osc::IOscCalc *	calc,
		double	miny,
		double	maxy
	)

Plot data/MC ratio for the given spectrum. Normalize MC to Data by area.

Definition at line 328 of file Plots.cxx.

   {
     DataMCAreaNormalizedRatio(data, mc->Predict(calc), miny, maxy);
   }

void ana::DataMCAreaNormalizedRatio	(	const Spectrum &	data,
		const Spectrum &	mc,
		double	miny,
		double	maxy
	)

Plot data/MC ratio for the given spectrum. Normalize MC to Data by area.

Definition at line 337 of file Plots.cxx.

   {
     Spectrum mcScaled = mc;
     mcScaled.OverridePOT(mcScaled.POT() * mc.Integral(1) / data.Integral(1));
 
     DataMCRatio(data, mcScaled, miny, maxy);
   }

TH1 * ana::DataMCComparison	(	const Spectrum &	data,
		const Spectrum &	mc
	)

Overlay MC spectrum with data spectrum

Returns: The first histogram drawn so you can alter axis labels etc

Definition at line 32 of file Plots.cxx.

   {
     TH1* ret = 0;
 
     TH1* hMC = mc.ToTH1(data.POT());
     hMC->SetLineColor(kTotalMCColor);
 
     TH1* hData = data.ToTH1(data.POT());
     hData->Sumw2();
     hData->SetMarkerStyle(kFullCircle);
 
     // Need to draw the biggest thing first to get correct axis limits
     if(hMC->GetMaximum() > hData->GetMaximum()+sqrt(hData->GetMaximum())){
       ret = hMC;
       hMC->Draw("hist");
       hData->Draw("ep same");
     }
     else{
       ret = hData;
       hData->Draw("ep");
       hMC->Draw("hist same");
       hData->Draw("ep same"); // Data always goes on top
     }
 
     gPad->Update();
 
     return ret;
   }

TH1 * ana::DataMCComparisonAreaNormalized	(	const Spectrum &	data,
		const Spectrum &	mc
	)

Overlay MC spectrum with data spectrum, area normalized

Returns: The first histogram drawn so you can alter axis labels etc

Definition at line 62 of file Plots.cxx.

   {
     TH1* ret = 0;
 
     TH1* hMC = mc.ToTH1(mc.POT());
     hMC->SetLineColor(kTotalMCColor);
 
     TH1* hData = data.ToTH1(data.POT());
     hData->Sumw2();
     hData->SetMarkerStyle(kFullCircle);
 
     hMC->Scale(hData->Integral()/hMC->Integral());
 
     // Need to draw the biggest thing first to get correct axis limits
     if(hMC->GetMaximum() > hData->GetMaximum()+sqrt(hData->GetMaximum())){
       ret = hMC;
       hMC->Draw("hist");
       hData->Draw("ep same");
     }
     else{
       ret = hData;
       hData->Draw("ep");
       hMC->Draw("hist same");
       hData->Draw("ep same"); // Data always goes on top
     }
 
     gPad->Update();
 
     return ret;
   }

TH1 * ana::DataMCComparisonComponents	(	const Spectrum &	data,
		const IPrediction *	mc,
		osc::IOscCalc *	calc
	)

Plot MC broken down into flavour components, overlayed with data.

Returns: The first histogram drawn so you can alter axis labels etc

Definition at line 94 of file Plots.cxx.

   {
     TH1* ret = 0;
 
     TH1* hMC = mc->Predict(calc).ToTH1(data.POT());
     hMC->SetLineColor(kTotalMCColor);
 
     TH1* hNC = mc->PredictComponent(calc,
                                     Flavors::kAll,
                                     Current::kNC,
                                     Sign::kBoth).ToTH1(data.POT());
     hNC->SetLineColor(kNCBackgroundColor);
 
     TH1* hCC = mc->PredictComponent(calc,
                                     Flavors::kAllNuMu,
                                     Current::kCC,
                                     Sign::kBoth).ToTH1(data.POT());
     hCC->SetLineColor(kNumuBackgroundColor);
 
     TH1* hBeam = mc->PredictComponent(calc,
                                       Flavors::kNuEToNuE,
                                       Current::kCC,
                                       Sign::kBoth).ToTH1(data.POT());
     hBeam->SetLineColor(kBeamNueBackgroundColor);
 
     TH1* hData = data.ToTH1(data.POT());
     hData->SetMarkerStyle(kFullCircle);
 
     // Need to draw the biggest thing first to get correct axis limits
     if(hMC->GetMaximum() > hData->GetMaximum()+sqrt(hData->GetMaximum())){
       ret = hMC;
       hMC->Draw("hist");
       hData->Draw("ep same");
     }
     else{
       ret = hData;
       hData->Draw("ep");
       hMC->Draw("hist same");
       hData->Draw("ep same"); // Data always goes on top
     }
 
     hNC->Draw("hist same");
     hCC->Draw("hist same");
     hBeam->Draw("hist same");
 
     gPad->Update();
 
     return ret;
   }

void ana::DataMCRatio	(	const Spectrum &	data,
		const IPrediction *	mc,
		osc::IOscCalc *	calc,
		double	miny,
		double	maxy
	)

Plot data/MC ratio for the given spectrum. Normalize MC to Data by POT.

Definition at line 299 of file Plots.cxx.

   {
     DataMCRatio(data, mc->Predict(calc), miny, maxy);
   }

void ana::DataMCRatio	(	const Spectrum &	data,
		const Spectrum &	mc,
		double	miny,
		double	maxy
	)

Plot data/MC ratio for the given spectrum. Normalize MC to Data by POT.

Definition at line 308 of file Plots.cxx.

   {
     Ratio ratio(data, mc);
     TH1* h = ratio.ToTH1();
     h->GetYaxis()->SetTitle("Data / MC");
     h->GetYaxis()->SetRangeUser(miny, maxy);
     h->Draw();
 
     TLine* one = new TLine(h->GetXaxis()->GetXmin(), 1,
                            h->GetXaxis()->GetXmax(), 1);
     one->SetLineWidth(2);
     one->SetLineStyle(7);
     one->Draw();
 
     gPad->Update();
   }

const ReactorExperiment * ana::DayaBayConstraint2014 ( )

A ReactorExperiment initialized with the Nu2014 Daya Bay constraints.

Definition at line 56 of file ReactorExperiment.cxx.

   {
     // Daya Bay, Neutrino 2014:
     // https://indico.fnal.gov/getFile.py/access?contribId=256&sessionId=15&resId=0&materialId=slides&confId=8022
     return new ReactorExperiment(.084, .005);
   }

osc::IOscCalcAdjustable * ana::DefaultOscCalc ( )

Create a new calc with default assumptions for all parameters.

Definition at line 39 of file Calcs.cxx.

   {
     osc::IOscCalcAdjustable* ret = new osc::OscCalcPMNSOpt;
     ResetOscCalcToDefault(ret);
     return ret;
   }

osc::IOscCalcAdjustable * ana::DefaultOscCalcIH ( )

Definition at line 58 of file Calcs.cxx.

   {
     osc::IOscCalcAdjustable* ret = new osc::OscCalcPMNSOpt;
     ResetOscCalcToDefaultIH(ret);
     return ret;
   }

OscCalcSterileApproxAdjustable * ana::DefaultSterileApproxCalc ( SterileOscAngles angles )

Definition at line 293 of file OscCalcSterileApprox.cxx.

   {
     auto ret = new OscCalcSterileApproxAdjustable;
     ret->calc.SetDmsq(0);
     if((angles & SterileOscAngles::kSinSq2ThetaMuMu) != SterileOscAngles::kNone)
       ret->calc.SetSinSq2ThetaMuMu(0);
     if((angles & SterileOscAngles::kSinSq2ThetaMuE) != SterileOscAngles::kNone)
       ret->calc.SetSinSq2ThetaMuE(0);
     if((angles & SterileOscAngles::kSinSq2ThetaEE) != SterileOscAngles::kNone)
       ret->calc.SetSinSq2ThetaEE(0);
     ret->calc.SetL(0); // make clear this is uninitialized
 
     return ret;
   }

osc::OscCalcSterile * ana::DefaultSterileCalc ( int nflavors )

Create a sterile calc with default assumptions for all parameters.

Definition at line 87 of file Calcs.cxx.

   {
     osc::OscCalcSterile* ret = new osc::OscCalcSterile;
 
     if(nflavors < 3) {
       std::cout << "The default calc requires at least 3 flavors." << std::endl;
       std::cout << "Using 3 flavors." << std::endl;
       ret->SetNFlavors(3);
     }
     else {
       ret->SetNFlavors(nflavors);
     }
 
     ResetSterileCalcToDefault(ret);
     return ret;
   }

const OscCalcSterileApprox * ana::DowncastToSterileApprox	(	const osc::IOscCalc *	calc,
		bool	allowFail
	)

Definition at line 309 of file OscCalcSterileApprox.cxx.

   {
     const OscCalcSterileApprox* ret1
       = dynamic_cast<const OscCalcSterileApprox*>(calc);
     if(ret1) return ret1;
 
     const OscCalcSterileApproxAdjustable* ret2
       = dynamic_cast<const OscCalcSterileApproxAdjustable*>(calc);
     if(ret2) return &ret2->calc;
 
     if(allowFail) return 0;
 
     std::cout << "Calculator was not of type OscCalcSterileApprox." << std::endl;
     abort();
   }

OscCalcSterileApprox * ana::DowncastToSterileApprox	(	osc::IOscCalc *	calc,
		bool	allowFail
	)

Definition at line 326 of file OscCalcSterileApprox.cxx.

   {
     OscCalcSterileApprox* ret1
       = dynamic_cast<OscCalcSterileApprox*>(calc);
     if(ret1) return ret1;
 
     OscCalcSterileApproxAdjustable* ret2
       = dynamic_cast<OscCalcSterileApproxAdjustable*>(calc);
     if(ret2) return &ret2->calc;
 
     if(allowFail) return 0;
 
     std::cout << "Calculator was not of type OscCalcSterileApprox." << std::endl;
     abort();
   }

void ana::DrawComponentsLegend	(	TH1 *	hnue,
		TH1 *	hnumu,
		TH1 *	hnc,
		TH1 *	hcos,
		TH1 *	hother
	)

Definition at line 146 of file tools_nuesel_icarus.h.

                                                                                     {
   // TLegend *l = new TLegend(0.60, 0.65, 0.85, 0.85, NULL,"brNDC");
     TLegend *l = new TLegend(0.70, 0.70, 0.85, 0.85, NULL,"brNDC");
     l->SetFillStyle(0);
     l->SetTextSize(0.035);
     // l->SetHeader(pot_tag.c_str());
     // l->SetHeader("Integral");
     // l->AddEntry(hnue,   Form("#nu_{e} CC:   %.2f", hnue->Integral()),   "l");
     // l->AddEntry(hnumu,  Form("#nu_{#mu} CC: %.2f", hnumu->Integral()),  "l");
     // l->AddEntry(hnc,    Form("NC:           %.2f", hnc->Integral()),    "l");
     // l->AddEntry(hcos,   Form("Cosmics:      %.2f", hcos->Integral()),   "l");
     // l->AddEntry(hother, Form("Other bkg:    %.2f", hother->Integral()), "l");
     l->AddEntry(hnue,   "#nu_{e} CC",   "l");
     l->AddEntry(hnumu,  "#nu_{#mu} CC", "l");
     l->AddEntry(hnc,    "NC",           "l");
     l->AddEntry(hcos,   "Cosmics",      "l");
     l->AddEntry(hother, "Other bkg",    "l");
     l->Draw("");
   }

void ana::DrawEffPurLegend	(	TH1D *	g1,
		char *	name1,
		TH1D *	g2,
		char *	name2
	)

Definition at line 230 of file tools_nuesel_icarus.h.

                                                                      {
 
     TLegend *leg = new TLegend(.65,.2,.85,.3);
     leg->AddEntry(g1, name1,"l");
     leg->AddEntry(g2, name2,"l");
     leg->SetBorderSize(0); //no border for legend
     leg->SetFillColor(0);  //fill colour is white
     leg->SetFillStyle(0);  //fill colour is white
     leg->SetTextSize(0.03); // this goes in the split canvas so use smaller text
     leg->Draw();
 
   }

void ana::DrawErrorBand	(	TH1 *	nom,
		TGraphAsymmErrors *	band,
		int	bandCol,
		double	alpha
	)

Definition at line 196 of file EnsembleSpectrum.cxx.

   {
     if(bandCol == -1) bandCol = nom->GetLineColor()-10; // hopefully a lighter version
 
     // Check if this pad has already been drawn in
     const bool same = gPad && !gPad->GetListOfPrimitives()->IsEmpty();
 
     nom->Draw(same ? "hist same" : "hist");
 
     band->SetFillColorAlpha(bandCol, alpha);
     band->Draw("e2 same");
 
     nom->Draw("hist same");
 
     // If we are the first spectrum to draw, scale the y-axis appropriately to
     // fit the error band as well as the nominal
     if(!same){
       double maxY = 0;
       // Don't consider underflow or overflow bins when determining maximum
       for(int i = 1; i < band->GetN()-1; ++i){
         maxY = std::max(maxY, band->GetY()[i] + band->GetErrorYhigh(i));
       }
 
       // Use non-zero lower value so that SetLogy() still works
       nom->GetYaxis()->SetRangeUser(1e-10, 1.1 * maxY);
     }
 
     gPad->RedrawAxis();
   }

void ana::DrawIntEffPurLegend	(	TH1D *	g1,
		char *	name1,
		TH1D *	g2,
		char *	name2
	)

Definition at line 199 of file tools_nuesel_icarus.h.

                                                                         {
     
     float int1 = g1->Integral();
     float int2 = g2->Integral();
     TLegend *leg = new TLegend(.65,.2,.85,.3);
     leg->AddEntry(g1, name1,"l");
     leg->AddEntry(g2, name2,"l");
     // leg->AddEntry(g1, Form("%s: %2.f", name1, int1),"l");
     // leg->AddEntry(g2, Form("%s: %2.f", name2, int2),"l");
     leg->SetBorderSize(0); //no border for legend
     leg->SetFillColor(0);  //fill colour is white
     leg->SetFillStyle(0);  //fill colour is white
     leg->SetTextSize(0.03); // this goes in the split canvas so use smaller text
     leg->Draw();
 
   }

void ana::DrawPurLegend	(	TH1D *	g1,
		char *	name1
	)

Definition at line 217 of file tools_nuesel_icarus.h.

                                            {
 
     TLegend *leg = new TLegend(.65,.25,.85,.35);
     leg->AddEntry(g1, name1,"l");
     leg->SetBorderSize(0); //no border for legend
     leg->SetFillColor(0);  //fill colour is white
     leg->SetFillStyle(0);  //fill colour is white
     leg->SetTextSize(0.03); // this goes in the split canvas so use smaller text
     leg->Draw();
 
   }

void ana::DrawSigBkgIntLegend	(	TH1 *	h1,
		char *	name1,
		double	iSig,
		TH1 *	h2,
		char *	name2,
		double	iBkg
	)

Definition at line 180 of file tools_nuesel_icarus.h.

                                                                                                 {
 
     //double iRatio = iBac/iSig;
 
     TLegend *leg = new TLegend(.60,.60,.8,.8);
     leg->AddEntry(h1, name1,"l");
     leg->AddEntry(h1, TString::Format("%.2f",iSig),"");
     leg->AddEntry(h2, name2,"l");
     leg->AddEntry(h2, TString::Format("%.2f",iBkg),"");
     //leg->AddEntry(h2, TString::Format("Ratio=%.2f",iRatio),"");
     leg->SetBorderSize(0); //no border for legend                                                                                                                                                                                                                             
     leg->SetFillColor(0);  //fill colour is white                                                                                                                                                                                                                             
     leg->SetFillStyle(0);  //fill colour is white                                                                                                                                                                                                                             
     leg->SetTextSize(0.04);
     leg->Draw();
 
   }

void ana::DrawSigBkgIntText	(	TH1 *	hsig,
		TH1 *	hbkg,
		float	textsize
	)

Definition at line 243 of file tools_nuesel_icarus.h.

                                                               {
 
     float isig = hsig->Integral();
     float ibkg = hbkg->Integral();
     float psig = 100. * isig / (isig + ibkg);
     float pbkg = 100. * ibkg / (isig + ibkg);
 
     TPaveText *pText1 = new TPaveText(0.15, 0.84, 0.30, 0.89, "brNDC");
     TText *text1 = (pText1->AddText("6.6 #times 10^{20} POT"));
     text1->SetTextSize(textsize);
     pText1->SetBorderSize(0);
     pText1->SetFillStyle(0);
     pText1->Draw();
     TPaveText *pText2 = new TPaveText(0.15, 0.72, 0.30, 0.80, "brNDC");
     TText *text2 = pText2->AddText(Form("Sig: %2.f = %2.f %%", isig, psig));
     text2->SetTextAlign(11);
     text2->SetTextSize(textsize);
     TText *text3 = pText2->AddText(Form("Bkg: %2.f = %2.f %%", ibkg, pbkg));
     text3->SetTextAlign(11);
     text3->SetTextSize(textsize);
     pText2->SetBorderSize(0);
     pText2->SetFillStyle(0);
     pText2->Draw();
   }

void ana::DrawSigBkgLegend	(	TH1 *	h1,
		char *	name1,
		TH1 *	h2,
		char *	name2
	)

Definition at line 166 of file tools_nuesel_icarus.h.

                                                                    {
 
     TLegend *leg = new TLegend(.60,.60,.8,.8);
     leg->AddEntry(h1, name1,"l");
     leg->AddEntry(h2, name2,"l");
     leg->SetBorderSize(0); //no border for legend
     leg->SetFillColor(0);  //fill colour is white
     leg->SetFillStyle(0);  //fill colour is white
     leg->SetTextSize(0.04);
     leg->Draw();
 
   }

TGraph* ana::EffOrPurGraph	(	TH1 *	hSelSignal,
		TH1 *	hSelBack,
		TH1 *	hSignal,
		bool	geteff
	)

Definition at line 292 of file tools_nuesel_icarus.h.

                                                                                    {
 
     const int NBins = hSignal->GetNbinsX();
 
     TString xTitle = hSignal->GetXaxis()->GetTitle();
     TString yTitle = hSignal->GetYaxis()->GetTitle();
 
     double eff[NBins], pur[NBins], val[NBins];
     double sb[NBins], ssb[NBins];
 
     // loop over bins to calculate eff and pur as functions of the bin
     for(unsigned int i = 1; i <= (unsigned int)NBins; ++i) {
       double allsig = hSignal   ->GetBinContent(i);
       double selsig = hSelSignal->GetBinContent(i);
       double selbac = hSelBack  ->GetBinContent(i);
 
       val[i-1] = hSignal->GetBinCenter(i);
       double EFF = selsig;
       double PUR = selsig;
 
       if ( (selsig + selbac) > 0 ){
         if ( allsig > 0 ) EFF = EFF/allsig;
         PUR = PUR / (selsig + selbac);
       }
 
       eff[i-1] = EFF;
       pur[i-1] = PUR;
       if ( PUR > 1 || EFF > 1 ){
         std::cout << "\n\n\n" << " >>> EFF " << EFF << "\t PUR " << PUR << std::endl;
       }
     }
 
     TString n = hSignal->GetName();
     TGraph *graphPur= new TGraph(NBins,val,pur);
     graphPur->SetName("SelPur_"+n);
     graphPur->GetXaxis()->SetTitle(xTitle);
     graphPur->GetYaxis()->SetTitle("Pur.");
     TGraph *graphEff= new TGraph(NBins,val,eff);
     graphEff->SetName("SelEff_"+n);
     graphEff->GetXaxis()->SetTitle(xTitle);
     graphEff->GetYaxis()->SetTitle("Eff.");
 
     if ( geteff )
       return graphEff;
     else
       return graphPur;
 
   }

TH1D* ana::EffOrPurHistogram	(	TH1 *	hSelSignal,
		TH1 *	hSelBack,
		TH1 *	hSignal,
		bool	geteff
	)

Definition at line 271 of file tools_nuesel_icarus.h.

                                                                                      {
 
     //
     // Make a ROC TGraph for the given signal and background histos
     //
     TH1D* hTotal = (TH1D*)hSelSignal->Clone();
     hTotal->Add(hSelBack);
 
     TH1D* hPurity = (TH1D*)hSelSignal->Clone();
     hPurity->Divide(hTotal);
 
     TH1D* hEfficiency = (TH1D*)hSelSignal->Clone();
     hEfficiency->Divide(hSignal);
 
     if ( geteff )
       return hEfficiency;
     else
       return hPurity;
 
   }

void ana::EnsurePositiveDefinite ( TH2 * mat )

Definition at line 903 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     // Convert histogram to a proper matrix
     assert(mat->GetNbinsX() == mat->GetNbinsY());
     const int N = mat->GetNbinsX();
     TMatrixD m(N, N);
     for(int i = 0; i < N; ++i)
       for(int j = 0; j < N; ++j)
         m(i, j) = mat->GetBinContent(i+1, j+1);
 
     // Decompose it
     TVectorD evals;
     TMatrixD evecs = m.EigenVectors(evals);
     TMatrixD evalmat(N, N);
     // Force any negative eigenvalues slightly positive (floating point errors)
     for(int i = 0; i < N; ++i) evalmat(i, i) = std::max(1e-14, evals[i]);
 
     // Put the original matrix back together
     const TMatrixD evecs_inv(TMatrixD::kTransposed, evecs);
     m = evecs*evalmat*evecs_inv;
 
     // Decompose again to check for floating point problems
     m.EigenVectors(evals);
     for(int i = 0; i < N; ++i) assert(evals[i] > 0);
 
     // Copy the new matrix contents back into the histogram
     for(int i = 0; i < N; ++i)
       for(int j = 0; j < N; ++j)
         mat->SetBinContent(i+1, j+1, m(i, j));
   }

TH2F* ana::ExpandedHistogram	(	const std::string &	title,
		int	nbinsx,
		double	xmin,
		double	xmax,
		bool	xlog,
		int	nbinsy,
		double	ymin,
		double	ymax,
		bool	ylog
	)

Definition at line 243 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     DontAddDirectory guard;
 
     if(xlog){xmin = log(xmin); xmax = log(xmax);}
     if(ylog){ymin = log(ymin); ymax = log(ymax);}
 
     // How wide the bins will be once we're done
     const double xwidth = (xmax-xmin)/(nbinsx-1);
     const double ywidth = (ymax-ymin)/(nbinsy-1);
 
     // Move the bin edges so that the limits occur at the centres
     xmin -= xwidth/2; ymin -= ywidth/2;
     xmax += xwidth/2; ymax += ywidth/2;
 
     std::vector<double> xedges(nbinsx+1);
     std::vector<double> yedges(nbinsy+1);
 
     for(int i = 0; i <= nbinsx; ++i){
       xedges[i] = xmin + (xmax-xmin)*i/double(nbinsx);
       if(xlog) xedges[i] = exp(xedges[i]);
     }
     for(int i = 0; i <= nbinsy; ++i){
       yedges[i] = ymin + (ymax-ymin)*i/double(nbinsy);
       if(ylog) yedges[i] = exp(yedges[i]);
     }
 
     return new TH2F(UniqueName().c_str(), title.c_str(),
                     nbinsx, &xedges.front(),
                     nbinsy, &yedges.front());
   }

std::string ana::Experiment ( )

$EXPERIMENT or a nice error message and abort

Definition at line 92 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     const char* ret = getenv("EXPERIMENT");
 
     if(!ret){
       std::cout << "\nERROR: Environment variable $EXPERIMENT not set." << std::endl;
       exit(1);
     }
 
     return ret;
   }

ana::fBins ( {binsX, binsY} )

ana::fCachedHash ( 0 )

Definition at line 42 of file OscillatableSpectrum.cxx.

   {
     fTrueLabel = "True baseline / True energy (km / GeV)";
 
     DontAddDirectory guard;
 
     fHist = HistCache::NewTH2D("", bins, kTrueLOverEBins);
 
     loader.AddReweightableSpectrum(*this, var, cut, shift, wei);
   }

void ana::FillWithDimColor	(	TH1 *	h,
		bool	usealpha = `false`,
		float	dim = `0.8`
	)

Definition at line 130 of file tools_nuesel_icarus.h.

   {
     if ( usealpha ){
       h->SetFillColorAlpha(h->GetLineColor(),dim);
       return;
     }
     TColor *color = gROOT->GetColor(h->GetLineColor());
     float R,G,B,hR,hG,hB,hHue,hSat,hVal;
     color->GetRGB(hR,hG,hB);
     color->RGB2HSV(hR,hG,hB,hHue,hSat,hVal);
     color->HSV2RGB(hHue,dim*hSat,hVal,R,G,B);
     h->SetFillColor(color->GetColor(R,G,B));
   }

std::string ana::FindCAFAnaDir ( )

Definition at line 562 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     return std::string(getenv("MRB_SOURCE"))+"/sbnana/sbnana/CAFAna";
   }

std::vector< double > ana::FindCurveCrossings	(	TH1 *	h,
		double	critVal
	)

Intended for use on the output of Profile.

Returns a list of all the x-coordinates at which the curve described by h crosses critVal. eg using critVal=1 will find the 1sigma lower and upper bounds.

Definition at line 691 of file Fit.cxx.

   {
     std::vector<double> ret;
 
     // Don't look at the under/overflow bins because they don't have properly
     // defined centre positions in any case. Stop one short because we compare
     // i and i+1 inside the loop.
     for(int i = 1; i < h->GetNbinsX(); ++i){
       const double x0 = h->GetXaxis()->GetBinCenter(i);
       const double x1 = h->GetXaxis()->GetBinCenter(i+1);
 
       const double y0 = h->GetBinContent(i);
       const double y1 = h->GetBinContent(i+1);
 
       // Passed the critical value between the two points
       if((y0 < critVal) != (y1 < critVal)){
         // Interpolate the actual crossing point
         const double x = x0 + (x1-x0)*(critVal-y0)/(y1-y0);
         ret.push_back(x);
       }
     } // end for i
 
     return ret;
   }

double ana::FindOptimumCut	(	TH1 *	hsig,
		TH1 *	hbkg,
		double &	best_fom
	)

Search for optimum cut position given signal and background histograms.

Parameters

	hsig	Signal distribution
	hbkg	Background distribution
[out]	best_fom	Figure of Merit obtained by best cut

Returns: Best cut position

Definition at line 37 of file CutOptimizer.cxx.

   {
     double nsig = 0;
     double nbkg = 0;
     best_fom = 0;
     double best_cut = -1;
 
     for(int binIdx = hsig->GetNbinsX()+1; binIdx >= 0; --binIdx){
       nsig += hsig->GetBinContent(binIdx);
       nbkg += hbkg->GetBinContent(binIdx);
       const double fom = nsig ? nsig/sqrt(nsig+nbkg) : 0;
       if(fom > best_fom){
         best_fom = fom;
         best_cut = hsig->GetXaxis()->GetBinLowEdge(binIdx);
       }
     } // end for binIdx
 
     return best_cut;
   }

double ana::FindQuantile	(	double	frac,
		std::vector< double > &	xs
	)

Definition at line 974 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     // This turns out to be a much more fraught issue than you would naively
     // expect. This algorithm is equivalent to R-6 here:
     // https://en.wikipedia.org/wiki/Quantile#Estimating_quantiles_from_a_sample
 
     // In principle we could use std::nth_element(). Probably doesn't matter
     // much in practice since this is only for plotting.
     std::sort(xs.begin(), xs.end());
 
     const int N = xs.size();
     // The index we would ideally be sampling at
     const double h = frac*(N+1);
     // The indices on either side where we have to actually evaluate
     const unsigned int h0 = std::floor(h);
     const unsigned int h1 = std::ceil(h);
     if(h0 == 0) return xs[0]; // Don't underflow indexing
     if(h1 > xs.size()) return xs.back(); // Don't overflow indexing
     // The values at those indices
     const double x0 = xs[h0-1]; // wikipedia is using 1-based indexing
     const double x1 = xs[h1-1];
 
     if(h0 == h1) return x0;
 
     // Linear interpolation
     return (h1-h)*x0 + (h-h0)*x1;
   }

TGraph * ana::FindValley	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const IFitVar &	scanVar,
		const IFitVar &	fitVar,
		int	nbinsx,
		double	xmin,
		double	xmax,
		const std::vector< const IFitVar * > &	profVars = `{}`,
		const std::vector< const ISyst * > &	profSysts = `{}`,
		const std::map< const IFitVar *, std::vector< double >> &	seedPts = `{}`,
		const std::vector< SystShifts > &	systsSeedPts = `{}`,
		bool	transpose = `false`
	)

Find the minimum in one variable as a function of another.

Parameters

transpose plot scanVar on the y axis

Definition at line 657 of file Fit.cxx.

   {
     TGraph* g = new TGraph;
     g->SetLineWidth(2);
 
     std::vector<const IFitVar*> vars = profVars;
     vars.push_back(&fitVar);
 
     for(int i = 0; i <= nbinsx; ++i){
       const double x = xmin + i*(xmax-xmin)/nbinsx;
       scanVar.SetValue(calc, x);
       Fitter fit(expt, vars, profSysts);
       SystShifts shiftSeed = SystShifts::Nominal();
       fit.Fit(calc, shiftSeed, seedPts, systSeedPts, Fitter::kQuiet);
       const double y = fitVar.GetValue(calc);
       if(transpose)
         g->SetPoint(i, y, x);
       else
         g->SetPoint(i, x, y);
     }
 
     return g;
   }

TString ana::fixLatexName ( TString mystring )

Definition at line 35 of file tools_nuesel_icarus.h.

                                         {
     // latex doesnt like underscores
     std::vector<TString> in = {"#"," ",".","_"};
     std::vector<TString> out = {"","","","\\_"};
 
     for(unsigned int i=0;i<in.size();i++)
       mystring.ReplaceAll(in[i],out[i]);
     return mystring;
   }

TH2* ana::Flat	(	double	level,
		const Surface &	s
	)

Helper function for the gaussian approximation surfaces.

Definition at line 525 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

   {
     TH2* h = s.ToTH2();
 
     for(int x = 0; x < h->GetNbinsX()+2; ++x)
       for(int y = 0; y < h->GetNbinsY()+2; ++y)
         h->SetBinContent(x, y, level);
 
     return h;
   }

ana::fSplitBySign ( mode = = kSplitBySign )

Definition at line 37 of file PredictionInterp.cxx.

   {
     for(const ISyst* syst: systs){
       ShiftedPreds sp;
       sp.systName = syst->ShortName();
 
       for(int x = -syst->PredInterpMaxNSigma(); x <= +syst->PredInterpMaxNSigma(); ++x){
         sp.shifts.push_back(x);
       }
 
       for(int sigma: sp.shifts){
         SystShifts shiftHere = shiftMC;
         shiftHere.SetShift(syst, sigma);
         sp.preds.push_back(predGen.Generate(loaders, shiftHere).release());
       }
 
       fPreds.emplace(syst, sp);
     } // end for syst
 
     fPredNom = predGen.Generate(loaders, shiftMC);
   }

ana::fVars ( {varX, varY} )

Definition at line 39 of file HistAxis.cxx.

             {varX, varY})
   {
   }

TH2 * ana::Gaussian2Sigma1D ( const Surface & s )

Up-value surface for 2 sigma confidence in 1D in gaussian approximation.

Definition at line 548 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

548 {return Flat(4.00, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian2Sigma2D ( const Surface & s )

Up-value surface for 2 sigma confidence in 2D in gaussian approximation.

Definition at line 540 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

540 {return Flat(6.18, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian3Sigma1D ( const Surface & s )

Up-value surface for 3 sigma confidence in 1D in gaussian approximation.

Definition at line 550 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

550 {return Flat(9.00, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian3Sigma1D1Sided ( const Surface & s )

Up-value surface for 3 sigma confidence in 1D in 1-sided gaussian approximation.

Definition at line 555 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

555 {return Flat(7.74, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian3Sigma2D ( const Surface & s )

Up-value surface for 3 sigma confidence in 2D in gaussian approximation.

Definition at line 542 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

542 {return Flat(11.83, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian5Sigma1D1Sided ( const Surface & s )

Up-value surface for 5 sigma confidence in 1D in 1-sided gaussian approximation.

Definition at line 556 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

556 {return Flat(23.66, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian5Sigma2D ( const Surface & s )

Up-value surface for 5 sigma confidence in 2D in gaussian approximation.

Definition at line 543 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

543 {return Flat(28.74, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian68Percent1D ( const Surface & s )

Up-value surface for 68% confidence in 1D in gaussian approximation.

Definition at line 545 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

545 {return Flat(1.00, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian68Percent2D ( const Surface & s )

Up-value surface for 68% confidence in 2D in gaussian approximation.

Definition at line 537 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

537 {return Flat(2.30, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian90Percent1D ( const Surface & s )

Up-value surface for 90% confidence in 1D in gaussian approximation.

Definition at line 546 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

546 {return Flat(2.71, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian90Percent1D1Sided ( const Surface & s )

Up-value surface for 90% confidence in 1D in 1-sided gaussian approximation.

Definition at line 552 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

552 {return Flat(1.64, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian90Percent2D ( const Surface & s )

Up-value surface for 90% confidence in 2D in gaussian approximation.

Definition at line 538 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

538 {return Flat(4.61, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian95Percent1D ( const Surface & s )

Up-value surface for 95% confidence in 1D in gaussian approximation.

Definition at line 547 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

547 {return Flat(3.84, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian95Percent1D1Sided ( const Surface & s )

Up-value surface for 95% confidence in 1D in 1-sided gaussian approximation.

Definition at line 553 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

553 {return Flat(2.71, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian95Percent2D ( const Surface & s )

Up-value surface for 95% confidence in 2D in gaussian approximation.

Definition at line 539 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

539 {return Flat(5.99, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian99Percent1D ( const Surface & s )

Up-value surface for 99% confidence in 1D in gaussian approximation.

Definition at line 549 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

549 {return Flat(6.63, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian99Percent1D1Sided ( const Surface & s )

Up-value surface for 99% confidence in 1D in 1-sided gaussian approxiamtion.

Definition at line 554 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

554 {return Flat(5.41, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

TH2 * ana::Gaussian99Percent2D ( const Surface & s )

Up-value surface for 99% confidence in 2D in gaussian approximation.

Definition at line 541 of file sbnana/sbnana/CAFAna/Analysis/Surface.cxx.

541 {return Flat(9.21, s);}

s

then echo File list $list not found else cat $list while read file do echo $file sed s

Definition: file_to_url.sh:60

ana::Flat

TH2 * Flat(double level, const Surface &s)

Helper function for the gaussian approximation surfaces.

Definition: sbnana/sbnana/CAFAna/Analysis/Surface.cxx:525

void ana::gdb_backtrace ( )

Definition at line 16 of file DebugHelpers.cxx.

   {
     // Have to end with a 'kill' command, otherwise GDB winds up sending us
     // SIGSTOP and never resuming us afterwards.
     char s[1024];
     sprintf(s, "gdb --batch -ex 'set confirm off' -ex sharedlibrary -ex bt -ex kill root.exe %d", getpid());
     system(s);
   }

std::vector< const ISyst * > ana::GetAllNuMIFluxSysts ( unsigned int Npcs )

Combination of all beamline systs plus Npcs hadron production components.

Definition at line 160 of file NuMIFluxSysts.cxx.

   {
     std::vector<const ISyst*> ret = GetNuMIBeamlineFluxSysts();
     std::vector<const ISyst*> add = GetNuMIPCAFluxSysts(Npcs);
     ret.insert(ret.end(), add.begin(), add.end());
     return ret;
   }

std::vector< const ISyst * > ana::GetBigEnergySysts ( )

Definition at line 185 of file EnergySysts.cxx.

                                               {
     return {&kEnergyScaleMuonBig,
             &kEnergyScaleMuonSqrtBig,
             &kEnergyScaleMuonInvSqrtBig,
             &kEnergyScaleMuonNDBig,
             &kEnergyScaleMuonSqrtNDBig,
             &kEnergyScaleMuonInvSqrtNDBig,
             //&kEnergyScaleMuonUBBig,
             //&kEnergyScaleMuonSqrtUBBig,
             //&kEnergyScaleMuonInvSqrtUBBig,
             &kEnergyScaleMuonFDBig,
             &kEnergyScaleMuonSqrtFDBig,
             &kEnergyScaleMuonInvSqrtFDBig,
             &kEnergyScaleHadronBig,
             &kEnergyScaleHadronSqrtBig,
             &kEnergyScaleHadronInvSqrtBig,
             &kEnergyScaleHadronNDBig,
             &kEnergyScaleHadronSqrtNDBig,
             &kEnergyScaleHadronInvSqrtNDBig,
             //&kEnergyScaleHadronUBBig,
             //&kEnergyScaleHadronSqrtUBBig,
             //&kEnergyScaleHadronInvSqrtUBBig,
             &kEnergyScaleHadronFDBig,
             &kEnergyScaleHadronSqrtFDBig,
             &kEnergyScaleHadronInvSqrtFDBig};
   }

const BoosterFluxHadronSyst * ana::GetBoosterFluxHadronSyst ( unsigned int i )

Definition at line 63 of file BoosterFluxSysts.cxx.

 {
   // Make sure we always give the same one back
   static std::vector<const BoosterFluxHadronSyst*> cache;
 
   if(i >= cache.size()) cache.resize(i+1);
 
   if(!cache[i]) cache[i] = new BoosterFluxHadronSyst(i);
 
   return cache[i];
 }

BoosterFluxHadronSystVector ana::GetBoosterFluxHadronSysts ( unsigned int N )

Parameters

N	total number of systematics

Definition at line 76 of file BoosterFluxSysts.cxx.

 {
   BoosterFluxHadronSystVector ret;
   for(unsigned int i = 0; i < N; ++i)
     ret.push_back(GetBoosterFluxHadronSyst(i));
 
   return ret;
 }

std::map<std::string, std::string> ana::GetCAFMetadata ( TDirectory * dir )

Definition at line 587 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     std::map<std::string, std::string> ret;
 
     TTree* tr = (TTree*)dir->Get("metatree");
     if(!tr){
       std::cout << "Failed to find metadata tree in input CAF. Metadata will be blank." << std::endl;
       return ret;
     }
 
     std::string key, value;
     std::string* pkey = &key;
     std::string* pvalue = &value;
     tr->SetBranchAddress("key", &pkey);
     tr->SetBranchAddress("value", &pvalue);
 
     for(int i = 0; i < tr->GetEntries(); ++i){
       tr->GetEntry(i);
       ret[key] = value;
     }
 
     return ret;
   }

std::vector< const ISyst * > ana::GetEnergySysts ( )

Definition at line 128 of file EnergySysts.cxx.

                                            {
     // MicroBooNE, ChargedHadron, Neutron, and EM systs
     // not being used right now
     return {&kEnergyScaleMuon,
             &kEnergyScaleMuonSqrt,
             &kEnergyScaleMuonInvSqrt,
             &kEnergyScaleMuonND,
             &kEnergyScaleMuonSqrtND,
             &kEnergyScaleMuonInvSqrtND,
             //&kEnergyScaleMuonUB,
             //&kEnergyScaleMuonSqrtUB,
             //&kEnergyScaleMuonInvSqrtUB,
             &kEnergyScaleMuonFD,
             &kEnergyScaleMuonSqrtFD,
             &kEnergyScaleMuonInvSqrtFD,
             &kEnergyScaleHadron,
             //&kEnergyScaleChargedHadron,
             //&kEnergyScaleEM,
             //&kEnergyScaleNeutron,
             &kEnergyScaleHadronSqrt,
             //&kEnergyScaleEMSqrt,
             //&kEnergyScaleNeutronSqrt,
             &kEnergyScaleHadronInvSqrt,
             //&kEnergyScaleEMInvSqrt,
             //&kEnergyScaleNeutronInvSqrt,
             &kEnergyScaleHadronND,
             //&kEnergyScaleChargedHadronND,
             //&kEnergyScaleEMND,
             //&kEnergyScaleNeutronND,
             &kEnergyScaleHadronSqrtND,
             //&kEnergyScaleEMSqrtND,
             //&kEnergyScaleNeutronSqrtND,
             &kEnergyScaleHadronInvSqrtND,
             //&kEnergyScaleEMInvSqrtND,
             //&kEnergyScaleNeutronInvSqrtND,
             //&kEnergyScaleHadronUB,
             //&kEnergyScaleChargedHadronUB,
             //&kEnergyScaleEMUB,
             //&kEnergyScaleNeutronUB,
             //&kEnergyScaleHadronSqrtUB,
             //&kEnergyScaleEMSqrtUB,
             //&kEnergyScaleNeutronSqrtUB,
             //&kEnergyScaleHadronInvSqrtUB,
             //&kEnergyScaleEMInvSqrtUB,
             //&kEnergyScaleNeutronInvSqrtUB,
             &kEnergyScaleHadronFD,
             //&kEnergyScaleChargedHadronFD,
             //&kEnergyScaleEMFD,
             //&kEnergyScaleNeutronFD,
             &kEnergyScaleHadronSqrtFD,
             //&kEnergyScaleEMSqrtFD,
             //&kEnergyScaleNeutronSqrtFD,
             //&kEnergyScaleEMInvSqrtFD,
             //&kEnergyScaleNeutronInvSqrtFD,
             &kEnergyScaleHadronInvSqrtFD};
   }

std::pair< double, double > ana::GetGenieDialLimits ( const std::string & name )

Definition at line 33 of file GenieWeightList.cxx.

                                                                   {
 
     static std::map<std::string,std::pair<double,double>> genieMap = {
       // Regular dials
       {"MaCCQE",{-3,3}},
       {"MaNCEL",{-3,3}},
       {"EtaNCEL",{-3,3}},
       {"MaCCRES",{-3,3}},
       {"MvCCRES",{-3,3}},
       {"MaNCRES",{-3,3}},
       {"MvNCRES",{-3,3}},
       {"RDecBR1gamma",{-3,3}},
       {"RDecBR1eta",{-3,3}},
       {"AhtBY",{-3,3}},
       {"BhtBY",{-3,3}},
       {"CV1uBY",{-3,3}},
       {"CV2uBY",{-3,3}},
       {"BeRPA_A",{-3,3}},
       {"BeRPA_B",{-3,3}},
       {"BeRPA_D",{-3,3}},
       {"BeRPA_E",{-3,3}},
       
       // NRpi dials
       {"NR_nu_n_CC_2Pi",{-2,3}},
       {"NR_nu_n_CC_3Pi",{-2,3}},
       {"NR_nu_p_CC_2Pi",{-2,3}},
       {"NR_nu_p_CC_3Pi",{-2,3}},
       {"NR_nu_np_CC_1Pi",{-2,3}},
       {"NR_nu_n_NC_1Pi",{-2,3}},
       {"NR_nu_n_NC_2Pi",{-2,3}},
       {"NR_nu_n_NC_3Pi",{-2,3}},
       {"NR_nu_p_NC_1Pi",{-2,3}},
       {"NR_nu_p_NC_2Pi",{-2,3}},
       {"NR_nu_p_NC_3Pi",{-2,3}},
       {"NR_nubar_n_CC_1Pi",{-2,3}},
       {"NR_nubar_n_CC_2Pi",{-2,3}},
       {"NR_nubar_n_CC_3Pi",{-2,3}},
       {"NR_nubar_p_CC_1Pi",{-2,3}},
       {"NR_nubar_p_CC_2Pi",{-2,3}},
       {"NR_nubar_p_CC_3Pi",{-2,3}},
       {"NR_nubar_n_NC_1Pi",{-2,3}},
       {"NR_nubar_n_NC_2Pi",{-2,3}},
       {"NR_nubar_n_NC_3Pi",{-2,3}},
       {"NR_nubar_p_NC_1Pi",{-2,3}},
       {"NR_nubar_p_NC_2Pi",{-2,3}},
       {"NR_nubar_p_NC_3Pi",{-2,3}},
       
       // FSI
       {"FormZone",{-2,2}},
       {"MFP_pi",{-2,2}},
       {"FrCEx_pi",{-2,2}},
       {"FrElas_pi",{-2,2}},
       {"FrInel_pi",{-2,2}},
       {"FrAbs_pi",{-2,2}},
       {"FrPiProd_pi",{-2,2}},
       {"MFP_N",{-2,2}},
       {"FrCEx_N",{-2,2}},
       {"FrElas_N",{-2,2}},
       {"FrInel_N",{-2,2}},
       {"FrAbs_N",{-2,2}},
       {"FrPiProd_N",{-2,2}},
       
       // On/Off dials
       {"VecFFCCQEshape",{-1,1}},
       {"Theta_Delta2Npi",{-1,1}},
       {"CCQEPauliSupViaKF",{-1,1}},
       {"Mnv2p2hGaussEnhancement",{-1,1}},
       {"MKSPP_ReWeight",{-1,1}},
       {"E2p2h_A_nu",{-1,1}},
       {"E2p2h_B_nu",{-1,1}},
       {"E2p2h_A_nubar",{-1,1}},
       {"E2p2h_B_nubar",{-1,1}},
       {"C12ToAr40_2p2hScaling_nu",{-1,1}},
       {"C12ToAr40_2p2hScaling_nubar",{-1,1}},
       {"nuenuebar_xsec_ratio",{-1,1}},
       {"nuenumu_xsec_ratio",{-1,1}},
       {"SPPLowQ2Suppression",{-1,1}}
     };
     
     if (genieMap.find(name) == genieMap.end()){
       std::cout << "Warning, no known systematic called " << name << " returning nominal" << std::endl;
       return {-3,3};
     }
     return genieMap[name];
   }

int ana::GetGenieIndex	(	const std::string &	name,
		bool	quiet
	)

Definition at line 121 of file GenieWeightList.cxx.

   {
     const std::vector<std::string> names = GetGenieWeightNames();
 
     auto it = std::find(names.begin(), names.end(), name);
 
     if(it == names.end()){
       if(!quiet){
         std::cerr << "Warning: couldn't find " << name
                   << " in list of genie systs" << std::endl;
       }
       return -1;
     }
 
     return it-names.begin();
   }

double ana::GetGenieMax ( int index )

Definition at line 148 of file GenieWeightList.cxx.

                                {
     static const std::vector<std::string> names = GetGenieWeightNames();
     return GetGenieDialLimits(names[index]).second;
   }  

double ana::GetGenieMin ( int index )

Definition at line 143 of file GenieWeightList.cxx.

                                {
     static const std::vector<std::string> names = GetGenieWeightNames();
     return GetGenieDialLimits(names[index]).first;
   }

std::string ana::GetGenieWeightName ( int index )

Definition at line 138 of file GenieWeightList.cxx.

                                          {
     const std::vector<std::string> names = GetGenieWeightNames();
     return names[index];
   }

std::vector< std::string > ana::GetGenieWeightNames ( )

Definition at line 9 of file GenieWeightList.cxx.

   {
     // I wonder if we can share this somehow with the code that generates these?
     return {"MaCCQE","VecFFCCQEshape",
         "MaNCEL","EtaNCEL","MaCCRES","MvCCRES",
         "MaNCRES","MvNCRES","RDecBR1gamma","RDecBR1eta",
         "Theta_Delta2Npi","AhtBY","BhtBY","CV1uBY",
         "CV2uBY","FormZone","MFP_pi","FrCEx_pi",
         "FrElas_pi","FrInel_pi","FrAbs_pi","FrPiProd_pi",
         "MFP_N","FrCEx_N","FrElas_N","FrInel_N",
         "FrAbs_N","FrPiProd_N","CCQEPauliSupViaKF","Mnv2p2hGaussEnhancement",
         "MKSPP_ReWeight","E2p2h_A_nu","E2p2h_B_nu","E2p2h_A_nubar",
         "E2p2h_B_nubar","NR_nu_n_CC_2Pi","NR_nu_n_CC_3Pi","NR_nu_p_CC_2Pi",
         "NR_nu_p_CC_3Pi","NR_nu_np_CC_1Pi","NR_nu_n_NC_1Pi","NR_nu_n_NC_2Pi",
         "NR_nu_n_NC_3Pi","NR_nu_p_NC_1Pi","NR_nu_p_NC_2Pi","NR_nu_p_NC_3Pi",
         "NR_nubar_n_CC_1Pi","NR_nubar_n_CC_2Pi","NR_nubar_n_CC_3Pi","NR_nubar_p_CC_1Pi",
         "NR_nubar_p_CC_2Pi","NR_nubar_p_CC_3Pi","NR_nubar_n_NC_1Pi","NR_nubar_n_NC_2Pi",
         "NR_nubar_n_NC_3Pi","NR_nubar_p_NC_1Pi","NR_nubar_p_NC_2Pi","NR_nubar_p_NC_3Pi",
         "BeRPA_A","BeRPA_B","BeRPA_D","BeRPA_E",
         "C12ToAr40_2p2hScaling_nu","C12ToAr40_2p2hScaling_nubar",
         "nuenuebar_xsec_ratio","nuenumu_xsec_ratio","SPPLowQ2Suppression"
         };
   }

float ana::GetHistMax ( std::vector< TH1 * > histos )

Definition at line 108 of file tools_nuesel_icarus.h.

                                           {
 
     float hmax = 0.;
     for(unsigned int hId=0; hId<histos.size(); hId++){
       float thismax = histos[hId]->GetMaximum();
       if(thismax>hmax) hmax=thismax;
     }
     return hmax;
   }

TH1* ana::GetMaskHist	(	const Spectrum &	s,
		double	xmin,
		double	xmax,
		double	ymin,
		double	ymax
	)

Definition at line 936 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     if (s.GetBinnings().size() > 2){
       std::cout << "Error: unable to apply a mask in " << s.GetBinnings().size() << " dimensions" << std::endl;
       abort();
     }
 
     // The exposure isn't important here
     TH1* fMaskND  = s.ToTHX(s.POT());
     TH1D* fMask1D = s.ToTH1(s.POT());
 
     int ybins = fMaskND->GetNbinsY();
 
     for(int i = 0; i < fMask1D->GetNbinsX()+2; ++i){
 
       int ix = i / ybins;
       int iy = i % ybins;
 
       bool isMask = false;
 
       if (xmin < xmax){
         if (fMaskND->GetXaxis()->GetBinLowEdge(ix+1) < xmin) isMask=true;
         if (fMaskND->GetXaxis()->GetBinUpEdge(ix+1) > xmax) isMask=true;
       }
 
       if (ymin < ymax){
         if (fMaskND->GetYaxis()->GetBinLowEdge(iy+1) < ymin) isMask=true;
         if (fMaskND->GetYaxis()->GetBinUpEdge(iy+1) > ymax) isMask=true;
       }
 
       if (isMask) fMask1D->SetBinContent(i+1, 0);
       else fMask1D->SetBinContent(i+1, 1);
 
     }
     return fMask1D;
   }

std::vector< TH1 * > ana::GetMCComponents	(	const IPrediction *	mc,
		osc::IOscCalc *	calc,
		std::string	hist_name,
		double	pot,
		bool	force1D = `false`
	)

A vector of histograms for the MC components. Easier to manipulate elsewhere Not ideal as returned pointers probably won't get deleted... but very useful...

Definition at line 167 of file Plots.cxx.

   {
     return GetMCSystComponents(mc, calc, kNoShift, hist_name, pot, force1D);
   }

std::vector< TH1 * > ana::GetMCSystComponents	(	const IPrediction *	mc,
		osc::IOscCalc *	calc,
		const SystShifts &	shift,
		std::string	hist_name,
		double	pot,
		bool	force1D
	)

Definition at line 176 of file Plots.cxx.

   {
     std::vector<TH1*> ret;
     
     TH1* hTotal = mc->PredictSyst(calc, shift).ToTHX(pot, force1D);
     hTotal->SetNameTitle((hist_name+"_total").c_str(), (hist_name+"_total").c_str());
     ret .push_back(hTotal);
     
     TH1* hNC = mc->PredictComponentSyst(calc,shift,
                                         Flavors::kAll,
                                         Current::kNC,
                                         Sign::kBoth).ToTHX(pot, force1D);
     hNC->SetNameTitle((hist_name+"_NC").c_str(), (hist_name+"_NC").c_str());
     ret .push_back(hNC);
     
     TH1* hAllNumu = mc->PredictComponentSyst(calc,shift,
                                              Flavors::kAllNuMu,
                                              Current::kCC,
                                              Sign::kBoth).ToTHX(pot, force1D);
     hAllNumu->SetNameTitle((hist_name+"_AllNumu").c_str(), (hist_name+"_AllNumu").c_str());
     ret .push_back(hAllNumu);
 
     TH1* hNumu = mc->PredictComponentSyst(calc,shift,
                                           Flavors::kAllNuMu,
                                           Current::kCC,
                                           Sign::kNu).ToTHX(pot, force1D);
     hNumu->SetNameTitle((hist_name+"_Numu").c_str(), (hist_name+"_Numu").c_str());
     ret .push_back(hNumu);
     
     TH1* hNumubar = mc->PredictComponentSyst(calc,shift,
                                              Flavors::kAllNuMu,
                                              Current::kCC,
                                              Sign::kAntiNu).ToTHX(pot, force1D);
     hNumubar->SetNameTitle((hist_name+"_Numubar").c_str(), (hist_name+"_Numubar").c_str());
     ret .push_back(hNumubar);
 
     TH1* hAllNutau = mc->PredictComponentSyst(calc,shift,
                                               Flavors::kAllNuTau,
                                               Current::kCC,
                                               Sign::kBoth).ToTHX(pot, force1D);
     hAllNutau->SetNameTitle((hist_name+"_AllNutau").c_str(), (hist_name+"_AllNutau").c_str());
     ret .push_back(hAllNutau);    
 
     // Want AllSignalNue, SignalNue, SignalNuebar
     TH1* hAllNue = mc->PredictComponentSyst(calc,shift,
                                             Flavors::kAllNuE,
                                             Current::kCC,
                                             Sign::kBoth).ToTHX(pot, force1D);
     hAllNue->SetNameTitle((hist_name+"_AllNue").c_str(), (hist_name+"_AllNue").c_str());
     ret .push_back(hAllNue);    
     
     TH1* hAllBeamNue = mc->PredictComponentSyst(calc,shift,
                                                 Flavors::kNuEToNuE,
                                                 Current::kCC,
                                                 Sign::kBoth).ToTHX(pot, force1D);
     hAllBeamNue->SetNameTitle((hist_name+"_AllBeamNue").c_str(), (hist_name+"_AllBeamNue").c_str());
     ret .push_back(hAllBeamNue);
 
     TH1* hBeamNue = mc->PredictComponentSyst(calc,shift,
                                              Flavors::kNuEToNuE,
                                              Current::kCC,
                                              Sign::kNu).ToTHX(pot, force1D);
     hBeamNue->SetNameTitle((hist_name+"_BeamNue").c_str(), (hist_name+"_BeamNue").c_str());
     ret .push_back(hBeamNue);
 
     TH1* hBeamNuebar = mc->PredictComponentSyst(calc,shift,
                                                 Flavors::kNuEToNuE,
                                                 Current::kCC,
                                                 Sign::kAntiNu).ToTHX(pot, force1D);
     hBeamNuebar->SetNameTitle((hist_name+"_BeamNuebar").c_str(), (hist_name+"_BeamNuebar").c_str());
     ret .push_back(hBeamNuebar);
     
     TH1* hAllSignalNue = mc->PredictComponentSyst(calc,shift,
                                                   Flavors::kNuMuToNuE,
                                                   Current::kCC,
                                                   Sign::kBoth).ToTHX(pot, force1D);
     hAllSignalNue->SetNameTitle((hist_name+"_AllSignalNue").c_str(), (hist_name+"_AllSignalNue").c_str());
     ret .push_back(hAllSignalNue);
     
     TH1* hSignalNue = mc->PredictComponentSyst(calc,shift,
                                                Flavors::kNuMuToNuE,
                                                Current::kCC,
                                                Sign::kNu).ToTHX(pot, force1D);
     hSignalNue->SetNameTitle((hist_name+"_SignalNue").c_str(), (hist_name+"_SignalNue").c_str());
     ret .push_back(hSignalNue);
     
     TH1* hSignalNuebar = mc->PredictComponentSyst(calc,shift,
                                                   Flavors::kNuMuToNuE,
                                                   Current::kCC,
                                                   Sign::kAntiNu).ToTHX(pot, force1D);
     hSignalNuebar->SetNameTitle((hist_name+"_SignalNuebar").c_str(), (hist_name+"_SignalNuebar").c_str());
     ret .push_back(hSignalNuebar);
     
     return ret;
   }

TH1 * ana::GetMCSystTotal	(	const IPrediction *	mc,
		osc::IOscCalc *	calc,
		const SystShifts &	shift,
		std::string	hist_name,
		double	pot,
		bool	force1D
	)

Definition at line 146 of file Plots.cxx.

   {
     TH1* hTotal = mc->PredictSyst(calc, shift).ToTHX(pot, force1D);
     hTotal->SetNameTitle((hist_name+"_total").c_str(), (hist_name+"_total").c_str());
     return hTotal;
   }

TH1 * ana::GetMCTotal	(	const IPrediction *	mc,
		osc::IOscCalc *	calc,
		std::string	hist_name,
		double	pot,
		bool	force1D
	)

Definition at line 158 of file Plots.cxx.

   {
     return GetMCSystTotal(mc, calc, kNoShift, hist_name, pot, force1D);
   }

std::vector< TH1 * > ana::GetMCTotalForSystShifts	(	const IPrediction *	mc,
		osc::IOscCalc *	calc,
		const ISyst *	syst,
		std::string	hist_base_name,
		double	pot,
		bool	force1D
	)

Definition at line 278 of file Plots.cxx.

   {
     std::vector<TH1*> ret;
     std::string syst_name = syst->ShortName();
     for (int i = -3; i < 4; ++i){
       SystShifts s(syst, double(i));
       TH1* hTotal = mc->PredictSyst(calc, s).ToTHX(pot, force1D);
       hTotal->SetNameTitle((hist_base_name+"_total_"+syst_name+"_"+std::to_string(i)).c_str(), 
                            (hist_base_name+"_total_"+syst_name+"_"+std::to_string(i)).c_str());
       ret .push_back(hTotal);
     }
     return ret;
   }

std::vector< const ISyst * > ana::GetNuMIBeamlineFluxSysts ( )

Definition at line 127 of file NuMIFluxSysts.cxx.

   {
     const std::vector<std::string> syst_names =
       {
         "horn_current",
         "horn1_position_xy",
         "horn2_position_xy",
         "beam_shift_xy",
         "target_position_z",
         "beam_spot_size",
         "water_layer",
         "B_field",
         "beam_divergence"
       };
 
     std::vector<const ISyst*> ret;
     for(std::string name: syst_names)
       ret.push_back(GetNuMIFluxSyst("fractional_uncertainties/beamline", "hfrac_", name));
     return ret;
   }

const NuMIFluxSyst * ana::GetNuMIFluxSyst	(	const std::string &	dir,
		const std::string &	prefix,
		const std::string &	name
	)

Definition at line 91 of file NuMIFluxSysts.cxx.

   {
     // Make sure we always give the same one back
     static std::map<std::string, const NuMIFluxSyst*> cache;
 
     const std::string key = dir+"/"+prefix+name;
     if(cache.count(key) == 0) cache[key] = new NuMIFluxSyst(dir, prefix, name);
 
     return cache[key];
   }

std::vector< const ISyst * > ana::GetNuMIHadronProductionFluxSysts ( )

These are envelopes not real systs. TODO make clearer in naming.

Definition at line 105 of file NuMIFluxSysts.cxx.

   {
     const std::vector<std::string> syst_names =
       {
         "pCpi",
         "pCk",
         "pCnu",
         "nCpi",
         "mesinc",
         "nua",
         "nuAlFe",
         "attenuation",
         "others"
       };
 
     std::vector<const ISyst*> ret;
     for(std::string name: syst_names)
       ret.push_back(GetNuMIFluxSyst("fractional_uncertainties/hadron_production", "hfrac_", name));
     return ret;
   }

std::vector< const ISyst * > ana::GetNuMIPCAFluxSysts ( unsigned int Npcs = 100 )

Parameters

Npcs	Number of principal components. High-indexed components should have negligible effect on the analysis.

Definition at line 149 of file NuMIFluxSysts.cxx.

   {
     std::vector<const ISyst*> ret;
     for(unsigned int i = 0; i < Npcs; ++i){
       ret.push_back(GetNuMIFluxSyst("principal_component_analysis",
                                     "h", "pc"+std::to_string(i)));
     }
     return ret;
   }

std::vector<std::string> ana::GetSBNBoosterFluxWeightNames ( )

Definition at line 172 of file SBNWeightSysts.cxx.

   {
     // We can't ask the UniverseOracle about this, because it doesn't get
     // properly configured until it's seen its first CAF file.
     return {"expskin",
             "horncurrent",
             "nucleoninexsec",
             "nucleonqexsec",
             "nucleontotxsec",
             "pioninexsec",
             "pionqexsec",
             "piontotxsec"};
   }

const std::vector< const ISyst * > & ana::GetSBNBoosterFluxWeightSysts ( )

Definition at line 188 of file SBNWeightSysts.cxx.

   {
     static std::vector<const ISyst*> ret;
     if(!ret.empty()) return ret;
 
     for(const std::string& name: GetSBNBoosterFluxWeightNames())
       ret.push_back(new SBNWeightSyst(name));
 
     return ret;
   }

std::vector< std::string > ana::GetSBNGenieWeightNames ( )

Definition at line 113 of file SBNWeightSysts.cxx.

   {
     // We can't ask the UniverseOracle about this, because it doesn't get
     // properly configured until it's seen its first CAF file.
     return {"AhtBY",
         "BhtBY",
         "CV1uBY",
         "CV2uBY",
         "EtaNCEL",
         "FormZone",
         "FrAbs_N",
         "FrAbs_pi",
         "FrCEx_N",
         "FrCEx_pi",
         "FrInel_N",
         "FrInel_pi",
         "FrPiProd_N",
         "FrPiProd_pi",
         "MFP_N",
         "MFP_pi",
         "MaCCQE",
         "MaCCRES",
         "MaNCEL",
         "MaNCRES",
         "MvCCRES",
         "MvNCRES",
         "NonRESBGvbarnCC1pi",
         "NonRESBGvbarnCC2pi",
         "NonRESBGvbarnNC1pi",
         "NonRESBGvbarnNC2pi",
         "NonRESBGvbarpCC1pi",
         "NonRESBGvbarpCC2pi",
         "NonRESBGvbarpNC1pi",
         "NonRESBGvbarpNC2pi",
         "NonRESBGvnCC1pi",
         "NonRESBGvnCC2pi",
         "NonRESBGvnNC1pi",
         "NonRESBGvnNC2pi",
         "NonRESBGvpCC1pi",
         "NonRESBGvpCC2pi",
         "NonRESBGvpNC1pi",
         "NonRESBGvpNC2pi",
     };
   }

const std::vector< const ISyst * > & ana::GetSBNGenieWeightSysts ( )

Definition at line 159 of file SBNWeightSysts.cxx.

   {
     static std::vector<const ISyst*> ret;
     if(!ret.empty()) return ret;
 
     for(const std::string& name: GetSBNGenieWeightNames())
       ret.push_back(new SBNWeightSyst(name));
 
     return ret;
   }

const std::vector< const ISyst * > & ana::GetSBNWeightSysts ( )

Definition at line 200 of file SBNWeightSysts.cxx.

   {
     static std::vector<const ISyst*> ret;
     if(ret.empty()){
       const std::vector<const ISyst*>& g = GetSBNGenieWeightSysts();
       const std::vector<const ISyst*>& f = GetSBNBoosterFluxWeightSysts();
       ret.reserve(g.size()+f.size());
       ret.insert(ret.end(), g.begin(), g.end());
       ret.insert(ret.end(), f.begin(), f.end());
     }
     return ret;
   }

caf::SRGlobal ana::GetSRGlobal ( )

Definition at line 22 of file UniverseOracle.cxx.

   {
     caf::SRGlobal global;
     bool got = false;
 
     TSeqCollection* seq = gROOT->GetListOfFiles();
     for(int i = 0; i < seq->GetEntries(); ++i){
       TFile* f = (TFile*)seq->At(i);
       if(f->GetOption() != std::string("READ")) continue;
       TTree* tr = (TTree*)f->Get("globalTree");
       if(!tr) continue;
       if(tr->GetEntries() < 1) continue;
 
       if(got){
         std::cout << "\nUniverseOracle: Found globalTree in multiple places. Will use first one, but this is unexpected" << std::endl;
       }
 
       caf::SRGlobal* pglobal = &global;
       tr->SetBranchAddress("global", &pglobal);
       tr->GetEntry(0);
       got = true;
     }
 
     if(!got){
       std::cout << "\nUniverseOracle: Failed to find globalTree in any open input file" << std::endl;
       abort();
     }
 
     return global;
   }

Var ana::GetUniverseWeight	(	const std::string &	psetName,
		int	univIdx
	)

Definition at line 27 of file SBNWeightSysts.h.

   {
     return Var(UniverseWeight(psetName, univIdx));
   }

TGraphAsymmErrors * ana::GraphWithPoissonErrors	(	const TH1 *	h,
		bool	noErrorsXaxis,
		bool	drawEmptyBins
	)

Calculate statistical errors appropriate for small Poisson numbers.

Definition at line 678 of file Plots.cxx.

   {
     TGraphAsymmErrors* gr = new TGraphAsymmErrors(h);
 
     TFeldmanCousins fc(0.6827);//1 sigma
     
     for(int i = 0; i < h->GetNbinsX(); ++i){
       double x, y;
       gr->GetPoint(i, x, y);
 
       if ( drawEmptyBins || y!=0 ){
         if ( y < 50 )   gr->SetPointEYlow(i, y-fc.CalculateLowerLimit(y,0));
         else            gr->SetPointEYlow(i,sqrt(y));
         if ( y < 30 )   gr->SetPointEYhigh(i,fc.CalculateUpperLimit(y,0)-y);
         else            gr->SetPointEYhigh(i,sqrt(y));
       }
 
       if(noErrorsXaxis){
         gr->SetPointEXlow(i, 0);
         gr->SetPointEXhigh(i, 0);
       } // Do not use bin width as X-error for points
     }
 
     return gr;
   }

void ana::handle_signal	(	int	sig,
		siginfo_t *	,
		void *
	)

Definition at line 34 of file DebugHelpers.cxx.

   {
     if(sig == SIGABRT && !gIsException)
       std::cout << "\n\nAborted\n" << std::endl;
     if(sig == SIGSEGV)
       std::cout << "\n\nSegmentation fault\n" << std::endl;
     if(sig == SIGFPE)
       std::cout << "\n\nFloating point exception\n" << std::endl;
     if(sig == SIGBUS)
       std::cout << "\n\nBus error\n" << std::endl;
 
     gdb_backtrace();
 
     // gdb_backtrace() never returns. But if it did, this would be the right
     // way to exit with the correct code.
     _exit(sig+128);
   }

void ana::handle_terminate ( )

Definition at line 27 of file DebugHelpers.cxx.

   {
     std::cout << "\n\nUncaught exception\n" << std::endl;
     gIsException = true;
     // Next thing that happens is abort(), which goes to handle_signal()
   }

bool ana::HasBraggPeak ( const caf::SRTrueParticleProxy & p )

Whether this particle should have a bragg peak in the detector.

Definition at line 11 of file TrueParticleHelpers.cxx.

                                                      {
     // check contained, id, & end process (stopping-only)
     return p.contained &&
       ( abs(p.pdg) == 13 || abs(p.pdg) == 2212 ||
         abs(p.pdg) == 211 || abs(p.pdg) == 321 ) &&
       ( p.end_process ==  caf::kG4CoupledTransportation ||
         p.end_process ==  caf::kG4FastScintillation ||
         p.end_process ==  caf::kG4Decay ||
         p.end_process ==  caf::kG4muMinusCaptureAtRest );
   }

bool ana::HasVar	(	std::vector< const IFitVar * >	oscVars,
		std::string	name
	)

Definition at line 39 of file CalcsNuFit.cxx.

                                                                 {
     for(auto *s :oscVars ) if(s->ShortName() == name) return true;
     return false;
   }

static bool ana::Icarus202208_proton_cut ( const caf::SRTrackProxy & trk )

static

Definition at line 48 of file NumuVarsIcarus202208.cxx.

 {
   return trk.chi2pid[trk.bestplane].chi2_proton < 100;
 }

static bool ana::Icarus202208contained ( const caf::SRTrackProxy & trk )

static

Definition at line 9 of file NumuCutsIcarus202208.cxx.

 {
   return ((trk.end.x < -71.1 - 5 && trk.end.x > -369.33 + 5)
              || (trk.end.x > 71.1 + 5 && trk.end.x < 369.33 - 5))
            && trk.end.y > -181.7 + 5 && trk.end.y < 134.8 - 5
            && trk.end.z > -895.95 + 5 && trk.end.z < 895.95 - 5;
 }

bool ana::IsCCQEOnArgon	(	const caf::SRTrueInteractionProxy *	nu,
		int	pdg
	)

Definition at line 10 of file Flux.cxx.

   {
     // It doesn't matter exactly what process we choose, so long as it
     // corresponds to one of the modes GENIE considers as a top-level
     // cross-section. Here we go for CC QE on Argon.
     return nu->pdg == pdg && nu->iscc &&
       nu->genie_mode == caf::kQE && nu->genie_inttype == caf::kCCQE &&
       nu->targetPDG == 1000180400 /* Argon 40 */ &&
       !nu->ischarm;
   }

Cut ana::IsCCQEOnArgonCut ( int pdg )

Definition at line 46 of file Flux.cxx.

   {
     return Cut([pdg](const caf::SRSliceProxy* slc)
                {
                  if(slc->truth.index < 0) return false;
                  return IsCCQEOnArgon(&slc->truth, pdg);
                });
   }

bool ana::IsGenie ( const caf::SRTrueParticleProxy & p )

Whether this particle was generated by genie (as opposed to geant or corsika)

Definition at line 22 of file TrueParticleHelpers.cxx.

                                                 {
     return p.gstatus !=  caf::kNotGenie;
   }

bool ana::IsNCQEOnArgon	(	const caf::SRTrueInteractionProxy *	nu,
		int	pdg
	)

Definition at line 22 of file Flux.cxx.

   {
     // This process works for very low neutrino energy where the muon mass
     // becomes relevant.
     return nu->pdg == pdg && !nu->iscc &&
       nu->genie_mode == caf::kQE && nu->genie_inttype == caf::kNCQE &&
       nu->targetPDG == 1000180400 /* Argon 40 */ && 
       !nu->ischarm &&
       nu->hitnuc == 2112;
   }

bool ana::IsPrimary ( const caf::SRTrueParticleProxy & p )

Whether this is a primary particle or generated by a secondary interaction.

Definition at line 7 of file TrueParticleHelpers.cxx.

                                                   {
     return p.start_process == caf::kG4primary;
   }

bool ana::IsStable ( const caf::SRTrueParticleProxy & p )

Whether this is a stable particle as generated by genie.

Definition at line 26 of file TrueParticleHelpers.cxx.

                                                  {
     // non-genie particles are stable, otherwise check with genie
     return ( p.gstatus ==  caf::kNotGenie || p.gstatus ==  caf::kIStStableFinalState);
   }

size_t ana::JobNumber ( )

Definition at line 776 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     if(!RunningOnGrid()){
       std::cout << "JobNumber() called, but we are not running on the grid" << std::endl;
       abort();
     }
 
     return Offset(false);
   }

const Var ana::kBaseline ( [] (const caf::SRSliceProxy *slc) -> double{return slc->truth.baseline *1e-3;} )

const Cut ana::kIsAntiNu ( [] (const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return false;return slc->truth.pdg< 0;} )

const Cut ana::kIsBeamNue ( CCFlavSel(12, 12) )

Select CC $\nu_e\to\nu_e$ .

const Cut ana::kIsCC ( [] (const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return false;return(slc->truth.iscc==1);} )

const Cut ana::kIsNC ( [] (const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return false;return(slc->truth.isnc==1);} )

const Cut ana::kIsNCFromNue ( NCFlavOrig(12) )

const Cut ana::kIsNCFromNumu ( NCFlavOrig(14) )

const Cut ana::kIsNueApp ( CCFlavSel(12, 14) )

Select CC $\nu_\mu\to\nu_e$ .

const Cut ana::kIsNumuApp ( CCFlavSel(14, 12) )

Select CC $\nu_e\to\nu_\mu$ .

const Cut ana::kIsNumuCC ( CCFlavSel(14, 14) )

Select CC $\nu_\mu\to\nu_\mu$ .

const Cut ana::kIsTauFromE ( CCFlavSel(16, 12) )

Select CC $\nu_e\to\nu_\tau$ .

const Cut ana::kIsTauFromMu ( CCFlavSel(16, 14) )

Select CC $\nu_\mu\to\nu_\tau$ .

const Cut ana::kNoCut ( [] (const caf::SRSliceProxy *){return true;} )

The simplest possible cut: pass everything, used as a default.

const SpillCut ana::kNoSpillCut ( [] (const caf::SRSpillProxy *){return true;} )

The simplest possible cut: pass everything, used as a default.

const Var ana::kNuScore ( [] (const caf::SRSliceProxy *slc) -> double{return slc->nu_score;} )

const Var ana::kSlcIsRecoNu ( [] (const caf::SRSliceProxy *slc) -> double{return!slc->is_clear_cosmic;} )

const SolarConstraints ana::kSolarConstraintsPDG2017	(	7.53e-	5,
		0.18e-	5,
		0.	851,
		0.	020
	)

const SpillVar ana::kSpillUnweighted ( [] (const caf::SRSpillProxy *){return 1;} )

const Var ana::kUnweighted ( [] (const caf::SRSliceProxy *){return 1;} )

The simplest possible Var, always 1. Used as a default weight.

const caf::SRShowerProxy* ana::LargestRecoShower ( const caf::SRSliceProxy * slc )

Pointer to largest reconstructed shower, or null pointer if none exists.

Definition at line 26 of file NueVars.cxx.

 {
   const int largestShwIdx = kLargestRecoShowerIdx(slc);
   if(largestShwIdx == -1) return 0;
   return &slc->reco.shw[largestShwIdx];
 }

int ana::Limit ( )

Definition at line 758 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     static int cache = 0;
 
     if(cache == 0){
       char* env = getenv("CAFANA_LIMIT");
       if(env){
         cache = std::atoi(env);
       }
       else{
         cache = -1;
       }
     }
 
     return cache;
   }

std::vector<std::string> ana::LoadFileList ( const std::string & listfile )

Definition at line 568 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     std::vector<std::string> ret;
 
     std::ifstream is(listfile);
     if(!is.good()){
       std::cerr << "Can't open file list '" << listfile << "'. Aborting." << std::endl;
       abort();
     }
 
     while(!is.eof()){
       std::string fname;
       is >> fname;
       if(!fname.empty()) ret.push_back(fname);
     }
     return ret;
   }

template<class T >

std::unique_ptr<T> ana::LoadFrom ( TDirectory * dir )

Definition at line 22 of file LoadFromFile.h.

   {
     return T::LoadFrom(dir);
   }

template<>

std::unique_ptr<IBkgdEstimator> ana::LoadFrom< IBkgdEstimator > ( TDirectory * dir )

template<>

std::unique_ptr<IDecomp> ana::LoadFrom< IDecomp > ( TDirectory * dir )

template<>

std::unique_ptr< IExperiment > ana::LoadFrom< IExperiment > ( TDirectory * dir )

Definition at line 22 of file IExperiment.cxx.

   {
     TObjString* ptag = (TObjString*)dir->Get("type");
     assert(ptag);
 
     const TString tag = ptag->GetString();
 
     if(tag == "CountingExperiment") return CountingExperiment::LoadFrom(dir);
     if(tag == "ReactorExperiment") return ReactorExperiment::LoadFrom(dir);
     if(tag == "SingleSampleExperiment") return SingleSampleExperiment::LoadFrom(dir);
     if(tag == "SolarConstraints") return SolarConstraints::LoadFrom(dir);
     if(tag == "MultiExperiment") return MultiExperiment::LoadFrom(dir);
 
     std::cerr << "Unknown Experiment type '" << tag << "'" << std::endl;
     abort();
   }

template<>

std::unique_ptr< IExtrap > ana::LoadFrom< IExtrap > ( TDirectory * dir )

Definition at line 17 of file IExtrap.cxx.

   {
     TObjString* ptag = (TObjString*)dir->Get("type");
     assert(ptag);
 
     const TString tag = ptag->GetString();
 
     if(tag == "TrivialExtrap") return TrivialExtrap::LoadFrom(dir);
 
     std::cerr << "Unknown Extrap type '" << tag << "'" << std::endl;
     abort();
   }

template<>

std::unique_ptr< IPrediction > ana::LoadFrom< IPrediction > ( TDirectory * dir )

Definition at line 26 of file IPrediction.cxx.

   {
     TObjString* ptag = (TObjString*)dir->Get("type");
     assert(ptag);
 
     const TString tag = ptag->GetString();
 
     if(tag == "PredictionNoExtrap") return PredictionNoExtrap::LoadFrom(dir);
 
     // Backwards compatibility
     if(tag == "PredictionInterp" ||
        tag == "PredictionInterp2") return PredictionInterp::LoadFrom(dir);
 
     //    if(tag == "PredictionLinFit") return PredictionLinFit::LoadFrom(dir);
 
     if(tag == "PredictionNoOsc") return PredictionNoOsc::LoadFrom(dir);
 
     if(tag == "PredictionScaleComp") return PredictionScaleComp::LoadFrom(dir);
 
     if(tag == "PredictionIncDirt") return PredictionIncDirt::LoadFrom(dir);
 
     if(tag == "PredictionSBNExtrap") return PredictionSBNExtrap::LoadFrom(dir);
 
     std::cerr << "Unknown Prediction type '" << tag << "'" << std::endl;
     abort();
   }

template<>

std::unique_ptr<ModularExtrapComponent> ana::LoadFrom< ModularExtrapComponent > ( TDirectory * dir )

template<>

std::unique_ptr< osc::IOscCalc > ana::LoadFrom< osc::IOscCalc > ( TDirectory * dir )

Definition at line 22 of file LoadFromFile.cxx.

   {
     TObjString* ptag = (TObjString*)dir->Get("type");
     assert(ptag);
     const TString tag = ptag->GetString();
 
     if(tag == "NoOscillations") return std::unique_ptr<osc::IOscCalc>(new osc::NoOscillations);
     if(tag == "OscCalculatorDumb") return std::unique_ptr<osc::IOscCalc>(new osc::OscCalcDumb);
 
     TVectorD* params = (TVectorD*)dir->Get("params");
     assert(params);
 
     osc::IOscCalcAdjustable* ret = 0;
 
     if(tag == "OscCalculator") ret = new osc::OscCalc;
     if(tag == "OscCalculatorGeneral") ret = new osc::OscCalcGeneral;
     if(tag == "OscCalculatorPMNS") ret = new osc::OscCalcPMNS;
     if(tag == "OscCalculatorPMNSOpt") ret = new osc::OscCalcPMNSOpt;
     if(tag == "OscCalculatorSterile") ret = new osc::OscCalcSterile;
     if(tag == "OscCalculatorPMNS_NSI") ret = new osc::OscCalcPMNS_NSI;
     if(tag == "OscCalcSterileApprox"){
       assert(params->GetNrows() == 4);
       auto ret = new OscCalcSterileApproxAdjustable;
       ret->calc.SetDmsq((*params)[0]);
       ret->calc.SetSinSq2ThetaMuMu((*params)[1]);
       ret->calc.SetSinSq2ThetaMuE((*params)[2]);
       ret->calc.SetL((*params)[3]);
       return std::unique_ptr<osc::IOscCalcAdjustable>(ret);
     }
 
     if(!ret){
       std::cout << "LoadFrom not implemented for " << tag << std::endl;
       abort();
     }
 
     //special case how OscCalcSterile is initialized
     if(tag == "OscCalculatorSterile") {
       std::vector<double> state;
       for (int i = 0; i < params->GetNrows(); ++i) {
         state.push_back( (*params)[i] );
       }
       dynamic_cast<osc::OscCalcSterile*>(ret)->SetState(state);
       return std::unique_ptr<osc::IOscCalcAdjustable>(ret);
     }
     //special case how OscCalcPMNS_NSI is initialized
     if(tag == "OscCalculatorPMNS_NSI") {
       std::vector<double> state;
       for (int i = 0; i < params->GetNrows(); ++i) {
         state.push_back( (*params)[i] );
       }
       dynamic_cast<osc::OscCalcPMNS_NSI*>(ret)->SetState(state);
       return std::unique_ptr<osc::IOscCalcAdjustable>(ret);
     }
 
     assert(params->GetNrows() == 8);
 
     ret->SetL     ((*params)[0]);
     ret->SetRho   ((*params)[1]);
     ret->SetDmsq21((*params)[2]);
     ret->SetDmsq32((*params)[3]);
     ret->SetTh12  ((*params)[4]);
     ret->SetTh13  ((*params)[5]);
     ret->SetTh23  ((*params)[6]);
     ret->SetdCP   ((*params)[7]);
 
     return std::unique_ptr<osc::IOscCalcAdjustable>(ret);
   }

template<class T >

std::unique_ptr<T> ana::LoadFromFile	(	const std::string &	fname,
		const std::string &	label
	)

Definition at line 61 of file LoadFromFile.h.

   {
     TFile fin(fname.c_str());
     assert(!fin.IsZombie());
     TDirectory* dir = fin.GetDirectory(label.c_str());
     if(!dir){
       std::cerr << "Didn't find '" << label << "' in " << fname << std::endl;
       abort();
     }
     return LoadFrom<T>(dir);
   }

double ana::LogLikelihood	(	double	exp,
		double	obs
	)

The log-likelihood formula for a single bin.

Parameters

exp	Expected count
obs	Observed count

Returns: The log-likelihood formula from the PDG
$\chi^2=2\left(e-o+o\ln\left({o\over e}\right)\right)$

Handles zero observed or expected events correctly.

Definition at line 163 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     // http://www.wolframalpha.com/input/?i=d%2Fds+m*(1%2Bs)+-d+%2B+d*ln(d%2F(m*(1%2Bs)))%2Bs%5E2%2FS%5E2%3D0
     // http://www.wolframalpha.com/input/?i=solve+-d%2F(s%2B1)%2Bm%2B2*s%2FS%5E2%3D0+for+s
     const double S = LLPerBinFracSystErr::GetError();
     if(S > 0){
       const double S2 = util::sqr(S);
       const double s = .25*(sqrt(8*o*S2+util::sqr(e*S2-2))-e*S2-2);
       e *= 1+s;
     }
 
     // With this value, negative expected events and one observed
     // event gives a chisq from this one bin of 182.
     const double minexp = 1e-40; // Don't let expectation go lower than this
 
     assert(o >= 0);
     if(e < minexp){
       if(!o) return 0;
       e = minexp;
     }
 
     if(o*1000 > e){
       // This strange form is for numerical stability when e~o
       return 2*o*((e-o)/o + log1p((o-e)/e));
     }
     else{
       // But log1p doesn't like arguments near -1 (observation much smaller
       // than expectation), and it's better to use the usual formula in that
       // case.
       if(o){
         return 2*(e-o + o*log(o/e));
       }
       else{
         return 2*e;
       }
     }
   }

double ana::LogLikelihood	(	const TH1 *	exp,
		const TH1 *	obs,
		bool	useOverflow = `false`
	)

The log-likelihood formula from the PDG.

Parameters

exp	The expected spectrum
obs	The corresponding observed spectrum

Returns: The log-likelihood formula from the PDG
$\chi^2=2\sum_i^{\rm bins}\left(e_i-o_i+o_i\ln\left({o_i\over e_i}\right)\right)$

Includes underflow bin and an option for overflow bin (off by default) and handles zero observed or expected events correctly.

Definition at line 202 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     assert(eh->GetNbinsX() == oh->GetNbinsX());
 
     double chi = 0;
 
     int bufferBins = useOverflow? 2 : 1;
 
     for(int i = 0; i < eh->GetNbinsX()+bufferBins; ++i){
       const double e = eh->GetBinContent(i);
       const double o = oh->GetBinContent(i);
 
       chi += LogLikelihood(e, o);
     }
 
     return chi;
   }

const caf::SRTrackProxy* ana::LongestRecoTrack ( const caf::SRSliceProxy * slc )

Pointer to longest reconstructed shower, or null pointer if none exists.

Definition at line 173 of file NueVars.cxx.

 {
   const int longestTrackIdx = kLongestTrackIdx(slc);
   if(longestTrackIdx == -1) return 0;
   return &slc->reco.trk[longestTrackIdx];
 }

const caf::SRTrkChi2PIDProxy* ana::LongestTrackBestPlaneChi2PID ( const caf::SRSliceProxy * slc )

Definition at line 199 of file NueVars.cxx.

 {
   const caf::SRTrackProxy* trk = LongestRecoTrack(slc);
   return trk ? BestPlaneChi2PID(trk) : 0;
 }

void ana::MakeNMinusOneSpectra	(	SpectrumLoader &	loader,
		const Cut &	sigcut,
		const Cut &	presel,
		const std::vector< HistAxis > &	axes,
		const std::vector< double > &	cut_pos,
		std::vector< Spectrum > &	sigs,
		std::vector< Spectrum > &	bkgs
	)

Make a series of spectra leaving out one cut in turn.

This function does not call Go() on the loader, allowing you to combine it with other spectra-filling if desired.

Parameters

	loader	SpectrumLoader to associate spectra with
	sigcut	Definition of signal (inverse defines background)
	presel	Cuts that will always be applied
	axes	Variables that will be cut on
	cut_pos	Cut position for each variable
[out]	sigs	Resulting signal spectra
[out]	bkgs	Resulting background spectra

Definition at line 10 of file CutOptimizer.cxx.

   {
     assert(cut_pos.size() == axes.size());
 
     sigs.reserve(axes.size());
     bkgs.reserve(axes.size());
 
     for(unsigned int i = 0; i < axes.size(); ++i){
       Cut nminusone = presel;
       for(unsigned j = 0; j < axes.size(); ++j){
         if(j == i) continue;
         // TODO support cuts with a < sign
         nminusone = nminusone && axes[j].GetVars()[0] > cut_pos[j];
       } // end for j
 
       sigs.emplace_back(loader, axes[i], nminusone && sigcut);
       bkgs.emplace_back(loader, axes[i], nminusone && !sigcut);
     } // end for i
   }

TH1D* ana::MakeTH1D	(	const char *	name,
		const char *	title,
		const Binning &	bins
	)

Definition at line 393 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     return MakeHist<TH1D>(bins, name, title);
   }

TH2D* ana::MakeTH2D	(	const char *	name,
		const char *	title,
		const Binning &	binsx,
		const Binning &	binsy
	)

Definition at line 399 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     return MakeHist<TH2D>(binsx, binsy, name, title);
   }

template<class T >

_MultiVar< T > ana::MultiVar2D	(	const _MultiVar< T > &	a,
		const Binning &	binsa,
		const _MultiVar< T > &	b,
		const Binning &	binsb
	)

Definition at line 69 of file MultiVar.cxx.

   {
     return _MultiVar<T>(MultiVar2DFunc<T>(a, binsa, b, binsb));
   }

template SpillMultiVar ana::MultiVar2D	(	const MultiVar &	,
		const Binning &	,
		const MultiVar &	,
		const Binning &
	)

osc::IOscCalcAdjustable * ana::NuFitOscCalc ( int hie )

Definition at line 12 of file CalcsNuFit.cxx.

   {
     assert(hie == +1 || hie == -1);
 
     osc::IOscCalcAdjustable* ret = new osc::OscCalcPMNSOpt;
     ret->SetL(kBaseline);
     ret->SetRho(kEarthDensity);
 
     ret->SetDmsq21(kNuFitDmsq21CV);
     ret->SetTh12(kNuFitTh12CV);
 
     if(hie > 0){
       ret->SetDmsq32(kNuFitDmsq32CVNH);
       ret->SetTh23(kNuFitTh23CVNH);
       ret->SetTh13(kNuFitTh13CVNH);
       ret->SetdCP(kNuFitdCPCVNH);
     }
     else{
       ret->SetDmsq32(kNuFitDmsq32CVIH);
       ret->SetTh23(kNuFitTh23CVIH);
       ret->SetTh13(kNuFitTh13CVIH);
       ret->SetdCP(kNuFitdCPCVIH);
     }
 
     return ret;
   }

osc::IOscCalcAdjustable * ana::NuFitOscCalcCDR ( int hie )

Definition at line 10 of file CalcsNuFit_cdr.cxx.

   {
     assert(hie == +1 || hie == -1);
 
     osc::IOscCalcAdjustable* ret = new osc::OscCalcPMNSOpt;
     ret->SetL(1300);
     ret->SetRho(2.95674); // g/cm^3. Dan Cherdack's doc "used in GLOBES"
 
     ret->SetDmsq21(kNuFitDmsq21CV);
     ret->SetTh12(kNuFitTh12CV);
 
     if(hie > 0){
       ret->SetDmsq32(kNuFitDmsq32CVNH);
       ret->SetTh23(kNuFitTh23CVNH);
       ret->SetTh13(kNuFitTh13CVNH);
       ret->SetdCP(kNuFitdCPCVNH);
     }
     else{
       ret->SetDmsq32(kNuFitDmsq32CVIH);
       ret->SetTh23(kNuFitTh23CVIH);
       ret->SetTh13(kNuFitTh13CVIH);
       ret->SetdCP(kNuFitdCPCVIH);
     }
 
     return ret;
   }

osc::IOscCalcAdjustable * ana::NuFitOscCalcCDRPlusOneSigma ( int hie )

Definition at line 73 of file CalcsNuFit_cdr.cxx.

   {
     assert(hie == +1 || hie == -1);
 
     osc::IOscCalcAdjustable* ret = new osc::OscCalcPMNSOpt;
     ret->SetL(1300);
     ret->SetRho(2.95674); // g/cm^3. Dan Cherdack's doc "used in GLOBES"
 
     ret->SetDmsq21(kNuFitDmsq21CV + kNuFitDmsq21Err);
     ret->SetTh12(kNuFitTh12CV + kNuFitTh12Err);
 
     if(hie > 0){
       ret->SetDmsq32(kNuFitDmsq32CVNH + kNuFitDmsq32ErrNH);
       ret->SetTh23(kNuFitTh23CVNH + kNuFitTh23ErrNH);
       ret->SetTh13(kNuFitTh13CVNH + kNuFitTh13ErrNH);
     }
     else{
       ret->SetDmsq32(kNuFitDmsq32CVIH + kNuFitDmsq32ErrIH);
       ret->SetTh23(kNuFitTh23CVIH + kNuFitTh23ErrIH);
       ret->SetTh13(kNuFitTh13CVIH + kNuFitTh13ErrIH);
     }
 
     ret->SetdCP(0); // a little ambiguous in the instructions
 
     return ret;
   }

osc::IOscCalcAdjustable * ana::NuFitOscCalcPlusOneSigma ( int hie )

Definition at line 98 of file CalcsNuFit.cxx.

   {
     assert(hie == +1 || hie == -1);
 
     osc::IOscCalcAdjustable* ret = new osc::OscCalcPMNSOpt;
     ret->SetL(kBaseline);
     ret->SetRho(kEarthDensity);
 
     ret->SetDmsq21(kNuFitDmsq21CV + kNuFitDmsq21Err);
     ret->SetTh12(kNuFitTh12CV + kNuFitTh12Err);
 
     if(hie > 0){
       ret->SetDmsq32(kNuFitDmsq32CVNH + kNuFitDmsq32ErrNH);
       ret->SetTh23(kNuFitTh23CVNH + kNuFitTh23ErrNH);
       ret->SetTh13(kNuFitTh13CVNH + kNuFitTh13ErrNH);
     }
     else{
       ret->SetDmsq32(kNuFitDmsq32CVIH + kNuFitDmsq32ErrIH);
       ret->SetTh23(kNuFitTh23CVIH + kNuFitTh23ErrIH);
       ret->SetTh13(kNuFitTh13CVIH + kNuFitTh13ErrIH);
     }
 
     ret->SetdCP(0); // a little ambiguous in the instructions
 
     return ret;
   }

size_t ana::NumJobs ( )

Definition at line 787 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     if(!RunningOnGrid()){
       std::cout << "NumJobs() called, but we are not running on the grid" << std::endl;
       abort();
     }
 
     return Stride(false);
   }

size_t ana::Offset ( bool allow_default )

Definition at line 734 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     static int cache = -1;
 
     if(cache < 0){
       char* env = getenv("CAFANA_OFFSET");
       if(env){
         cache = std::atoi(env);
       }
       else{
         if(allow_default){
           cache = 0;
         }
         else{
           std::cout << "Offset() called, but CAFANA_OFFSET is not set (--offset not passed?)" << std::endl;
           abort();
         }
       }
     }
 
     return cache;
   }

template<class T >

_Cut< T > ana::operator! ( const _Cut< T > & a )

Definition at line 100 of file Cut.cxx.

   {
     static std::map<int, int> ids;
     if(ids.count(a.ID())){
       return _Cut<T>([a](const T* sr){return !a(sr);},
                            0, 0, ids[a.ID()]);
     }
     else{
       const _Cut<T> ret([a](const T* sr){return !a(sr);});
       ids[a.ID()] = ret.ID();
       return ret;
     }
   }

template Cut ana::operator!< caf::SRSliceProxy > ( const Cut & a )

template SpillCut ana::operator!< caf::SRSpillProxy > ( const SpillCut & a )

template<class T >

_Cut< T > ana::operator!=	(	const _Var< T > &	v,
		double	c
	)

Definition at line 156 of file Cut.cxx.

   {
     return !(v == c);
   }

template<class T >

_Cut< T > ana::operator!=	(	double	c,
		const _Var< T > &	v
	)

Definition at line 188 of file Cut.cxx.

188 {return v != c;}

template<class T >

_Cut< T > ana::operator!=	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 192 of file Cut.cxx.

192 {return !(b == a);}

a

process_name gaushit a

Definition: decode_signalprocess_icarus.fcl:37

template Cut ana::operator!=	(	const Var &	,
		double
	)

template Cut ana::operator!=	(	const Var &	,
		const Var &
	)

SterileOscAngles ana::operator&	(	const SterileOscAngles	a,
		const SterileOscAngles	b
	)

inline

Definition at line 97 of file OscCalcSterileApprox.h.

   {
     int a_int = static_cast<int>(a);
     int b_int = static_cast<int>(b);
     return static_cast<SterileOscAngles>(a_int & b_int);
   }

template<class T >

_Cut< T > ana::operator&&	(	const _Cut< T > &	a,
		const _Cut< T > &	b
	)

Definition at line 49 of file Cut.cxx.

   {
     // The same pairs of cuts are frequently and-ed together. Make sure those
     // duplicates get the same IDs by remembering what we've done in the past.
     static std::map<std::pair<int, int>, int> ids;
     const std::pair<int, int> key(a.ID(), b.ID());
 
     if(ids.count(key)){
       return _Cut<T>([a, b](const T* sr){return a(sr) && b(sr);},
                            CombineExposures(a.fLiveFunc, b.fLiveFunc),
                            CombineExposures(a.fPOTFunc, b.fPOTFunc),
                            ids[key]);
     }
     else{
       const _Cut<T> ret([a, b](const T* sr){return a(sr) && b(sr);},
                               CombineExposures(a.fLiveFunc, b.fLiveFunc),
                               CombineExposures(a.fPOTFunc, b.fPOTFunc));
       ids[key] = ret.ID();
       return ret;
     }
   }

template Cut ana::operator&&< caf::SRSliceProxy >	(	const Cut &	a,
		const Cut &	b
	)

template SpillCut ana::operator&&< caf::SRSpillProxy >	(	const SpillCut &	a,
		const SpillCut &	b
	)

EnsembleSpectrum ana::operator*	(	const EnsembleRatio &	lhs,
		const EnsembleSpectrum &	rhs
	)

inline

Definition at line 79 of file EnsembleSpectrum.h.

79 {return rhs*lhs;}

template<class T >

_Var< T > ana::operator*	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 179 of file Var.cxx.

   {
     static std::map<std::pair<int, int>, int> ids;
     const std::pair<int, int> key(a.ID(), b.ID());
 
     if(ids.count(key)){
       return _Var<T>([a, b](const T* sr){return a(sr) * b(sr);},
                            ids[key]);
     }
     else{
       const _Var<T> ret([a, b](const T* sr){return a(sr) * b(sr);});
       ids[key] = ret.ID();
       return ret;
     }
   }

template Var ana::operator*	(	const Var &	,
		const Var &
	)

Spectrum ana::operator*	(	const Ratio &	lhs,
		const Spectrum &	rhs
	)

inline

Definition at line 353 of file Spectrum.h.

353 {return rhs*lhs;}

template<class T >

_Var< T > ana::operator+	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 229 of file Var.cxx.

   {
     static std::map<std::pair<int, int>, int> ids;
     const std::pair<int, int> key(a.ID(), b.ID());
 
     if(ids.count(key)){
       return _Var<T>([a, b](const T* sr){return a(sr) + b(sr);},
                            ids[key]);
     }
     else{
       const _Var<T> ret([a, b](const T* sr){return a(sr) + b(sr);});
       ids[key] = ret.ID();
       return ret;
     }
   }

template Var ana::operator+	(	const Var &	,
		const Var &
	)

template<class T >

_Var< T > ana::operator-	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 247 of file Var.cxx.

   {
     static std::map<std::pair<int, int>, int> ids;
     const std::pair<int, int> key(a.ID(), b.ID());
 
     if(ids.count(key)){
       return _Var<T>([a, b](const T* sr){return a(sr) - b(sr);},
                            ids[key]);
     }
     else{
       const _Var<T> ret([a, b](const T* sr){return a(sr) - b(sr);});
       ids[key] = ret.ID();
       return ret;
     }
   }

template Var ana::operator-	(	const Var &	,
		const Var &
	)

Ratio ana::operator/	(	const Spectrum &	lhs,
		const Spectrum &	rhs
	)

inline

Definition at line 39 of file Ratio.h.

39 {return Ratio(lhs, rhs);}

EnsembleRatio ana::operator/	(	const EnsembleSpectrum &	lhs,
		const EnsembleSpectrum &	rhs
	)

inline

Definition at line 39 of file EnsembleRatio.h.

   {
     return EnsembleRatio(lhs, rhs);
   }

EnsembleSpectrum ana::operator/	(	const EnsembleRatio &	lhs,
		const EnsembleSpectrum &	rhs
	)

inline

Definition at line 80 of file EnsembleSpectrum.h.

80 {return rhs/lhs;}

template<class T >

_Var< T > ana::operator/	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 197 of file Var.cxx.

   {
     static std::map<std::pair<int, int>, int> ids;
     const std::pair<int, int> key(a.ID(), b.ID());
 
     if(ids.count(key)){
       return _Var<T>([a, b](const T* sr)
                            {
                              const double denom = b(sr);
                              if(denom != 0)
                                return a(sr) / denom;
                              else
                                return 0.0;
                            },
                            ids[key]);
     }
     else{
       const _Var<T> ret([a, b](const T* sr)
                               {
                                 const double denom = b(sr);
                                 if(denom != 0)
                                   return a(sr) / denom;
                                 else
                                   return 0.0;
                               });
       ids[key] = ret.ID();
       return ret;
     }
   }

template Var ana::operator/	(	const Var &	,
		const Var &
	)

Spectrum ana::operator/	(	const Ratio &	lhs,
		const Spectrum &	rhs
	)

inline

Definition at line 354 of file Spectrum.h.

354 {return rhs/lhs;}

template<class T >

_Cut< T > ana::operator<	(	const _Var< T > &	v,
		double	c
	)

Definition at line 135 of file Cut.cxx.

   {
     return _Cut<T>([v, c](const T* sr){return v(sr) < c;});
   }

template<class T >

_Cut< T > ana::operator<	(	double	c,
		const _Var< T > &	v
	)

Definition at line 185 of file Cut.cxx.

185 {return v > c;}

template<class T >

_Cut< T > ana::operator<	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 190 of file Cut.cxx.

190 {return !(b >= a);}

a

process_name gaushit a

Definition: decode_signalprocess_icarus.fcl:37

template Cut ana::operator<	(	const Var &	,
		double
	)

template Cut ana::operator<	(	const Var &	,
		const Var &
	)

template Cut ana::operator<	(	double	,
		const Var &
	)

template<class T >

_Cut< T > ana::operator<=	(	const _Var< T > &	v,
		double	c
	)

Definition at line 142 of file Cut.cxx.

   {
     return _Cut<T>([v, c](const T* sr){return v(sr) <= c;});
   }

template<class T >

_Cut< T > ana::operator<=	(	double	c,
		const _Var< T > &	v
	)

Definition at line 187 of file Cut.cxx.

187 {return v >= c;}

template<class T >

_Cut< T > ana::operator<=	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 191 of file Cut.cxx.

191 {return !(b > a);}

a

process_name gaushit a

Definition: decode_signalprocess_icarus.fcl:37

template Cut ana::operator<=	(	const Var &	,
		double
	)

template Cut ana::operator<=	(	const Var &	,
		const Var &
	)

template Cut ana::operator<=	(	double	,
		const Var &
	)

template<class T >

_Cut< T > ana::operator==	(	const _Var< T > &	v,
		double	c
	)

Definition at line 149 of file Cut.cxx.

   {
     return _Cut<T>([v, c](const T* sr){return v(sr) == c;});
   }

template<class T >

_Cut< T > ana::operator==	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 177 of file Cut.cxx.

   {
     return _Cut<T>([a, b](const T* sr){return a(sr) == b(sr);});
   }

template Cut ana::operator==	(	const Var &	,
		double
	)

template Cut ana::operator==	(	const Var &	,
		const Var &
	)

template<class T >

_Cut< T > ana::operator>	(	const _Var< T > &	v,
		double	c
	)

Definition at line 121 of file Cut.cxx.

   {
     return _Cut<T>([v, c](const T* sr){return v(sr) > c;});
   }

template<class T >

_Cut< T > ana::operator>	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 163 of file Cut.cxx.

   {
     return _Cut<T>([a, b](const T* sr){return a(sr) > b(sr);});
   }

template<class T >

_Cut< T > ana::operator>	(	double	c,
		const _Var< T > &	v
	)

Definition at line 184 of file Cut.cxx.

184 {return v < c;}

template Cut ana::operator>	(	const Var &	,
		double
	)

template Cut ana::operator>	(	const Var &	,
		const Var &
	)

template Cut ana::operator>	(	double	,
		const Var &
	)

template<class T >

_Cut< T > ana::operator>=	(	const _Var< T > &	v,
		double	c
	)

Definition at line 128 of file Cut.cxx.

   {
     return _Cut<T>([v, c](const T* sr){return v(sr) >= c;});
   }

template<class T >

_Cut< T > ana::operator>=	(	const _Var< T > &	a,
		const _Var< T > &	b
	)

Definition at line 170 of file Cut.cxx.

   {
     return _Cut<T>([a, b](const T* sr){return a(sr) >= b(sr);});
   }

template<class T >

_Cut< T > ana::operator>=	(	double	c,
		const _Var< T > &	v
	)

Definition at line 186 of file Cut.cxx.

186 {return v <= c;}

template Cut ana::operator>=	(	const Var &	,
		double
	)

template Cut ana::operator>=	(	const Var &	,
		const Var &
	)

template Cut ana::operator>=	(	double	,
		const Var &
	)

SterileOscAngles ana::operator\|	(	const SterileOscAngles	a,
		const SterileOscAngles	b
	)

inline

Definition at line 90 of file OscCalcSterileApprox.h.

   {
     int a_int = static_cast<int>(a);
     int b_int = static_cast<int>(b);
     return static_cast<SterileOscAngles>(a_int | b_int);
   }

Fitter::Precision ana::operator\|	(	Fitter::Precision	a,
		Fitter::Precision	b
	)

inline

Definition at line 199 of file Fit.h.

   {
     return Fitter::Precision(int(a) | int(b));
   }

template<class T >

_Cut< T > ana::operator\|\|	(	const _Cut< T > &	a,
		const _Cut< T > &	b
	)

Definition at line 76 of file Cut.cxx.

   {
     static std::map<std::pair<int, int>, int> ids;
     const std::pair<int, int> key(a.ID(), b.ID());
     if(ids.count(key)){
       return _Cut<T>([a, b](const T* sr){return a(sr) || b(sr);},
                            CombineExposures(a.fLiveFunc, b.fLiveFunc),
                            CombineExposures(a.fPOTFunc, b.fPOTFunc),
                            ids[key]);
     }
     else{
       const _Cut<T> ret([a, b](const T* sr){return a(sr) || b(sr);},
                               CombineExposures(a.fLiveFunc, b.fLiveFunc),
                               CombineExposures(a.fPOTFunc, b.fPOTFunc));
       ids[key] = ret.ID();
       return ret;
     }
   }

template Cut ana::operator\|\|< caf::SRSliceProxy >	(	const Cut &	a,
		const Cut &	b
	)

template SpillCut ana::operator\|\|< caf::SRSpillProxy >	(	const SpillCut &	a,
		const SpillCut &	b
	)

void ana::OptimizeCuts	(	const std::string &	wildcard,
		double	pot,
		const Cut &	sigcut,
		const Cut &	presel,
		const std::vector< HistAxis > &	axes,
		std::vector< double > &	cut_pos
	)

Repeatedly invoke OptimizeOneCut until the FOM increase becomes small.

Definition at line 99 of file CutOptimizer.cxx.

   {
     std::cout << "Initial cuts:" << std::endl;
     for(unsigned int i = 0; i < axes.size(); ++i){
       std::cout << "  " << axes[i].GetLabels()[0] << " > " << cut_pos[i] << std::endl;
     }
 
     double fom = 0;
     while(true){
       const double new_fom = OptimizeOneCut(wildcard, pot, sigcut, presel, axes, cut_pos);
       // Give up once the new FOM is not more than a 1% improvement
       if(new_fom < fom*1.01) break;
       fom = new_fom;
     }
 
     std::cout << "Final optimized cuts:" << std::endl;
     for(unsigned int i = 0; i < axes.size(); ++i){
       std::cout << "  " << axes[i].GetLabels()[0] << " > " << cut_pos[i] << std::endl;
     }
   }

double ana::OptimizeOneCut	(	const std::string &	wildcard,
		double	pot,
		const Cut &	sigcut,
		const Cut &	presel,
		const std::vector< HistAxis > &	axes,
		std::vector< double > &	cut_pos
	)

Scan all cuts and update the one giving the largest FOM gain.

Parameters

	wildcard	File name / wildcard / dataset name
	pot	POT to scale to
	sigcut	Definition of signal (inverse defines background)
	presel	Cuts that will always be applied
	axes	Variables that will be cut on
[out]	cut_pos	Starting cut position for each variable. One of these values will be updated

Returns: FOM achieved by optimized cuts

Definition at line 58 of file CutOptimizer.cxx.

   {
     SpectrumLoader loader(wildcard);
     std::vector<Spectrum> sigs, bkgs;
     MakeNMinusOneSpectra(loader, sigcut, presel, axes, cut_pos, sigs, bkgs);
     loader.Go();
 
     double best_fom = 0;
     double best_cut = -1;
     int best_idx = -1;
 
     for(unsigned int cutIdx = 0; cutIdx < axes.size(); ++cutIdx){
       TH1* hsig = sigs[cutIdx].ToTH1(pot, kRed);
       TH1* hbkg = bkgs[cutIdx].ToTH1(pot, kBlue);
       // TODO support multiple background spectra, such as cosmics
 
       double fom;
       const double cut = FindOptimumCut(hsig, hbkg, fom);
 
       if(fom > best_fom){
         best_fom = fom;
         best_cut = cut;
         best_idx = cutIdx;
       }
 
       // TODO plot distributions and optimized cuts at each phase
     } // end for cutIdx
 
     std::cout << "Updated cut on '" << axes[best_idx].GetLabels()[0] << "' to " << best_cut << ". FOM now " << best_fom << std::endl;
 
     // Store the result
     cut_pos[best_idx] = best_cut;
     return best_fom;
   }

void ana::PimpHist	(	TH1 *	histo,
		Color_t	color,
		Style_t	linestyle,
		int	linewidth,
		Style_t	markerstyle = `8`,
		double	markersize = `8`
	)

Definition at line 119 of file tools_nuesel_icarus.h.

                                                                                                                         {
 
     histo->SetLineColor(color);
     histo->SetLineStyle(linestyle);
     histo->SetLineWidth(linewidth);
     histo->SetMarkerColor(color);
     histo->SetMarkerStyle(markerstyle);
     histo->SetMarkerSize(markersize);
 
   }

void ana::PlotWithSystErrorBand	(	IPrediction *	pred,
		const std::vector< const ISyst * > &	systs,
		osc::IOscCalc *	calc,
		double	pot,
		int	col = `-1`,
		int	errCol = `-1`,
		float	headroom = `1.3`,
		bool	newaxis = `true`
	)

Plot prediction with +/-1sigma error band.

When multiple systematics are used, the errors are the quadrature sum

Parameters

pred	The prediction. Must be able to generate shifted spectra
systs	List of systematics to include in error band
calc	Oscillation parameters
pot	POT to evaluate prediction at
col	Color of the prediction, default kRed
errCol	Color of the shading, default col-7 (kRed-7 is light red)
headroom	Fraction of maximum bin for headroom, default 30%

Definition at line 377 of file Plots.cxx.

   {
 
     Spectrum nom = pred->Predict(calc);
 
     std::vector<Spectrum> ups, dns;
 
     for(const ISyst* syst: systs){
       SystShifts shifts;
       shifts.SetShift(syst, +1);
       ups.push_back(pred->PredictSyst(calc, shifts));
       shifts.SetShift(syst, -1);
       dns.push_back(pred->PredictSyst(calc, shifts));
     }
 
     PlotWithSystErrorBand(nom, ups, dns, pot, col, errCol, headroom, newaxis);
 
 
   }

void ana::PlotWithSystErrorBand	(	const Spectrum &	nominal,
		const std::vector< Spectrum > &	upShifts,
		const std::vector< Spectrum > &	downShifts,
		double	pot,
		int	col = `-1`,
		int	errCol = `-1`,
		float	headroom = `1.3`,
		bool	newaxis = `true`
	)

Plot prediction with error band.

When multiple systematics are used, the errors are the quadrature sum

Parameters

nominal	Nominal spectrum
upShifts	Vector of spectra which have + shifts
downShifts	Vector of spectra which have - shifts, same order as +
pot	POT to scale spectra to
col	Color of the prediction, default kRed
errCol	Color of the shading, default col-7(kRed-7 is light red)
headroom	Fraction of maximum bin for headroom, default 30%

Definition at line 404 of file Plots.cxx.

   {
     if(col == -1){
       col = kTotalMCColor;
       errCol = kTotalMCErrorBandColor;
     }
     else if(errCol == -1) errCol = col-7; // hopefully a lighter version
 
     TH1* nom =  nominal.ToTH1(pot);
 
     std::vector<TH1*> ups, dns;
 
     for(const auto& upShift:upShifts)     ups.push_back(upShift.ToTH1(pot));
     for(const auto& downShift:downShifts) dns.push_back(downShift.ToTH1(pot));
 
     nom->SetLineColor(col);
     nom->GetXaxis()->CenterTitle();
     nom->GetYaxis()->CenterTitle();
     if(newaxis) nom->Draw("hist ]["); // Set the axes up
 
     double yMax = nom->GetBinContent(nom->GetMaximumBin());
 
     TGraphAsymmErrors* g = new TGraphAsymmErrors;
 
     for(int binIdx = 0; binIdx < nom->GetNbinsX()+2; ++binIdx){
       const double y = nom->GetBinContent(binIdx);
       g->SetPoint(binIdx, nom->GetXaxis()->GetBinCenter(binIdx), y);
 
       const double w = nom->GetXaxis()->GetBinWidth(binIdx);
 
       double errUp = 0;
       double errDn = 0;
 
       for(unsigned int systIdx = 0; systIdx < ups.size(); ++systIdx){
         double hi = ups[systIdx]->GetBinContent(binIdx)-y;
         double lo = y-dns[systIdx]->GetBinContent(binIdx);
 
         if(lo <= 0 && hi <= 0) std::swap(lo, hi);
 
         errUp += hi*hi;
         errDn += lo*lo;
 
         // TODO: what happens if they're both high or both low?
       } // end for systIdx
 
 
       g->SetPointError(binIdx, w/2, w/2, sqrt(errDn), sqrt(errUp));
     } // end for i
 
     g->SetFillColor(errCol);
     g->Draw("e2 same");
     g->GetYaxis()->SetRangeUser(0, headroom*yMax);
     nom->GetYaxis()->SetRangeUser(0, headroom*yMax);
 
     nom->Draw("hist ][ same");
 
     for(TH1* up: ups) delete up;
     for(TH1* dn: dns) delete dn;
   }

std::string ana::pnfs2xrootd	(	std::string	loc,
		bool	unauth
	)

Definition at line 808 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     static bool first = true;
     static bool onsite = false;
 
     if (first && unauth) {
       first = false;
       char chostname[255];
       gethostname(chostname, 255);
       std::string hostname = chostname;
 
       if ( hostname.find("fnal.gov") != std::string::npos ){
         onsite = true;
         std::cout << "Using unauthenticated xrootd access (port 1095) while on-site, hostname: " << hostname << std::endl;
       }
       else {
         onsite = false;
         std::cout << "Using authenticated xrootd access (port 1094) access while off-site, hostname: " << hostname << std::endl;
       }
     }
 
     if(loc.rfind("/pnfs/", 0) == 0){ // ie begins with
       if ( onsite && unauth )
         loc = std::string("root://fndcagpvm01.fnal.gov:1095//pnfs/fnal.gov/usr/")+&loc.c_str()[6];
       else
         loc = std::string("root://fndcagpvm01.fnal.gov:1094//pnfs/fnal.gov/usr/")+&loc.c_str()[6];
     }
     return loc;
   }

double ana::PointDistanceToBox	(	double	x,
		double	y,
		double	x0,
		double	y0,
		double	x1,
		double	y1
	)

Helper for AutoPlaceLegend.

Definition at line 483 of file Plots.cxx.

   {
     // Inside
     if(x > x0 && x < x1 && y > y0 && y < y1) return 0;
 
     // Corners
     double d = util::sqr(x-x0)+util::sqr(y-y0);
     d = std::min(d, util::sqr(x-x1)+util::sqr(y-y0));
     d = std::min(d, util::sqr(x-x1)+util::sqr(y-y1));
     d = std::min(d, util::sqr(x-x0)+util::sqr(y-y1));
 
     // Top and bottom edges
     if(x > x0 && x < x1){
       d = std::min(d, util::sqr(y-y0));
       d = std::min(d, util::sqr(y-y1));
     }
     // Left and right
     if(y > y0 && y < y1){
       d = std::min(d, util::sqr(x-x0));
       d = std::min(d, util::sqr(x-x1));
     }
 
     return d;
   }

void ana::printEventsLine	(	std::string	cutname,
		float	nue,
		float	numu,
		float	nc,
		float	cos,
		float	other,
		float	eff,
		float	pur
	)

Definition at line 67 of file tools_nuesel_icarus.h.

                                                                                                                         {
     float total = nue+numu+nc+cos+other;
     float percnue    = 100*nue/total;
     float percnumu   = 100*numu/total;
     float percnc     = 100*nc/total;
     float perccos    = 100*cos/total;
     float percother  = 100*other/total;
     float perctotbkg = 100*(numu+nc+cos+other)/total;
     // output << std::fixed << std::setw(6) << std::setprecision(3) << cutname << "&" << nue <<"("<<percnue<<")"<< "&" << numu<<"("<<percnumu<<")"<< "&" << nc<<"("<<percnc<<")"<< "&" << cos<<"("<<perccos<<")"<< "&" << other<<"("<<percother<<")"<< "&" << eff << "&" << pur << "\\\\ \\hline \n";
     output << std::fixed << std::setw(6) << std::setprecision(3) << cutname << "&" << nue <<"("<<percnue<<")"<< "&" << numu<<"("<<percnumu<<")"<< "&" << nc<<"("<<percnc<<")"<< "&" << cos<<"("<<perccos<<")"<< "&" << eff << "&" << pur << "\\\\ \\hline \n";
   }

void ana::PrintSRGlobal ( const caf::SRGlobal & global )

Definition at line 54 of file UniverseOracle.cxx.

   {
     std::cout << global.wgts.size() << " parameter sets:" << std::endl;
     for(unsigned int i = 0; i < global.wgts.size(); ++i){
       const caf::SRWeightPSet& pset = global.wgts[i];
       std::cout << "  " << i << ": " << pset.name << ", type " << pset.type << ", " << pset.nuniv << " universes, adjusted parameters:" << std::endl;
 
       for(const caf::SRWeightMapEntry& entry: pset.map){
         std::cout << "    " << entry.param.name << std::endl;
       }
     }
   }

void ana::printTableFooter ( )

Definition at line 60 of file tools_nuesel_icarus.h.

                          {
     output << "\\end{tabular}}\n";
     output << "\\end{table}";
     output << "\n\n\n";
     //output.close();
   }

void ana::printTableHeader ( int quantId = 0 )

Definition at line 45 of file tools_nuesel_icarus.h.

   {
     std::setprecision(3);
     output << "\\begin{table}[H]\n";
     output << "\\centering\n";
     output << "\\resizebox{\\textwidth}{!}{\n";
     // output << "\\begin{tabular}{|l||c|c|c|c|c||c|c|}\n";
     output << "\\begin{tabular}{|l||c|c|c|c|c||c|}\n";
     output << "\\hline \n";
     // output << "\\multicolumn{1}{|c||}{} & \\multicolumn{5}{c||}{Number of interactions (\\% total)} & \\multicolumn{2}{c|}{Integrated} \\\\ \\hline \n \
     // \\multicolumn{1}{|c||}{Cut} & $\\nu_{e}$ CC & $\\nu_{\\mu}$ CC & NC & Cosmic & Other bkg & Efficiency & Purity \\\\ \\hline \n";
     output << "\\multicolumn{1}{|c||}{} & \\multicolumn{4}{c||}{Number of interactions (\\% total)} & \\multicolumn{2}{c|}{Integrated} \\\\ \\hline \n \
     \\multicolumn{1}{|c||}{Cut} & $\\nu_{e}$ CC & $\\nu_{\\mu}$ CC & NC & Cosmic & Efficiency & Purity \\\\ \\hline \n";
   }// printTableHeader

TH1 * ana::Profile	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const IFitVar *	v,
		int	nbinsx,
		double	minx,
		double	maxx,
		double	minchi = `-1`,
		const std::vector< const IFitVar * > &	profVars = `{}`,
		const std::vector< const ISyst * > &	profSysts = `{}`,
		const std::map< const IFitVar *, std::vector< double >> &	seedPts = `{}`,
		const std::vector< SystShifts > &	systsSeedPts = `{}`,
		std::map< const IFitVar , TGraph > &	profVarsMap = `empty_vars_map`,
		std::map< const ISyst , TGraph > &	systsMap = `empty_syst_map`
	)

$\chi^2$ scan in one variable, profiling over all others

Parameters

	expt	The experiment to retrieve chisq values from
	calc	Initial values of all oscillation parameters
	v	Scan over this variable
	nbinsx	Binning
	minx	Binning
	maxx	Binning
	minchi	Set non-default to force a chisq value to evaluate delta chisqs against. Useful for comparing two profiles. If set to zero it will not zero-adjust and the axis will be labelled without "delta"
	profVars	Profile over these variables
	profSysts	Profile over these systematics
	seedPts	Set each var to each of the values. Try all combinations. Beware of combinatorical explosion...
	systSeedPts	If non-empty, try fit starting at each of these
[out]	profVarsMap	Pass empty map. Returns best values of each var.
[out]	systsMap	Pass empty map. Returns best values of each syst.

Returns: The best fit delta chisq as a function of a

Definition at line 390 of file Fit.cxx.

   {
     Progress prog ("Filling profile");
     // If we're called with the default arguments they could already have stuff
     // in from before.
     for(auto it: profVarsMap) delete it.second;
     for(auto it: profSystsMap) delete it.second;
     profVarsMap.clear();
     profSystsMap.clear();
 
     // And then create the plots we'll be filling
     for(const IFitVar* v: profVars) profVarsMap[v] = new TGraph;
     for(const ISyst* s: profSysts) profSystsMap[s] = new TGraph;
 
     TH1* ret = new TH1F(UniqueName().c_str(),
                         (";"+v->LatexName()+ (input_minchi == 0? ";#chi^{2}" : ";#Delta#chi^{2}") ).c_str(),
                         nbinsx, minx, maxx);
 
     // Save the values of the fit vars as they were in the seed so we can put
     // them back to that value every iteration.
     std::vector<double> seedValues;
     for(const IFitVar* v: profVars) seedValues.push_back(v->GetValue(calc));
 
     double minpos = 0;
     double minchi = 1e10;
 
     Fitter fit(expt, profVars, profSysts);
 
     for(int n = 0; n < nbinsx; ++n){
       prog.SetProgress((double) n/nbinsx);
 
       const double x = ret->GetXaxis()->GetBinCenter(n+1);
       v->SetValue(calc, x);
 
       // Put oscillation values back to their seed position each iteration
       for(unsigned int i = 0; i < seedValues.size(); ++i)
         profVars[i]->SetValue( calc, seedValues[i] );
 
       SystShifts systshift = SystShifts::Nominal();
       const double chi = fit.Fit(calc, systshift, seedPts, systSeedPts, Fitter::kQuiet);
 
       ret->Fill(x, chi);
 
       if(chi < minchi){
         minchi = chi;
         minpos = x;
       }
       for(const IFitVar* var: profVars){
         profVarsMap[var]->SetPoint(n, x, var->GetValue(calc));
       }
       for(const ISyst* s: profSysts){
         profSystsMap[s]->SetPoint(n, x, systshift.GetShift(s));
       }
     }
     prog.Done();
     // If we weren't given an explicit minimum chisq, go find one
     if(input_minchi == -1){
       std::vector<const IFitVar*> allVars = {v};
       for(unsigned int i = 0; i < seedValues.size(); ++i) {
          profVars[i]->SetValue(calc, seedValues[i]);
          allVars.push_back(profVars[i]);
       }
       Fitter fit(expt, allVars, profSysts);
       // Seed from best grid point
       v->SetValue(calc, minpos);
       minchi = fit.Fit(calc); // get a better value
     }
     else{
       minchi = input_minchi;
     }
 
     // Zero-subtract the result histogram
     for(int n = 0; n < nbinsx; ++n) ret->AddBinContent(n+1, -minchi);
 
     return ret;
   }

TH1 * ana::Profile	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const ISyst *	s,
		int	nbinsx,
		double	minx,
		double	maxx,
		double	input_minchi,
		const std::vector< const IFitVar * > &	profVars,
		const std::vector< const ISyst * > &	profSysts,
		const std::map< const IFitVar *, std::vector< double >> &	seedPts,
		const std::vector< SystShifts > &	systSeedPts,
		std::map< const IFitVar , TGraph > &	profVarsMap,
		std::map< const ISyst , TGraph > &	profSystsMap
	)

Definition at line 477 of file Fit.cxx.

   {
     Progress prog ("Filling profile");
     // If we're called with the default arguments they could already have stuff
     // in from before.
     for(auto it: profVarsMap) delete it.second;
     for(auto it: profSystsMap) delete it.second;
     profVarsMap.clear();
     profSystsMap.clear();
 
     // And then create the plots we'll be filling
     for(const IFitVar* v: profVars) profVarsMap[v] = new TGraph;
     for(const ISyst* prof_syst: profSysts) profSystsMap[prof_syst] = new TGraph;
 
     TH1* ret = new TH1F(UniqueName().c_str(),
                         (";"+s->LatexName()+ (input_minchi == 0? ";#chi^{2}" : ";#Delta#chi^{2}") ).c_str(),
                         nbinsx, minx, maxx);
 
     // Save the values of the fit vars as they were in the seed so we can put
     // them back to that value every iteration.
     std::vector<double> seedValues;
     for(const IFitVar* v: profVars) seedValues.push_back(v->GetValue(calc));
 
     double minpos = 0;
     double minchi = 1e10;
 
     Fitter fit(expt, profVars, profSysts);
 
     for(int n = 0; n < nbinsx; ++n){
       prog.SetProgress((double) n/nbinsx);
 
       const double x = ret->GetXaxis()->GetBinCenter(n+1);
       SystShifts systshift(s, x);
 
       // Put oscillation values back to their seed position each iteration
       for(unsigned int i = 0; i < seedValues.size(); ++i)
         profVars[i]->SetValue( calc, seedValues[i] );
 
       const double chi = fit.Fit(calc, systshift, seedPts, systSeedPts, Fitter::kQuiet);
 
       ret->Fill(x, chi);
 
       if(chi < minchi){
         minchi = chi;
         minpos = x;
       }
       for(const IFitVar* var: profVars){
         profVarsMap[var]->SetPoint(n, x, var->GetValue(calc));
       }
       for(const ISyst* s: profSysts){
         profSystsMap[s]->SetPoint(n, x, systshift.GetShift(s));
       }
     }
     prog.Done();
     // If we weren't given an explicit minimum chisq, go find one
     if(input_minchi == -1){
       std::vector<const ISyst*> allSysts = {s};
       for(unsigned int i = 0; i < seedValues.size(); ++i) {
          profVars[i]->SetValue(calc, seedValues[i]);
       }
       for(unsigned int i = 0; i < profSysts.size(); ++i) {
          allSysts.push_back(profSysts[i]);
       }
       Fitter fit(expt, profVars, allSysts);
       // Seed from best grid point
       SystShifts systshift(s, minpos);
       minchi = fit.Fit(calc, systshift); // get a better value
     }
     else{
       minchi = input_minchi;
     }
 
     // Zero-subtract the result histogram
     for(int n = 0; n < nbinsx; ++n) ret->AddBinContent(n+1, -minchi);
 
     return ret;
   }

TGraphAsymmErrors * ana::ProfileQuantile	(	const TH2 *	hist,
		const std::string &	axisName,
		const std::string &	graphName,
		const std::pair< double, double > &	quantileDivisions
	)

Calculate profile with error bars corresponding to specified quantiles of a 2D distribution (by default, 68% coverage)

Definition at line 728 of file Plots.cxx.

   {
     if (hist->GetDimension() != 2)
             throw std::runtime_error(Form("Can't profile a histogram with other than 2 dimensions.  Yours is a %d-D histogram...", hist->GetDimension()));
 
     const TAxis * axis = nullptr;
     std::function<TH1D*(const char *, Int_t, Int_t, Option_t*)> projectionMethod;
     if (axisName == "x" || axisName == "X")
     {
       axis = hist->GetXaxis();
       projectionMethod = std::bind(&TH2::ProjectionY, hist, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
     }
     else if (axisName == "y" || axisName == "Y")
     {
       axis = hist->GetYaxis();
       projectionMethod = std::bind(&TH2::ProjectionX, hist, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
     }
     else
       throw std::runtime_error( Form("Can't profile onto unknown axis: '%s'", axisName.c_str()) );
 
 
     std::vector<double> points_x, points_y, errors_x_low, errors_x_high, errors_y_low, errors_y_high;
 
     double quantiles[2] = {0, 0};
     double _quantileDivisions[2] = {quantileDivisions.first, quantileDivisions.second};
     for (int binNum = 1; binNum <= axis->GetNbins(); binNum++)  // remember, 0 is underflow and Nbins+1 is overflow...
     {
       std::unique_ptr<TH1D> proj ( projectionMethod(Form("%s_tmp_%d", hist->GetName(), int(std::time(nullptr))), binNum, binNum, "") );  // randomish name, just to be safe
 
       double y = proj->GetMean();
       points_x.push_back(axis->GetBinCenter(binNum));
       points_y.push_back(y);
 
       // for now, make the errors for an empty projection 0
       unsigned int n_qs = 0;
       if (proj->Integral() == 0)
       {
         n_qs = 2;
         quantiles[0] = quantiles[1] = 0;
       }
       else
         n_qs = proj->GetQuantiles(2, quantiles, _quantileDivisions);
       if (n_qs != 2)
         throw std::runtime_error( Form("GetQuantiles() didn't compute all the quantiles in HistoTools.ProfileQuantile().  I requested 2 quantiles, but got %d of them...", n_qs) );
 
       double binWidth = axis->GetBinWidth(binNum);
       errors_x_low.push_back(binWidth/2.);
       errors_x_high.push_back(binWidth/2.);
       errors_y_low.push_back(y-quantiles[0]);
       errors_y_high.push_back(quantiles[1]-y);
     }
 
     TGraphAsymmErrors * outGraph = new TGraphAsymmErrors(
             points_x.size(),
             &points_x[0],
             &points_y[0],
             &errors_x_low[0],
             &errors_x_high[0],
             &errors_y_low[0],
             &errors_y_high[0]
     );
     std::string name = (graphName.size()) ? graphName : Form("%s_quantile_errors", hist->GetName());
     outGraph->SetName(name.c_str());
 
     return outGraph;
 
   }

void ana::ProjectionX	(	TH2D *	from,
		TH1D *	to
	)

Helper for Unweighted.

Definition at line 255 of file ReweightableSpectrum.cxx.

   {
     const int Nx = from->GetNbinsX();
     const int Ny = from->GetNbinsY();
 
     // Direct access to the bins is faster
     double* fromArr = from->GetArray();
     double* toArr = to->GetArray();
 
     int fromBin = 0;
     for(int y = 0; y < Ny+2; ++y){
       for(int x = 0; x < Nx+2; ++x){
         // Our loops go over the bins in the order they are internally in
         // 'from', and we do overflows, so we keep up exactly. If you get
         // paranoid, reenable this briefly.
         //        assert(fromBin == from->GetBin(x, y));
 
         const double z = fromArr[fromBin];
         ++fromBin;
 
         toArr[x] += z;
       }
     }
   }

void ana::ProjectionY	(	TH2D *	from,
		TH1D *	to
	)

Helper for WeightingVariable.

Definition at line 294 of file ReweightableSpectrum.cxx.

   {
     const int Nx = from->GetNbinsX();
     const int Ny = from->GetNbinsY();
 
     // Direct access to the bins is faster
     double* fromArr = from->GetArray();
     double* toArr = to->GetArray();
 
     int fromBin = 0;
     for(int y = 0; y < Ny+2; ++y){
       for(int x = 0; x < Nx+2; ++x){
         // Our loops go over the bins in the order they are internally in
         // 'from', and we do overflows, so we keep up exactly. If you get
         // paranoid, reenable this briefly.
         //        assert(fromBin == from->GetBin(x, y));
 
         const double z = fromArr[fromBin];
         ++fromBin;
 
         toArr[y] += z;
       }
     }
   }

void ana::RatioPlot	(	const Spectrum &	data,
		const Spectrum &	expected,
		const Spectrum &	fit,
		double	miny,
		double	maxy
	)

Plot data/expected, compared with fit/expected.

Definition at line 348 of file Plots.cxx.

   {
     Ratio fitRatio(fit, expected);
     Ratio dataRatio(data, expected);
 
     TH1* h = fitRatio.ToTH1();
     h->GetYaxis()->SetTitle("Ratio to expectation");
     h->GetYaxis()->SetRangeUser(miny, maxy);
     h->SetLineColor(kTotalMCColor);
     h->Draw("][");
 
     h = dataRatio.ToTH1();
     h->SetMarkerStyle(kFullCircle);
     h->Draw("ep same");
 
     TLine* one = new TLine(h->GetXaxis()->GetXmin(), 1,
                            h->GetXaxis()->GetXmax(), 1);
     one->SetLineWidth(2);
     one->SetLineStyle(7);
     one->Draw();
 
     gPad->Update();
   }

void ana::ResetOscCalcToDefault ( osc::IOscCalcAdjustable * calc )

Reset calc to default assumptions for all parameters.

Definition at line 12 of file Calcs.cxx.

   {
     // Default to ICARUS
     calc->SetL(0.6);
 
     // TODO: get good reference from Alex and Joao
     calc->SetRho(2.84); // g/cm^3
 
     // PDG: http://pdg.lbl.gov/2014/tables/rpp2014-sum-leptons.pdf
     calc->SetDmsq21(7.53e-5);
     calc->SetTh12(asin(sqrt(.846))/2);
 
     // Picking anything other than maximal mixing opens a can of worms
     calc->SetTh23(M_PI/4);
 
     // NH from PDG2014 + 2015 update
     //http://pdg.lbl.gov/2015/tables/rpp2015-sum-leptons.pdf 
     calc->SetDmsq32(2.44e-3); // NB: this is normal hierarchy
 
     // Reactor average from PDG2014 + 2015 update
     calc->SetTh13(asin(sqrt(.085))/2);
 
     // Going to have to plot for nue analysis anyway
     calc->SetdCP(0);
   }

void ana::ResetOscCalcToDefaultIH ( osc::IOscCalcAdjustable * calc )

Definition at line 47 of file Calcs.cxx.

   {
     //Share most defaults 
     ResetOscCalcToDefault(calc);
     // IH from PDG2014 + 2015 update 
     // http://pdg.lbl.gov/2015/tables/rpp2015-sum-leptons.pdf
     calc->SetDmsq32(-2.49e-3); 
 
   }

void ana::ResetSterileCalcToDefault ( osc::OscCalcSterile * calc )

Reset calc to default assumptions for all parameters.

Definition at line 66 of file Calcs.cxx.

   {
     osc::OscCalcPMNSOpt* tmp = new osc::OscCalcPMNSOpt();
     ResetOscCalcToDefault(tmp);
 
     calc->SetL(tmp->GetL());
     calc->SetRho(tmp->GetRho());
 
     calc->SetDm(2, tmp->GetDmsq21());
     calc->SetDm(3, tmp->GetDmsq21() + tmp->GetDmsq32());
 
     calc->SetAngle(1, 2, tmp->GetTh12());
     calc->SetAngle(1, 3, tmp->GetTh13());
     calc->SetAngle(2, 3, tmp->GetTh23());
 
     calc->SetDelta(1, 3, tmp->GetdCP());
 
     delete tmp;
   }

bool ana::RunningOnGrid ( )

Definition at line 697 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     static bool cache;
     static bool cache_set = false;
     if(!cache_set){
       cache = (getenv("_CONDOR_SCRATCH_DIR") != 0);
       cache_set = true;
     }
 
     return cache;
   }

std::string ana::SAMExperiment ( )

$SAM_EXPERIMENT or a nice error message and abort

Definition at line 105 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     const char* ret = getenv("SAM_EXPERIMENT");
 
     if(!ret){
       std::cout << "\nERROR: Environment variable $SAM_EXPERIMENT not set.\nThis is required for various ifdh/sam functionality.\nYou likely want it to be set to 'sbn', though it should have been set automatically by setup scripts." << std::endl;
       exit(1);
     }
 
     return ret;
   }

template<class T >

void ana::SaveTo	(	const T &	x,
		TDirectory *	dir
	)

Definition at line 52 of file LoadFromFile.h.

   {
     x.SaveTo(dir);
   }

template<>

void ana::SaveTo	(	const osc::IOscCalc &	x,
		TDirectory *	dir
	)

Definition at line 91 of file LoadFromFile.cxx.

   {
     TDirectory* tmp = gDirectory;
 
     dir->cd();
 
     if(dynamic_cast<const osc::NoOscillations*>(&x)){
       TObjString("NoOscillations").Write("type");
       tmp->cd();
       return;
     }
 
     if(dynamic_cast<const osc::OscCalcDumb*>(&x)){
       TObjString("OscCalculatorDumb").Write("type");
       tmp->cd();
       return;
     }
 
     const OscCalcSterileApproxAdjustable* approx = dynamic_cast<const OscCalcSterileApproxAdjustable*>(&x);
     if(approx){
       TObjString("OscCalcSterileApprox").Write("type");
       TVectorD params(4);
       params[0] = approx->calc.GetDmsq();
       params[1] = approx->calc.GetSinSq2ThetaMuMu();
       params[2] = approx->calc.GetSinSq2ThetaMuE();
       params[3] = approx->calc.GetL();
       params.Write("params");
       tmp->cd();
       return;
     }
 
     const osc::IOscCalcAdjustable* y = dynamic_cast<const osc::IOscCalcAdjustable*>(&x);
     if(!y){
       std::cout << "Unknown calculator in SaveTo " << typeid(x).name() << std::endl;
       abort();
     }
     
     const osc::OscCalcSterile* tmpSterile = dynamic_cast<const osc::OscCalcSterile*>(&x);
     if(tmpSterile) {
       TObjString("OscCalculatorSterile").Write("type");      
       std::vector<double> state = tmpSterile->GetState();
       TVectorD params(state.size());
       for (unsigned int i = 0; i < state.size(); ++i) params[i] = state[i];
       params.Write("params");
       tmp->cd();
       return;
     }
 
     //for the implementation of OscCalcPMNS_NSI
     const osc::OscCalcPMNS_NSI* tmpNSI = dynamic_cast<const osc::OscCalcPMNS_NSI*>(&x);
     if(tmpNSI) {
       TObjString("OscCalcPMNS_NSI").Write("type");      
       std::vector<double> state = tmpNSI->GetState();
       TVectorD params(state.size());
       for (unsigned int i = 0; i < state.size(); ++i) params[i] = state[i];
       params.Write("params");
       tmp->cd();
       return;
     }
 
     /* */if(dynamic_cast<const osc::OscCalc*>(&x)) TObjString("OscCalculatorPMNS").Write("type");
     else if(dynamic_cast<const osc::OscCalcGeneral*>(&x)) TObjString("OscCalculatorGeneral").Write("type");
     else if(dynamic_cast<const osc::OscCalcPMNS*>(&x)) TObjString("OscCalculatorPMNS").Write("type");
     else if(dynamic_cast<const osc::OscCalcPMNSOpt*>(&x)) TObjString("OscCalculatorPMNSOpt").Write("type");
     else{
       std::cout << "Unimplemented calculator in SaveTo " << typeid(x).name() << std::endl;
       abort();
     }
     
     TVectorD params(8);
 
     params[0] = y->GetL();
     params[1] = y->GetRho();
     params[2] = y->GetDmsq21();
     params[3] = y->GetDmsq32();
     params[4] = y->GetTh12();
     params[5] = y->GetTh13();
     params[6] = y->GetTh23();
     params[7] = y->GetdCP();
 
     params.Write("params");
 
     tmp->cd();
   }

template<class T >

void ana::SaveToFile	(	const T &	x,
		const std::string &	fname,
		const std::string &	label
	)

Definition at line 75 of file LoadFromFile.h.

   {
     TFile fout(fname.c_str(), "RECREATE");
     x.SaveTo(fout.mkdir(label.c_str()));
   }

Var ana::Scaled	(	const Var &	v,
		double	s
	)

Use to rescale another variable.

Definition at line 159 of file Var.cxx.

   {
     return Var([v, s](const caf::SRSliceProxy* sr){return s*v(sr);});
   }

TGraph * ana::ShadeBetweenHistograms	(	TH1 *	hmin,
		TH1 *	hmax
	)

Gives a TGraph with the area between two histograms. Do Draw("f") to draw this area. By default it has a lighter version of the colour of hmin

Definition at line 704 of file Plots.cxx.

   {
     int n = hmin->GetNbinsX();
     TGraph* gr = new TGraph(4*n);
 
     for(int i=1; i<=n; i++)
       {
         double xdown = hmax->GetBinLowEdge(i);
         double xup = hmax->GetBinLowEdge(i+1);
         double ydown = hmin->GetBinContent(i);
         double yup = hmax->GetBinContent(i);
 
         gr->SetPoint(2*(i-1), xdown, ydown);
         gr->SetPoint(2*(i-1)+1, xup, ydown);
         gr->SetPoint(4*n-2*i, xup, yup);
         gr->SetPoint(4*n-2*i+1, xdown, yup);
       }
 
       gr->SetFillColor(hmin->GetLineColor() - 9); // In principle this is lighter
       gr->SetLineColor(hmin->GetLineColor() - 9); // In case one does Draw("lf")
 
       return gr;
   }

double ana::Si ( double x )

Definition at line 138 of file OscCalcSterileApprox.cxx.

   {
     if(isinf(x)) return TMath::Pi()/2;
     return ROOT::Math::sinint(x);
   }

double ana::SimpleFOM	(	const Spectrum &	obs,
		const Spectrum &	unosc,
		double	pot = `0`
	)

Figure-of-merit with no systematics, for binned data.

Parameters

obs	The observed data
unosc	A spectrum representing the null hypothesis
pot	POT to scale to. Leave at default to adopt POT from obs

Returns: Sum in quadrature over the bins
$\sqrt{\sum_i^{\rm bins}\left({s_i\over\sqrt{s_i+b_i}}\right)^2}$

Definition at line 28 of file Fit.cxx.

   {
     if(pot == 0) pot = obs.POT();
 
     std::unique_ptr<TH1> oh(obs.ToTH1(pot));
     std::unique_ptr<TH1> bh(unosc.ToTH1(pot));
     assert(oh->GetNbinsX() == bh->GetNbinsX());
 
     double fomSq = 0;
 
     // Combine s/sqrt(s+b) in quadrature between bins
     for(int i = 0; i < oh->GetNbinsX(); ++i){
       const double o = oh->GetBinContent(i);
       const double b = bh->GetBinContent(i);
       const double s = o-b;
 
       if(s <= 0) continue;
 
       fomSq += util::sqr(s)/(s+b);
     }
 
     return sqrt(fomSq);
   }

TH1 * ana::Slice	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const IFitVar *	v,
		int	nbinsx,
		double	minx,
		double	maxx,
		double	minchi
	)

$\chi^2$ scan in one variable, holding all others constant

Definition at line 611 of file Fit.cxx.

   {
     return Profile(expt, calc, v, nbinsx, minx, maxx, minchi);
   }

TH1 * ana::Slice	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const ISyst *	s,
		int	nbinsx,
		double	minx,
		double	maxx,
		double	minchi
	)

Definition at line 620 of file Fit.cxx.

   {
     return Profile(expt, calc, s, nbinsx, minx, maxx, minchi);
   }

void ana::SplitCanvas2	(	TCanvas *&	c1,
		TPad *&	pad1,
		TPad *&	pad2
	)

Definition at line 83 of file tools_nuesel_icarus.h.

                                                               {
 
     c1 = new TCanvas("c1","",700,800);
     c1->cd();
 
     pad1 = new TPad("pad1","pad1",0,0,1,1);
     pad1->SetTopMargin(0.1);
     pad1->SetBottomMargin(0.4);
     pad1->SetLeftMargin(0.12);
     pad1->SetRightMargin(0.03);
     pad1->SetFillStyle(0);
     pad1->Draw();
     c1->cd();
 
     pad2 = new TPad("pad2","pad2",0,0,1,1);// x1 y1 x2 y2
     pad2->SetTopMargin(0.6);
     pad2->SetBottomMargin(0.1);
     pad2->SetLeftMargin(0.12);
     pad2->SetRightMargin(0.03);
     pad2->SetFillStyle(0);
     pad2->Draw();
     c1->cd();
 
   }

Var ana::Sqrt ( const Var & v )

Use to take sqrt of a var.

Definition at line 172 of file Var.cxx.

   {
     return Var([v](const caf::SRSliceProxy* sr){return sqrt(v(sr));});
   }

TH1 * ana::SqrtProfile	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const IFitVar *	v,
		int	nbinsx,
		double	minx,
		double	maxx,
		double	minchi,
		std::vector< const IFitVar * >	profVars,
		std::vector< const ISyst * >	profSysts,
		const std::map< const IFitVar *, std::vector< double >> &	seedPts,
		const std::vector< SystShifts > &	systSeedPts,
		std::map< const IFitVar , TGraph > &	profVarsMap,
		std::map< const ISyst , TGraph > &	systsMap
	)

Forward to Profile but sqrt the result for a crude significance.

Definition at line 565 of file Fit.cxx.

   {
     TH1* ret = Profile(expt, calc,
                        v, nbinsx, minx, maxx,
                        minchi, profVars, profSysts, seedPts, systSeedPts,
                        profVarsMap, systsMap);
     for(int n = 0; n < ret->GetNbinsX()+2; ++n){
       const double v = ret->GetBinContent(n);
       ret->SetBinContent(n, v > 0 ? sqrt(v) : 0);
     }
     ret->GetYaxis()->SetTitle("#sigma");
     return ret;
   }

TH1 * ana::SqrtProfile	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const ISyst *	s,
		int	nbinsx,
		double	minx,
		double	maxx,
		double	minchi,
		std::vector< const IFitVar * >	profVars,
		std::vector< const ISyst * >	profSysts,
		const std::map< const IFitVar *, std::vector< double >> &	seedPts,
		const std::vector< SystShifts > &	systSeedPts,
		std::map< const IFitVar , TGraph > &	profVarsMap,
		std::map< const ISyst , TGraph > &	systsMap
	)

Definition at line 588 of file Fit.cxx.

   {
     TH1* ret = Profile(expt, calc,
                        s, nbinsx, minx, maxx,
                        minchi, profVars, profSysts, seedPts, systSeedPts,
                        profVarsMap, systsMap);
     for(int n = 0; n < ret->GetNbinsX()+2; ++n){
       const double v = ret->GetBinContent(n);
       ret->SetBinContent(n, v > 0 ? sqrt(v) : 0);
     }
     ret->GetYaxis()->SetTitle("#sigma");
     return ret;
   }

TH1 * ana::SqrtSlice	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const IFitVar *	v,
		int	nbinsx,
		double	minx,
		double	maxx,
		double	minchi
	)

Forward to Slice but sqrt the result for a crude significance.

Definition at line 629 of file Fit.cxx.

   {
     TH1* ret = Slice(expt, calc, v, nbinsx, minx, maxx, minchi);
     for(int n = 0; n < ret->GetNbinsX()+2; ++n){
       const double v = ret->GetBinContent(n);
       ret->SetBinContent(n, v > 0 ? sqrt(v) : 0);
     }
     ret->GetYaxis()->SetTitle("#sigma");
     return ret;
   }

TH1 * ana::SqrtSlice	(	const IExperiment *	expt,
		osc::IOscCalcAdjustable *	calc,
		const ISyst *	s,
		int	nbinsx,
		double	minx,
		double	maxx,
		double	minchi
	)

Definition at line 643 of file Fit.cxx.

   {
     TH1* ret = Slice(expt, calc, s, nbinsx, minx, maxx, minchi);
     for(int n = 0; n < ret->GetNbinsX()+2; ++n){
       const double v = ret->GetBinContent(n);
       ret->SetBinContent(n, v > 0 ? sqrt(v) : 0);
     }
     ret->GetYaxis()->SetTitle("#sigma");
     return ret;
   }

size_t ana::Stride ( bool allow_default )

Definition at line 710 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     static int cache = -1;
 
     if(cache < 0){
       char* env = getenv("CAFANA_STRIDE");
       if(env){
         cache = std::atoi(env);
       }
       else{
         if(allow_default){
           cache = 1;
         }
         else{
           std::cout << "Stride() called, but CAFANA_STRIDE is not set (--stride not passed?)" << std::endl;
           abort();
         }
       }
     }
 
     return cache;
   }

std::unique_ptr<TMatrixD> ana::SymmMxInverse ( const TMatrixD & mx )

Definition at line 279 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     // check if there are any null rows/columns.
     // if there are, they make the matrix singular.
     // we will remove them temporarily,
     // invert the matrix, then put them back afterwards.
     std::set<int> nullRows;
     for (auto row = mx.GetRowLwb(); row <= mx.GetRowUpb(); row++)
     {
       bool rowIsNull = true;
       for (auto col = mx.GetColLwb(); col <= mx.GetColUpb(); col++)
       {
         if (mx[row][col] != 0.)
         {
           rowIsNull = false;
           break;
         }
       }
 
       if (rowIsNull)
         nullRows.insert(row);
     }
 
     std::cerr << " Notice: covariance matrix '" << mx.GetName() << "' has " << nullRows.size() << " null rows.\n"
         << "They will be removed before inverting and added back afterwards." << std::endl;
 
     // create a new matrix for inverting, skipping the null rows
     auto invMx = std::make_unique<TMatrixD>(mx.GetRowLwb(), mx.GetRowUpb() - nullRows.size(),
                                            mx.GetColLwb(), mx.GetColUpb() - nullRows.size());
     unsigned int skippedRows = 0;
     for (auto row = mx.GetRowLwb(); row <= mx.GetRowUpb(); row++)
     {
       if (nullRows.find(row) != nullRows.end())
       {
         skippedRows++;
         continue;
       }
       unsigned int skippedCols = 0;
       for (auto col = mx.GetColLwb(); col <= mx.GetColUpb(); col++)
       {
         // since we assumed the matrix is symmetric,
         // we can just use the null rows list here
         if (nullRows.find(col) != nullRows.end())
         {
           skippedCols++;
           continue;
         }
 
         (*invMx)[col-skippedCols][row-skippedRows] = (*invMx)[row-skippedRows][col-skippedCols] = mx[row][col];
       }
     }
 
     invMx->Invert();
 
     // put back the empty rows if there were any
     if (nullRows.size())
     {
       skippedRows = 0;
       auto retMx = std::make_unique<TMatrixD>(mx.GetRowLwb(), mx.GetRowUpb(),
                                               mx.GetColLwb(), mx.GetColUpb());
       for (auto row = mx.GetRowLwb(); row <= mx.GetRowUpb(); row++)
       {
         if (nullRows.find(row) != nullRows.end())
         {
           skippedRows++;
           continue;
         }
 
         unsigned int skippedCols = skippedRows;
         for (auto col = row; col <= mx.GetColUpb(); col++)
         {
           if (nullRows.find(col) != nullRows.end())
           {
             skippedCols++;
             continue;
           }
 
           (*retMx)[col][row] = (*retMx)[row][col] = (*invMx)[row-skippedRows][col-skippedCols];
         }
       }
 
       return retMx;
     }
 
     return invMx;
   }

TString ana::thisCellColor ( double weird )

Definition at line 26 of file tools_nuesel_icarus.h.

                                      {
     TString mystring = "";
     double thisval = abs(weird);
     if( thisval>=0.05 && thisval<0.10) mystring = "\\cellcolor{green!25}";
     else if( thisval>=0.10 && thisval<0.15) mystring = "\\cellcolor{yellow!25}";
     else if( thisval>=0.15) mystring = "\\cellcolor{red!25}";
     return mystring;
   }

osc::IOscCalcAdjustable * ana::ThrownNuFitOscCalc	(	int	hie,
		std::vector< const IFitVar * >	oscVars
	)

Definition at line 45 of file CalcsNuFit.cxx.

   {
     assert(hie == +1 || hie == -1);
 
     osc::IOscCalcAdjustable* ret = NuFitOscCalc(hie);//new osc::OscCalcPMNSOpt;
 
     // Throw 12 and rho within errors
     if (HasVar(oscVars, kFitRho.ShortName()))
       ret->SetRho(kEarthDensity*(1+0.02*gRandom->Gaus()));
 
     if (HasVar(oscVars, kFitDmSq21.ShortName()))
       ret->SetDmsq21(kNuFitDmsq21CV*(1+kNuFitDmsq21Err*gRandom->Gaus()));
 
     if (HasVar(oscVars, kFitSinSq2Theta12.ShortName()))
       ret->SetTh12(kNuFitTh12CV*(1+kNuFitTh12Err*gRandom->Gaus()));
 
     // Uniform throws within +/-3 sigma
     if(hie > 0){
       if (HasVar(oscVars, kFitDmSq32Scaled.ShortName()))
         ret->SetDmsq32(gRandom->Uniform(kNuFitDmsq32CVNH-3*kNuFitDmsq32ErrNH,
                                         kNuFitDmsq32CVNH+3*kNuFitDmsq32ErrNH));
 
       if (HasVar(oscVars, kFitSinSqTheta23.ShortName()))
         ret->SetTh23(gRandom->Uniform(kNuFitTh23CVNH-3*kNuFitTh23ErrNH,
                                       kNuFitTh23CVNH+3*kNuFitTh23ErrNH));
 
       if (HasVar(oscVars, kFitTheta13.ShortName()))
         ret->SetTh13(gRandom->Uniform(kNuFitTh13CVNH-3*kNuFitTh13ErrNH,
                                       kNuFitTh13CVNH+3*kNuFitTh13ErrNH));
 
       if (HasVar(oscVars, kFitDeltaInPiUnits.ShortName()))
         ret->SetdCP(gRandom->Uniform(-1*TMath::Pi(), TMath::Pi()));
 
     } else {
       if (HasVar(oscVars, kFitDmSq32Scaled.ShortName()))
         ret->SetDmsq32(gRandom->Uniform(kNuFitDmsq32CVIH-3*kNuFitDmsq32ErrIH,
                                         kNuFitDmsq32CVIH+3*kNuFitDmsq32ErrIH));
 
       if (HasVar(oscVars, kFitSinSqTheta23.ShortName()))
         ret->SetTh23(gRandom->Uniform(kNuFitTh23CVIH-3*kNuFitTh23ErrIH,
                                       kNuFitTh23CVIH+3*kNuFitTh23ErrIH));
 
       if (HasVar(oscVars, kFitTheta13.ShortName()))
         ret->SetTh13(gRandom->Uniform(kNuFitTh13CVIH-3*kNuFitTh13ErrIH,
                                       kNuFitTh13CVIH+3*kNuFitTh13ErrIH));
 
       if (HasVar(oscVars, kFitDeltaInPiUnits.ShortName()))
         ret->SetdCP(gRandom->Uniform(-1*TMath::Pi(), TMath::Pi()));
     }
     return ret;
   }

osc::IOscCalcAdjustable * ana::ThrownNuFitOscCalcCDR ( int hie )

Definition at line 38 of file CalcsNuFit_cdr.cxx.

   {
     assert(hie == +1 || hie == -1);
 
     osc::IOscCalcAdjustable* ret = new osc::OscCalcPMNSOpt;
     ret->SetL(1300);
 
     // Throw 12 and rho within errors
     ret->SetRho(2.95674*(1+0.02*gRandom->Gaus()));
     ret->SetDmsq21(kNuFitDmsq21CV*(1+kNuFitDmsq21Err*gRandom->Gaus()));
     ret->SetTh12(kNuFitTh12CV*(1+kNuFitTh12Err*gRandom->Gaus()));
 
     // Uniform throws within +/-3 sigma
     if(hie > 0){
       ret->SetDmsq32(gRandom->Uniform(kNuFitDmsq32CVNH-3*kNuFitDmsq32ErrNH, 
                                       kNuFitDmsq32CVNH+3*kNuFitDmsq32ErrNH));
       ret->SetTh23(gRandom->Uniform(kNuFitTh23CVNH-3*kNuFitTh23ErrNH,
                                     kNuFitTh23CVNH+3*kNuFitTh23ErrNH));
       ret->SetTh13(gRandom->Uniform(kNuFitTh13CVNH-3*kNuFitTh13ErrNH,
                                     kNuFitTh13CVNH+3*kNuFitTh13ErrNH));
     } else {
       ret->SetDmsq32(gRandom->Uniform(kNuFitDmsq32CVIH-3*kNuFitDmsq32ErrIH,
                                       kNuFitDmsq32CVIH+3*kNuFitDmsq32ErrIH));
       ret->SetTh23(gRandom->Uniform(kNuFitTh23CVIH-3*kNuFitTh23ErrIH,
                                     kNuFitTh23CVIH+3*kNuFitTh23ErrIH));
       ret->SetTh13(gRandom->Uniform(kNuFitTh13CVIH-3*kNuFitTh13ErrIH,
                                     kNuFitTh13CVIH+3*kNuFitTh13ErrIH));
     }
     ret->SetdCP(gRandom->Uniform(-1*TMath::Pi(), TMath::Pi()));
                   
     return ret;
   }

TH2* ana::ToTH2	(	const Spectrum &	s,
		double	exposure,
		ana::EExposureType	expotype,
		const Binning &	binsx,
		const Binning &	binsy,
		ana::EBinType	bintype
	)

Definition at line 407 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     DontAddDirectory guard;
 
     std::unique_ptr<TH1> h1(s.ToTH1(exposure, expotype));
     return ToTH2Helper(std::move(h1), binsx, binsy, bintype);
   }

TH2* ana::ToTH2	(	const Ratio &	r,
		const Binning &	binsx,
		const Binning &	binsy
	)

Definition at line 417 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     DontAddDirectory guard;
 
     std::unique_ptr<TH1> h1(r.ToTH1());
     return ToTH2Helper(std::move(h1), binsx, binsy);
   }

TH2* ana::ToTH2Helper	(	std::unique_ptr< TH1 >	h1,
		const Binning &	binsx,
		const Binning &	binsy,
		ana::EBinType	bintype
	)

Definition at line 427 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     // Make sure it's compatible with having been made with this binning
     assert(h1->GetNbinsX() == binsx.NBins()*binsy.NBins());
 
     TH2* ret = MakeTH2D(UniqueName().c_str(), "", binsx, binsy);
 
     for(int i = 0; i < h1->GetNbinsX(); ++i){
       const double val = h1->GetBinContent(i+1);
       const double err = h1->GetBinError(i+1);
 
       const int ix = i / binsy.NBins();
       const int iy = i % binsy.NBins();
 
       ret->SetBinContent(ix+1, iy+1, val);
       ret->SetBinError  (ix+1, iy+1, err);
     }
 
     if(bintype == ana::EBinType::kBinDensity) ret->Scale(1, "width");
 
     return ret;
   }

TH3* ana::ToTH3	(	const Spectrum &	s,
		double	exposure,
		ana::EExposureType	expotype,
		const Binning &	binsx,
		const Binning &	binsy,
		const Binning &	binsz,
		ana::EBinType	bintype
	)

Definition at line 454 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     DontAddDirectory guard;
 
     std::unique_ptr<TH1> h1(s.ToTH1(exposure, expotype));
 
     return ToTH3Helper(std::move(h1), binsx, binsy, binsz, bintype);
   }

TH3* ana::ToTH3	(	const Ratio &	r,
		const Binning &	binsx,
		const Binning &	binsy,
		const Binning &	binsz
	)

Definition at line 467 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     DontAddDirectory guard;
 
     std::unique_ptr<TH1> h1(r.ToTH1());
 
     return ToTH3Helper(std::move(h1), binsx, binsy, binsz);
   }

TH3* ana::ToTH3Helper	(	std::unique_ptr< TH1 >	h1,
		const Binning &	binsx,
		const Binning &	binsy,
		const Binning &	binsz,
		ana::EBinType	bintype
	)

Definition at line 478 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
 
     const int nx = binsx.NBins();
     const int ny = binsy.NBins();
     const int nz = binsz.NBins();
 
     // Make sure it's compatible with having been made with this binning
     assert(h1->GetNbinsX() == nx*ny*nz);
 
     TH3* ret;
 
     // If all three axes are simple, we can call a simpler constructor
     if(binsx.IsSimple() && binsy.IsSimple() && binsz.IsSimple()){
       ret = new TH3F(UniqueName().c_str(), "",
                      nx, binsx.Min(), binsx.Max(),
                      ny, binsy.Min(), binsy.Max(),
                      nz, binsz.Min(), binsz.Max());
 
       if(!binsx.IsSimple() || !binsy.IsSimple() || !binsz.IsSimple()){
         // TH3 doesn't have the constructors for mixed simple and custom
         std::cerr << "ToTH3: one or more axes is custom, but not all three. Applying Simple binning to all three axes" << std::endl;
       }
     }
     else{
       ret = new TH3F(UniqueName().c_str(), "",
                      nx, &binsx.Edges().front(),
                      ny, &binsy.Edges().front(),
                      nz, &binsz.Edges().front());
     }
 
     for(int i = 0; i < h1->GetNbinsX(); ++i){
       const double val = h1->GetBinContent(i+1);
       const double err = h1->GetBinError(i+1);
 
       const int nynz = ny*nz;
       const int nmodnynz = i%nynz;
       const int ix = i/nynz;
       const int iy = nmodnynz/nz;
       const int iz = i%nz;
 
       ret->SetBinContent(ix+1, iy+1, iz+1, val);
       ret->SetBinError  (ix+1, iy+1, iz+1, err);
     }
 
     if(bintype == ana::EBinType::kBinDensity) ret->Scale(1, "width");
 
     return ret;
 
   }

THStack * ana::ToTHStack	(	const std::vector< std::pair< Spectrum, Color_t >> &	s,
		double	pot
	)

Can call like ToTHStack({{h1, kRed}, {h2, kBlue}}, pot)

Definition at line 469 of file Plots.cxx.

   {
     THStack* ret = new THStack;
     for(auto it: s){
       TH1* h = it.first.ToTH1(pot);
       h->SetFillColor(it.second);
       ret->Add(h, "hist");
     }
     return ret;
   }

Binning ana::TrueEnergyBins ( )

Default true-energy bin edges.

Definition at line 152 of file Binning.cxx.

   {
     // Osc P is ~sin^2(1/E). Difference in prob across a bin is ~dP/dE which
     // goes as 1/E^2 times a trigonometric term depending on the parameters but
     // bounded between -1 and +1. So bins should have width ~1/E^2. E_i~1/i
     // achieves that.
 
     // Binning roughly re-optimized for SBN sterile analyses
 
     const int kNumTrueEnergyBins = 80;
 
     // N+1 bin low edges
     std::vector<double> edges(kNumTrueEnergyBins+1);
 
     const double Emin = .2; // 200 MeV
 
     // How many edges to generate. Allow room for 0-Emin bin
     const double N = kNumTrueEnergyBins-1;
     const double A = N*Emin;
 
     edges[0] = 0;
 
     for(int i = 1; i <= N; ++i){
       edges[kNumTrueEnergyBins-i] = A/i;
     }
 
     edges[kNumTrueEnergyBins] = 20; // Replace the infinity that would be here
 
     return Binning::Custom(edges);
   }

Binning ana::TrueLOverTrueEBins ( )

Definition at line 185 of file Binning.cxx.

   {
     // constant binnig
 
     const int kNumTrueLOverTrueEBins = 2000;
     const double klow = 0.0;
     const double khigh = 5.0;
 
     return Binning::Simple(kNumTrueLOverTrueEBins, klow, khigh);
   }

Spectrum ana::UnfoldIterative	(	const Spectrum &	reco,
		const ReweightableSpectrum &	recoVsTrue,
		unsigned int	nIterations
	)

Definition at line 8 of file UnfoldIterative.cxx.

   {
     assert(nIterations > 0);
 
     // Working copy
     ReweightableSpectrum rt = recoVsTrue;
 
     rt.ReweightToRecoSpectrum(reco);
 
     // First result after one iteration
     Spectrum truth = rt.WeightingVariable();
 
     for(unsigned int i = 2; i <= nIterations; ++i){
       rt = recoVsTrue; // put it back how it started
       rt.ReweightToTrueSpectrum(truth); // project back the other way
       rt.ReweightToRecoSpectrum(reco); // and then forward again
       truth = rt.WeightingVariable();
     }
 
     return truth.FakeData(reco.POT());
   }

Spectrum ana::UnfoldSVD	(	const Spectrum &	reco,
		const ReweightableSpectrum &	recoVsTrue,
		unsigned int	reg
	)

Singular value decomposition unfolding using ROOT's TSVDDecomp.

SVD decomposition requires the reco and true spectra to have the same number of bins (recoVsTrue must be square).

Lower values of reg are more regularized

Definition at line 12 of file UnfoldSVD.cxx.

   {
     const double pot = reco.POT();
 
     DontAddDirectory guard;
 
     std::unique_ptr<TH1D> hReco(reco.ToTH1(pot));
     std::unique_ptr<TH1D> hMCReco(recoVsTrue.UnWeighted().ToTH1(pot));
     std::unique_ptr<TH1D> hMCTrue(recoVsTrue.WeightingVariable().ToTH1(pot));
     std::unique_ptr<TH2D> hRT(recoVsTrue.ToTH2(pot));
 
     TSVDUnfold uf(hReco.get(), hMCReco.get(), hMCTrue.get(), hRT.get());
 
     std::unique_ptr<TH1D> h_unf(uf.Unfold(reg));
 
     // Enforce matching normalization
     h_unf->Scale(reco.Integral(pot)/h_unf->Integral(0, -1));
 
     // TODO in principle these should be the true labels and bins. Will be
     // easier with cafanacore
     return Spectrum(std::move(h_unf), reco.GetLabels(), reco.GetBinnings(),
                     pot, reco.Livetime());
   }

Spectrum ana::UnfoldTikhonov	(	const Spectrum &	reco,
		const ReweightableSpectrum &	recoVsTrue,
		double	regStrength
	)

Unfolding using Tikhonov regularization (penalizing true spectra with large second derivatives)

Currently requires 1D reco and true axes, but that is not a fundamental restriction of the method and could be lifted in future versions.

Large regStrength corresponds to more regularization (biased towards smooth results), small strength suffers more from statistical fluctuations.

Definition at line 16 of file UnfoldTikhonov.cxx.

   {
     assert(regStrength >= 0);
 
     if(recoVsTrue.NDimensions() != 1){
       std::cout << "UnfoldTikhonov: must use 1D reco axis. This is not a fundamental limitation. The code could be improved relatively easily." << std::endl;
       abort();
     }
 
     DontAddDirectory guard;
 
     // This is where that requirement comes in
     const unsigned int Nreco = recoVsTrue.GetBinnings()[0].NBins();
     const unsigned int Ntrue = recoVsTrue.GetBinnings()[1].NBins();
 
     // Smearing matrix from true to reco
     Eigen::MatrixXd M(Nreco, Ntrue);
 
     TH2D* m = recoVsTrue.ToTH2(1);
     for(unsigned int j = 0; j < Ntrue; ++j){
       double tot = 0;
       for(unsigned int i = 0; i < Nreco; ++i){
         const double mij = m->GetBinContent(i+1, j+1);
         M(i, j) = mij; 
         tot += mij;
       }
       // Normalize each column of true energy. One true event smears to one
       // reco event total.
       if(tot != 0) for(unsigned int i = 0; i < Nreco; ++i) M(i, j) /= tot;
     } // end for j
     delete m;
 
     // Data vector
     TH1D* hy = reco.ToTH1(reco.POT());
     Eigen::VectorXd y(Nreco);
     for(unsigned int i = 0; i < Nreco; ++i) y[i] = hy->GetBinContent(i+1);
     HistCache::Delete(hy);
 
     // Matrix penalizing true distributions with large second derivative. Would
     // also need an update here for multi-dimensional distribution. I think you
     // would add an extra P term to the equations for each dimension.
     Eigen::MatrixXd P = Eigen::MatrixXd::Zero(Ntrue, Ntrue);
     for(unsigned int i = 1; i+1 < Ntrue; ++i){
       P(i, i) = -2;
       P(i, i-1) = P(i, i+1) = 1;
     }
 
     // We are trying to minimize a chisq
     //
     // chisq = (M*x-y)^2 + lambda*(P*x)^2
     //
     // to solve for the best true distribution x.
     //
     // This results in needing to solve
     //
     // (M^T*M + lambda*P^T*P)*x = M^T*y
 
     const Eigen::MatrixXd lhs = M.transpose()*M + regStrength*P.transpose()*P;
     const Eigen::VectorXd rhs = M.transpose()*y;
 
     // https://eigen.tuxfamily.org/dox/group__TutorialLinearAlgebra.html
     Eigen::ColPivHouseholderQR<Eigen::MatrixXd> dec(lhs);
     const Eigen::VectorXd ret = dec.solve(rhs);
 
 
     // To get the correct binning
     std::unique_ptr<TH1D> hret(recoVsTrue.WeightingVariable().ToTH1(reco.POT()));
     hret->Reset();
     for(unsigned int i = 0; i < Ntrue; ++i) hret->SetBinContent(i+1, ret[i]);
 
     // TODO in principle these should be the true labels and bins. Will be
     // easier with cafanacore
     return Spectrum(std::move(hret), {""}, {recoVsTrue.GetBinnings()[1]},
                     reco.POT(), reco.Livetime());
   }

std::string ana::UniqueName ( )

Return a different string each time, for creating histograms.

Definition at line 32 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     static int N = 0;
     return TString::Format("cafanauniq%d", N++).Data();
   }

template<class T >

_Var< T > ana::Var2D	(	const _Var< T > &	a,
		const Binning &	binsa,
		const _Var< T > &	b,
		const Binning &	binsb
	)

Variable formed from two input variables.

The binning of each variable has to be given to allow conversion into a 1D binned representation.

Definition at line 109 of file Var.cxx.

   {
     return _Var<T>(Var2DFunc<T>(a, binsa, b, binsb));
   }

template<class T >

_Var< T > ana::Var2D	(	const _Var< T > &	a,
		int	na,
		double	a0,
		double	a1,
		const _Var< T > &	b,
		int	nb,
		double	b0,
		double	b1
	)

Variable formed from two input variables.

The binning of each variable has to be given to allow conversion into a 1D binned representation.

Definition at line 117 of file Var.cxx.

   {
     return Var2D(a, Binning::Simple(na, a0, a1),
                  b, Binning::Simple(nb, b0, b1));
   }

template Var ana::Var2D	(	const Var &	,
		const Binning &	,
		const Var &	,
		const Binning &
	)

template Var ana::Var2D	(	const Var &	,
		int	,
		double	,
		double	,
		const Var &	,
		int	,
		double	,
		double
	)

template<class T >

_Var< T > ana::Var3D	(	const _Var< T > &	a,
		const Binning &	binsa,
		const _Var< T > &	b,
		const Binning &	binsb,
		const _Var< T > &	c,
		const Binning &	binsc
	)

This is just like a Var2D, but useful for 3D Spectra.

Definition at line 133 of file Var.cxx.

   {
     return _Var<T>(Var3DFunc<T>(a, binsa, b, binsb, c, binsc));
   }

template<class T >

_Var< T > ana::Var3D	(	const _Var< T > &	a,
		int	na,
		double	a0,
		double	a1,
		const _Var< T > &	b,
		int	nb,
		double	b0,
		double	b1,
		const _Var< T > &	c,
		int	nc,
		double	c0,
		double	c1
	)

This is just like a Var2D, but useful for 3D Spectra.

Definition at line 142 of file Var.cxx.

   {
     return Var3D(a, Binning::Simple(na, a0, a1),
                  b, Binning::Simple(nb, b0, b1),
                  c, Binning::Simple(nc, c0, c1));
   }

template Var ana::Var3D	(	const Var &	,
		const Binning &	,
		const Var &	,
		const Binning &	,
		const Var &	,
		const Binning &
	)

template Var ana::Var3D	(	const Var &	,
		int	,
		double	,
		double	,
		const Var &	,
		int	,
		double	,
		double	,
		const Var &	,
		int	,
		double	,
		double
	)

std::vector<std::string> ana::Wildcard ( const std::string & wildcardString )

Definition at line 534 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     // Expand environment variables and wildcards like the shell would
     wordexp_t p;
     const int status = wordexp(wildcardString.c_str(), &p, WRDE_SHOWERR);
 
     if(status != 0){
       std::cerr << "Wildcard string '" << wildcardString
                 << "' returned error " << status << " from wordexp()."
                 << std::endl;
       return {};
     }
 
     std::vector<std::string> fileList;
 
     for(unsigned int i = 0; i < p.we_wordc; ++i){
       // Check the file exists before adding it
       struct stat sb;
       if(stat(p.we_wordv[i], &sb) == 0)
         fileList.push_back(p.we_wordv[i]);
     }
 
     wordfree(&p);
 
     return fileList;
   }

const ReactorExperiment * ana::WorldReactorConstraint2015 ( )

Weighted average of all experiments as of first nue paper writing.

Definition at line 64 of file ReactorExperiment.cxx.

   {
     // Weighted average of
     // Daya Bay: arXiv:1505.03456
     // RENO: arXiv:1410.7987
     // Double Chooz: 1406.7763
     return new ReactorExperiment(.086, .005);
   }

const ReactorExperiment * ana::WorldReactorConstraint2016 ( )

Updated value for SecondAna based on the latest PDG.

Definition at line 74 of file ReactorExperiment.cxx.

   {
     // PDG website as of Jun 2016
     return new ReactorExperiment(.085, .005);
   }

const ReactorExperiment * ana::WorldReactorConstraint2017 ( )

Reactor constraint from PDG 2017 update.

Definition at line 81 of file ReactorExperiment.cxx.

   {
     // http://pdg.lbl.gov/2017/tables/rpp2017-sum-leptons.pdf
     // ssth13=0.021+/-0.0011 -> ss2th13=0.082+/-0.004
     return new ReactorExperiment(.082, .004);
   }

void ana::WriteCAFMetadata	(	TDirectory *	dir,
		const std::map< std::string, std::string > &	meta
	)

Definition at line 674 of file sbnana/sbnana/CAFAna/Core/Utilities.cxx.

   {
     TDirectory* tmp = gDirectory;
     dir->cd();
 
     TTree* trmeta = new TTree("metatree", "metatree");
     std::string key, value;
     trmeta->Branch("key", &key);
     trmeta->Branch("value", &value);
     for(const auto& keyval: meta){
       key = keyval.first;
       value = keyval.second;
       trmeta->Fill();
     }
     trmeta->Write();
 
     dir->Save();
 
     tmp->cd();
   }

Variable Documentation

std::map<const ISyst*, TGraph*> ana::empty_syst_map

static

Definition at line 206 of file Fit.h.

std::map<const IFitVar*, TGraph*> ana::empty_vars_map

static

Definition at line 205 of file Fit.h.

InstallHandlers ana::gHandlerInstaller

static

Definition at line 89 of file DebugHelpers.cxx.

bool ana::gIsException = false

Definition at line 25 of file DebugHelpers.cxx.

const Color_t ana::k1SigmaConfidenceColorIH = kOrange+9

Definition at line 54 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::k1SigmaConfidenceColorNH = kAzure+3

Definition at line 48 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Style_t ana::k1SigmaConfidenceStyle = 7

Definition at line 43 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::k2SigmaConfidenceColorIH = kOrange+10

Definition at line 55 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::k2SigmaConfidenceColorNH = kAzure+2

Definition at line 50 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Style_t ana::k2SigmaConfidenceStyle = 9

Definition at line 44 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::k3SigmaConfidenceColorIH = kOrange+8

Definition at line 56 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::k3SigmaConfidenceColorNH = kAzure+1

Definition at line 51 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Style_t ana::k3SigmaConfidenceStyle = 10

Definition at line 45 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Style_t ana::k68PercentConfidenceStyle = 7

Dashed.

Definition at line 31 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::k90PercConfidenceColorIH = kOrange+10

Definition at line 57 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::k90PercConfidenceColorNH = kAzure+2

Definition at line 49 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Style_t ana::k90PercentConfidenceStyle = 9

Definition at line 30 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Cut ana::kActiveVolumeFDCryo1

Definition at line 19 of file SBNAna/Cuts/Cuts.h.

const Cut ana::kActiveVolumeFDCryo2

Definition at line 20 of file SBNAna/Cuts/Cuts.h.

const Cut ana::kActiveVolumeND

Definition at line 16 of file SBNAna/Cuts/Cuts.h.

const Var ana::kBaseline([](const caf::SRSliceProxy *slc) -> double{return slc->truth.baseline *1e-3;}) = 1284.9

Definition at line 41 of file CalcsNuFit.h.

const double ana::kBaselineIcarus = 0.6

Definition at line 10 of file ExpInfo.h.

const double ana::kBaselineMicroBoone = 0.47

Definition at line 9 of file ExpInfo.h.

const double ana::kBaselineSBND = 0.11

Definition at line 8 of file ExpInfo.h.

const Binning ana::kBDTBinning = Binning::Simple(50,0, 1.0)

Definition at line 40 of file Binnings.cxx.

const Color_t ana::kBeamNueBackgroundColor = kPink+9

Definition at line 18 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Float_t ana::kBlessedLabelFontSize = 0.06

Definition at line 63 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Float_t ana::kBlessedTitleFontSize = 0.08

Definition at line 62 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const std::vector<double> ana::kBLs = {kBaselineSBND, kBaselineMicroBoone, kBaselineIcarus}

Definition at line 14 of file ExpInfo.h.

const Color_t ana::kCentralValueColor = kGray+2

Definition at line 59 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::kCentralValueColorIH = kOrange+9

Definition at line 53 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::kCentralValueColorNH = kAzure+3

Definition at line 47 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Style_t ana::kCentralValueStyle = kSolid

Definition at line 60 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Var ana::kCompletness

Definition at line 8 of file TruthVars.h.

const Cut ana::kContainedFD = kFiducialVolumeFDCryo1 || kFiducialVolumeFDCryo2

Definition at line 30 of file SBNAna/Cuts/Cuts.h.

const Cut ana::kCosmic_ClearCos = ( kCosmic_RFiducial && kNotClearCosmic )

Definition at line 112 of file NumuCutsIcarus202106.cxx.

const Cut ana::kCosmic_Cryo0 = ( kIsCosmic && kCryo0 )

Definition at line 94 of file NumuCutsIcarus202106.cxx.

const Cut ana::kCosmic_FMScore = ( kCosmic_NuScore && kFMScore )

Definition at line 124 of file NumuCutsIcarus202106.cxx.

const Cut ana::kCosmic_NuScore = ( kCosmic_ClearCos && kNuScore )

Definition at line 118 of file NumuCutsIcarus202106.cxx.

const Cut ana::kCosmic_PTrack = ( kCosmic_FMScore && kPTrack )

Definition at line 130 of file NumuCutsIcarus202106.cxx.

const Cut ana::kCosmic_RFiducial = ( kCosmic_Cryo0 && kRFiducial )

Definition at line 104 of file NumuCutsIcarus202106.cxx.

const Cut ana::kCosmic_TFiducial = ( kCosmic_Cryo0 && kTFiducial )

Definition at line 102 of file NumuCutsIcarus202106.cxx.

const Color_t ana::kCosmicBackgroundColor = kAzure+1

Definition at line 19 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Var ana::kCounting = kUnweighted

Definition at line 19 of file Vars.cxx.

const Var ana::kCRLongestTrackDirY = SIMPLEVAR(nuid.crlongtrkdiry)

Definition at line 11 of file NumuVarsIcarus202208.cxx.

const Var ana::kCRTHitDist

Definition at line 16 of file NumuVarsSBND202106.h.

const Cut ana::kCRTHitDistanceCut

Definition at line 13 of file NumuCutsSBND202106.h.

const SpillMultiVar ana::kCRTHitPE

Definition at line 18 of file Vars.h.

const SpillMultiVar ana::kCRTHitTime

Definition at line 19 of file Vars.h.

const SpillMultiVar ana::kCRTHitTimeFD

Definition at line 20 of file Vars.h.

const SpillCut ana::kCRTHitVetoFD

Definition at line 14 of file SBNAna/Cuts/Cuts.h.

const SpillCut ana::kCRTHitVetoND

Definition at line 13 of file SBNAna/Cuts/Cuts.h.

const SpillMultiVar ana::kCRTHitX

Definition at line 15 of file Vars.h.

const SpillMultiVar ana::kCRTHitY

Definition at line 16 of file Vars.h.

const SpillMultiVar ana::kCRTHitZ

Definition at line 17 of file Vars.h.

const Cut ana::kCRTTrackAngleCut

Definition at line 12 of file NumuCutsSBND202106.h.

const Var ana::kCRTTrkAngle

Definition at line 14 of file NumuVarsSBND202106.h.

const Var ana::kCRTTrkTime

Definition at line 15 of file NumuVarsSBND202106.h.

const Binning ana::kCRTXFDBinning = Binning::Simple(60, crtfd.xmin, crtfd.xmax)

Definition at line 36 of file Binnings.cxx.

const Binning ana::kCRTYFDBinning = Binning::Simple(100, crtfd.ymin, crtfd.ymax)

Definition at line 37 of file Binnings.cxx.

const Binning ana::kCRTZFDBinning = Binning::Simple(130, crtfd.zmin, crtfd.zmax)

Definition at line 38 of file Binnings.cxx.

const Cut ana::kCryo0

Definition at line 18 of file NumuCutsIcarus202106.h.

const double ana::kEarthDensity = 2.848

Definition at line 42 of file CalcsNuFit.h.

const EnergyScaleSyst ana::kEnergyScaleHadron

Definition at line 64 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronBig

Definition at line 96 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronFD

Definition at line 76 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronFDBig

Definition at line 108 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronInvSqrt

Definition at line 66 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronInvSqrtBig

Definition at line 98 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronInvSqrtFD

Definition at line 78 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronInvSqrtFDBig

Definition at line 110 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronInvSqrtND

Definition at line 70 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronInvSqrtNDBig

Definition at line 102 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronInvSqrtUB

Definition at line 74 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronInvSqrtUBBig

Definition at line 106 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronND

Definition at line 68 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronNDBig

Definition at line 100 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronSqrt

Definition at line 65 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronSqrtBig

Definition at line 97 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronSqrtFD

Definition at line 77 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronSqrtFDBig

Definition at line 109 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronSqrtND

Definition at line 69 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronSqrtNDBig

Definition at line 101 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronSqrtUB

Definition at line 73 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronSqrtUBBig

Definition at line 105 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronUB

Definition at line 72 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleHadronUBBig

Definition at line 104 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuon

Definition at line 48 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonBig

Definition at line 80 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonFD

Definition at line 60 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonFDBig

Definition at line 92 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonInvSqrt

Definition at line 50 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonInvSqrtBig

Definition at line 82 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonInvSqrtFD

Definition at line 62 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonInvSqrtFDBig

Definition at line 94 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonInvSqrtND

Definition at line 54 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonInvSqrtNDBig

Definition at line 86 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonInvSqrtUB

Definition at line 58 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonInvSqrtUBBig

Definition at line 90 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonND

Definition at line 52 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonNDBig

Definition at line 84 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonSqrt

Definition at line 49 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonSqrtBig

Definition at line 81 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonSqrtFD

Definition at line 61 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonSqrtFDBig

Definition at line 93 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonSqrtND

Definition at line 53 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonSqrtNDBig

Definition at line 85 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonSqrtUB

Definition at line 57 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonSqrtUBBig

Definition at line 89 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonUB

Definition at line 56 of file EnergySysts.h.

const EnergyScaleSyst ana::kEnergyScaleMuonUBBig

Definition at line 88 of file EnergySysts.h.

const SpillVar ana::kEvt = SIMPLESPILLVAR(hdr.evt)

Definition at line 16 of file Vars.cxx.

const Cut ana::kFiducialVolumeFDCryo1

Definition at line 21 of file SBNAna/Cuts/Cuts.h.

const Cut ana::kFiducialVolumeFDCryo2

Definition at line 22 of file SBNAna/Cuts/Cuts.h.

const Cut ana::kFiducialVolumeND

Definition at line 17 of file SBNAna/Cuts/Cuts.h.

const Style_t ana::kFillStyleIH = 3003

Definition at line 41 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Style_t ana::kFillStyleNH = 3013

Definition at line 40 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const SpillCut ana::kFirstEvents = kEvt < 10

Definition at line 14 of file Cuts.cxx.

const FitDelta13InPiUnitsSterile ana::kFitDelta13InPiUnitsSterile = FitDelta13InPiUnitsSterile()

$\delta_{CP}/\pi$

Definition at line 66 of file FitVarsSterile.h.

const FitDelta14InPiUnitsSterile ana::kFitDelta14InPiUnitsSterile = FitDelta14InPiUnitsSterile()

$\delta_{14}/\pi$

Definition at line 81 of file FitVarsSterile.h.

const FitDelta24InPiUnitsSterile ana::kFitDelta24InPiUnitsSterile = FitDelta24InPiUnitsSterile()

$\delta_{24}/\pi$

Definition at line 96 of file FitVarsSterile.h.

const FitDeltaInPiUnits ana::kFitDeltaInPiUnits = FitDeltaInPiUnits()

$\delta_{CP}/\pi$

Definition at line 53 of file FitVars.h.

const FitDmSq21 ana::kFitDmSq21 = FitDmSq21()

$\Delta m^2_{21}$

Definition at line 199 of file FitVars.h.

const FitDmSq32 ana::kFitDmSq32 = FitDmSq32()

$\Delta m^2_{32}$

Definition at line 123 of file FitVars.h.

const FitDmSq32Scaled ana::kFitDmSq32Scaled = FitDmSq32Scaled()

$\Delta m^2_{32}\times10^3{\rm eV}^2$

Definition at line 143 of file FitVars.h.

const FitDmSq32Sterile ana::kFitDmSq32Sterile = FitDmSq32Sterile()

$\Delta m^2_{32}$

Definition at line 21 of file FitVarsSterile.h.

const FitDmSq41Sterile ana::kFitDmSq41Sterile = FitDmSq41Sterile()

$\Delta m^2_{41}$

Definition at line 36 of file FitVarsSterile.h.

const FitDmSq43Sterile ana::kFitDmSq43Sterile = FitDmSq43Sterile()

$\Delta m^2_{43}$

Definition at line 51 of file FitVarsSterile.h.

const FitDmSqSterile ana::kFitDmSqSterile = FitDmSqSterile()

m^2

Definition at line 23 of file FitVarsSterileApprox.h.

const FitRho ana::kFitRho = FitRho()

$\rho$

Definition at line 217 of file FitVars.h.

const FitSinSq2Theta12 ana::kFitSinSq2Theta12 = FitSinSq2Theta12()

$\sin^22\theta_{12}$

Definition at line 179 of file FitVars.h.

const FitSinSq2Theta13 ana::kFitSinSq2Theta13 = FitSinSq2Theta13()

$\sin^22\theta_{13}$

Definition at line 38 of file FitVars.h.

const FitSinSq2Theta14Sterile ana::kFitSinSq2Theta14Sterile = FitSinSq2Theta14Sterile()

$\sin^22\theta_{14}$

Definition at line 223 of file FitVarsSterile.h.

const FitSinSq2Theta23 ana::kFitSinSq2Theta23 = FitSinSq2Theta23()

$\sin^22\theta_{23}$

Definition at line 103 of file FitVars.h.

const FitSinSq2Theta24Sterile ana::kFitSinSq2Theta24Sterile = FitSinSq2Theta24Sterile()

$\sin^22\theta_{24}$

Definition at line 277 of file FitVarsSterile.h.

const FitSinSq2Theta34Sterile ana::kFitSinSq2Theta34Sterile = FitSinSq2Theta34Sterile()

$\sin^22\theta_{34}$

Definition at line 331 of file FitVarsSterile.h.

const FitSinSqTheta13Sterile ana::kFitSinSqTheta13Sterile = FitSinSqTheta13Sterile()

$\sin^2\theta_{13}$

Definition at line 132 of file FitVarsSterile.h.

const FitSinSqTheta14Sterile ana::kFitSinSqTheta14Sterile = FitSinSqTheta14Sterile()

$\sin^2\theta_{14}$

Definition at line 204 of file FitVarsSterile.h.

const FitSinSqTheta23 ana::kFitSinSqTheta23 = FitSinSqTheta23()

$\sin^2\theta_{23}$

Definition at line 84 of file FitVars.h.

const FitSinSqTheta23Sterile ana::kFitSinSqTheta23Sterile = FitSinSqTheta23Sterile()

$\sin^2\theta_{23}$

Definition at line 168 of file FitVarsSterile.h.

const FitSinSqTheta24Sterile ana::kFitSinSqTheta24Sterile = FitSinSqTheta24Sterile()

$\sin^2\theta_{24}$

Definition at line 259 of file FitVarsSterile.h.

const FitSinSqTheta34Sterile ana::kFitSinSqTheta34Sterile = FitSinSqTheta34Sterile()

$\sin^2\theta_{34}$

Definition at line 313 of file FitVarsSterile.h.

const FitTanSqTheta12 ana::kFitTanSqTheta12 = FitTanSqTheta12()

$\tan^2\theta_{12}$

Definition at line 161 of file FitVars.h.

const FitTheta13 ana::kFitTheta13 = FitTheta13()

$\theta_{13}$

Definition at line 20 of file FitVars.h.

const FitTheta13InDegreesSterile ana::kFitTheta13InDegreesSterile = FitTheta13InDegreesSterile()

$\theta_{13}$

Definition at line 349 of file FitVarsSterile.h.

const FitTheta13Sterile ana::kFitTheta13Sterile = FitTheta13Sterile()

$\theta_{13}$

Definition at line 114 of file FitVarsSterile.h.

const FitTheta14InDegreesSterile ana::kFitTheta14InDegreesSterile = FitTheta14InDegreesSterile()

$\theta_{14}$

Definition at line 385 of file FitVarsSterile.h.

const FitTheta14Sterile ana::kFitTheta14Sterile = FitTheta14Sterile()

$\theta_{14}$

Definition at line 186 of file FitVarsSterile.h.

const FitTheta23 ana::kFitTheta23 = FitTheta23()

$\theta_{13}$

Definition at line 67 of file FitVars.h.

const FitTheta23InDegreesSterile ana::kFitTheta23InDegreesSterile = FitTheta23InDegreesSterile()

$\theta_{23}$

Definition at line 367 of file FitVarsSterile.h.

const FitTheta23Sterile ana::kFitTheta23Sterile = FitTheta23Sterile()

$\theta_{23}$

Definition at line 150 of file FitVarsSterile.h.

const FitTheta24InDegreesSterile ana::kFitTheta24InDegreesSterile = FitTheta24InDegreesSterile()

$\theta_{24}$

Definition at line 403 of file FitVarsSterile.h.

const FitTheta24Sterile ana::kFitTheta24Sterile = FitTheta24Sterile()

$\theta_{24}$

Definition at line 241 of file FitVarsSterile.h.

const FitTheta34InDegreesSterile ana::kFitTheta34InDegreesSterile = FitTheta34InDegreesSterile()

$\theta_{34}$

Definition at line 421 of file FitVarsSterile.h.

const FitTheta34Sterile ana::kFitTheta34Sterile = FitTheta34Sterile()

$\theta_{34}$

Definition at line 295 of file FitVarsSterile.h.

const Cut ana::kFlashMatchNumuCut = kHasFlashMatch && kFlashMatchScore

Definition at line 29 of file NumuCuts.cxx.

const Cut ana::kFlashMatchScore

Definition at line 11 of file NumuCuts.h.

const SpillCut ana::kFlashTrigger

Definition at line 11 of file SBNAna/Cuts/Cuts.h.

const Cut ana::kFMScore

Definition at line 28 of file NumuCutsIcarus202106.h.

const Var ana::kFMScoreVar = SIMPLEVAR(fmatch.score)

Definition at line 13 of file NumuVarsIcarus202208.cxx.

const Var ana::kFMTimeVar = SIMPLEVAR(fmatch.time)

Definition at line 12 of file NumuVarsIcarus202208.cxx.

const Cut ana::kFullNueSel = kNueTrackLenCut && kShowerConvGapCut && kShowerdEdxCut && kShowerDensityCut

Definition at line 38 of file NueCuts.h.

const Cut ana::kHasFlashMatch

Definition at line 9 of file NumuCuts.h.

const Cut ana::kHasMatchedNu

Definition at line 9 of file CAFAna/Cuts/TruthCuts.h.

const Cut ana::kHasNu

Definition at line 10 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kHasPrimaryMuonTrk

Definition at line 9 of file NumuCutsSBND202106.h.

const Var ana::kHasTruthMatch

Definition at line 7 of file TruthVars.h.

const int ana::kICARUS = 2

Definition at line 13 of file ExpInfo.h.

const Cut ana::kIcarus202208ContainedHadrons

Definition at line 16 of file NumuCutsIcarus202208.h.

const Cut ana::kIcarus202208ContainedMuon

Definition at line 17 of file NumuCutsIcarus202208.h.

const Cut ana::kIcarus202208ContainedMuonAndHadrons = kIcarus202208ContainedMuon && kIcarus202208ContainedHadrons

Definition at line 47 of file NumuCutsIcarus202208.cxx.

const Cut ana::kIcarus202208FMScoreCut = kFMScoreVar < 9

Definition at line 18 of file NumuCutsIcarus202208.cxx.

const Cut ana::kIcarus202208FMTimeCut = kFMTimeVar > 0 && kFMTimeVar < 1.8

Definition at line 17 of file NumuCutsIcarus202208.cxx.

const Cut ana::kIcarus202208FoundMuon = kIcarus202208MuonIdx >= 0

Definition at line 20 of file NumuCutsIcarus202208.cxx.

const Cut ana::kIcarus202208LongTrackDirCut = kCRLongestTrackDirY > -0.91

Definition at line 19 of file NumuCutsIcarus202208.cxx.

const Var ana::kIcarus202208MuonIdx

Definition at line 11 of file NumuVarsIcarus202208.h.

const Cut ana::kIcarus202208NoPion = kIcarus202208NumPions == 0

Definition at line 33 of file NumuCutsIcarus202208.cxx.

const Var ana::kIcarus202208NumPions

Definition at line 12 of file NumuVarsIcarus202208.h.

const Cut ana::kIcarus202208NumuSelection = kIcarus202208RecoFiducial && kIcarus202208FMScoreCut && kIcarus202208FMTimeCut && kIcarus202208LongTrackDirCut && kIcarus202208FoundMuon

Definition at line 31 of file NumuCutsIcarus202208.cxx.

const Cut ana::kIcarus202208QELike = kIcarus202208NumuSelection && kIcarus202208NoPion && kIcarus202208ContainedHadrons

Definition at line 48 of file NumuCutsIcarus202208.cxx.

const Cut ana::kIcarus202208QELikeContainedMuon = kIcarus202208QELike && kIcarus202208ContainedMuon

Definition at line 49 of file NumuCutsIcarus202208.cxx.

const Cut ana::kIcarus202208RecoFiducial

Definition at line 11 of file NumuCutsIcarus202208.h.

const Cut ana::kInBeamSpill

Does the event fall inside the beam spill window.

const Cut ana::kInFV

Definition at line 7 of file NumuCutsSBND202106.h.

const Cut ana::kInTimingSideband

Is the event far from the start and end of the spill window.

const Color_t ana::kInvertedHierarchyColor = kOrange+9

Definition at line 28 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Var ana::kInvXSec([](const caf::SRSliceProxy *sr){const double GeV2perm2=2.56819e31;return GeV2perm2/sr->truth.xsec;})

const Cut ana::kIsAntiNu

Is this truly an antineutrino?

Definition at line 70 of file CAFAna/Cuts/TruthCuts.h.

const Cut ana::kIsCC

Definition at line 17 of file CAFAna/Cuts/TruthCuts.h.

const SpillCut ana::kIsCCSpill

Definition at line 37 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kIsCosmic = ( !kIsNuSlice )

Definition at line 10 of file NumuCutsIcarus202106.cxx.

const SpillCut ana::kIsCosmicSpill

Definition at line 31 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kIsNC

Is this a Neutral Current event?

In this case the selection function is simple enough that we can include it inline as a lambda function.

Definition at line 15 of file CAFAna/Cuts/TruthCuts.h.

const SpillCut ana::kIsNCSpill

Definition at line 38 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kIsNu

Definition at line 9 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kIsNue

Definition at line 12 of file SBNAna/Cuts/TruthCuts.h.

const SpillCut ana::kIsNueSpill

Definition at line 33 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kIsNumu

Definition at line 13 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kIsNuMuCC

Definition at line 13 of file NumuCutsIcarus202106.h.

const SpillCut ana::kIsNumuSpill

Definition at line 34 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kIsNuOther = ( kIsNuSlice && !kIsNuMuCC )

Definition at line 16 of file NumuCutsIcarus202106.cxx.

const Cut ana::kIsNuSlice = ( kTruthIndex >= 0.f )

Definition at line 8 of file NumuCutsIcarus202106.cxx.

const Cut ana::kIsNutau

Definition at line 14 of file SBNAna/Cuts/TruthCuts.h.

const SpillCut ana::kIsNutauSpill

Definition at line 35 of file SBNAna/Cuts/TruthCuts.h.

const SpillCut ana::kIsSingleNuSpill

Definition at line 32 of file SBNAna/Cuts/TruthCuts.h.

const Var ana::kLargestRecoShowerIdx

Definition at line 9 of file NueVars.h.

const Var ana::kLongestTrackChi2Kaon

Definition at line 37 of file NueVars.h.

const Var ana::kLongestTrackChi2Muon

Definition at line 35 of file NueVars.h.

const Var ana::kLongestTrackChi2Pion

Definition at line 36 of file NueVars.h.

const Var ana::kLongestTrackChi2Proton

Definition at line 38 of file NueVars.h.

const Var ana::kLongestTrackDazzleMuonScore

Definition at line 43 of file NueVars.h.

const Var ana::kLongestTrackDazzlePID

Definition at line 42 of file NueVars.h.

const Var ana::kLongestTrackIdx

Definition at line 33 of file NueVars.h.

const Var ana::kLongestTrackLength

Definition at line 34 of file NueVars.h.

const Var ana::kLongestTrackTruePdg

Definition at line 30 of file NueVars.h.

const SpillCut ana::kLongTrack

Definition at line 83 of file NumuCutsIcarus202106.h.

const Binning ana::kLowEnergyBinning = Binning::Custom( kLowEnergyEdges )

Definition at line 25 of file Binnings.cxx.

const std::vector<double> ana::kLowEnergyEdges

Initial value:

= {100., 200., 300., 400., 500., 750.,
                                               1000., 1250., 1500., 1750.,
                                               2000., 2250., 2500., 2750.,
                                               3000., 3250., 3500., 3750.,
                                               4000., 4250., 4500., 4750., 5000.}

Definition at line 9 of file Binnings.cxx.

const Binning ana::kLowEnergyGeVBinning = Binning::Custom( kLowEnergyGeVEdges )

Definition at line 26 of file Binnings.cxx.

const std::vector<double> ana::kLowEnergyGeVEdges

Initial value:

= {.1, .2, .3, .4, .5, .75,
                                                    1., 1.25, 1.5, 1.75,
                                                    2., 2.25, 2.5, 2.75,
                                                    3., 3.25, 3.5, 3.75,
                                                    4., 4.25, 4.5, 4.75, 5.}

Definition at line 15 of file Binnings.cxx.

const int ana::kMicroBoone = 1

Definition at line 12 of file ExpInfo.h.

const Var ana::kMuMaxTrack

Definition at line 11 of file NumuVarsIcarus202106.h.

const Var ana::kMuonTrackLength

Definition at line 40 of file NueVars.h.

const Color_t ana::kNCBackgroundColor = kAzure

Definition at line 17 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::kNormalHierarchyColor = kAzure+3

Definition at line 27 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const SystShifts ana::kNoShift = SystShifts::Nominal()

Definition at line 61 of file SystShifts.h.

const Cut ana::kNotClearCosmic

Definition at line 24 of file NumuCutsIcarus202106.h.

const Cut ana::kNueAllTrackDazzleMuonCut

Definition at line 30 of file NueCuts.h.

const Cut ana::kNueAllTrackDazzleMuonScoreCut

Definition at line 31 of file NueCuts.h.

const Cut ana::kNueBasicCut

Definition at line 9 of file NueCuts.h.

const Cut ana::kNueContainedFD

Definition at line 34 of file NueCuts.h.

const Cut ana::kNueContainedND

Definition at line 33 of file NueCuts.h.

const Binning ana::kNueEnergyBinning = Binning::Simple( 20, 0., 5000.)

Definition at line 22 of file Binnings.cxx.

const Cut ana::kNueFD = kContainedFD && kNueFlashScoreFDCut && kNuePandoraScoreFDCut && kRecoShowerFD

Definition at line 45 of file NueCuts.h.

const Cut ana::kNueFlashScoreFDCut = kSlcFlashMatchCut

Definition at line 42 of file NueCuts.h.

const Cut ana::kNueHasTrackCut

Definition at line 11 of file NueCuts.h.

const Cut ana::kNueLongestTrackDazzleMuonCut = kLongestTrackDazzlePID != 13

Definition at line 131 of file NueCuts.cxx.

const Cut ana::kNueLongestTrackDazzleMuonScoreCut = kLongestTrackDazzleMuonScore < 0.8

Definition at line 132 of file NueCuts.cxx.

const Cut ana::kNueMuonCut

Definition at line 16 of file NueCuts.h.

const Cut ana::kNueMuonCutNEW

const Cut ana::kNueMuonCutOLD

const Cut ana::kNueNumShowersCut

Definition at line 18 of file NueCuts.h.

const Cut ana::kNuePandoraScoreFDCut = kSlcNuScoreCut

Definition at line 43 of file NueCuts.h.

const Color_t ana::kNueSignalColor = kViolet-5

Definition at line 15 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Cut ana::kNueTrackContainmentCut

Definition at line 12 of file NueCuts.h.

const Cut ana::kNueTrackLenCut

Definition at line 13 of file NueCuts.h.

const double ana::kNuFitdCPCVIH = 284 * TMath::Pi()/180

Definition at line 26 of file CalcsNuFit.h.

const double ana::kNuFitdCPCVNH = 215 * TMath::Pi()/180

Definition at line 21 of file CalcsNuFit.h.

const double ana::kNuFitDmsq21CV = 7.39e-5

Definition at line 14 of file CalcsNuFit.h.

const double ana::kNuFitDmsq21Err = ((8.01-6.79)/6)*1e-5

Definition at line 29 of file CalcsNuFit.h.

const double ana::kNuFitDmsq32CVIH = -2.512e-3

Definition at line 23 of file CalcsNuFit.h.

const double ana::kNuFitDmsq32CVNH = +2.525e-3 - kNuFitDmsq21CV

Definition at line 18 of file CalcsNuFit.h.

const double ana::kNuFitDmsq32ErrIH = ((2.611-2.412)/6)*1e-3

Definition at line 36 of file CalcsNuFit.h.

const double ana::kNuFitDmsq32ErrNH = ((2.625-2.427)/6)*1e-3

Definition at line 32 of file CalcsNuFit.h.

const double ana::kNuFitTh12CV = 33.82 * TMath::Pi()/180

Definition at line 15 of file CalcsNuFit.h.

const double ana::kNuFitTh12Err = ((36.27-31.61)/6) * TMath::Pi()/180

Definition at line 30 of file CalcsNuFit.h.

const double ana::kNuFitTh13CVIH = 8.65 * TMath::Pi()/180

Definition at line 25 of file CalcsNuFit.h.

const double ana::kNuFitTh13CVNH = 8.61 * TMath::Pi()/180

Definition at line 20 of file CalcsNuFit.h.

const double ana::kNuFitTh13ErrIH = ((9.03-8.27)/6) * TMath::Pi()/180

Definition at line 38 of file CalcsNuFit.h.

const double ana::kNuFitTh13ErrNH = ((8.99-8.22)/6) * TMath::Pi()/180

Definition at line 34 of file CalcsNuFit.h.

const double ana::kNuFitTh23CVIH = 49.8 * TMath::Pi()/180

Definition at line 24 of file CalcsNuFit.h.

const double ana::kNuFitTh23CVNH = 49.6 * TMath::Pi()/180

Definition at line 19 of file CalcsNuFit.h.

const double ana::kNuFitTh23ErrIH = ((52.5-40.6)/6) * TMath::Pi()/180

Definition at line 37 of file CalcsNuFit.h.

const double ana::kNuFitTh23ErrNH = ((52.4-40.3)/6) * TMath::Pi()/180

Definition at line 33 of file CalcsNuFit.h.

NullLoader ana::kNullLoader

static

Dummy loader that doesn't load any files.

Useful when a loader is required for a component you want to ignore

Definition at line 269 of file SpectrumLoaderBase.h.

const Color_t ana::kNumuBackgroundColor = kGreen+2

This is the color for the numu CC background to the nue analysis. I doubt numu plots will ever use this, preferring to just show the total MC.

Definition at line 22 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Cut ana::kNumuBasicQual

Definition at line 7 of file NumuCuts.h.

const Cut ana::kNuMuCC_ClearCos = ( kNuMuCC_TFiducial && kNotClearCosmic )

Definition at line 110 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuMuCC_Cryo0 = ( kIsNuMuCC && kCryo0 )

Definition at line 92 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuMuCC_FMScore = ( kNuMuCC_NuScore && kFMScore )

Definition at line 122 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuMuCC_FullSelection = ( kCryo0 && kRFiducial && kNotClearCosmic && kNuScore && kFMScore && kPTrack )

Definition at line 135 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuMuCC_NuScore = ( kNuMuCC_ClearCos && kNuScore )

Definition at line 116 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuMuCC_PTrack = ( kNuMuCC_FMScore && kPTrack )

Definition at line 128 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuMuCC_RFiducial = ( kNuMuCC_Cryo0 && kRFiducial )

Definition at line 100 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuMuCC_TFiducial = ( kNuMuCC_Cryo0 && kTFiducial )

Definition at line 98 of file NumuCutsIcarus202106.cxx.

const Binning ana::kNumuEnergyBinning = Binning::Simple( 20, 0., 5000.)

Definition at line 23 of file Binnings.cxx.

const Cut ana::kNumuTrkLen

Definition at line 15 of file NumuCuts.h.

const Cut ana::kNuOther_ClearCos = ( kNuOther_TFiducial && kNotClearCosmic )

Definition at line 114 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuOther_Cryo0 = ( kIsNuOther && kCryo0 )

Definition at line 96 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuOther_FMScore = ( kNuOther_NuScore && kFMScore )

Definition at line 126 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuOther_NuScore = ( kNuOther_ClearCos && kNuScore )

Definition at line 120 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuOther_PTrack = ( kNuOther_FMScore && kPTrack )

Definition at line 132 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuOther_RFiducial = ( kNuOther_Cryo0 && kRFiducial )

Definition at line 108 of file NumuCutsIcarus202106.cxx.

const Cut ana::kNuOther_TFiducial = ( kNuOther_Cryo0 && kTFiducial )

Definition at line 106 of file NumuCutsIcarus202106.cxx.

const Var ana::kNuScore

Definition at line 26 of file NumuCutsIcarus202106.h.

const Binning ana::kPositionXFDBinning = Binning::Simple(47, avfd_cryo1.xmin, avfd_cryo1.xmax)

Definition at line 32 of file Binnings.cxx.

const Binning ana::kPositionXNDBinning = Binning::Simple(40, avnd.xmin, avnd.xmax)

Definition at line 29 of file Binnings.cxx.

const Binning ana::kPositionYFDBinning = Binning::Simple(35, avfd_cryo1.ymin, avfd_cryo1.ymax)

Definition at line 33 of file Binnings.cxx.

const Binning ana::kPositionYNDBinning = Binning::Simple(40, avnd.ymin, avnd.ymax)

Definition at line 30 of file Binnings.cxx.

const Binning ana::kPositionZFDBinning = Binning::Simple(90, avfd_cryo1.zmin, avfd_cryo1.zmax)

Definition at line 34 of file Binnings.cxx.

const Binning ana::kPositionZNDBinning = Binning::Simple(50, avnd.zmin, avnd.zmax)

Definition at line 31 of file Binnings.cxx.

const double ana::kPOTnominal = 6.6e20

Definition at line 6 of file ExpInfo.h.

const double ana::kPOTuBoone = 1.3e21

Definition at line 7 of file ExpInfo.h.

const Cut ana::kPreNueSelND = kFiducialVolumeND && kSlcNuScoreCut && kSlcFlashMatchCut

Definition at line 36 of file NueCuts.h.

const Var ana::kPrimaryEnergy = SIMPLEVAR(truth.E)

Definition at line 9 of file NumuVarsIcarus202106.cxx.

const Var ana::kPrimaryMuonTrkIdx

Definition at line 11 of file NumuVarsSBND202106.h.

const Var ana::kPrimaryMuonTrkLen

Definition at line 13 of file NumuVarsSBND202106.h.

const Var ana::kPrimaryMuonTrkP

Definition at line 12 of file NumuVarsSBND202106.h.

const Color_t ana::kPrimColorIH = kOrange+9

Definition at line 37 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::kPrimColorNH = kAzure+2

Definition at line 34 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Var ana::kPrimMuonIdx

Definition at line 11 of file NumuVars.h.

const Var ana::kPrimTrkLen

Definition at line 9 of file NumuVars.h.

const Cut ana::kPTrack

Definition at line 30 of file NumuCutsIcarus202106.h.

const Cut ana::kPTrackContained

Definition at line 32 of file NumuCutsIcarus202106.h.

const Cut ana::kPTrackExiting

Definition at line 34 of file NumuCutsIcarus202106.h.

const Var ana::kPTrackInd

Definition at line 13 of file NumuVarsIcarus202106.h.

const Cut ana::kRazzleDazzleNueSel = kNueAllTrackDazzleMuonCut && kShowerRazzleElectronScoreCut

Definition at line 39 of file NueCuts.h.

const Var ana::kRecoMuonP

Definition at line 15 of file NumuVarsIcarus202106.h.

const Cut ana::kRecoNueSel = kRecoShower && kShowerEnergyCut

Definition at line 37 of file NueCuts.h.

const Cut ana::kRecoShower

Definition at line 8 of file NueCuts.h.

const Var ana::kRecoShower_BestdEdx

Definition at line 11 of file NueVars.h.

const Var ana::kRecoShower_BestEnergy

Definition at line 10 of file NueVars.h.

const Var ana::kRecoShower_ConversionGap

Definition at line 12 of file NueVars.h.

const Var ana::kRecoShower_Density

Definition at line 13 of file NueVars.h.

const Var ana::kRecoShower_densityGradient

Definition at line 24 of file NueVars.h.

const Var ana::kRecoShower_densityGradientPower

Definition at line 25 of file NueVars.h.

const Var ana::kRecoShower_EndX

Definition at line 20 of file NueVars.h.

const Var ana::kRecoShower_EndY

Definition at line 21 of file NueVars.h.

const Var ana::kRecoShower_EndZ

Definition at line 22 of file NueVars.h.

const Var ana::kRecoShower_Energy

Definition at line 14 of file NueVars.h.

const Var ana::kRecoShower_Length

Definition at line 15 of file NueVars.h.

const Var ana::kRecoShower_OpenAngle

Definition at line 16 of file NueVars.h.

const Var ana::kRecoShower_StartX

Definition at line 17 of file NueVars.h.

const Var ana::kRecoShower_StartY

Definition at line 18 of file NueVars.h.

const Var ana::kRecoShower_StartZ

Definition at line 19 of file NueVars.h.

const Var ana::kRecoShower_trackLength

Definition at line 26 of file NueVars.h.

const Var ana::kRecoShower_trackWidth

Definition at line 27 of file NueVars.h.

const Var ana::kRecoShower_TruePdg

Definition at line 29 of file NueVars.h.

const Cut ana::kRecoShowerFD = kRecoShower && kNueNumShowersCut && kShowerdEdxCut && kShowerConvGapCut && kNueTrackLenCut && kShowerDensityCut && kShowerEnergyCut

Definition at line 44 of file NueCuts.h.

const Var ana::kRecoShowerRazzleElectronScore

Definition at line 45 of file NueVars.h.

const Var ana::kRecoShowerRazzlePID

Definition at line 44 of file NueVars.h.

const Var ana::kRecoShowers_EnergyCut

Definition at line 31 of file NueVars.h.

const Cut ana::kRFiducial

Definition at line 22 of file NumuCutsIcarus202106.h.

const SpillVar ana::kRun = SIMPLESPILLVAR(hdr.run)

Definition at line 15 of file Vars.cxx.

const int ana::kSBND = 0

Definition at line 11 of file ExpInfo.h.

const Color_t ana::kSecoColorIH = kOrange+10

Definition at line 38 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::kSecoColorNH = kAzure+1

Definition at line 35 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Cut ana::kShowerConvGapCut

Definition at line 22 of file NueCuts.h.

const Cut ana::kShowerdEdxCut

Definition at line 21 of file NueCuts.h.

const Cut ana::kShowerDensityCut

Definition at line 23 of file NueCuts.h.

const Cut ana::kShowerEnergyCut

Definition at line 20 of file NueCuts.h.

const Cut ana::kShowerOpenAngleCut

Definition at line 24 of file NueCuts.h.

const Cut ana::kShowerRazzleElectronCut = kRecoShowerRazzlePID == 11

Definition at line 128 of file NueCuts.cxx.

const Cut ana::kShowerRazzleElectronScoreCut = kRecoShowerRazzleElectronScore > 0.8

Definition at line 129 of file NueCuts.cxx.

const Cut ana::kSlcCompletenessCut

Definition at line 29 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kSlcFlashMatchCut

Definition at line 28 of file SBNAna/Cuts/Cuts.h.

const Cut ana::kSlcFlashMatchScoreCut

Definition at line 15 of file NumuCutsSBND202106.h.

const Cut ana::kSlcFlashMatchTimeCut

Definition at line 14 of file NumuCutsSBND202106.h.

const Var ana::kSlcFlashScore

Definition at line 35 of file Vars.h.

const Var ana::kSlcHasFlash

Definition at line 34 of file Vars.h.

const Cut ana::kSlcHasFlashMatch

Definition at line 27 of file SBNAna/Cuts/Cuts.h.

const Cut ana::kSlcIsRecoNu

Definition at line 24 of file SBNAna/Cuts/Cuts.h.

const Var ana::kSlcNuScore

Definition at line 33 of file Vars.h.

const Cut ana::kSlcNuScoreCut

Definition at line 25 of file SBNAna/Cuts/Cuts.h.

const Var ana::kSlcVtxX

Definition at line 30 of file Vars.h.

const Var ana::kSlcVtxY

Definition at line 31 of file Vars.h.

const Var ana::kSlcVtxZ

Definition at line 32 of file Vars.h.

const SpillVar ana::kSpillCounting = kSpillUnweighted

Definition at line 20 of file Vars.cxx.

const Cut ana::kTFiducial

Definition at line 20 of file NumuCutsIcarus202106.h.

const Color_t ana::kTotalBackgroundColor = kAzure+2

Definition at line 16 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::kTotalMCColor = kRed

Definition at line 13 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Color_t ana::kTotalMCErrorBandColor = kRed-10

Definition at line 14 of file sbnana/sbnana/CAFAna/Analysis/Style.h.

const Cut ana::kTrueActiveVolumeFDCryo1

Definition at line 21 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kTrueActiveVolumeFDCryo2

Definition at line 22 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kTrueActiveVolumeND

Definition at line 19 of file SBNAna/Cuts/TruthCuts.h.

const Var ana::kTrueE([](const caf::SRSliceProxy *slc) -> double{return slc->truth.E;})

const Binning ana::kTrueEnergyBins = TrueEnergyBins()

Default true-energy bin edges.

Definition at line 71 of file Binning.h.

const Cut ana::kTrueFiducialVolumeFDCryo1

Definition at line 24 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kTrueFiducialVolumeFDCryo2

Definition at line 25 of file SBNAna/Cuts/TruthCuts.h.

const Cut ana::kTrueFiducialVolumeND

Definition at line 20 of file SBNAna/Cuts/TruthCuts.h.

const Var ana::kTrueLOverE = kBaseline / kTrueE

Definition at line 30 of file OscillatableSpectrum.cxx.

const Binning ana::kTrueLOverEBins = Binning::Simple(100, 0, 2)

Definition at line 74 of file Binning.h.

const Var ana::kTrueMuonP

Definition at line 17 of file NumuVarsIcarus202106.h.

const Var ana::kTruthEnergy

Definition at line 10 of file TruthVars.h.

const Var ana::kTruthIndex = SIMPLEVAR(truth.index)

Definition at line 7 of file NumuVarsIcarus202106.cxx.

const SpillVar ana::kTruthLeptonEnergy

Definition at line 23 of file TruthVars.h.

const SpillVar ana::kTruthNuEnergy

Definition at line 22 of file TruthVars.h.

const Var ana::kTruthVtxDistMag

Definition at line 20 of file TruthVars.h.

const Var ana::kTruthVtxDistX

Definition at line 16 of file TruthVars.h.

const Var ana::kTruthVtxDistY

Definition at line 17 of file TruthVars.h.

const Var ana::kTruthVtxDistZ

Definition at line 18 of file TruthVars.h.

const Var ana::kTruthVtxX

Definition at line 12 of file TruthVars.h.

const Var ana::kTruthVtxY

Definition at line 13 of file TruthVars.h.

const Var ana::kTruthVtxZ

Definition at line 14 of file TruthVars.h.

const Cut ana::kVtxDistMagCut

Definition at line 27 of file SBNAna/Cuts/TruthCuts.h.

f sin ana::theta_

Initial value:

{\mu\mu} \f$
  class FitSinSq2ThetaMuMu: public IConstrainedFitVar
  {
  public:
    virtual double GetValue(const osc::IOscCalcAdjustable* osc) const;
    virtual void SetValue(osc::IOscCalcAdjustable* osc, double val) const;
    virtual std::string ShortName() const {return "ss2thmm";}
    virtual std::string LatexName() const {return "sin^{2}2#theta_{#mu#mu}";}
    virtual double LowLimit() const {return 0;}
    virtual double HighLimit() const {return 1;}
  }

Definition at line 27 of file FitVarsSterileApprox.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation