cmf Namespace Reference

Module to combine a set of results into a single file currently only does one data product type at a time. More...

Classes
class	BeamSyst
class	CAFToEventList
class	CalibSyst
class	ChiSqrCalculator
struct	ChiSqrInfo
class	CMFCappedEventList
class	CMFDecorrelator
class	CMFSpectraMaker
class	CombineResults
class	ContourFromLibrary
class	CovarianceBinUtility
class	CovarianceFitHelper
class	CovarianceMatrixFitter
class	CovarianceMatrixMaker
class	CovarianceTools
struct	CovFitIteration
struct	DataVars
class	DataVarVals
	Base container for the MC related Vars that constitute an event. More...
class	Event
class	EventId
class	EventList
class	EventListManipulator
class	FakeUniverse
class	FCResultCollection
class	FCUniverseCollection
struct	FileExtracts
class	FitFeldmanCousinsPoint
class	GridPoint
struct	HiddenParameterConfig
class	InputPoint
class	Location
class	MCVarVals
	Base container for the MC related Vars that constitute an event. More...
struct	MetaData
struct	MetaDataLite
class	OscPar
class	OscParamPoint
class	Parameter
class	ParameterUtility
struct	PeriodRun
class	PlotUtilities
class	PointResult
class	PointSpectra
struct	POTLiveTime
class	PredictionLibraryMaker
class	RandomUniverses
class	RandomUniverseUtility
class	SelectionUtility
class	ShifterAndWeighter
class	SpectrumPredictionMaker
struct	SpillSummary
struct	SubMatrixData
class	SystPar
struct	SystVar
struct	TruthVars
struct	WeightVars

Typedefs
typedef std::unique_ptr< Event >	EventPtr
typedef std::vector< EventPtr >	EventContainer
typedef std::vector< cmf::EventList >	EventListColl
typedef std::vector< cmf::SystVar >	SystVarColl
typedef enum cmf::det_type	DetType_t
typedef enum cmf::beam_type	BeamType_t
typedef enum cmf::chisqr_type	ChiSqrCalc_t
typedef enum cmf::sel_type	SelectionType_t
typedef enum cmf::interaction_type	InteractionType_t
typedef enum cmf::file_type	FileType_t
typedef enum cmf::osc_params	OscParm_t
typedef enum cmf::calc_type	CalcType_t
typedef enum cmf::covmat_type	CovMat_t
typedef enum cmf::cont_type	ContourType_t
typedef enum cmf::dataMC_type	DataMC_t
typedef enum cmf::par_type	ParType_t
typedef enum cmf::weight_type	WeightType_t
typedef std::pair< std::string, cmf::DetType_t >	ParameterDet
typedef std::vector< float >	Spectrum
typedef std::map< double, double >	ParamChiSqr
typedef std::map< cmf::OscParm_t, float >	OscillationParameterMap
typedef std::map< cmf::GridPoint, double >	PointMap
typedef std::map< cmf::GridPoint, std::vector< double > >	UniverseChiSqrMap
typedef std::map< std::string, Parameter >	ParameterSpaceLoc
typedef std::map< cmf::MetaData, cmf::SpillSummary >	ExposureMap
typedef std::vector< cmf::FakeUniverse >	FakeUniColl

Enumerations
enum	det_type {   kUnknownDet = 0, kNEARDET, kFARDET, kMINOSNEAR,   kMINOSFAR }
enum	beam_type { kFHC = 0, kRHC, k0HC, kUnknownBeam }
enum	chisqr_type {   kCovMat = 0, kPoisson, kCNP, kGauss,   kUnknownChiSqr }
enum	sel_type {   kNuESelection = 0, kNuESelectionLowPID, kNuESelectionMidPID, kNuESelectionHighPID,   kNuESelectionPeripheral, kNuMuSelection, kNuMuSelectionQ1, kNuMuSelectionQ2,   kNuMuSelectionQ3, kNuMuSelectionQ4, kNCSelection, kUnknownSelection }
enum	interaction_type {   kUnknownInteraction = 0, kNuMuCC, kNuMuBarCC, kNuECC,   kNuEBarCC, kNuTauCC, kNuTauBarCC, kNC,   kCosmicMuon, kRockMuon, kUncategorised }
enum	file_type {   kBeam =0, kSwap, kTauSwap, kDataFile,   kCosmicBackgroundFile, kRockFluxSwap, kRockNonSwap, kNumFileTypes,   kBadFileType, kUnknownFileType }
enum	osc_params {   kL = 0, kRho, kDmsq21, kDmsq32,   kTh12, kTh13, kTh23, kdCP,   kTh14, kTh24, kTh34, kDmsq41,   kd24, kEps_ee, kEps_emu, kEps_etau,   kEps_mumu, kEps_mutau, kEps_tautau, kDelta_emu,   kDelta_etau, kDelta_mutau, kNumOscParams }
enum	calc_type { kPMNS =0, kNSI, kSterile }
enum	covmat_type { kStatMatrix =0, kSystMatrix, kTotalMatrix }
enum	cont_type {   kAsimovContour =0, kMedianContour, kFCContour, kDataContour,   kUnknownContour }
enum	dataMC_type { kData = 0, kMC, kFakeData, kBoth }
enum	varpar_type {   kUnknownVar = 0, kNuE_CVN, kNuE_NumMichel, kHad_RecoE,   kLep_RecoE, kNu_RecoE, kLep_RecoE_MCFrac, kRecoQ2,   kFake_Weight, kTrueE, kTruePDG, kTrueCCNC,   kTrueIntType, kTruePDGOrig, kTrueParentPDG, kTrueParentPT,   kTrueParentPZ, kTrueParentDecay, kTrueParentTargetPDG, kTrueHitNuc,   kTrueIntMode, kXSecCVPPFX_Weight, kXSecCV2020Wgt, kPPFXFluxCVWgt,   kRPACCQE_Weight, kRPARES_Weight, kDISvnCC1pi_Weight, kEmpiricalMEC_Weight,   kEmpiricalMECtoGENIEQE_Weight, kEmpiricalMECtoGENIERES_Weight, kOtherDIS_Weight, kLightModelLightDownCalibUp,   kLightModelLightUpCalibDown, kCkvProtonShiftDown, kRelativeCalibration, kAbsoluteCalibration,   kCalibShape, kMinus2Sigma, kMinus1Sigma, kPlus1Sigma,   kPlus2Sigma, kFirstSigmaVar, kMaCCRES =kFirstSigmaVar, kMvCCRES,   kMaNCRES, kMvNCRES, kRPACCQEshapeEnh, kRPACCQEshapeSupp,   kGENIEPCA00, kGENIEPCA01, kGENIEPCA02, kGENIEPCA03,   kGENIEPCA04, kGENIEPCA05, kGENIEPCA06, kGENIEPCA07,   kGENIEPCA08, kGENIEPCA09, kGENIEPCA10, kGENIEPCA11,   kZNormCCQE, kZExpEV1Syst2020, kZExpEV2Syst2020, kZExpEV3Syst2020,   kZExpEV4Syst2020, kRESLowQ2SuppSyst2020, khNFSISyst2020_MFP, khNFSISyst2020_EV1,   kMECEnuShapeSyst2020Nu, kMECEnuShapeSyst2020AntiNu, kMECShapeSyst2020Nu, kMECShapeSyst2020AntiNu,   kMECInitStateNPFracSyst2020Nu, kMECInitStateNPFracSyst2020AntiNu, kRadCorrNue, kRadCorrNuebar,   k2ndClassCurrs, kUnCorrNDMuEScaleSyst2020, kUnCorrMuCatMuESyst2020, kPileupMuESyst2020,   kCorrMuEScaleSyst2020, kNeutronVisEScalePrimariesSyst2018, kMichelTaggingSyst2020, kAna2020NormFHC,   kAna2020NormRHC, kTauScaleSyst, kNorm_1Nux, kMeanQ0_1Nux,   kMeanQ3_1Nux, kSigmaQ0_1Nux, kSigmaQ3_1Nux, kCorr_1Nux,   kNorm_2Nux, kMeanQ0_2Nux, kMeanQ3_2Nux, kSigmaQ0_2Nux,   kSigmaQ3_2Nux, kCorr_2Nux, kBaselineNux, kDISvpCC0pi_2020,   kDISvpCC1pi_2020, kDISvpCC2pi_2020, kDISvpCC3pi_2020, kDISvpNC0pi_2020,   kDISvpNC1pi_2020, kDISvpNC2pi_2020, kDISvpNC3pi_2020, kDISvnCC0pi_2020,   kDISvnCC1pi_2020, kDISvnCC2pi_2020, kDISvnCC3pi_2020, kDISvnNC0pi_2020,   kDISvnNC1pi_2020, kDISvnNC2pi_2020, kDISvnNC3pi_2020, kDISvbarpCC0pi_2020,   kDISvbarpCC1pi_2020, kDISvbarpCC2pi_2020, kDISvbarpCC3pi_2020, kDISvbarpNC0pi_2020,   kDISvbarpNC1pi_2020, kDISvbarpNC2pi_2020, kDISvbarpNC3pi_2020, kDISvbarnCC0pi_2020,   kDISvbarnCC1pi_2020, kDISvbarnCC2pi_2020, kDISvbarnCC3pi_2020, kDISvbarnNC0pi_2020,   kDISvbarnNC1pi_2020, kDISvbarnNC2pi_2020, kDISvbarnNC3pi_2020, kFormZone_2020,   khNFSISyst2020_EV2, khNFSISyst2020_EV3, kCOHCCScaleSyst2018, kCOHNCScaleSyst2018,   kMaNCEL, kEtaNCEL, kAhtBY, kBhtBY,   kCV1uBY, kCV2uBY, kAGKY_xF1pi, kAGKY_pT1pi,   kBR1gamma, kBR1eta, kTheta_Delta2Npi, kLastSigmaVar =kTheta_Delta2Npi }
enum	par_type { kOscPar = 0, kCMFSystPar, kOtherSystPar, kUnknownPar }
enum	weight_type { kSystWgtOnly =0, kOscWgtOnly, kSystAndOscWgt, kAllWgt }

Functions
std::ostream &	operator<< (std::ostream &o, cmf::Event const &event)
cmf::EventListColl::iterator	FindEventList (cmf::MetaData const &md, cmf::EventListColl &eventListColl)
void	SerializeEvents (TTree *eventTree, cmf::MetaData const &md, cmf::EventList const &events)
void	SerializeEventListColl (std::string const &dirName, cmf::EventListColl const &listColl)
void	FillSpectrumFromSingleList (cmf::EventList const &list, cmf::MetaData const &md, cmf::ExposureMap const &exposureMap, std::vector< float > &spectrum, std::vector< float > &count, bool applyExposureNorm)
void	FillSpectrum (cmf::EventListColl const &eventLists, cmf::ExposureMap const &exposureMap, std::vector< float > &spectrum, std::vector< float > &count, cmf::InteractionType_t intType, bool applyExposureNorm)
void	FillSpectrum (cmf::EventListColl const &eventLists, cmf::ExposureMap const &exposureMap, std::vector< float > &spectrum, std::vector< float > &count, bool applyExposureNorm)
std::ostream &	operator<< (std::ostream &o, cmf::MCVarVals const &mcvv)
std::ostream &	operator<< (std::ostream &o, cmf::SystVar const &sv)
std::ostream &	operator<< (std::ostream &o, cmf::EventId const &evid)
std::ostream &	operator<< (std::ostream &o, cmf::DataVarVals const &dvv)
static float	RecoEnergy (float leptonicEnergy, float hadronicEnergy, cmf::MetaData const &md)
static float	NuMuEnergy (float leptonicEnergy, float hadronicEnergy)
static float	NuEEnergy (float leptonicEnergy, float hadronicEnergy, cmf::BeamType_t const &beamType)
static float	NCEnergy (float leptonicEnergy, float hadronicEnergy, cmf::BeamType_t const &beamType, cmf::DetType_t const &detector)
static const std::set< cmf::DetType_t >	cDetIds ({cmf::kNEARDET, cmf::kFARDET})
static const std::set< cmf::BeamType_t >	cBeamTypes ({kFHC, kRHC})
static const std::map< std::string, uint8_t >	kVarNameToKey ({{"NuE_CVN", cmf::kNuE_CVN},{"NuE_NumMichel", cmf::kNuE_NumMichel},{"Had_RecoE", cmf::kHad_RecoE},{"Lep_RecoE", cmf::kLep_RecoE},{"Nu_RecoE", cmf::kNu_RecoE},{"Lep_RecoE_MCFrac", cmf::kLep_RecoE_MCFrac},{"Reco_Q2", cmf::kRecoQ2},{"Fake_Weight", cmf::kFake_Weight},{"TrueE", cmf::kTrueE},{"TruePDG", cmf::kTruePDG},{"TrueCCNC", cmf::kTrueCCNC},{"TrueIntType", cmf::kTrueIntType},{"TruePDGOrig", cmf::kTruePDGOrig},{"TrueParentPDG", cmf::kTrueParentPDG},{"TrueParentPT", cmf::kTrueParentPT},{"TrueParentPZ", cmf::kTrueParentPZ},{"TrueParentDecay", cmf::kTrueParentDecay},{"TrueParentTargetPDG", cmf::kTrueParentTargetPDG},{"TrueHitNuc", cmf::kTrueHitNuc},{"TrueIntMode", cmf::kTrueIntMode},{"XsecCV2020", cmf::kXSecCV2020Wgt},{"PPFXFluxCV", cmf::kPPFXFluxCVWgt},{"RPARES", cmf::kRPARES_Weight},{"-2sigma", cmf::kMinus2Sigma},{"-1sigma", cmf::kMinus1Sigma},{"+1sigma", cmf::kPlus1Sigma},{"+2sigma", cmf::kPlus2Sigma},{"lightmodel-lightdown", cmf::kLightModelLightDownCalibUp},{"lightmodel-lightup", cmf::kLightModelLightUpCalibDown},{"ckv-proton", cmf::kCkvProtonShiftDown},{"RelativeCalibration", cmf::kRelativeCalibration},{"AbsoluteCalibration", cmf::kAbsoluteCalibration},{"CalibrationShape", cmf::kCalibShape},{"MaNCEL", cmf::kMaNCEL},{"EtaNCEL", cmf::kEtaNCEL},{"AhtBY", cmf::kAhtBY},{"BhtBY", cmf::kBhtBY},{"CV1uBY", cmf::kCV1uBY},{"CV2uBY", cmf::kCV2uBY},{"AGKY_xF1pi", cmf::kAGKY_xF1pi},{"AGKY_pT1pi", cmf::kAGKY_pT1pi},{"BR1gamma", cmf::kBR1gamma},{"BR1eta", cmf::kBR1eta},{"Theta_Delta2Npi", cmf::kTheta_Delta2Npi},{"MvCCRES", cmf::kMvCCRES},{"MaCCRES", cmf::kMaCCRES},{"MvNCRES", cmf::kMvNCRES},{"MaNCRES", cmf::kMaNCRES},{"RPACCQEshapeEnh", cmf::kRPACCQEshapeEnh},{"RPACCQEshapeSupp", cmf::kRPACCQEshapeSupp},{"COHCCScale2018", cmf::kCOHCCScaleSyst2018},{"COHNCScale2018", cmf::kCOHNCScaleSyst2018},{"ZExpAxialFFSyst2020_eV1", cmf::kZExpEV1Syst2020},{"ZExpAxialFFSyst2020_eV2", cmf::kZExpEV2Syst2020},{"ZExpAxialFFSyst2020_eV3", cmf::kZExpEV3Syst2020},{"ZExpAxialFFSyst2020_eV4", cmf::kZExpEV4Syst2020},{"ZNormCCQE", cmf::kZNormCCQE},{"RESLowQ2SuppSyst2020", cmf::kRESLowQ2SuppSyst2020},{"hNFSISyst2020_MFP", cmf::khNFSISyst2020_MFP},{"hNFSISyst2020_EV1", cmf::khNFSISyst2020_EV1},{"MECEnuShapeSyst2020Nu", cmf::kMECEnuShapeSyst2020Nu},{"MECEnuShapeSyst2020AntiNu", cmf::kMECEnuShapeSyst2020AntiNu},{"MECShapeSyst2020Nu", cmf::kMECShapeSyst2020Nu},{"MECShapeSyst2020AntiNu", cmf::kMECShapeSyst2020AntiNu},{"MECInitStateNPFracSyst2020Nu", cmf::kMECInitStateNPFracSyst2020Nu},{"MECInitStateNPFracSyst2020AntiNu", cmf::kMECInitStateNPFracSyst2020AntiNu},{"RadCorrNue", cmf::kRadCorrNue},{"RadCorrNuebar", cmf::kRadCorrNuebar},{"2ndClassCurrs", cmf::k2ndClassCurrs},{"GENIEPCA00", cmf::kGENIEPCA00},{"GENIEPCA01", cmf::kGENIEPCA01},{"GENIEPCA02", cmf::kGENIEPCA02},{"GENIEPCA03", cmf::kGENIEPCA03},{"GENIEPCA04", cmf::kGENIEPCA04},{"GENIEPCA05", cmf::kGENIEPCA05},{"GENIEPCA06", cmf::kGENIEPCA06},{"GENIEPCA07", cmf::kGENIEPCA07},{"GENIEPCA08", cmf::kGENIEPCA08},{"GENIEPCA09", cmf::kGENIEPCA09},{"GENIEPCA10", cmf::kGENIEPCA10},{"GENIEPCA11", cmf::kGENIEPCA11},{"UnCorrNDMuEScaleSyst2020", cmf::kUnCorrNDMuEScaleSyst2020},{"UnCorrMuCatMuESyst2020", cmf::kUnCorrMuCatMuESyst2020},{"PileupMuESyst2020", cmf::kPileupMuESyst2020},{"CorrMuEScaleSyst2020", cmf::kCorrMuEScaleSyst2020},{"NeutronVisEScalePrimariesSyst2018", cmf::kNeutronVisEScalePrimariesSyst2018},{"MichelTaggingSyst2020", cmf::kMichelTaggingSyst2020},{"Ana2020NormFHC", cmf::kAna2020NormFHC},{"Ana2020NormRHC", cmf::kAna2020NormRHC},{"Norm_1Nux", cmf::kNorm_1Nux},{"MeanQ0_1Nux", cmf::kMeanQ0_1Nux},{"MeanQ3_1Nux", cmf::kMeanQ3_1Nux},{"SigmaQ0_1Nux", cmf::kSigmaQ0_1Nux},{"SigmaQ3_1Nux", cmf::kSigmaQ3_1Nux},{"Corr_1Nux", cmf::kCorr_1Nux},{"Norm_2Nux", cmf::kNorm_2Nux},{"MeanQ0_2Nux", cmf::kMeanQ0_2Nux},{"MeanQ3_2Nux", cmf::kMeanQ3_2Nux},{"SigmaQ0_2Nux", cmf::kSigmaQ0_2Nux},{"SigmaQ3_2Nux", cmf::kSigmaQ3_2Nux},{"Corr_2Nux", cmf::kCorr_2Nux},{"BaselineNux", cmf::kBaselineNux},{"TauScaleSyst", cmf::kTauScaleSyst},{"DISvpCC0pi_2020", cmf::kDISvpCC0pi_2020},{"DISvpCC1pi_2020", cmf::kDISvpCC1pi_2020},{"DISvpCC2pi_2020", cmf::kDISvpCC2pi_2020},{"DISvpCC3pi_2020", cmf::kDISvpCC3pi_2020},{"DISvpNC0pi_2020", cmf::kDISvpNC0pi_2020},{"DISvpNC1pi_2020", cmf::kDISvpNC1pi_2020},{"DISvpNC2pi_2020", cmf::kDISvpNC2pi_2020},{"DISvpNC3pi_2020", cmf::kDISvpNC3pi_2020},{"DISvnCC0pi_2020", cmf::kDISvnCC0pi_2020},{"DISvnCC1pi_2020", cmf::kDISvnCC1pi_2020},{"DISvnCC2pi_2020", cmf::kDISvnCC2pi_2020},{"DISvnCC3pi_2020", cmf::kDISvnCC3pi_2020},{"DISvnNC0pi_2020", cmf::kDISvnNC0pi_2020},{"DISvnNC1pi_2020", cmf::kDISvnNC1pi_2020},{"DISvnNC2pi_2020", cmf::kDISvnNC2pi_2020},{"DISvnNC3pi_2020", cmf::kDISvnNC3pi_2020},{"DISvbarpCC0pi_2020", cmf::kDISvbarpCC0pi_2020},{"DISvbarpCC1pi_2020", cmf::kDISvbarpCC1pi_2020},{"DISvbarpCC2pi_2020", cmf::kDISvbarpCC2pi_2020},{"DISvbarpCC3pi_2020", cmf::kDISvbarpCC3pi_2020},{"DISvbarpNC0pi_2020", cmf::kDISvbarpNC0pi_2020},{"DISvbarpNC1pi_2020", cmf::kDISvbarpNC1pi_2020},{"DISvbarpNC2pi_2020", cmf::kDISvbarpNC2pi_2020},{"DISvbarpNC3pi_2020", cmf::kDISvbarpNC3pi_2020},{"DISvbarnCC0pi_2020", cmf::kDISvbarnCC0pi_2020},{"DISvbarnCC1pi_2020", cmf::kDISvbarnCC1pi_2020},{"DISvbarnCC2pi_2020", cmf::kDISvbarnCC2pi_2020},{"DISvbarnCC3pi_2020", cmf::kDISvbarnCC3pi_2020},{"DISvbarnNC0pi_2020", cmf::kDISvbarnNC0pi_2020},{"DISvbarnNC1pi_2020", cmf::kDISvbarnNC1pi_2020},{"DISvbarnNC2pi_2020", cmf::kDISvbarnNC2pi_2020},{"DISvbarnNC3pi_2020", cmf::kDISvbarnNC3pi_2020},{"FormZone_2020", cmf::kFormZone_2020},{"hNFSISyst2020_EV2", cmf::khNFSISyst2020_EV2},{"hNFSISyst2020_EV3", cmf::khNFSISyst2020_EV3},{"COHCCScaleSyst2018", cmf::kCOHCCScaleSyst2018},{"COHNCScaleSyst2018", cmf::kCOHNCScaleSyst2018}})
std::ostream &	operator<< (std::ostream &o, cmf::FakeUniverse const &fu)
std::ostream &	operator<< (std::ostream &o, cmf::GridPoint const &gp)
std::ostream &	operator<< (std::ostream &o, cmf::OscParamPoint const &hpp)
std::ostream &	operator<< (std::ostream &o, cmf::InputPoint const &ip)
std::ostream &	operator<< (std::ostream &o, cmf::Parameter const &par)
std::ostream &	operator<< (std::ostream &o, cmf::Location const &loc)
std::ostream &	operator<< (std::ostream &o, cmf::PointResult const &pr)
static long	DetectorTypeKey (cmf::DetType_t const &det)
static long	PeriodKey (long const &ep)
static long	FileTypeKey (cmf::FileType_t const &ft)
static long	BeamTypeKey (cmf::BeamType_t const &bt)
static long	SelectionTypeKey (cmf::SelectionType_t const &st)
static long	InteractionTypeKey (cmf::InteractionType_t const &it)
static long	DetectorBeamSelectionTypesToKey (cmf::DetType_t const &det, cmf::BeamType_t const &bt, cmf::SelectionType_t const &sel)
static cmf::DetType_t	KeyToDetectorType (long const &key)
static int	KeyToEpoch (long const &key)
static cmf::FileType_t	KeyToFileType (long const &key)
static cmf::BeamType_t	KeyToBeamType (long const &key)
static cmf::SelectionType_t	KeyToSelectionType (long const &key)
static cmf::InteractionType_t	KeyToInteractionType (long const &key)
static std::string	KeyToString (long const &key)
static int	BeamToPeriod (cmf::BeamType_t const &beam)
static cmf::SelectionType_t	StringToSelectionType (std::string const &str)
static cmf::BeamType_t	StringToBeamType (std::string const &str)
static cmf::DetType_t	StringToDetectorType (std::string const &str)
static cmf::OscParm_t	StringToOscParmType (std::string const &str)
static cmf::ChiSqrCalc_t	StringToChiSqrType (std::string const &str)
static cmf::ContourType_t	StringToContourType (std::string const &str)
static cmf::BeamType_t	PeriodToBeamType (std::string const &str)
static bool	IsOscillationParameter (std::string const &str)
static bool	IsAngleParameter (cmf::OscParm_t const &par)
static bool	IsNuMuSelected (cmf::SelectionType_t const &sel)
static bool	IsNuMuQuantiles (cmf::SelectionType_t const &sel)
static bool	IsNuESelected (cmf::SelectionType_t const &sel)
static uint8_t	VarNameToKey (std::string const &name)
static std::string	KeyToVarName (uint8_t const &key)
long	StringToKey (std::string const &str)
long	PeriodStringToInt (std::string const &epochStr)
std::ostream &	operator<< (std::ostream &o, SpillSummary const &ss)
double	FitFunction_ForROOT (const double *params)
void	ParameterSetToLocation (fhicl::ParameterSet const &pset, cmf::DetType_t const &det, cmf::Location &loc)
void	ParameterSetToLocation (fhicl::ParameterSet const &pset, cmf::DetType_t const &det, cmf::ParameterSpaceLoc &loc)
template<class T >
static bool	readSingleResult (art::Results const &r, std::string const &module, std::string const &instance, std::vector< T > &resvec)
template<class T >
static bool	readVectorResults (art::Results const &r, std::string const &module, std::string const &instance, std::vector< T > &resvec, bool clearResVec=true)
template<class T >
static bool	readVectorResults (art::Results const &r, std::string const &module, std::vector< T > &resvec, bool clearResVec=true)

Variables
static ShifterAndWeighter *	gShifterAndWeighter = nullptr
static double	gWeight
static double	gNormalization
static float	gLepE
static float	gRecoE
static float	gLepMass
static float	gHadE
static int	gBin
static int	gOffset
static const double	kGarbageDouble = std::numeric_limits<double>::max()
static const float	kGarbageFloat = std::numeric_limits<float >::max()
const std::string	cDetType_Strings [5]
const std::string	cBeamType_Strings [4]
const std::string	cBeamType_LatexStrings [4]
const std::string	cChiSqrCalcType_Strings [5]
const std::string	cSelectionType_Strings [12]
const std::string	cSelectionType_LatexStrings [12]
const std::string	cInteractionType_LatexStrings [11]
const std::string	cInteractionType_Strings [11]
const std::string	cFileTypeStrings [10]
const std::string	cFileTypeStrings_Latex [10]
const double	cOscParams_Scales [kNumOscParams]
const std::string	cOscParams_LatexScales [kNumOscParams]
const std::string	cOscParams_Strings [kNumOscParams]
const std::string	cOscParams_Strings_Latex [kNumOscParams]
const std::string	cContourTypeStrings [5]
static const uint8_t	kNumSigmaSysts = kLastSigmaVar - kFirstSigmaVar + 1
static CovarianceFitHelper *	gCovFitHelp = nullptr
std::unique_ptr< cmf::EventListColl >	gMCEventLists
std::unique_ptr< cmf::ExposureMap >	gExposureMap
std::unique_ptr< cmf::Location >	gLoc
std::unique_ptr< std::vector< double > >	gFFVals
std::unique_ptr< std::vector< std::string > >	gFFNames
ROOT::Math::Minimizer *	gFFMin
cmf::ChiSqrCalc_t	gChiSqrCalc
double	gMinChiSqr
int	gMinStatus
static const double	gPI = 3.141592653589793238462643383279502884
static SpectrumPredictionMaker *	gLPU = nullptr
static ChiSqrCalculator *	gChiSqrCalculator = nullptr
static CovarianceBinUtility *	gCovBinUtil = nullptr
static ParameterUtility *	gParUtil = nullptr
static PlotUtilities *	gPlotUtil = nullptr
static RandomUniverseUtility *	gRUU = nullptr
static SelectionUtility *	gSU = nullptr

Detailed Description

Module to combine a set of results into a single file currently only does one data product type at a time.

Create a set of Covariance matrices to be used in fits.

Use covariance matrices in fits.

Author

brebe.nosp@m.l@fn.nosp@m.al.go.nosp@m.v

Typedef Documentation

typedef enum cmf::beam_type cmf::BeamType_t

typedef enum cmf::calc_type cmf::CalcType_t

typedef enum cmf::chisqr_type cmf::ChiSqrCalc_t

typedef enum cmf::cont_type cmf::ContourType_t

typedef enum cmf::covmat_type cmf::CovMat_t

typedef enum cmf::dataMC_type cmf::DataMC_t

typedef enum cmf::det_type cmf::DetType_t

typedef std::vector<EventPtr> cmf::EventContainer

Definition at line 92 of file Event.h.

typedef std::vector<cmf::EventList> cmf::EventListColl

Definition at line 147 of file Event.h.

typedef std::unique_ptr<Event> cmf::EventPtr

Definition at line 91 of file Event.h.

typedef std::map<cmf::MetaData, cmf::SpillSummary> cmf::ExposureMap

Definition at line 215 of file Structs.h.

typedef std::vector<cmf::FakeUniverse> cmf::FakeUniColl

Definition at line 43 of file CMFContourFromLibrary_plugin.cc.

typedef enum cmf::file_type cmf::FileType_t

typedef enum cmf::interaction_type cmf::InteractionType_t

typedef std::map<cmf::OscParm_t, float > cmf::OscillationParameterMap

Definition at line 741 of file Constants.h.

typedef enum cmf::osc_params cmf::OscParm_t

typedef std::map<double, double> cmf::ParamChiSqr

Definition at line 740 of file Constants.h.

typedef std::pair<std::string, cmf::DetType_t> cmf::ParameterDet

Definition at line 734 of file Constants.h.

typedef std::map<std::string, Parameter> cmf::ParameterSpaceLoc

Definition at line 19 of file Parameter.h.

typedef enum cmf::par_type cmf::ParType_t

typedef std::map<cmf::GridPoint, double> cmf::PointMap

Definition at line 43 of file GridPointResult.h.

typedef enum cmf::sel_type cmf::SelectionType_t

typedef std::vector<float> cmf::Spectrum

Definition at line 739 of file Constants.h.

typedef std::vector<cmf::SystVar> cmf::SystVarColl

Definition at line 219 of file VarVals.h.

typedef std::map<cmf::GridPoint, std::vector<double> > cmf::UniverseChiSqrMap

Definition at line 44 of file GridPointResult.h.

typedef enum cmf::weight_type cmf::WeightType_t

Enumeration Type Documentation

enum cmf::beam_type

Enumerator
kFHC
kRHC
k0HC
kUnknownBeam

Definition at line 41 of file Constants.h.

                        {
    kFHC = 0,
    kRHC,
    k0HC,
    kUnknownBeam
  } BeamType_t;

enum cmf::calc_type

Enumerator
kPMNS
kNSI
kSterile

Definition at line 321 of file Constants.h.

                        {
    kPMNS=0,
    kNSI,
    kSterile
  } CalcType_t;

enum cmf::chisqr_type

Enumerator
kCovMat
kPoisson
kCNP
kGauss
kUnknownChiSqr

Definition at line 62 of file Constants.h.

                          {
    kCovMat = 0,
    kPoisson,
    kCNP,
    kGauss,
    kUnknownChiSqr
  } ChiSqrCalc_t;

enum cmf::cont_type

Enumerator
kAsimovContour
kMedianContour
kFCContour
kDataContour
kUnknownContour

Definition at line 337 of file Constants.h.

                        {
    kAsimovContour=0,
    kMedianContour,
    kFCContour,
    kDataContour,
    kUnknownContour
  }ContourType_t;

enum cmf::covmat_type

Enumerator
kStatMatrix
kSystMatrix
kTotalMatrix

Definition at line 329 of file Constants.h.

                          {
    kStatMatrix=0,
    kSystMatrix,
    kTotalMatrix
  }CovMat_t;

enum cmf::dataMC_type

Enumerator
kData
kMC
kFakeData
kBoth

Definition at line 353 of file Constants.h.

                          {
    kData = 0,
    kMC,
    kFakeData,
    kBoth
  } DataMC_t;

enum cmf::det_type

Enumerator
kUnknownDet
kNEARDET
kFARDET
kMINOSNEAR
kMINOSFAR

Definition at line 21 of file Constants.h.

                       {
    kUnknownDet = 0,
    kNEARDET,
    kFARDET,
    kMINOSNEAR,
    kMINOSFAR
  }DetType_t;

enum cmf::file_type

Enumerator
kBeam
kSwap
kTauSwap
kDataFile
kCosmicBackgroundFile
kRockFluxSwap
kRockNonSwap
kNumFileTypes
kBadFileType
kUnknownFileType

Definition at line 163 of file Constants.h.

                        {
    kBeam=0,
    kSwap,
    kTauSwap,
    kDataFile,
    kCosmicBackgroundFile,
    kRockFluxSwap,
    kRockNonSwap,
    kNumFileTypes,
    kBadFileType,
    kUnknownFileType
  }FileType_t;

enum cmf::interaction_type

Enumerator
kUnknownInteraction
kNuMuCC
kNuMuBarCC
kNuECC
kNuEBarCC
kNuTauCC
kNuTauBarCC
kNC
kCosmicMuon
kRockMuon
kUncategorised

Definition at line 123 of file Constants.h.

                               {
    kUnknownInteraction = 0,
    kNuMuCC,
    kNuMuBarCC,
    kNuECC,
    kNuEBarCC,
    kNuTauCC,
    kNuTauBarCC,
    kNC,
    kCosmicMuon,
    kRockMuon,
    kUncategorised
  } InteractionType_t;

enum cmf::osc_params

Enumerator
kL
kRho
kDmsq21
kDmsq32
kTh12
kTh13
kTh23
kdCP
kTh14
kTh24
kTh34
kDmsq41
kd24
kEps_ee
kEps_emu
kEps_etau
kEps_mumu
kEps_mutau
kEps_tautau
kDelta_emu
kDelta_etau
kDelta_mutau
kNumOscParams

Definition at line 201 of file Constants.h.

                         {
      kL = 0,
      kRho,
      kDmsq21,
      kDmsq32,
      kTh12,
      kTh13,
      kTh23,
      kdCP,
      kTh14,
      kTh24,
      kTh34,
      kDmsq41,
      kd24,
      kEps_ee,
      kEps_emu,
      kEps_etau,
      kEps_mumu,
      kEps_mutau,
      kEps_tautau,
      kDelta_emu,
      kDelta_etau,
      kDelta_mutau,
      kNumOscParams
    } OscParm_t;

enum cmf::par_type

Enumerator
kOscPar
kCMFSystPar
kOtherSystPar
kUnknownPar

Definition at line 718 of file Constants.h.

                       {
    kOscPar = 0,
    kCMFSystPar,
    kOtherSystPar,
    kUnknownPar
  } ParType_t;

enum cmf::sel_type

Enumerator
kNuESelection
kNuESelectionLowPID
kNuESelectionMidPID
kNuESelectionHighPID
kNuESelectionPeripheral
kNuMuSelection
kNuMuSelectionQ1
kNuMuSelectionQ2
kNuMuSelectionQ3
kNuMuSelectionQ4
kNCSelection
kUnknownSelection

Definition at line 78 of file Constants.h.

                       {
    kNuESelection = 0,
    kNuESelectionLowPID,
    kNuESelectionMidPID,
    kNuESelectionHighPID,
    kNuESelectionPeripheral,
    kNuMuSelection,
    kNuMuSelectionQ1,
    kNuMuSelectionQ2,
    kNuMuSelectionQ3,
    kNuMuSelectionQ4,
    kNCSelection,
    kUnknownSelection
  } SelectionType_t;

enum cmf::varpar_type

Enumerator
kUnknownVar
kNuE_CVN
kNuE_NumMichel
kHad_RecoE
kLep_RecoE
kNu_RecoE
kLep_RecoE_MCFrac
kRecoQ2
kFake_Weight
kTrueE
kTruePDG
kTrueCCNC
kTrueIntType
kTruePDGOrig
kTrueParentPDG
kTrueParentPT
kTrueParentPZ
kTrueParentDecay
kTrueParentTargetPDG
kTrueHitNuc
kTrueIntMode
kXSecCVPPFX_Weight
kXSecCV2020Wgt
kPPFXFluxCVWgt
kRPACCQE_Weight
kRPARES_Weight
kDISvnCC1pi_Weight
kEmpiricalMEC_Weight
kEmpiricalMECtoGENIEQE_Weight
kEmpiricalMECtoGENIERES_Weight
kOtherDIS_Weight
kLightModelLightDownCalibUp
kLightModelLightUpCalibDown
kCkvProtonShiftDown
kRelativeCalibration
kAbsoluteCalibration
kCalibShape
kMinus2Sigma
kMinus1Sigma
kPlus1Sigma
kPlus2Sigma
kFirstSigmaVar
kMaCCRES
kMvCCRES
kMaNCRES
kMvNCRES
kRPACCQEshapeEnh
kRPACCQEshapeSupp
kGENIEPCA00
kGENIEPCA01
kGENIEPCA02
kGENIEPCA03
kGENIEPCA04
kGENIEPCA05
kGENIEPCA06
kGENIEPCA07
kGENIEPCA08
kGENIEPCA09
kGENIEPCA10
kGENIEPCA11
kZNormCCQE
kZExpEV1Syst2020
kZExpEV2Syst2020
kZExpEV3Syst2020
kZExpEV4Syst2020
kRESLowQ2SuppSyst2020
khNFSISyst2020_MFP
khNFSISyst2020_EV1
kMECEnuShapeSyst2020Nu
kMECEnuShapeSyst2020AntiNu
kMECShapeSyst2020Nu
kMECShapeSyst2020AntiNu
kMECInitStateNPFracSyst2020Nu
kMECInitStateNPFracSyst2020AntiNu
kRadCorrNue
kRadCorrNuebar
k2ndClassCurrs
kUnCorrNDMuEScaleSyst2020
kUnCorrMuCatMuESyst2020
kPileupMuESyst2020
kCorrMuEScaleSyst2020
kNeutronVisEScalePrimariesSyst2018
kMichelTaggingSyst2020
kAna2020NormFHC
kAna2020NormRHC
kTauScaleSyst
kNorm_1Nux
kMeanQ0_1Nux
kMeanQ3_1Nux
kSigmaQ0_1Nux
kSigmaQ3_1Nux
kCorr_1Nux
kNorm_2Nux
kMeanQ0_2Nux
kMeanQ3_2Nux
kSigmaQ0_2Nux
kSigmaQ3_2Nux
kCorr_2Nux
kBaselineNux
kDISvpCC0pi_2020
kDISvpCC1pi_2020
kDISvpCC2pi_2020
kDISvpCC3pi_2020
kDISvpNC0pi_2020
kDISvpNC1pi_2020
kDISvpNC2pi_2020
kDISvpNC3pi_2020
kDISvnCC0pi_2020
kDISvnCC1pi_2020
kDISvnCC2pi_2020
kDISvnCC3pi_2020
kDISvnNC0pi_2020
kDISvnNC1pi_2020
kDISvnNC2pi_2020
kDISvnNC3pi_2020
kDISvbarpCC0pi_2020
kDISvbarpCC1pi_2020
kDISvbarpCC2pi_2020
kDISvbarpCC3pi_2020
kDISvbarpNC0pi_2020
kDISvbarpNC1pi_2020
kDISvbarpNC2pi_2020
kDISvbarpNC3pi_2020
kDISvbarnCC0pi_2020
kDISvbarnCC1pi_2020
kDISvbarnCC2pi_2020
kDISvbarnCC3pi_2020
kDISvbarnNC0pi_2020
kDISvbarnNC1pi_2020
kDISvbarnNC2pi_2020
kDISvbarnNC3pi_2020
kFormZone_2020
khNFSISyst2020_EV2
khNFSISyst2020_EV3
kCOHCCScaleSyst2018
kCOHNCScaleSyst2018
kMaNCEL
kEtaNCEL
kAhtBY
kBhtBY
kCV1uBY
kCV2uBY
kAGKY_xF1pi
kAGKY_pT1pi
kBR1gamma
kBR1eta
kTheta_Delta2Npi
kLastSigmaVar

Definition at line 365 of file Constants.h.

                   {
    kUnknownVar = 0,

    // Data info - kFake_Weight is in this group because it only applies to fake data
    kNuE_CVN,
    kNuE_NumMichel,
    kHad_RecoE,
    kLep_RecoE,
    kNu_RecoE,
    kLep_RecoE_MCFrac,
    kRecoQ2,
    kFake_Weight,

    // Truth information
    kTrueE,
    kTruePDG,
    kTrueCCNC,
    kTrueIntType,
    kTruePDGOrig,
    kTrueParentPDG,
    kTrueParentPT,
    kTrueParentPZ,
    kTrueParentDecay,
    kTrueParentTargetPDG,
    kTrueHitNuc,
    kTrueIntMode,

    // MC Reweighting info
    kXSecCVPPFX_Weight,
    kXSecCV2020Wgt,
    kPPFXFluxCVWgt,
    kRPACCQE_Weight,                // TODO: deprecated, delete
    kRPARES_Weight,
    kDISvnCC1pi_Weight,             // TODO: deprecated, delete
    kEmpiricalMEC_Weight,           // TODO: deprecated, delete
    kEmpiricalMECtoGENIEQE_Weight,  // TODO: deprecated, delete
    kEmpiricalMECtoGENIERES_Weight, // TODO: deprecated, delete
    kOtherDIS_Weight,               // TODO: deprecated, delete

    // calibration related uncertainties
    kLightModelLightDownCalibUp,
    kLightModelLightUpCalibDown,
    kCkvProtonShiftDown,
    kRelativeCalibration,
    kAbsoluteCalibration,
    kCalibShape,

    // Systematic uncertainties where we store -2, -1, +1, +2 sigma values
    kMinus2Sigma,
    kMinus1Sigma,
    kPlus1Sigma,
    kPlus2Sigma,
    kFirstSigmaVar,
    kMaCCRES=kFirstSigmaVar,
    kMvCCRES,
    kMaNCRES,
    kMvNCRES,
    kRPACCQEshapeEnh,
    kRPACCQEshapeSupp,

    // new for 2020
    kGENIEPCA00,
    kGENIEPCA01,
    kGENIEPCA02,
    kGENIEPCA03,
    kGENIEPCA04,
    kGENIEPCA05,
    kGENIEPCA06,
    kGENIEPCA07,
    kGENIEPCA08,
    kGENIEPCA09,
    kGENIEPCA10,
    kGENIEPCA11,
    kZNormCCQE,
    kZExpEV1Syst2020,
    kZExpEV2Syst2020,
    kZExpEV3Syst2020,
    kZExpEV4Syst2020,
    kRESLowQ2SuppSyst2020,
    khNFSISyst2020_MFP,
    khNFSISyst2020_EV1,
    kMECEnuShapeSyst2020Nu,
    kMECEnuShapeSyst2020AntiNu,
    kMECShapeSyst2020Nu,
    kMECShapeSyst2020AntiNu,
    kMECInitStateNPFracSyst2020Nu,
    kMECInitStateNPFracSyst2020AntiNu,
    kRadCorrNue,
    kRadCorrNuebar,
    k2ndClassCurrs,
    kUnCorrNDMuEScaleSyst2020,
    kUnCorrMuCatMuESyst2020,
    kPileupMuESyst2020,
    kCorrMuEScaleSyst2020,
    kNeutronVisEScalePrimariesSyst2018,
    kMichelTaggingSyst2020,
    kAna2020NormFHC,
    kAna2020NormRHC,
    kTauScaleSyst,
    kNorm_1Nux,
    kMeanQ0_1Nux,
    kMeanQ3_1Nux,
    kSigmaQ0_1Nux,
    kSigmaQ3_1Nux,
    kCorr_1Nux,
    kNorm_2Nux,
    kMeanQ0_2Nux,
    kMeanQ3_2Nux,
    kSigmaQ0_2Nux,
    kSigmaQ3_2Nux,
    kCorr_2Nux,
    kBaselineNux,

    kDISvpCC0pi_2020,
    kDISvpCC1pi_2020,
    kDISvpCC2pi_2020,
    kDISvpCC3pi_2020,
    kDISvpNC0pi_2020,
    kDISvpNC1pi_2020,
    kDISvpNC2pi_2020,
    kDISvpNC3pi_2020,
    kDISvnCC0pi_2020,
    kDISvnCC1pi_2020,
    kDISvnCC2pi_2020,
    kDISvnCC3pi_2020,
    kDISvnNC0pi_2020,
    kDISvnNC1pi_2020,
    kDISvnNC2pi_2020,
    kDISvnNC3pi_2020,
    kDISvbarpCC0pi_2020,
    kDISvbarpCC1pi_2020,
    kDISvbarpCC2pi_2020,
    kDISvbarpCC3pi_2020,
    kDISvbarpNC0pi_2020,
    kDISvbarpNC1pi_2020,
    kDISvbarpNC2pi_2020,
    kDISvbarpNC3pi_2020,
    kDISvbarnCC0pi_2020,
    kDISvbarnCC1pi_2020,
    kDISvbarnCC2pi_2020,
    kDISvbarnCC3pi_2020,
    kDISvbarnNC0pi_2020,
    kDISvbarnNC1pi_2020,
    kDISvbarnNC2pi_2020,
    kDISvbarnNC3pi_2020,
    kFormZone_2020,
    khNFSISyst2020_EV2,
    khNFSISyst2020_EV3,
    kCOHCCScaleSyst2018,
    kCOHNCScaleSyst2018,
    kMaNCEL,
    kEtaNCEL,
    kAhtBY,
    kBhtBY,
    kCV1uBY,
    kCV2uBY,
    kAGKY_xF1pi,
    kAGKY_pT1pi,
    kBR1gamma,
    kBR1eta,
    kTheta_Delta2Npi,
    kLastSigmaVar=kTheta_Delta2Npi,

    // The following variables are not currently used
    //----------------
    // kVecCCQE_shape,
    // kMaCOHpi,
    // kR0COHpi,
    // kNormDISCC,
    // kRnubarnuCC,
    // kDISNuclMod,
    // kMFP_pi,
    // kMFP_N,
    // kFrCEx_pi,
    // kFrElas_pi,
    // kFrAbs_pi,
    // kFrPiProd_pi,
    // kFrInel_N,
    // kFrPiProd_N,
    // kCCQEMomDistroFGtoSF,

    /* kNormCCQE_EnuDep     , */
    /* kNormCCRES           , */
    /* kMaCCRES_shape       , */
    /* kMvCCRES_shape       , */
    /* kNormNCRES           , */
    /* kMaNCRES_shape       , */
    /* kMvNCRES_shape       , */
    /* kNCGENIE             , */
    /* kNormCCQE            , */
    /* kMaCCQE_shape        , */
    /* kRvpCC1pi            , */
    /* kRvpCC2pi            , */
    /* kRvpNC1pi            , */
    /* kRvpNC2pi            , */
    /* kRvnCC1pi            , */
    /* kRvnCC2pi            , */
    /* kRvnNC1pi            , */
    /* kRvnNC2pi            , */
    /* kRvbarpCC1pi         , */
    /* kRvbarpCC2pi         , */
    /* kRvbarpNC1pi         , */
    /* kRvbarpNC2pi         , */
    /* kRvbarnCC1pi         , */
    /* kRvbarnCC2pi         , */
    /* kRvbarnNC1pi         , */
    /* kRvbarnNC2pi         , */
  };

enum cmf::weight_type

Enumerator
kSystWgtOnly
kOscWgtOnly
kSystAndOscWgt
kAllWgt

Definition at line 725 of file Constants.h.

                          {
    kSystWgtOnly=0,
    kOscWgtOnly,
    kSystAndOscWgt,
    kAllWgt
  } WeightType_t;

Function Documentation

static int cmf::BeamToPeriod ( cmf::BeamType_t const &  beam )

inlinestatic

Definition at line 236 of file StaticFuncs.h.

References kFHC, and kRHC.

Referenced by InteractionTypeKey(), and cmf::SelectionUtility::SelectionsToUseAsMetaData().

{
  if     (beam == cmf::kFHC) return 1;
  else if(beam == cmf::kRHC) return 4;

  return 0;
}

static long cmf::BeamTypeKey ( cmf::BeamType_t const &  bt )

inlinestatic

Definition at line 18 of file StaticFuncs.h.

Referenced by cmf::MetaData::BeamTypeKey(), DetectorBeamSelectionTypesToKey(), KeyToInteractionType(), and KeyToSelectionType().

{ return (bt + 1) * 10000;      }

static const std::set<cmf::BeamType_t> cmf::cBeamTypes ( {kFHC, kRHC}  )

static

Referenced by cmf::SelectionUtility::DetermineUnusedSelections(), and cmf::SelectionUtility::Initialize().

static const std::set<cmf::DetType_t> cmf::cDetIds ( {cmf::kNEARDET, cmf::kFARDET}  )

static

Referenced by cmf::SelectionUtility::DetermineUnusedSelections(), and cmf::SelectionUtility::Initialize().

static long cmf::DetectorBeamSelectionTypesToKey ( cmf::DetType_t const &  det, cmf::BeamType_t const &  bt, cmf::SelectionType_t const &  sel  )

inlinestatic

Definition at line 58 of file StaticFuncs.h.

References BeamTypeKey(), DetectorTypeKey(), and SelectionTypeKey().

Referenced by cmf::MetaData::DetectorBeamSelectionKey(), cmf::CovarianceBinUtility::FillOffsetAndBinMaps(), InteractionTypeKey(), cmf::SelectionUtility::DetBeamSels::Keys(), cmf::CovarianceFitHelper::MakeDataMCCanv(), and cmf::SelectionUtility::SelectionsToUseAsKeys().

{
  return cmf::DetectorTypeKey(det) + cmf::BeamTypeKey(bt) + cmf::SelectionTypeKey(sel);
}

static long cmf::DetectorTypeKey ( cmf::DetType_t const &  det )

inlinestatic

Definition at line 15 of file StaticFuncs.h.

Referenced by DetectorBeamSelectionTypesToKey(), cmf::MetaData::DetectorKey(), KeyToBeamType(), KeyToEpoch(), KeyToFileType(), KeyToInteractionType(), KeyToSelectionType(), and StringToKey().

{ return det      * 1000000000; }

static long cmf::FileTypeKey ( cmf::FileType_t const &  ft )

inlinestatic

Definition at line 17 of file StaticFuncs.h.

Referenced by cmf::MetaData::FileKey(), KeyToBeamType(), KeyToInteractionType(), KeyToSelectionType(), and StringToKey().

{ return (ft + 1) * 100000;     }

void cmf::FillSpectrum	(	cmf::EventListColl const &	eventLists,
		cmf::ExposureMap const &	exposureMap,
		std::vector< float > &	spectrum,
		std::vector< float > &	count,
		cmf::InteractionType_t	intType,
		bool	applyExposureNorm
	)

Definition at line 148 of file SpectrumTools.cxx.

References FillSpectrumFromSingleList(), cmf::CovarianceBinUtility::Instance(), and fetch_tb_beamline_files::md.

Referenced by cmf::CovarianceMatrixFitter::FillDataSpectrum(), cmf::CovarianceFitHelper::FillDataSpectrum(), cmf::CMFSpectraMaker::FillHistograms(), cmf::CovarianceFitHelper::FillMCSpectrum(), cmf::CovarianceMatrixMaker::FillSpectrum(), cmf::SpectrumPredictionMaker::MakePredictions(), cmf::CMFDecorrelator::writeResults(), and cmf::RandomUniverses::writeResults().

  {

    // resize the spectrum if it is empty
    if(spectrum.size() == 0){
      spectrum.resize(cmf::CovarianceBinUtility::Instance()->TotalBins(), 0.);
      count   .resize(cmf::CovarianceBinUtility::Instance()->TotalBins(), 0.);
    }

    // loop over each list and fill the spectrum
    for(auto const& itr : eventLists){
      auto const& md = itr.ListMetaData();

      if(md.interactionType != intType) continue;

      cmf::FillSpectrumFromSingleList(itr,
                                      md,
                                      exposureMap,
                                      spectrum,
                                      count,
                                      applyExposureNorm);
    } // end loop over lists of events

  }

void cmf::FillSpectrum	(	cmf::EventListColl const &	eventLists,
		cmf::ExposureMap const &	exposureMap,
		std::vector< float > &	spectrum,
		std::vector< float > &	count,
		bool	applyExposureNorm
	)

Definition at line 179 of file SpectrumTools.cxx.

References FillSpectrumFromSingleList(), cmf::CovarianceBinUtility::Instance(), and fetch_tb_beamline_files::md.

  {
    // resize the spectrum if it is empty
    if(spectrum.size() == 0){
      spectrum.resize(cmf::CovarianceBinUtility::Instance()->TotalBins(), 0.);
      count   .resize(cmf::CovarianceBinUtility::Instance()->TotalBins(), 0.);
    }

    // loop over each list and fill the spectrum
    for(auto const& itr : eventLists){
      auto const& md = itr.ListMetaData();

      cmf::FillSpectrumFromSingleList(itr,
                                      md,
                                      exposureMap,
                                      spectrum,
                                      count,
                                      applyExposureNorm);
    } // end loop over lists of events
  }

void cmf::FillSpectrumFromSingleList	(	cmf::EventList const &	list,
		cmf::MetaData const &	md,
		cmf::ExposureMap const &	exposureMap,
		std::vector< float > &	spectrum,
		std::vector< float > &	count,
		bool	applyExposureNorm
	)

Definition at line 29 of file SpectrumTools.cxx.

References cmf::MetaData::detector, cmf::MetaData::DetectorBeamSelectionKey(), cmf::CovarianceBinUtility::EnergyToBin(), evt, cmf::MetaData::fileType, cmf::ShifterAndWeighter::FractionalShift(), gBin, gLepMass, gNormalization, cmf::SpillSummary::goodPOT, gWeight, cmf::CovarianceBinUtility::Instance(), cmf::ShifterAndWeighter::Instance(), cmf::MetaData::isMC, cmf::MetaData::IsNuMuSelected(), kCosmicBackgroundFile, kDataFile, cmf::CovarianceBinUtility::KeyToOffset(), kHad_RecoE, kLep_RecoE, kUnknownInteraction, cmf::EventList::ListSpillSummary(), cmf::SpillSummary::liveTime, LOG_DEBUG, cmf::MetaData::period, RecoEnergy(), cmf::MetaData::selectionType, cmf::MetaData::ToString(), and cmf::ShifterAndWeighter::Weight().

Referenced by FillSpectrum().

  {

    // figure out the offset for this metadata
    gOffset = cmf::CovarianceBinUtility::Instance()->KeyToOffset(md.DetectorBeamSelectionKey());

    if(!md.isMC){
      // fill the spectrum
      for(auto const& evt : list){
        gLepE = evt->DataVals().val_at(cmf::kLep_RecoE, md);
        gHadE = evt->DataVals().val_at(cmf::kHad_RecoE, md);

        gRecoE = cmf::RecoEnergy(gLepE, gHadE, md);

        gBin = gOffset + cmf::CovarianceBinUtility::Instance()->EnergyToBin(gRecoE, md);

        ++spectrum[gBin];
        ++count[gBin];
      } // end loop over the events
    } // end if looking at a data lists
    else{

      // the exposure maps are stored for the data, not MC, so create
      // a temporary md to get the proper exposure
      cmf::MetaData tmpmd(false,
                          md.detector,
                          cmf::kDataFile,
                          md.selectionType,
                          cmf::kUnknownInteraction,
                          md.period);

      if (applyExposureNorm){
        auto const exItr = exposureMap.find(cmf::MetaData(tmpmd));
        if (md.fileType == kCosmicBackgroundFile){
          gNormalization = (exItr != exposureMap.end()) ? exItr->second.liveTime : 0.;
          gNormalization /= list.ListSpillSummary().liveTime;
        }
        else {
          gNormalization = (exItr != exposureMap.end()) ? exItr->second.goodPOT : 0.;
          gNormalization /= list.ListSpillSummary().goodPOT;
        }

        LOG_DEBUG("SpectrumTools")
            << md.ToString()
            << " bin offset: "
            << gOffset
            << " exposure "
            << exItr->second.goodPOT
            << " spill summary "
            << list.ListSpillSummary().goodPOT
            << " normalization "
            << gNormalization;

      }
      else gNormalization = 1;

      // for nu_mu energy we have to subtract off the muon rest mass before
      // scaling, but we can figure out the rest mass before looping over any
      // events
      gLepMass = (md.IsNuMuSelected()) ? 0.1056583668 : 0.;

      // fill the spectrum
      for(auto const& evt : list){

        gWeight = cmf::ShifterAndWeighter::Instance()->Weight(evt,
                                                              md);

        // get any shifts to the hadronic and leptonic energy
        gLepE = evt->DataVals().val_at(cmf::kLep_RecoE, md) - gLepMass;
        gLepE *= cmf::ShifterAndWeighter::Instance()->FractionalShift(kLep_RecoE);
        gLepE += gLepMass;
        gHadE = (evt->DataVals().val_at(cmf::kHad_RecoE, md) *
                cmf::ShifterAndWeighter::Instance()->FractionalShift(kHad_RecoE));

        gRecoE = cmf::RecoEnergy(gLepE, gHadE, md);

        if(gRecoE < cmf::CovarianceBinUtility::Instance()->SelectionLowEdge(md) ) continue;

        gBin = gOffset + cmf::CovarianceBinUtility::Instance()->EnergyToBin(gRecoE, md);

        // if(std::isnan(gWeight))
        //   LOG_VERBATIM("SpectrumTools")
        //     << "FillSpectrumFromSingleList "
        //     << md.ToString()
        //     << " "
        //     << md.IsCosmicMuon()
        //     << " "
        //     << evt->MCValsFilled()
        //     << " "
        //     << evt->DataVals().DataVars().fFake_Weight
        //     << " "
        //     << evt->DataVals().val_at(cmf::kFake_Weight, md)
        //     << " "
        //     << gLepE
        //     << " "
        //     << gHadE
        //     << " " 
        //     << gRecoE
        //     << " "
        //     << gBin
        //     << " "
        //     << gWeight
        //     << " "
        //     << gNormalization;

        spectrum[gBin] += gNormalization * gWeight;
        ++count[gBin];
      } // end loop over events
    } // end if looking at a MC event list

  }

cmf::EventListColl::iterator cmf::FindEventList	(	cmf::MetaData const &	md,
		cmf::EventListColl &	eventListColl
	)

Definition at line 44 of file Event.cxx.

References fetch_tb_beamline_files::md.

Referenced by cmf::EventList::AddEvent(), cmf::EventListManipulator::Deserialize(), cmf::CAFToEventList::endJob(), and cmf::CAFToEventList::InitializeEventListColls().

  {
    for(auto itr = eventListColl.begin(); itr < eventListColl.end(); ++itr){
      if( itr->ListMetaData() == md) return itr;
    }

    return eventListColl.end();
  }

double cmf::FitFunction_ForROOT

(

const double *

params

)

Definition at line 50 of file CovarianceFitHelper.cxx.

References cmf::CovarianceFitHelper::AddIteration(), cmf::ChiSqrCalculator::ChiSqr(), cmf::CovarianceFitHelper::FillMCSpectrum(), MECModelEnuComparisons::i, cmf::ChiSqrCalculator::Instance(), cmf::CovarianceFitHelper::Instance(), cmf::ShifterAndWeighter::Instance(), IsAngleParameter(), LOG_DEBUG, LOG_VERBATIM, cet::pow(), cmf::ShifterAndWeighter::SetCurrentVals(), std::sin(), and StringToOscParmType().

Referenced by cmf::CovarianceFitHelper::InitializeMinimizer().

  {
    // debug
    LOG_VERBATIM("CovarianceFit") << "Processing guess: ";

    for(size_t i = 0; i < gFFVals->size(); ++i){
      (*gFFVals)[i] = params[i];

      if(cmf::IsAngleParameter(cmf::StringToOscParmType((*gFFNames)[i])) )
        LOG_VERBATIM("CovarianceFit")
        << "\t"
        << (*gFFNames)[i]
        << " : "
        << params[i]
        << "; sin^2("
        << (*gFFNames)[i]
        << "): "
        << std::pow(std::sin(params[i]), 2.);
      else if ((*gFFNames)[i] == "dCP")
        LOG_VERBATIM("CovarianceFit")
        << "\t"
        << (*gFFNames)[i]
        << " : "
        << params[i]
        << " = "
        << params[i] / gPI
        << " (pi)";
      else
        LOG_VERBATIM("CovarianceFit")
        << "\t"
        << (*gFFNames)[i]
        << " : "
        << params[i];
    }

    // Now update the ShifterAndWeighter to check the goodness of fit
    cmf::ShifterAndWeighter::Instance()->SetCurrentVals(*gFFNames,
                                                        gFFVals->data());

    LOG_DEBUG("CovarianceMatrixFitter")
      << "fill the MC spectrum with the new values";

    // fill the MC spectrum
    cmf::CovarianceFitHelper::Instance()->FillMCSpectrum(*gMCEventLists);

    LOG_DEBUG("CovarianceMatrixFitter")
      << "get the new chi^2";

    // Get Chisq
    double chisq = cmf::ChiSqrCalculator::Instance()->ChiSqr(gChiSqrCalc,
                                                             *gFFNames,
                                                             gFFVals->data());

    LOG_DEBUG("CovarianceMatrixFitter")
      << "add to the iterations";

    // store this iteration of the fitter
    cmf::CovarianceFitHelper::Instance()->AddIteration(chisq,
                                                       *gFFNames,
                                                       *gFFVals,
                                                       gChiSqrCalc);

    LOG_VERBATIM("CovarianceFit")
      << "\t"
      << "FitValue = "
      << chisq;

    // Return the fit value; that's what we're looking to minimize
    return chisq;
  }

static long cmf::InteractionTypeKey ( cmf::InteractionType_t const &  it )

inlinestatic

Definition at line 20 of file StaticFuncs.h.

References POTSpillRate::beam, BeamToPeriod(), fillBadChanDBTables::det, DetectorBeamSelectionTypesToKey(), IsAngleParameter(), IsNuESelected(), IsNuMuQuantiles(), IsNuMuSelected(), IsOscillationParameter(), findDuplicateFiles::key, KeyToBeamType(), KeyToDetectorType(), KeyToEpoch(), KeyToFileType(), KeyToInteractionType(), KeyToSelectionType(), KeyToString(), KeyToVarName(), par, PeriodToBeamType(), submit_syst::str, string, StringToBeamType(), StringToChiSqrType(), StringToContourType(), StringToDetectorType(), StringToOscParmType(), StringToSelectionType(), and VarNameToKey().

Referenced by cmf::MetaData::InteractionKey(), and StringToKey().

{ return it       * 1;          }

static bool cmf::IsAngleParameter ( cmf::OscParm_t const &  par )

inlinestatic

Definition at line 346 of file StaticFuncs.h.

References kTh13, kTh14, kTh23, kTh24, and kTh34.

Referenced by cmf::FitFeldmanCousinsPoint::beginJob(), cmf::FitFeldmanCousinsPoint::FillHistograms(), FitFunction_ForROOT(), InteractionTypeKey(), cmf::ContourFromLibrary::MakeAndStorePlots(), cmf::PlotUtilities::MakeGeneric2DHist(), operator<<(), and cmf::ContourFromLibrary::readResults().

{
  if(par == cmf::kTh13 ||
     par == cmf::kTh23 ||
     par == cmf::kTh14 ||
     par == cmf::kTh24 ||
     par == cmf::kTh34 ) return true;

  return false;
}

static bool cmf::IsNuESelected ( cmf::SelectionType_t const &  sel )

inlinestatic

Definition at line 372 of file StaticFuncs.h.

References kNuESelection, and kNuESelectionPeripheral.

Referenced by cmf::EventListManipulator::Deserialize(), cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), cmf::MetaData::IsNuESelected(), cmf::CovarianceBinUtility::NumSelectionBins(), cmf::MetaData::Period(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), cmf::CovarianceBinUtility::SelectionHighEdges(), cmf::SelectionUtility::SelectionsUsedOfType(), cmf::CovarianceBinUtility::SetBinning(), cmf::SelectionUtility::UsesDetBeamAndSel(), and cmf::SelectionUtility::UsesSelection().

{
  return (sel >= cmf::kNuESelection &&
          sel <= cmf::kNuESelectionPeripheral);
}

static bool cmf::IsNuMuQuantiles ( cmf::SelectionType_t const &  sel )

inlinestatic

Definition at line 365 of file StaticFuncs.h.

References kNuMuSelectionQ1, and kNuMuSelectionQ4.

Referenced by cmf::EventListManipulator::Deserialize(), InteractionTypeKey(), cmf::MetaData::IsNuMuQuantiles(), IsNuMuSelected(), cmf::MetaData::Period(), cmf::SelectionUtility::UsesDetBeamAndSel(), and cmf::SelectionUtility::UsesSelection().

{
  return (sel >= cmf::kNuMuSelectionQ1 &&
          sel <= cmf::kNuMuSelectionQ4);
}

static bool cmf::IsNuMuSelected ( cmf::SelectionType_t const &  sel )

inlinestatic

Definition at line 358 of file StaticFuncs.h.

References IsNuMuQuantiles(), and kNuMuSelection.

Referenced by cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), cmf::MetaData::IsNuMuSelected(), cmf::CovarianceBinUtility::NumSelectionBins(), cmf::MetaData::Period(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), cmf::CovarianceBinUtility::SelectionHighEdges(), cmf::SelectionUtility::SelectionsUsedOfType(), and cmf::CovarianceBinUtility::SetBinning().

{
  return (sel == cmf::kNuMuSelection ||
          cmf::IsNuMuQuantiles(sel));
}

static bool cmf::IsOscillationParameter ( std::string const &  str )

static

Referenced by cmf::CovarianceFitHelper::FindInitialGuess(), InteractionTypeKey(), cmf::CovarianceFitHelper::MakeIterationGraphs(), operator<<(), cmf::Parameter::Parameter(), and StringToDetectorType().

static cmf::BeamType_t cmf::KeyToBeamType ( long const &  key )

inlinestatic

Definition at line 132 of file StaticFuncs.h.

References DetectorTypeKey(), mkDefs::fileType, FileTypeKey(), KeyToDetectorType(), KeyToEpoch(), KeyToFileType(), kUnknownBeam, kUnknownDet, kUnknownFileType, LOG_DEBUG, and PeriodKey().

Referenced by cmf::CovarianceBinUtility::BinToBeamType(), cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), KeyToInteractionType(), cmf::CovarianceBinUtility::KeyToOffset(), KeyToSelectionType(), and KeyToString().

{
  auto detType  = cmf::KeyToDetectorType(key);
  auto fileType = cmf::KeyToFileType(key);
  auto epoch    = cmf::KeyToEpoch(key);

  long tmpKey = key - cmf::PeriodKey(epoch);

  if(detType  != cmf::kUnknownDet     ) tmpKey -= cmf::DetectorTypeKey(detType);
  if(fileType != cmf::kUnknownFileType) tmpKey -= cmf::FileTypeKey(fileType);

  if(tmpKey < 10000) return cmf::kUnknownBeam;

  LOG_DEBUG("StaticFuncs")
      << "KeyToBeam: "
      << key
      << " "
      << detType
      << "/"
      << cmf::DetectorTypeKey(detType)
      << " "
      << fileType
      << "/"
      << cmf::FileTypeKey(fileType)
      << " "
      << tmpKey
      << " "
      << (tmpKey / 10000) - 1;


  return (cmf::BeamType_t)((tmpKey / 10000) - 1);
}

static cmf::DetType_t cmf::KeyToDetectorType ( long const &  key )

inlinestatic

Definition at line 66 of file StaticFuncs.h.

References kUnknownDet, and LOG_DEBUG.

Referenced by cmf::CovarianceBinUtility::BinToDetector(), cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), KeyToBeamType(), KeyToEpoch(), KeyToFileType(), KeyToInteractionType(), cmf::CovarianceBinUtility::KeyToOffset(), KeyToSelectionType(), KeyToString(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), and cmf::CovarianceBinUtility::SelectionHighEdges().

{
  if(key < 1000000000) return cmf::kUnknownDet;

  LOG_DEBUG("StaticFuncs")
      << "KeyToDetector: "
      << key
      << " "
      << (key / 1000000000);

  return (cmf::DetType_t)(key / 1000000000);
}

static int cmf::KeyToEpoch ( long const &  key )

inlinestatic

Definition at line 80 of file StaticFuncs.h.

References DetectorTypeKey(), findDuplicateFiles::key, KeyToDetectorType(), kUnknownDet, and LOG_DEBUG.

Referenced by InteractionTypeKey(), KeyToBeamType(), KeyToFileType(), KeyToInteractionType(), KeyToSelectionType(), and KeyToString().

{
  auto detType = cmf::KeyToDetectorType(key);

  long tmpKey = key;
  if(detType != cmf::kUnknownDet) tmpKey -= cmf::DetectorTypeKey(detType);

  if(tmpKey < 10000000) return 0;

  LOG_DEBUG("StaticFuncs")
      << "KeyToEpoch: "
      << key
      << " "
      << detType
      << "/"
      << cmf::DetectorTypeKey(detType)
      << " "
      << tmpKey
      << " "
      << (tmpKey / 10000000);

  return (tmpKey / 10000000);
}

static cmf::FileType_t cmf::KeyToFileType ( long const &  key )

inlinestatic

Definition at line 105 of file StaticFuncs.h.

References DetectorTypeKey(), KeyToDetectorType(), KeyToEpoch(), kUnknownDet, kUnknownFileType, LOG_DEBUG, and PeriodKey().

Referenced by InteractionTypeKey(), KeyToBeamType(), KeyToInteractionType(), KeyToSelectionType(), and KeyToString().

{
  auto detType = cmf::KeyToDetectorType(key);
  auto epoch   = cmf::KeyToEpoch(key);

  // if the epoch is not part of the key, KeyToEpoch returns 0
  long tmpKey = key - cmf::PeriodKey(epoch);
  if(detType != cmf::kUnknownDet) tmpKey -= cmf::DetectorTypeKey(detType);

  if(tmpKey < 100000) return cmf::kUnknownFileType;

  LOG_DEBUG("StaticFuncs")
      << "KeyToFile: "
      << key
      << " "
      << detType
      << "/"
      << cmf::DetectorTypeKey(detType)
      << " "
      << tmpKey
      << " "
      << (tmpKey / 100000) - 1;

  return (cmf::FileType_t)((tmpKey / 100000) - 1);
}

static cmf::InteractionType_t cmf::KeyToInteractionType ( long const &  key )

inlinestatic

Definition at line 204 of file StaticFuncs.h.

References BeamTypeKey(), DetectorTypeKey(), mkDefs::fileType, FileTypeKey(), KeyToBeamType(), KeyToDetectorType(), KeyToEpoch(), KeyToFileType(), KeyToSelectionType(), kUnknownBeam, kUnknownDet, kUnknownFileType, kUnknownInteraction, kUnknownSelection, PeriodKey(), and SelectionTypeKey().

Referenced by InteractionTypeKey(), and KeyToString().

{
  auto detType  = cmf::KeyToDetectorType(key);
  auto beamType = cmf::KeyToBeamType(key);
  auto fileType = cmf::KeyToFileType(key);
  auto selType  = cmf::KeyToSelectionType(key);
  auto epoch    = cmf::KeyToEpoch(key);

  long tmpKey = key - cmf::PeriodKey(epoch);
  if(detType  != cmf::kUnknownDet      ) tmpKey -= cmf::DetectorTypeKey(detType);
  if(beamType != cmf::kUnknownBeam     ) tmpKey -= cmf::BeamTypeKey(beamType);
  if(fileType != cmf::kUnknownFileType ) tmpKey -= cmf::FileTypeKey(fileType);
  if(selType  != cmf::kUnknownSelection) tmpKey -= cmf::SelectionTypeKey(selType);

  if(tmpKey < 1) return cmf::kUnknownInteraction;

  return (cmf::InteractionType_t)(tmpKey);
}

static cmf::SelectionType_t cmf::KeyToSelectionType ( long const &  key )

inlinestatic

Definition at line 166 of file StaticFuncs.h.

References BeamTypeKey(), DetectorTypeKey(), mkDefs::fileType, FileTypeKey(), KeyToBeamType(), KeyToDetectorType(), KeyToEpoch(), KeyToFileType(), kUnknownBeam, kUnknownDet, kUnknownFileType, kUnknownSelection, LOG_DEBUG, and PeriodKey().

Referenced by cmf::CovarianceBinUtility::BinToSelection(), cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), KeyToInteractionType(), cmf::CovarianceBinUtility::KeyToOffset(), KeyToString(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), and cmf::CovarianceBinUtility::SelectionHighEdges().

{
  auto detType  = cmf::KeyToDetectorType(key);
  auto beamType = cmf::KeyToBeamType(key);
  auto fileType = cmf::KeyToFileType(key);
  auto epoch    = cmf::KeyToEpoch(key);

  long tmpKey = key - cmf::PeriodKey(epoch);
  if(detType  != cmf::kUnknownDet     ) tmpKey -= cmf::DetectorTypeKey(detType);
  if(beamType != cmf::kUnknownBeam    ) tmpKey -= cmf::BeamTypeKey(beamType);
  if(fileType != cmf::kUnknownFileType) tmpKey -= cmf::FileTypeKey(fileType);

  if(tmpKey < 100) return cmf::kUnknownSelection;

  LOG_DEBUG("StaticFuncs")
  << "KeyToSelection: "
  << key
  << " "
  << detType
  << "/"
  << cmf::DetectorTypeKey(detType)
  << " "
  << beamType
  << "/"
  << cmf::BeamTypeKey(beamType)
  << " "
  << fileType
  << "/"
  << cmf::FileTypeKey(fileType)
  << " "
  << tmpKey
  << " "
  << (tmpKey / 100) - 1;

  return (cmf::SelectionType_t)((tmpKey / 100) - 1);
}

static std::string cmf::KeyToString ( long const &  key )

inlinestatic

Definition at line 224 of file StaticFuncs.h.

References cBeamType_Strings, cDetType_Strings, cFileTypeStrings, cInteractionType_Strings, cSelectionType_Strings, KeyToBeamType(), KeyToDetectorType(), KeyToEpoch(), KeyToFileType(), KeyToInteractionType(), KeyToSelectionType(), and art::to_string().

Referenced by cmf::CovarianceBinUtility::BinToEnergy(), cmf::EventListManipulator::Deserialize(), cmf::CovarianceBinUtility::FillOffsetAndBinMaps(), cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), and cmf::RandomUniverseUtility::PoissonSpectrumBinByBin().

{
  return (cmf::cDetType_Strings[cmf::KeyToDetectorType(key)] +
          "Period"                                                    +
          std::to_string(cmf::KeyToEpoch(key))                        +
          cmf::cFileTypeStrings[cmf::KeyToFileType(key)]              +
          cmf::cBeamType_Strings[cmf::KeyToBeamType(key)]             +
          cmf::cSelectionType_Strings[cmf::KeyToSelectionType(key)]   +
          cmf::cInteractionType_Strings[cmf::KeyToInteractionType(key)]);
}

static std::string cmf::KeyToVarName ( uint8_t const &  key )

inlinestatic

Definition at line 560 of file StaticFuncs.h.

References kVarNameToKey().

Referenced by InteractionTypeKey(), cmf::Parameter::Name(), operator<<(), cmf::DataVarVals::set_val_at(), and testSystematics().

{
  for(auto const& itr : cmf::kVarNameToKey){
    if(itr.second == key) return itr.first;
  }
  // if     (key == cmf::kNuE_CVN         ) return "NuE_CVN";
  // else if(key == cmf::kNuE_NumMichel   ) return "NuE_NumMichel";
  // else if(key == cmf::kHad_RecoE       ) return "Had_RecoE";
  // else if(key == cmf::kLep_RecoE       ) return "Lep_RecoE";
  // else if(key == cmf::kNu_RecoE        ) return "Nu_RecoE";
  // else if(key == cmf::kLep_RecoE_MCFrac) return "Lep_RecoE_MCFrac";
  // else if(key == cmf::kRecoQ2          ) return "Reco_Q2";
  // else if(key == cmf::kFake_Weight     ) return "Fake_Weight";

  // else if(key == cmf::kTrueE              ) return "TrueE";
  // else if(key == cmf::kTruePDG            ) return "TruePDG";
  // else if(key == cmf::kTrueCCNC           ) return "TrueCCNC";
  // else if(key == cmf::kTrueIntType        ) return "TrueIntType";
  // else if(key == cmf::kTruePDGOrig        ) return "TruePDGOrig";
  // else if(key == cmf::kTrueParentPDG      ) return "TrueParentPDG";
  // else if(key == cmf::kTrueParentPT       ) return "TrueParentPT";
  // else if(key == cmf::kTrueParentPZ       ) return "TrueParentPZ";
  // else if(key == cmf::kTrueParentDecay    ) return "TrueParentDecay";
  // else if(key == cmf::kTrueParentTargetPDG) return "TrueParentTargetPDG";
  // else if(key == cmf::kTrueHitNuc         ) return "TrueHitNuc";
  // else if(key == cmf::kTrueIntMode        ) return "TrueIntMode";

  // else if(key == cmf::kXSecCVPPFX_Weight) return "XsecCVWgt";
  // else if(key == cmf::kXSecCV2020Wgt    ) return "XsecCV2020";
  // else if(key == cmf::kPPFXFluxCVWgt    ) return "PPFXFluxCV";
  // else if(key == cmf::kRPARES_Weight    ) return "RPARESWgt";

  // else if(key == cmf::kMinus2Sigma) return "-2sigma";
  // else if(key == cmf::kMinus1Sigma) return "-1sigma";
  // else if(key == cmf::kPlus1Sigma ) return "+1sigma";
  // else if(key == cmf::kPlus2Sigma ) return "+2sigma";

  // // calibration
  // else if(key == cmf::kLightModelLightUpCalibDown) return "lightmodel-lightdown-calibupWgt";
  // else if(key == cmf::kLightModelLightDownCalibUp) return "lightmodel-lightup-calibdownWgt";
  // else if(key == cmf::kCkvProtonShiftDown        ) return "ckv-proton-shift-downWgt";
  // else if(key == cmf::kRelativeCalibration       ) return "RelativeCalibrationWgt";
  // else if(key == cmf::kAbsoluteCalibration       ) return "AbsoluteCalibrationWgt";
  // else if(key == cmf::kCalibShape                ) return "CalibrationShapeWgt";

  // //GENIE knobs

  // // NC elastic parameters
  // else if(key == cmf::kMaNCEL ) return "MaNCEL";
  // else if(key == cmf::kEtaNCEL) return "EtaNCEL";

  // // DIS tweaking parameters
  // else if(key == cmf::kAhtBY ) return "AhtBY";
  // else if(key == cmf::kBhtBY ) return "BhtBY";
  // else if(key == cmf::kCV1uBY) return "CV1uBY";
  // else if(key == cmf::kCV2uBY) return "CV2uBY";

  // // Hadronization (free nucleon target)
  // else if(key == cmf::kAGKY_xF1pi) return "AGKY_xF1pi";
  // else if(key == cmf::kAGKY_pT1pi) return "AGKY_pT1pi";

  // // Resonance decays
  // else if(key == cmf::kBR1gamma       ) return "BR1gamma";
  // else if(key == cmf::kBR1eta         ) return "BR1eta";
  // else if(key == cmf::kTheta_Delta2Npi) return "Theta_Delta2Npi";

  // else if(key == cmf::kMvCCRES         ) return "MvCCRES";
  // else if(key == cmf::kMaCCRES         ) return "MaCCRES";
  // else if(key == cmf::kMaNCRES         ) return "MaNCRES";
  // else if(key == cmf::kRPACCQEshapeEnh ) return "RPACCQEshapeEnh";
  // else if(key == cmf::kRPACCQEshapeSupp) return "RPACCQEshapeSupp";

  // // coherent scattering
  // else if(key == cmf::kCOHCCScaleSyst2018) return "COHCCScale2018";
  // else if(key == cmf::kCOHNCScaleSyst2018) return "COHNCScale2018";

  // // 2020
  // else if(key == cmf::kZExpEV1Syst2020                  ) return "ZExpAxialFFSyst2020_eV1";
  // else if(key == cmf::kZExpEV2Syst2020                  ) return "ZExpAxialFFSyst2020_eV2";
  // else if(key == cmf::kZExpEV3Syst2020                  ) return "ZExpAxialFFSyst2020_eV3";
  // else if(key == cmf::kZExpEV4Syst2020                  ) return "ZExpAxialFFSyst2020_eV4";
  // else if(key == cmf::kZNormCCQE                        ) return "ZNormCCQE";
  // else if(key == cmf::kRESLowQ2SuppSyst2020             ) return "RESLowQ2SuppSyst2020";
  // else if(key == cmf::khNFSISyst2020_MFP                ) return "hNFSISyst2020_MFP";
  // else if(key == cmf::khNFSISyst2020_EV1                ) return "hNFSISyst2020_EV1";
  // else if(key == cmf::kMECEnuShapeSyst2020Nu            ) return "MECEnuShapeSyst2020Nu";
  // else if(key == cmf::kMECEnuShapeSyst2020AntiNu        ) return "MECEnuShapeSyst2020AntiNu";
  // else if(key == cmf::kMECShapeSyst2020Nu               ) return "MECShapeSyst2020Nu";
  // else if(key == cmf::kMECShapeSyst2020AntiNu           ) return "MECShapeSyst2020AntiNu";
  // else if(key == cmf::kMECInitStateNPFracSyst2020Nu     ) return "MECInitStateNPFracSyst2020Nu";
  // else if(key == cmf::kMECInitStateNPFracSyst2020AntiNu ) return "MECInitStateNPFracSyst2020AntiNu";
  // else if(key == cmf::kRadCorrNue                       ) return "RadCorrNue";
  // else if(key == cmf::kRadCorrNuebar                    ) return "RadCorrNuebar";
  // else if(key == cmf::k2ndClassCurrs                    ) return "2ndClassCurrs";
  // else if(key == cmf::kGENIEPCA00                       ) return "GENIEPCA00";
  // else if(key == cmf::kGENIEPCA01                       ) return "GENIEPCA01";
  // else if(key == cmf::kGENIEPCA02                       ) return "GENIEPCA02";
  // else if(key == cmf::kGENIEPCA03                       ) return "GENIEPCA03";
  // else if(key == cmf::kGENIEPCA04                       ) return "GENIEPCA04";
  // else if(key == cmf::kGENIEPCA05                       ) return "GENIEPCA05";
  // else if(key == cmf::kGENIEPCA06                       ) return "GENIEPCA06";
  // else if(key == cmf::kGENIEPCA07                       ) return "GENIEPCA07";
  // else if(key == cmf::kGENIEPCA08                       ) return "GENIEPCA08";
  // else if(key == cmf::kGENIEPCA09                       ) return "GENIEPCA09";
  // else if(key == cmf::kGENIEPCA10                       ) return "GENIEPCA10";
  // else if(key == cmf::kGENIEPCA11                       ) return "GENIEPCA11";
  // else if(key == cmf::kMvNCRES                          ) return "MvNCRES";
  // else if(key == cmf::kUnCorrNDMuEScaleSyst2020         ) return "UnCorrNDMuEScaleSyst2020";
  // else if(key == cmf::kUnCorrMuCatMuESyst2020           ) return "UnCorrMuCatMuESyst2020";
  // else if(key == cmf::kPileupMuESyst2020                ) return "PileupMuESyst2020";
  // else if(key == cmf::kCorrMuEScaleSyst2020             ) return "CorrMuEScaleSyst2020";
  // else if(key == cmf::kNeutronVisEScalePrimariesSyst2018) return "NeutronVisEScalePrimariesSyst2018";
  // else if(key == cmf::kMichelTaggingSyst2020            ) return "MichelTaggingSyst2020";
  // else if(key == cmf::kAna2020NormFHC                   ) return "Ana2020NormFHC";
  // else if(key == cmf::kAna2020NormRHC                   ) return "Ana2020NormRHC";
  // else if(key == cmf::kNorm_1Nux                        ) return "Norm_1Nux";
  // else if(key == cmf::kMeanQ0_1Nux                      ) return "MeanQ0_1Nux";
  // else if(key == cmf::kMeanQ3_1Nux                      ) return "MeanQ3_1Nux";
  // else if(key == cmf::kSigmaQ0_1Nux                     ) return "SigmaQ0_1Nux";
  // else if(key == cmf::kSigmaQ3_1Nux                     ) return "SigmaQ3_1Nux";
  // else if(key == cmf::kCorr_1Nux                        ) return "Corr_1Nux";
  // else if(key == cmf::kNorm_2Nux                        ) return "Norm_2Nux";
  // else if(key == cmf::kMeanQ0_2Nux                      ) return "MeanQ0_2Nux";
  // else if(key == cmf::kMeanQ3_2Nux                      ) return "MeanQ3_2Nux";
  // else if(key == cmf::kSigmaQ0_2Nux                     ) return "SigmaQ0_2Nux";
  // else if(key == cmf::kSigmaQ3_2Nux                     ) return "SigmaQ3_2Nux";
  // else if(key == cmf::kCorr_2Nux                        ) return "Corr_2Nux";
  // else if(key == cmf::kBaselineNux                      ) return "BaselineNux"; 
  // else if(key == cmf::kTauScaleSyst                     ) return "TauScaleSyst";
  // else if(key == cmf::kDISvpCC0pi_2020                  ) return "DISvpCC0pi_2020";
  // else if(key == cmf::kDISvpCC1pi_2020                  ) return "DISvpCC1pi_2020";
  // else if(key == cmf::kDISvpCC2pi_2020                  ) return "DISvpCC2pi_2020";
  // else if(key == cmf::kDISvpCC3pi_2020                  ) return "DISvpCC3pi_2020";
  // else if(key == cmf::kDISvpNC0pi_2020                  ) return "DISvpNC0pi_2020";
  // else if(key == cmf::kDISvpNC1pi_2020                  ) return "DISvpNC1pi_2020";
  // else if(key == cmf::kDISvpNC2pi_2020                  ) return "DISvpNC2pi_2020";
  // else if(key == cmf::kDISvpNC3pi_2020                  ) return "DISvpNC3pi_2020";
  // else if(key == cmf::kDISvnCC0pi_2020                  ) return "DISvnCC0pi_2020";
  // else if(key == cmf::kDISvnCC1pi_2020                  ) return "DISvnCC1pi_2020";
  // else if(key == cmf::kDISvnCC2pi_2020                  ) return "DISvnCC2pi_2020";
  // else if(key == cmf::kDISvnCC3pi_2020                  ) return "DISvnCC3pi_2020";
  // else if(key == cmf::kDISvnNC0pi_2020                  ) return "DISvnNC0pi_2020";
  // else if(key == cmf::kDISvnNC1pi_2020                  ) return "DISvnNC1pi_2020";
  // else if(key == cmf::kDISvnNC2pi_2020                  ) return "DISvnNC2pi_2020";
  // else if(key == cmf::kDISvnNC3pi_2020                  ) return "DISvnNC3pi_2020";
  // else if(key == cmf::kDISvbarpCC0pi_2020               ) return "DISvbarpCC0pi_2020";
  // else if(key == cmf::kDISvbarpCC1pi_2020               ) return "DISvbarpCC1pi_2020";
  // else if(key == cmf::kDISvbarpCC2pi_2020               ) return "DISvbarpCC2pi_2020";
  // else if(key == cmf::kDISvbarpCC3pi_2020               ) return "DISvbarpCC3pi_2020";
  // else if(key == cmf::kDISvbarpNC0pi_2020               ) return "DISvbarpNC0pi_2020";
  // else if(key == cmf::kDISvbarpNC1pi_2020               ) return "DISvbarpNC1pi_2020";
  // else if(key == cmf::kDISvbarpNC2pi_2020               ) return "DISvbarpNC2pi_2020";
  // else if(key == cmf::kDISvbarpNC3pi_2020               ) return "DISvbarpNC3pi_2020";
  // else if(key == cmf::kDISvbarnCC0pi_2020               ) return "DISvbarnCC0pi_2020";
  // else if(key == cmf::kDISvbarnCC1pi_2020               ) return "DISvbarnCC1pi_2020";
  // else if(key == cmf::kDISvbarnCC2pi_2020               ) return "DISvbarnCC2pi_2020";
  // else if(key == cmf::kDISvbarnCC3pi_2020               ) return "DISvbarnCC3pi_2020";
  // else if(key == cmf::kDISvbarnNC0pi_2020               ) return "DISvbarnNC0pi_2020";
  // else if(key == cmf::kDISvbarnNC1pi_2020               ) return "DISvbarnNC1pi_2020";
  // else if(key == cmf::kDISvbarnNC2pi_2020               ) return "DISvbarnNC2pi_2020";
  // else if(key == cmf::kDISvbarnNC3pi_2020               ) return "DISvbarnNC3pi_2020";
  // else if(key == cmf::kFormZone_2020                    ) return "FormZone_2020";
  // else if(key == cmf::khNFSISyst2020_EV2                ) return "hNFSISyst2020_EV2";
  // else if(key == cmf::khNFSISyst2020_EV3                ) return "hNFSISyst2020_EV3";
  // else if(key == cmf::kCOHCCScaleSyst2018               ) return "COHCCScaleSyst2018";
  // else if(key == cmf::kCOHNCScaleSyst2018               ) return "COHNCScaleSyst2018";

  return "Unknown";

  //else if( isSumSmallXSecJoint2017Key(key) ) return "SumSmallXSecJoint2017";

  // CCQE parameters
  //else if(key == cmf::kNormCCQE           ) return "NormCCQE";
  //else if(key == cmf::kNormCCQE_EnuDep    ) return "NormCCQE_EnuDep";
  //else if(key == cmf::kMaCCQE_shape       ) return "MaCCQE_shape";
  //else if(key == cmf::kVecCCQE_shape      ) return "VecCCQE_shape";

  // Resonant production: CC
  //else if(key == cmf::kNormCCRES          ) return "NormCCRES";
  //else if(key == cmf::kMaCCRES_shape      ) return "MaCCRES_shape";
  //else if(key == cmf::kMvCCRES_shape      ) return "MvCCRES_shape";
  //else if(key == cmf::kMaCCRES            ) return "MaCCRES";

  // Resonant production: NC
  //else if(key == cmf::kNormNCRES          ) return "NormNCRES";
  //else if(key == cmf::kMaNCRES_shape      ) return "MaNCRES_shape";
  //else if(key == cmf::kMvNCRES_shape      ) return "MvNCRES_shape";

  // Coherent pion production
  //else if(key == cmf::kMaCOHpi            ) return "MaCOHpi";
  //else if(key == cmf::kR0COHpi            ) return "R0COHpi";

  // Non-resonant background
  //else if(key == cmf::kRvpCC1pi           ) return "RvpCC1pi";
  //else if(key == cmf::kRvpCC2pi           ) return "RvpCC2pi";
  //else if(key == cmf::kRvpNC1pi           ) return "RvpNC1pi";
  //else if(key == cmf::kRvpNC2pi           ) return "RvpNC2pi";
  //else if(key == cmf::kRvnCC1pi           ) return "RvnCC1pi";
  //else if(key == cmf::kRvnCC2pi           ) return "RvnCC2pi";
  //else if(key == cmf::kRvnNC1pi           ) return "RvnNC1pi";
  //else if(key == cmf::kRvnNC2pi           ) return "RvnNC2pi";
  //else if(key == cmf::kRvbarpCC1pi        ) return "RvbarpCC1pi";
  //else if(key == cmf::kRvbarpCC2pi        ) return "RvbarpCC2pi";
  //else if(key == cmf::kRvbarpNC1pi        ) return "RvbarpNC1pi";
  //else if(key == cmf::kRvbarpNC2pi        ) return "RvbarpNC2pi";
  //else if(key == cmf::kRvbarnCC1pi        ) return "RvbarnCC1pi";
  //else if(key == cmf::kRvbarnCC2pi        ) return "RvbarnCC2pi";
  //else if(key == cmf::kRvbarnNC1pi        ) return "RvbarnNC1pi";
  //else if(key == cmf::kRvbarnNC2pi        ) return "RvbarnNC2pi";

  //else if(key == cmf::kAhtBYshape         ) return "AhtBYshape";
  //else if(key == cmf::kBhtBYshape         ) return "BhtBYshape";
  //else if(key == cmf::kCV1uBYshape        ) return "CV1uBYshape";
  //else if(key == cmf::kCV2uBYshape        ) return "CV2uBYshape";
  //else if(key == cmf::kNormDISCC          ) return "NormDISCC";
  //else if(key == cmf::kRnubarnuCC         ) return "RnubarnuCC";
  //else if(key == cmf::kDISNuclMod         ) return "DISNuclMod";

  //else if(key == cmf::kNCGENIE            ) return "NC";

  // Medium-effects to hadronization

  // Intranuclear rescattering parameters.
//  else if(key == cmf::kMFP_pi             ) return "MFP_pi";
//  else if(key == cmf::kMFP_N              ) return "MFP_N";
//  else if(key == cmf::kFrPiProd_pi        ) return "FrPiProd_pi";
//  else if(key == cmf::kFrPiProd_N         ) return "FrPiProd_N";

  // Nuclear model
//  else if(key == cmf::kCCQEMomDistroFGtoSF) return "CCQEMomDistroFGtoSF";


  // 2017 RPA shape systematics
}

static const std::map<std::string, uint8_t> cmf::kVarNameToKey ( {{"NuE_CVN", cmf::kNuE_CVN},{"NuE_NumMichel", cmf::kNuE_NumMichel},{"Had_RecoE", cmf::kHad_RecoE},{"Lep_RecoE", cmf::kLep_RecoE},{"Nu_RecoE", cmf::kNu_RecoE},{"Lep_RecoE_MCFrac", cmf::kLep_RecoE_MCFrac},{"Reco_Q2", cmf::kRecoQ2},{"Fake_Weight", cmf::kFake_Weight},{"TrueE", cmf::kTrueE},{"TruePDG", cmf::kTruePDG},{"TrueCCNC", cmf::kTrueCCNC},{"TrueIntType", cmf::kTrueIntType},{"TruePDGOrig", cmf::kTruePDGOrig},{"TrueParentPDG", cmf::kTrueParentPDG},{"TrueParentPT", cmf::kTrueParentPT},{"TrueParentPZ", cmf::kTrueParentPZ},{"TrueParentDecay", cmf::kTrueParentDecay},{"TrueParentTargetPDG", cmf::kTrueParentTargetPDG},{"TrueHitNuc", cmf::kTrueHitNuc},{"TrueIntMode", cmf::kTrueIntMode},{"XsecCV2020", cmf::kXSecCV2020Wgt},{"PPFXFluxCV", cmf::kPPFXFluxCVWgt},{"RPARES", cmf::kRPARES_Weight},{"-2sigma", cmf::kMinus2Sigma},{"-1sigma", cmf::kMinus1Sigma},{"+1sigma", cmf::kPlus1Sigma},{"+2sigma", cmf::kPlus2Sigma},{"lightmodel-lightdown", cmf::kLightModelLightDownCalibUp},{"lightmodel-lightup", cmf::kLightModelLightUpCalibDown},{"ckv-proton", cmf::kCkvProtonShiftDown},{"RelativeCalibration", cmf::kRelativeCalibration},{"AbsoluteCalibration", cmf::kAbsoluteCalibration},{"CalibrationShape", cmf::kCalibShape},{"MaNCEL", cmf::kMaNCEL},{"EtaNCEL", cmf::kEtaNCEL},{"AhtBY", cmf::kAhtBY},{"BhtBY", cmf::kBhtBY},{"CV1uBY", cmf::kCV1uBY},{"CV2uBY", cmf::kCV2uBY},{"AGKY_xF1pi", cmf::kAGKY_xF1pi},{"AGKY_pT1pi", cmf::kAGKY_pT1pi},{"BR1gamma", cmf::kBR1gamma},{"BR1eta", cmf::kBR1eta},{"Theta_Delta2Npi", cmf::kTheta_Delta2Npi},{"MvCCRES", cmf::kMvCCRES},{"MaCCRES", cmf::kMaCCRES},{"MvNCRES", cmf::kMvNCRES},{"MaNCRES", cmf::kMaNCRES},{"RPACCQEshapeEnh", cmf::kRPACCQEshapeEnh},{"RPACCQEshapeSupp", cmf::kRPACCQEshapeSupp},{"COHCCScale2018", cmf::kCOHCCScaleSyst2018},{"COHNCScale2018", cmf::kCOHNCScaleSyst2018},{"ZExpAxialFFSyst2020_eV1", cmf::kZExpEV1Syst2020},{"ZExpAxialFFSyst2020_eV2", cmf::kZExpEV2Syst2020},{"ZExpAxialFFSyst2020_eV3", cmf::kZExpEV3Syst2020},{"ZExpAxialFFSyst2020_eV4", cmf::kZExpEV4Syst2020},{"ZNormCCQE", cmf::kZNormCCQE},{"RESLowQ2SuppSyst2020", cmf::kRESLowQ2SuppSyst2020},{"hNFSISyst2020_MFP", cmf::khNFSISyst2020_MFP},{"hNFSISyst2020_EV1", cmf::khNFSISyst2020_EV1},{"MECEnuShapeSyst2020Nu", cmf::kMECEnuShapeSyst2020Nu},{"MECEnuShapeSyst2020AntiNu", cmf::kMECEnuShapeSyst2020AntiNu},{"MECShapeSyst2020Nu", cmf::kMECShapeSyst2020Nu},{"MECShapeSyst2020AntiNu", cmf::kMECShapeSyst2020AntiNu},{"MECInitStateNPFracSyst2020Nu", cmf::kMECInitStateNPFracSyst2020Nu},{"MECInitStateNPFracSyst2020AntiNu", cmf::kMECInitStateNPFracSyst2020AntiNu},{"RadCorrNue", cmf::kRadCorrNue},{"RadCorrNuebar", cmf::kRadCorrNuebar},{"2ndClassCurrs", cmf::k2ndClassCurrs},{"GENIEPCA00", cmf::kGENIEPCA00},{"GENIEPCA01", cmf::kGENIEPCA01},{"GENIEPCA02", cmf::kGENIEPCA02},{"GENIEPCA03", cmf::kGENIEPCA03},{"GENIEPCA04", cmf::kGENIEPCA04},{"GENIEPCA05", cmf::kGENIEPCA05},{"GENIEPCA06", cmf::kGENIEPCA06},{"GENIEPCA07", cmf::kGENIEPCA07},{"GENIEPCA08", cmf::kGENIEPCA08},{"GENIEPCA09", cmf::kGENIEPCA09},{"GENIEPCA10", cmf::kGENIEPCA10},{"GENIEPCA11", cmf::kGENIEPCA11},{"UnCorrNDMuEScaleSyst2020", cmf::kUnCorrNDMuEScaleSyst2020},{"UnCorrMuCatMuESyst2020", cmf::kUnCorrMuCatMuESyst2020},{"PileupMuESyst2020", cmf::kPileupMuESyst2020},{"CorrMuEScaleSyst2020", cmf::kCorrMuEScaleSyst2020},{"NeutronVisEScalePrimariesSyst2018", cmf::kNeutronVisEScalePrimariesSyst2018},{"MichelTaggingSyst2020", cmf::kMichelTaggingSyst2020},{"Ana2020NormFHC", cmf::kAna2020NormFHC},{"Ana2020NormRHC", cmf::kAna2020NormRHC},{"Norm_1Nux", cmf::kNorm_1Nux},{"MeanQ0_1Nux", cmf::kMeanQ0_1Nux},{"MeanQ3_1Nux", cmf::kMeanQ3_1Nux},{"SigmaQ0_1Nux", cmf::kSigmaQ0_1Nux},{"SigmaQ3_1Nux", cmf::kSigmaQ3_1Nux},{"Corr_1Nux", cmf::kCorr_1Nux},{"Norm_2Nux", cmf::kNorm_2Nux},{"MeanQ0_2Nux", cmf::kMeanQ0_2Nux},{"MeanQ3_2Nux", cmf::kMeanQ3_2Nux},{"SigmaQ0_2Nux", cmf::kSigmaQ0_2Nux},{"SigmaQ3_2Nux", cmf::kSigmaQ3_2Nux},{"Corr_2Nux", cmf::kCorr_2Nux},{"BaselineNux", cmf::kBaselineNux},{"TauScaleSyst", cmf::kTauScaleSyst},{"DISvpCC0pi_2020", cmf::kDISvpCC0pi_2020},{"DISvpCC1pi_2020", cmf::kDISvpCC1pi_2020},{"DISvpCC2pi_2020", cmf::kDISvpCC2pi_2020},{"DISvpCC3pi_2020", cmf::kDISvpCC3pi_2020},{"DISvpNC0pi_2020", cmf::kDISvpNC0pi_2020},{"DISvpNC1pi_2020", cmf::kDISvpNC1pi_2020},{"DISvpNC2pi_2020", cmf::kDISvpNC2pi_2020},{"DISvpNC3pi_2020", cmf::kDISvpNC3pi_2020},{"DISvnCC0pi_2020", cmf::kDISvnCC0pi_2020},{"DISvnCC1pi_2020", cmf::kDISvnCC1pi_2020},{"DISvnCC2pi_2020", cmf::kDISvnCC2pi_2020},{"DISvnCC3pi_2020", cmf::kDISvnCC3pi_2020},{"DISvnNC0pi_2020", cmf::kDISvnNC0pi_2020},{"DISvnNC1pi_2020", cmf::kDISvnNC1pi_2020},{"DISvnNC2pi_2020", cmf::kDISvnNC2pi_2020},{"DISvnNC3pi_2020", cmf::kDISvnNC3pi_2020},{"DISvbarpCC0pi_2020", cmf::kDISvbarpCC0pi_2020},{"DISvbarpCC1pi_2020", cmf::kDISvbarpCC1pi_2020},{"DISvbarpCC2pi_2020", cmf::kDISvbarpCC2pi_2020},{"DISvbarpCC3pi_2020", cmf::kDISvbarpCC3pi_2020},{"DISvbarpNC0pi_2020", cmf::kDISvbarpNC0pi_2020},{"DISvbarpNC1pi_2020", cmf::kDISvbarpNC1pi_2020},{"DISvbarpNC2pi_2020", cmf::kDISvbarpNC2pi_2020},{"DISvbarpNC3pi_2020", cmf::kDISvbarpNC3pi_2020},{"DISvbarnCC0pi_2020", cmf::kDISvbarnCC0pi_2020},{"DISvbarnCC1pi_2020", cmf::kDISvbarnCC1pi_2020},{"DISvbarnCC2pi_2020", cmf::kDISvbarnCC2pi_2020},{"DISvbarnCC3pi_2020", cmf::kDISvbarnCC3pi_2020},{"DISvbarnNC0pi_2020", cmf::kDISvbarnNC0pi_2020},{"DISvbarnNC1pi_2020", cmf::kDISvbarnNC1pi_2020},{"DISvbarnNC2pi_2020", cmf::kDISvbarnNC2pi_2020},{"DISvbarnNC3pi_2020", cmf::kDISvbarnNC3pi_2020},{"FormZone_2020", cmf::kFormZone_2020},{"hNFSISyst2020_EV2", cmf::khNFSISyst2020_EV2},{"hNFSISyst2020_EV3", cmf::khNFSISyst2020_EV3},{"COHCCScaleSyst2018", cmf::kCOHCCScaleSyst2018},{"COHNCScaleSyst2018", cmf::kCOHNCScaleSyst2018}}  )

static

Referenced by KeyToVarName(), and VarNameToKey().

float cmf::NCEnergy ( float  leptonicEnergy, float  hadronicEnergy, cmf::BeamType_t const &  beamType, cmf::DetType_t const &  detector  )

inlinestatic

Definition at line 361 of file VarVals.h.

References stan::math::exp(), kFARDET, kFHC, kNEARDET, kRHC, pars(), and cet::pow().

Referenced by cmf::DataVarVals::DataVars(), and RecoEnergy().

{
  // Note: leptonicEnergy must be the EM-like energy, as calculated by kEME_2020
  // and hadronicEnergy must be the hadronic-like energy, as calculated by kHADE_2020
  // If we don't have a tuned correction return the total calorimetric energy
  if (beamType != kFHC ||
      (detector != cmf::kNEARDET && detector != cmf::kFARDET))
    return leptonicEnergy + hadronicEnergy;

  // Set up correction parameters
  double pars[4][6] = { {1.049, 0.795, 0.8409, 0.17,  0.82, -1.00},  // ND FHC
                        {1.025, 0.797, 0.9162, 0.53, -0.26, -1.48},  // FD FHC
                        {1.000, 1.000, 1.0000, 0.00,  0.00,  0.00},  // ND RHC
                        {1.000, 1.000, 1.0000, 0.00,  0.00,  0.00} };// FD RHC

  // set detector/beam index
  int detCur = (detector == cmf::kFARDET) + ((beamType == kRHC)<<1); // bitshift magic

  // return the energy estimator
  return (leptonicEnergy / pars[detCur][0] + hadronicEnergy / pars[detCur][1])
    / (pars[detCur][2] + pars[detCur][3] * std::pow(leptonicEnergy + hadronicEnergy + pars[detCur][4],2) * std::exp(pars[detCur][5] * (leptonicEnergy + hadronicEnergy)));
}

float cmf::NuEEnergy ( float  leptonicEnergy, float  hadronicEnergy, cmf::BeamType_t const &  beamType  )

inlinestatic

Definition at line 338 of file VarVals.h.

References e, kFHC, PandAna.Demos.pi0_spectra::p0, plot_validation_datamc::p1, plot_validation_datamc::p2, make_associated_cosmic_defs::p3, make_associated_cosmic_defs::p4, and make_associated_cosmic_defs::p5.

Referenced by cmf::DataVarVals::DataVars(), and RecoEnergy().

{
  // p0 and p3 are 0.0 for both FHC and RHC
  // 2020
  float p0 = 0.0;
  float p1 = (beamType == kFHC) ? 1.01777 : 0.988258;
  float p2 = (beamType == kFHC) ? 1.10868 : 1.20084;
  float p3 = 0.0;
  float p4 = (beamType == kFHC) ? 1.43541e-03 : 1.92904e-07;
  float p5 = (beamType == kFHC) ? 1.09628e-01 : 1.20704e-07;
  float fr = (beamType == kFHC) ? 1. / 1.0355622 : 1. / 1.0111873;

  return fr *(( p5 * hadronicEnergy * hadronicEnergy) +
              ( p4 * leptonicEnergy * leptonicEnergy) +
              ( p3 * leptonicEnergy * hadronicEnergy) +
              ( p2 * hadronicEnergy)                  +
              ( p1 * leptonicEnergy)                  +
              p0 );
}

float cmf::NuMuEnergy ( float  leptonicEnergy, float  hadronicEnergy  )

inlinestatic

Definition at line 330 of file VarVals.h.

Referenced by cmf::DataVarVals::DataVars(), and RecoEnergy().

{
  return leptonicEnergy + hadronicEnergy;

}

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::Event const &	event
	)

Definition at line 27 of file Event.cxx.

References cmf::Event::DataVals(), cmf::Event::DataValsFilled(), allTimeWatchdog::endl, cmf::Event::EventID(), cmf::Event::EventIDFilled(), cmf::Event::MCVals(), cmf::Event::MCValsFilled(), and msf_helper::o.

Referenced by cmf::DataVarVals::DataVarVals(), cmf::MCVarVals::MCVarVals(), cmf::SystVar::operator<(), and cmf::Parameter::SetValue().

  {
    o << "Event Variables are: \n";

    if(event.EventIDFilled() ) o << event.EventID() ;
    if(event.DataValsFilled()) o << event.DataVals();
    if(event.MCValsFilled()  ) o << event.MCVals()  ;

    o << std::endl;

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::GridPoint const &	gp
	)

Definition at line 32 of file GridPointResult.cxx.

References cOscParams_Strings, IsAngleParameter(), msf_helper::o, cmf::GridPoint::X(), cmf::GridPoint::XPar(), cmf::GridPoint::Y(), and cmf::GridPoint::YPar().

  {

    if(cmf::IsAngleParameter(gp.XPar()))
      o << "sin^{2}("
        << cmf::cOscParams_Strings[gp.XPar()]
        << ") : ";
    else
      o << cmf::cOscParams_Strings[gp.XPar()]
        << " : ";

    o << gp.X()
      << " ";

    if(cmf::IsAngleParameter(gp.YPar()))
      o << "sin^{2}("
        << cmf::cOscParams_Strings[gp.YPar()]
        << ") : ";
    else
      o << cmf::cOscParams_Strings[gp.YPar()]
        << " : ";

    o << gp.Y();

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::InputPoint const &	ip
	)

Definition at line 36 of file InputPoint.cxx.

References allTimeWatchdog::endl, cmf::InputPoint::FDParameters(), IsOscillationParameter(), cmf::InputPoint::NDParameters(), msf_helper::o, cet::pow(), std::sin(), string, and febshutoff_auto::val.

  {

    double val;
    std::string name;

    o << "InputPoint ND" << std::endl;

    for(auto const& itr : ip.NDParameters()){
      name = itr.first;
      val  = itr.second.Value();
      if     (name == "dCP")
        o << "\t" << std::setw(20) << name << " " << std::setw(10) << val << " = " << val/TMath::Pi() << "(pi)" << " fixed: " << itr.second.IsFixed() << std::endl;
      else if(name == "Th23")
        o << "\t" << std::setw(20) << name << " " << std::setw(10) << val << ": sin^2(Th23) : " << std::pow(std::sin(val), 2.) << " fixed: " << itr.second.IsFixed() << std::endl;
      else if(cmf::IsOscillationParameter(name))
        o << "\t" << std::setw(20) << name << " " << std::setw(10) << val << " fixed: " << itr.second.IsFixed() << std::endl;
      else
        o << "\t"<< std::setw(10) << name << " " << std::setw(10) << val << " fixed: " << itr.second.IsFixed() << std::endl;
    }

    o << std::endl
      << "\nInputPoint FD:"
      << std::endl;
    for(auto const& itr : ip.FDParameters() ){
      name = itr.first;
      val  = itr.second.Value();
      if(name == "dCP")
        o << "\t" << std::setw(20) << name << " " << std::setw(10) << val << " = " << val / TMath::Pi() << "(pi)" << " fixed: " << itr.second.IsFixed() << std::endl;
      else if(name == "Th23")
        o << "\t" << std::setw(20) << name << " " << std::setw(10) << val << ": sin^2(Th23) : " << std::pow(std::sin(val), 2.) << " fixed: " << itr.second.IsFixed() << std::endl;
      else if(cmf::IsOscillationParameter(name))
        o << "\t" << std::setw(20) << name << " " << std::setw(10) << val << " fixed: " << itr.second.IsFixed() << std::endl;
      else
        o << "\t" << std::setw(10) << name << " " << std::setw(10) << val << " fixed: " << itr.second.IsFixed() << std::endl;
    }

    o << std::endl;

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::FakeUniverse const &	fu
	)

Definition at line 57 of file FakeUniverse.cxx.

References cOscParams_Strings, allTimeWatchdog::endl, and cmf::FakeUniverse::OscParMap().

  {
    o << "universe location ";

    for(auto const& itr : fu.OscParMap())
      o << cmf::cOscParams_Strings[itr.first]
        << " "
        << itr.second
        << " ";

    o << std::endl;

//    for(size_t b = 0; b < fu.AsimovSpectrum().size(); ++b){
//      o << "fake universe spectrum bin "
//        << b
//        << " poisson: "
//        << fu.PoissonSpectrum()[b]
//        << " asimov: "
//        << fu.AsimovSpectrum()[b]
//        << "\n";
//    }

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::PointResult const &	pr
	)

Definition at line 59 of file PointResult.cxx.

References cmf::PointResult::ChiSqr(), cOscParams_Strings, allTimeWatchdog::endl, IsAngleParameter(), kdCP, msf_helper::o, cmf::PointResult::ParameterSpaceLocation(), cet::pow(), art::right(), and std::sin().

  {
    o << "PointResult:" << std::endl
      << "\tChiSqr = "   << std::setw(5) << std::right << pr.ChiSqr() << std::endl;

    o << "Oscillation parameters:" << std::endl;
    for(auto itr : pr.ParameterSpaceLocation() ){
      if(itr.first == cmf::kdCP)
        o << "\t" << std::setw(20) << cmf::cOscParams_Strings[itr.first] << " " << itr.second << " = " << itr.second/TMath::Pi() << "(pi)" << std::endl;
      else if(cmf::IsAngleParameter(itr.first))
        o << "\t" << std::setw(20) << cmf::cOscParams_Strings[itr.first] << " " << itr.second << ": sin^2(" << cmf::cOscParams_Strings[itr.first] << ") : " << std::pow(std::sin(itr.second), 2.) << std::endl;
      else o << "\t" << std::setw(20) << cmf::cOscParams_Strings[itr.first] << " " << itr.second << std::endl;
    }

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::MCVarVals const &	mcvv
	)

Definition at line 71 of file VarVals.cxx.

References allTimeWatchdog::endl, kDISvnCC1pi_Weight, kEmpiricalMEC_Weight, kEmpiricalMECtoGENIEQE_Weight, kEmpiricalMECtoGENIERES_Weight, KeyToVarName(), kOtherDIS_Weight, kRPACCQE_Weight, kRPARES_Weight, kTrueCCNC, kTrueE, kTrueHitNuc, kTrueIntMode, kTrueIntType, kTrueParentDecay, kTrueParentPDG, kTrueParentPT, kTrueParentPZ, kTrueParentTargetPDG, kTruePDG, kTruePDGOrig, kXSecCVPPFX_Weight, msf_helper::o, and cmf::MCVarVals::val_at().

  {
    o << "Event MC related variables are: "
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueE)                         << " " << mcvv.val_at(cmf::kTrueE              )
    << "\n\t" << cmf::KeyToVarName(cmf::kTruePDG)                       << " " << mcvv.val_at(cmf::kTruePDG            )
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueCCNC)                      << " " << mcvv.val_at(cmf::kTrueCCNC           )
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueIntType)                   << " " << mcvv.val_at(cmf::kTrueIntType        )
    << "\n\t" << cmf::KeyToVarName(cmf::kTruePDGOrig)                   << " " << mcvv.val_at(cmf::kTruePDGOrig        )
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueParentPDG)                 << " " << mcvv.val_at(cmf::kTrueParentPDG      )
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueParentPT)                  << " " << mcvv.val_at(cmf::kTrueParentPT       )
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueParentPZ)                  << " " << mcvv.val_at(cmf::kTrueParentPZ       )
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueParentDecay)               << " " << mcvv.val_at(cmf::kTrueParentDecay    )
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueParentTargetPDG)           << " " << mcvv.val_at(cmf::kTrueParentTargetPDG)
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueHitNuc)                    << " " << mcvv.val_at(cmf::kTrueHitNuc         )
    << "\n\t" << cmf::KeyToVarName(cmf::kTrueIntMode)                   << " " << mcvv.val_at(cmf::kTrueIntMode        )
    << "\n\t" << cmf::KeyToVarName(cmf::kXSecCVPPFX_Weight)             << " " << mcvv.val_at(cmf::kXSecCVPPFX_Weight  )
    << "\n\t" << cmf::KeyToVarName(cmf::kRPACCQE_Weight)                << " " << mcvv.val_at(cmf::kRPACCQE_Weight     )
    << "\n\t" << cmf::KeyToVarName(cmf::kRPARES_Weight)                 << " " << mcvv.val_at(cmf::kRPARES_Weight      )
    << "\n\t" << cmf::KeyToVarName(cmf::kDISvnCC1pi_Weight)             << " " << mcvv.val_at(cmf::kDISvnCC1pi_Weight  )
    << "\n\t" << cmf::KeyToVarName(cmf::kEmpiricalMEC_Weight)           << " " << mcvv.val_at(cmf::kEmpiricalMEC_Weight)
    << "\n\t" << cmf::KeyToVarName(cmf::kEmpiricalMECtoGENIEQE_Weight)  << " " << mcvv.val_at(cmf::kEmpiricalMECtoGENIEQE_Weight)
    << "\n\t" << cmf::KeyToVarName(cmf::kEmpiricalMECtoGENIERES_Weight) << " " << mcvv.val_at(cmf::kEmpiricalMECtoGENIERES_Weight)
    << "\n\t" << cmf::KeyToVarName(cmf::kOtherDIS_Weight)               << " " << mcvv.val_at(cmf::kOtherDIS_Weight    )
    << "\n\t and too many GENIE knobs to list"
    << std::endl;

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::Parameter const &	par
	)

Definition at line 89 of file Parameter.cxx.

References allTimeWatchdog::endl, cmf::Parameter::IsConstrained(), cmf::Parameter::IsFixed(), cmf::Parameter::IsNuisance(), cmf::Parameter::IsOscPar(), cmf::Parameter::LowerBound(), cmf::Parameter::Name(), msf_helper::o, cmf::Parameter::UpperBound(), and cmf::Parameter::Value().

                                                                 {

    o  << "-- parameter: "
       << std::setw(30)     << par.Name()  << std::setw(10)
       << " val: "          << par.Value()
       << " fixed: "        << par.IsFixed()
       << " oscillation "   << par.IsOscPar()
       << " nuisance "      << par.IsNuisance()
       << " constrained "   << par.IsConstrained()
       << " lower: "        << par.LowerBound()
       << " upper: "        << par.UpperBound()
       << std::endl;

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::SystVar const &	sv
	)

Definition at line 101 of file VarVals.cxx.

References cmf::SystVar::fMinus1Sigma, cmf::SystVar::fMinus2Sigma, cmf::SystVar::fPlus1Sigma, cmf::SystVar::fPlus2Sigma, cmf::SystVar::fType, KeyToVarName(), and msf_helper::o.

  {
    o << cmf::KeyToVarName(sv.fType)
      << " | -2 sigma wgt: "
      << sv.fMinus2Sigma
      << " | -1 sigma wgt: "
      << sv.fMinus1Sigma
      << " | 1 sigma wgt: "
      << sv.fPlus1Sigma
      << " | 2 sigma wgt: "
      << sv.fPlus2Sigma
      << " | ";

      return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::Location const &	loc
	)

Definition at line 106 of file Parameter.cxx.

References cOscParams_Strings, allTimeWatchdog::endl, cmf::Location::FDLocation(), kFARDET, kL, kNEARDET, cmf::Location::Location(), cmf::Location::NDLocation(), and msf_helper::o.

                                                                {
    o << std::endl;
    for(auto const& itr : loc.NDLocation()){
      o << " -- parameter: "  
        << std::setw(30)
        << itr.first
        << std::setw(15)
        << " val ND: "
        << itr.second.Value()
        << " fixed: "
        << std::setw(5)
        << itr.second.IsFixed();
      if(loc.FDLocation().count(itr.first) > 0)
        o << " val FD: "
          << std::setw(15)
          << " "
          << loc.FDLocation().find(itr.first)->second.Value()
          << " fixed: "
          << std::setw(5)
          << itr.second.IsFixed();

      o << std::endl;
    }
    for(auto const& itr : loc.FDLocation()){
      if(loc.NDLocation().count(itr.first) < 1)
       o  << " -- parameter: "
          << std::setw(30)
          << itr.first
          << std::setw(15)
          << " val FD: "
          << itr.second.Value()
          << " fixed: "
          << std::setw(5)
          << itr.second.IsFixed()
          << std::endl;
    }

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::EventId const &	evid
	)

Definition at line 148 of file VarVals.cxx.

References cmf::EventId::cycle, cmf::EventId::event, msf_helper::o, cmf::EventId::run, cmf::EventId::slice, and cmf::EventId::subrun.

  {
    o << "run "
    << evid.run
    << "\tsubrun "
    << evid.subrun
    << "\tevent "
    << evid.event
    << "\tcycle "
    << evid.cycle
    << "\tslice "
    << evid.slice;

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::OscParamPoint const &	hpp
	)

Definition at line 196 of file GridPointResult.cxx.

References cOscParams_Strings, allTimeWatchdog::endl, msf_helper::o, and cmf::OscParamPoint::OscPointAsVec().

  {
    for(auto const& itr : hpp.OscPointAsVec())
      o << cmf::cOscParams_Strings[itr.Param()]
        << " "
        << itr.Value()
        << " ";

    o << std::endl;

    return o;
  }

std::ostream& cmf::operator<< ( std::ostream &  o, SpillSummary const &  ss  )

inline

Definition at line 199 of file Structs.h.

References cmf::SpillSummary::goodPOT, cmf::SpillSummary::liveTime, cmf::SpillSummary::numGoodSpills, msf_helper::o, cmf::SpillSummary::totalNumSpills, and cmf::SpillSummary::totalPOT.

  {
    o << "good POT: "
      << ss.goodPOT
      << " total POT: "
      << ss.totalPOT
      << " live time: "
      << ss.liveTime
      << " good spills: "
      << ss.numGoodSpills
      << " total spills: "
      << ss.totalNumSpills;

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::DataVarVals const &	dvv
	)

Definition at line 209 of file VarVals.cxx.

References allTimeWatchdog::endl, cmf::MetaData::isMC, KeyToVarName(), kFake_Weight, kHad_RecoE, kLep_RecoE, kLep_RecoE_MCFrac, kNu_RecoE, kNuE_CVN, kNuE_NumMichel, kNuESelection, kNuMuSelection, msf_helper::o, cmf::MetaData::selectionType, and cmf::DataVarVals::val_at().

  {
    cmf::MetaData numumd;
    cmf::MetaData nuemd;

    numumd.isMC          = false;
    nuemd .isMC          = false;
    numumd.selectionType = cmf::kNuMuSelection;
    nuemd .selectionType = cmf::kNuESelection;

    o << "Event Data related variables are: "
    << "\n\t" << cmf::KeyToVarName(cmf::kNuE_CVN)          << "      " << dvv.val_at(cmf::kNuE_CVN,          nuemd )
    << "\n\t" << cmf::KeyToVarName(cmf::kNuE_NumMichel)    << "      " << dvv.val_at(cmf::kNuE_NumMichel,    nuemd )
    << "\n\t" << cmf::KeyToVarName(cmf::kHad_RecoE)        << "      " << dvv.val_at(cmf::kHad_RecoE,        nuemd )
    << "\n\t" << cmf::KeyToVarName(cmf::kLep_RecoE)        << "      " << dvv.val_at(cmf::kLep_RecoE,        nuemd )
    << "\n\t" << cmf::KeyToVarName(cmf::kLep_RecoE_MCFrac) << "      " << dvv.val_at(cmf::kLep_RecoE_MCFrac, numumd)
    << "\n\t" << cmf::KeyToVarName(cmf::kNu_RecoE )        << " nue  " << dvv.val_at(cmf::kNu_RecoE,         nuemd )
    << "\n\t" << cmf::KeyToVarName(cmf::kNu_RecoE )        << " numu " << dvv.val_at(cmf::kNu_RecoE,         numumd)
    << "\n\t" << cmf::KeyToVarName(cmf::kFake_Weight)      << "      " << dvv.val_at(cmf::kFake_Weight,      nuemd )
    << std::endl;

    return o;
  }

void cmf::ParameterSetToLocation	(	fhicl::ParameterSet const &	pset,
		cmf::DetType_t const &	det,
		cmf::Location &	loc
	)

Definition at line 10 of file ParameterUtility.cxx.

References fillBadChanDBTables::det, fhicl::ParameterSet::get(), fhicl::ParameterSet::get_names(), cmf::Location::InsertParameter(), fhicl::ParameterSet::is_empty(), LOG_DEBUG, ParseFluxesFile::param, sigma(), string, StringToDetectorType(), fhicl::ParameterSet::to_indented_string(), febshutoff_auto::val, and variance().

Referenced by cmf::CovarianceMatrixFitter::FillDataSpectrum(), cmf::ParameterUtility::Initialize(), and cmf::CovarianceMatrixFitter::writeResults().

  {
    // nothing to be done with an empty parameter set
    if(pset.is_empty()) return;

    fhicl::ParameterSet param;
    bool        fixed;
    bool        nuisance;
    bool        constraint;
    float       centralVal;
    float       variance;
    float       sigma;
    double      val;
    float       lowerBound;
    float       upperBound;
    std::string parstr;
    std::string detstr;

    auto const& parNames = pset.get_names();

    for(auto const& itr : parNames){

      param = pset.get<fhicl::ParameterSet>(itr);

      LOG_DEBUG("ParameterSetToLocation")
          << param.to_indented_string();

      detstr     = param.get<std::string>("Detector",     "BOTH");
      parstr     = param.get<std::string>("Parameter"           );
      fixed      = param.get<bool       >("Fixed",        true  );
      val        = param.get<double     >("Value",        0.    );
      nuisance   = param.get<bool       >("Nuisance",     false );
      sigma      = param.get<float      >("Sigma",        1.e6  );
      centralVal = param.get<float      >("CentralValue", 0.    );
      variance   = param.get<float      >("Variance",     1.e-5 );
      constraint = param.get<bool       >("Constraint",   false );
      lowerBound = param.get<float      >("LoVal",        0.    );
      upperBound = param.get<float      >("HiVal",        1.e6  );

      // remove any Wgt from the parameter name
      if(parstr.find("Wgt") != std::string::npos) parstr.erase(parstr.find("Wgt"), 3);

      if(detstr == "BOTH" || cmf::StringToDetectorType(detstr) == det){
        loc.InsertParameter(cmf::Parameter(parstr,
                                           det,
                                           val,
                                           fixed,
                                           sigma,
                                           centralVal,
                                           variance,
                                           nuisance,
                                           constraint,
                                           lowerBound,
                                           upperBound));

        LOG_DEBUG("ParameterSpaceLoc")
            << "inserting parameter "
            << parstr;

      } // end if using the correct detector

    } // end loop over parameter names

  }

void cmf::ParameterSetToLocation	(	fhicl::ParameterSet const &	pset,
		cmf::DetType_t const &	det,
		cmf::ParameterSpaceLoc &	loc
	)

Definition at line 78 of file ParameterUtility.cxx.

References fillBadChanDBTables::det, fhicl::ParameterSet::get(), fhicl::ParameterSet::get_names(), fhicl::ParameterSet::is_empty(), LOG_DEBUG, ParseFluxesFile::param, sigma(), string, StringToDetectorType(), fhicl::ParameterSet::to_indented_string(), febshutoff_auto::val, and variance().

  {
    // nothing to be done with an empty parameter set
    if(pset.is_empty()) return;

    fhicl::ParameterSet param;
    bool        fixed;
    bool        nuisance;
    bool        constraint;
    float       centralVal;
    float       variance;
    float       sigma;
    double      val;
    float       lowerBound;
    float       upperBound;
    std::string parstr;
    std::string detstr;

    auto const& parNames = pset.get_names();

    for(auto const& itr : parNames){

      param = pset.get<fhicl::ParameterSet>(itr);

      LOG_DEBUG("ParameterSetToLocation")
          << param.to_indented_string();

      detstr     = param.get<std::string>("Detector",     "BOTH");
      parstr     = param.get<std::string>("Parameter"           );
      fixed      = param.get<bool       >("Fixed",        true  );
      val        = param.get<double     >("Value",        0.    );
      nuisance   = param.get<bool       >("Nuisance",     false );
      sigma      = param.get<float      >("Sigma",        1.e6  );
      centralVal = param.get<float      >("CentralValue", 0.    );
      variance   = param.get<float      >("Variance",     1.e-5 );
      constraint = param.get<bool       >("Constraint",   false );
      lowerBound = param.get<float      >("LoVal",        0.    );
      upperBound = param.get<float      >("HiVal",        1.e6  );

      // remove any Wgt from the parameter name
      if(parstr.find("Wgt") != std::string::npos) parstr.erase(parstr.find("Wgt"), 3);

      if(detstr == "BOTH" || cmf::StringToDetectorType(detstr) == det){
        loc.emplace(parstr, cmf::Parameter(parstr,
                                           det,
                                           val,
                                           fixed,
                                           sigma,
                                           centralVal,
                                           variance,
                                           nuisance,
                                           constraint,
                                           lowerBound,
                                           upperBound));

        LOG_DEBUG("ParameterSpaceLoc")
            << "inserting parameter "
            << loc.find(parstr)->second.Name()
                  << " "
                  << loc.find(parstr)->second.Value()
                  << " / "
                  << val;
      
      } // end if using the correct detector

    } // end loop over parameter names

  }

static long cmf::PeriodKey ( long const &  ep )

inlinestatic

Definition at line 16 of file StaticFuncs.h.

Referenced by KeyToBeamType(), KeyToFileType(), KeyToInteractionType(), KeyToSelectionType(), cmf::MetaData::PeriodKey(), and StringToKey().

{ return ep       * 10000000;   }

long cmf::PeriodStringToInt

(

std::string const &

epochStr

)

Definition at line 67 of file Structs.cxx.

References LOG_DEBUG, and LOG_WARNING.

Referenced by cmf::MetaData::MetaData(), and cmf::MetaDataLite::MetaDataLite().

                                                   {
    size_t first = epochStr.find_first_of("abcdefghijklmnopqrstuvwxyz");
    if(first != std::string::npos){
      LOG_WARNING("MetaData")
          << "use of subperiods is deprecated, only full periods are used";

      //auto alpha = epochStr.substr(first, first + 1);
      //return (std::stol(epochStr.substr(0, first).c_str(), nullptr, 0) * 1000 + static_cast<int>(*(alpha.c_str())));
    }

    LOG_DEBUG("MetaData")
    << epochStr
    << " "
    << std::stol(epochStr.substr(0, epochStr.length()).c_str(), nullptr, 0);

    return std::stol(epochStr.substr(0, epochStr.length()).c_str(), nullptr, 0);
  }

static cmf::BeamType_t cmf::PeriodToBeamType ( std::string const &  str )

static

Referenced by cmf::MetaData::BeamType(), InteractionTypeKey(), cmf::EventListManipulator::SetExposures(), StringToDetectorType(), cmf::SelectionUtility::UsesDetAndBeam(), and cmf::SelectionUtility::UsesDetBeamAndSel().

template<class T >

static bool cmf::readSingleResult ( art::Results const &  r, std::string const &  module, std::string const &  instance, std::vector< T > &  resvec  )

static

template<class T >

static bool cmf::readVectorResults ( art::Results const &  r, std::string const &  module, std::string const &  instance, std::vector< T > &  resvec, bool  clearResVec = true  )

static

Referenced by cmf::CombineResults::ReadFakeUniverses(), cmf::CombineResults::ReadOscParamPoints(), cmf::CombineResults::ReadPointResults(), cmf::CovarianceMatrixFitter::readResults(), and cmf::FitFeldmanCousinsPoint::readResults().

template<class T >

static bool cmf::readVectorResults ( art::Results const &  r, std::string const &  module, std::vector< T > &  resvec, bool  clearResVec = true  )

static

float cmf::RecoEnergy ( float  leptonicEnergy, float  hadronicEnergy, cmf::MetaData const &  md  )

inlinestatic

Definition at line 313 of file VarVals.h.

References cmf::MetaData::BeamType(), cmf::MetaData::detector, cmf::MetaData::IsNCSelected(), cmf::MetaData::IsNuESelected(), cmf::MetaData::IsNuMuSelected(), NCEnergy(), NuEEnergy(), NuMuEnergy(), and cmf::MetaData::selectionType.

Referenced by cmf::DataVarVals::DataVars(), FillSpectrumFromSingleList(), cmf::EventListManipulator::FillTextFile(), and cmf::DataVarVals::NuRecoEVal().

{
  if     (md.IsNuMuSelected()) return cmf::NuMuEnergy(leptonicEnergy, hadronicEnergy               );
  else if(md.IsNCSelected()  ) return cmf::NCEnergy  (leptonicEnergy, hadronicEnergy, md.BeamType(), md.detector);
  else if(md.IsNuESelected() ) return cmf::NuEEnergy (leptonicEnergy, hadronicEnergy, md.BeamType());
  else
    throw cet::exception("DataVarVals")
        << "Unknown selection type "
        << md.selectionType
        << " requested to be used in calculating reconstructed energy";

  return std::numeric_limits<float>::lowest();
}

static long cmf::SelectionTypeKey ( cmf::SelectionType_t const &  st )

inlinestatic

Definition at line 19 of file StaticFuncs.h.

Referenced by DetectorBeamSelectionTypesToKey(), cmf::FileExtracts::FileExtracts(), cmf::ChiSqrCalculator::FindReducedMatrixBin(), KeyToInteractionType(), cmf::MetaData::SelectionKey(), and StringToKey().

{ return (st + 1) * 100;        }

void cmf::SerializeEventListColl	(	std::string const &	dirName,
		cmf::EventListColl const &	listColl
	)

Definition at line 117 of file Event.cxx.

References dir, fetch_tb_beamline_files::md, art::TFileDirectory::mkdir(), SerializeEvents(), ss, and cmf::MetaData::ToString().

Referenced by cmf::EventList::AddEvent(), and cmf::CAFToEventList::endJob().

  {

    // make a directory in the output file, and the act of making it puts us
    // into that directory of the file
    art::ServiceHandle<art::TFileService> tfs;
    auto dir = tfs->mkdir(dirName.c_str());

    cmf::MetaData     md;
    cmf::SpillSummary ss;

    // first the metadata tree
    // leave this pointer dangling because the fileService created & manages it
    TTree *metadataTree = dir.make<TTree>( "metadata", "Event list metadata" );
    metadataTree->Branch("metadata",     &md);
    metadataTree->Branch("spillsummary", &ss);

    for(auto const& itr : listColl){

      md = itr.ListMetaData();
      ss = itr.ListSpillSummary();

      metadataTree->Fill();

      // same principle as above for the event tree
      TTree *eventTree = dir.make<TTree>(md.ToString().c_str(), "CovarianceMatrixFit event records");

      cmf::SerializeEvents(eventTree,
                           md,
                           itr);

    } // end loop over the lists
  }

void cmf::SerializeEvents	(	TTree *	eventTree,
		cmf::MetaData const &	md,
		cmf::EventList const &	events
	)

Definition at line 55 of file Event.cxx.

References cmf::DataVars::DataVars(), cmf::MetaData::isMC, kMinus1Sigma, kMinus2Sigma, kPlus1Sigma, kPlus2Sigma, string, cmf::TruthVars::TruthVars(), and cmf::WeightVars::WeightVars().

Referenced by cmf::EventList::AddEvent(), cmf::CMFCappedEventList::Serialize(), and SerializeEventListColl().

  {

    cmf::DataVars    dataVars;
    cmf::TruthVars   truthVars;
    cmf::WeightVars  weightVars;
    cmf::EventId     eventId;

    std::string eventidst("run/I:subrun/I:event/I:cycle/I:slice/I");
    std::string datavarst("fNue_CVN/F:fNuE_NumMichel/F:fHad_RecoE/F:fLep_RecoE/F:fLep_RecoE_MCFrac/F:fRecoQ2/F:fFake_Weight/F");
    std::string weightvst("fXSecCVPPFX_Weight/F:fRPACCQE_Weight/F:fRPARES_Weight/F:fDISvnCC1pi_Weight/F:fEmpiricalMEC_Weight/F:fEmpiricalMECtoGENIEQE_Weight/F:fEmpiricalMECtoGENIERES_Weight/F:fOtherDIS_Weight/F:fXSecCVPPFX2020_Weight/F:fPPFXFluxCV_Weight/F");
    std::string truthvrst("fTrueE/F:fTruePDG/F:fTrueCCNC/F:fTrueIntType/F:fTruePDGOrig/F:fTrueParentPDG/F:fTrueNucHit/F:fTrueParentPT/F:fTrueParentPZ/F:fTrueParentDecay/F:fTrueParentTargetPDG/F:fTrueIntMode/F");

    eventTree->Branch("eventId" , &eventId , eventidst.c_str());
    eventTree->Branch("dataVars", &dataVars, datavarst.c_str());

    std::vector<unsigned char> systVarKeys;
    std::vector<float>         systVarMinus2Wgts;
    std::vector<float>         systVarMinus1Wgts;
    std::vector<float>         systVarPlus1Wgts;
    std::vector<float>         systVarPlus2Wgts;
    if(md.isMC){
      eventTree->Branch("truthVars" ,        &truthVars , truthvrst.c_str());
      eventTree->Branch("weightVars",        &weightVars, weightvst.c_str());
      eventTree->Branch("systVarKeys",       &systVarKeys                  );
      eventTree->Branch("systVarMinus2Wgts", &systVarMinus2Wgts            );
      eventTree->Branch("systVarMinus1Wgts", &systVarMinus1Wgts            );
      eventTree->Branch("systVarPlus1Wgts",  &systVarPlus1Wgts             );
      eventTree->Branch("systVarPlus2Wgts",  &systVarPlus2Wgts             );
    } // end if MC

    for(auto & itr : events){

      eventId    = itr->EventID();
      dataVars   = itr->DataVals().DataVars();

      if(md.isMC){
        truthVars  = itr->MCVals().TruthVars();
        weightVars = itr->MCVals().WeightVars();
        systVarKeys      .clear();
        systVarMinus2Wgts.clear();
        systVarMinus1Wgts.clear();
        systVarPlus1Wgts .clear();
        systVarPlus2Wgts .clear();
        for(auto const& systItr : itr->MCVals().SystematicShifts()){
          systVarKeys.emplace_back(systItr.Type());
          systVarMinus2Wgts.emplace_back(systItr.SigmaWeight(cmf::kMinus2Sigma));
          systVarMinus1Wgts.emplace_back(systItr.SigmaWeight(cmf::kMinus1Sigma));
          systVarPlus1Wgts .emplace_back(systItr.SigmaWeight(cmf::kPlus1Sigma));
          systVarPlus2Wgts .emplace_back(systItr.SigmaWeight(cmf::kPlus2Sigma));
        }
      }

      eventTree->Fill();
    }
  }

static cmf::BeamType_t cmf::StringToBeamType ( std::string const &  str )

inlinestatic

Definition at line 262 of file StaticFuncs.h.

References kFHC, kRHC, and kUnknownBeam.

Referenced by InteractionTypeKey().

{
  if     (str == "RHC") return cmf::kRHC;
  else if(str == "FHC") return cmf::kFHC;

  return cmf::kUnknownBeam;
}

static cmf::ChiSqrCalc_t cmf::StringToChiSqrType ( std::string const &  str )

static

Referenced by InteractionTypeKey(), cmf::FitFeldmanCousinsPoint::reconfigure(), cmf::ContourFromLibrary::reconfigure(), StringToDetectorType(), and cmf::CovarianceMatrixFitter::writeResults().

static cmf::ContourType_t cmf::StringToContourType ( std::string const &  str )

static

Referenced by InteractionTypeKey(), and StringToDetectorType().

static cmf::DetType_t cmf::StringToDetectorType ( std::string const &  str )

inlinestatic

Definition at line 271 of file StaticFuncs.h.

References cOscParams_Strings, MECModelEnuComparisons::i, makeTrainCVSamples::int, IsOscillationParameter(), kAsimovContour, kCNP, kCovMat, kDataContour, kFARDET, kFCContour, kFHC, kGauss, kMedianContour, kNEARDET, kNumOscParams, kPoisson, kRHC, kUnknownBeam, kUnknownChiSqr, kUnknownContour, kUnknownDet, LOG_WARNING, PeriodToBeamType(), submit_syst::str, string, StringToChiSqrType(), StringToContourType(), and StringToOscParmType().

Referenced by InteractionTypeKey(), ParameterSetToLocation(), cmf::EventListManipulator::reconfigure(), and cmf::CAFToEventList::reconfigure().

{
  if     (str.find("Near") != std::string::npos) return cmf::kNEARDET;
  else if(str.find("Far")  != std::string::npos) return cmf::kFARDET;

  return cmf::kUnknownDet;
}

long cmf::StringToKey

(

std::string const &

str

)

Definition at line 15 of file Structs.cxx.

References DetectorTypeKey(), FileTypeKey(), InteractionTypeKey(), kBeam, kCosmicMuon, kDataFile, findDuplicateFiles::key, kFARDET, kNC, kNEARDET, kNuEBarCC, kNuECC, kNuESelection, kNuESelectionHighPID, kNuESelectionLowPID, kNuESelectionMidPID, kNuESelectionPeripheral, kNuMuBarCC, kNuMuCC, kNuMuSelection, kNuMuSelectionQ1, kNuMuSelectionQ2, kNuMuSelectionQ3, kNuMuSelectionQ4, kNuTauBarCC, kNuTauCC, kRockFluxSwap, kRockNonSwap, kSwap, kTauSwap, PeriodKey(), and SelectionTypeKey().

  {
    long key = 0;
    
    // check for the detector
    if     (str.find("Near") != std::string::npos) key += cmf::DetectorTypeKey(cmf::kNEARDET);
    else if(str.find("Far" ) != std::string::npos) key += cmf::DetectorTypeKey(cmf::kFARDET );
    
    // check the period
    if(str.find("Period") != std::string::npos)
      key += cmf::PeriodKey(std::stol(str.substr(str.find("Period") + 6, std::string::npos)));
    else if(str.find("P") != std::string::npos)
      key += cmf::PeriodKey(std::stol(str.substr(str.find("P") + 1, std::string::npos)));

    // check the file type
    if     (str.find("Beam"        )  != std::string::npos) key += cmf::FileTypeKey(cmf::kBeam        );
    else if(str.find("TauSwap"     )  != std::string::npos) key += cmf::FileTypeKey(cmf::kTauSwap     );
    else if(str.find("FluxSwap"    )  != std::string::npos) key += cmf::FileTypeKey(cmf::kSwap        );
    else if(str.find("RockFluxSwap")  != std::string::npos) key += cmf::FileTypeKey(cmf::kRockFluxSwap);
    else if(str.find("RockNonSwap" )  != std::string::npos) key += cmf::FileTypeKey(cmf::kRockNonSwap );
    else if(str.find("Data"        )  != std::string::npos) key += cmf::FileTypeKey(cmf::kDataFile    );
    
    // check for a selection
    if     (str.find("NuMuSelQ1"        ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelectionQ1       );
    else if(str.find("NuMuSelQ2"        ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelectionQ2       );
    else if(str.find("NuMuSelQ3"        ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelectionQ3       );
    else if(str.find("NuMuSelQ4"        ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelectionQ4       );
    else if(str.find("NuMuSel"          ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuMuSelection         );
    else if(str.find("NuESel_AllPID"    ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelection          );
    else if(str.find("NuESel_LowPID"    ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelectionLowPID    );
    else if(str.find("NuESel_MidPID"    ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelectionMidPID    );
    else if(str.find("NuESel_HighPID"   ) != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelectionHighPID   );
    else if(str.find("NuESel_Peripheral") != std::string::npos) key += cmf::SelectionTypeKey(cmf::kNuESelectionPeripheral);
    
    // check for an interaction type
    if     (str.find("NuMuCC"    ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuMuCC    );
    else if(str.find("NuMuBarCC" ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuMuBarCC );
    else if(str.find("NuECC"     ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuECC     );
    else if(str.find("NuEBarCC"  ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuEBarCC  );
    else if(str.find("NuTauCC"   ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuTauCC   );
    else if(str.find("NuTauBarCC") != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNuTauBarCC);
    else if(str.find("NC"        ) != std::string::npos) key += cmf::InteractionTypeKey(cmf::kNC        );
    else if(str.find("CosmicMuon") != std::string::npos) key += cmf::InteractionTypeKey(cmf::kCosmicMuon);

    // check if this is data or MC, multiply by +/- 1 depending on the answer
    if     (str.find("MC")   != std::string::npos)   key *=  1;
    else if(str.find("Data") != std::string::npos)   key *= -1;

    return key;
  }

static cmf::OscParm_t cmf::StringToOscParmType ( std::string const &  str )

static

Referenced by cmf::CombineResults::CombineResults(), cmf::CovarianceFitHelper::FindInitialGuess(), cmf::SpectrumPredictionMaker::FindOscillationPoints(), FitFunction_ForROOT(), cmf::SpectrumPredictionMaker::Initialize(), InteractionTypeKey(), cmf::Parameter::Parameter(), cmf::FitFeldmanCousinsPoint::reconfigure(), cmf::ContourFromLibrary::reconfigure(), cmf::CovarianceFitHelper::Result(), and StringToDetectorType().

static cmf::SelectionType_t cmf::StringToSelectionType ( std::string const &  str )

inlinestatic

Definition at line 245 of file StaticFuncs.h.

References kNCSelection, kNuESelection, kNuESelectionHighPID, kNuESelectionLowPID, kNuESelectionPeripheral, kNuMuSelection, kNuMuSelectionQ1, kNuMuSelectionQ2, kNuMuSelectionQ3, kNuMuSelectionQ4, and kUnknownSelection.

Referenced by cmf::SelectionUtility::Initialize(), and InteractionTypeKey().

{
  if     (str == "NuESel_LowPID"    ) return cmf::kNuESelectionLowPID;
  else if(str == "NuESel_HighPID"   ) return cmf::kNuESelectionHighPID;
  else if(str == "NuESel_Peripheral") return cmf::kNuESelectionPeripheral;
  else if(str == "NuESel_AllPID"    ) return cmf::kNuESelection;
  else if(str == "NuMuSel"          ) return cmf::kNuMuSelection;
  else if(str == "NuMuSelQ1"        ) return cmf::kNuMuSelectionQ1;
  else if(str == "NuMuSelQ2"        ) return cmf::kNuMuSelectionQ2;
  else if(str == "NuMuSelQ3"        ) return cmf::kNuMuSelectionQ3;
  else if(str == "NuMuSelQ4"        ) return cmf::kNuMuSelectionQ4;
  else if(str == "NCSel"            ) return cmf::kNCSelection;

  return cmf::kUnknownSelection;
}

static uint8_t cmf::VarNameToKey ( std::string const &  name )

inlinestatic

Definition at line 381 of file StaticFuncs.h.

References febshutoff_auto::end, kUnknownVar, kVarNameToKey(), and LOG_VERBATIM.

Referenced by cmf::ShifterAndWeighter::CMFSystVarWeight(), cmf::CAFToEventList::FillMCVals(), InteractionTypeKey(), and cmf::Parameter::Parameter().

{
  auto const& itr = cmf::kVarNameToKey.find(name);
  if(itr != cmf::kVarNameToKey.end()) return itr->second;
  // if     (name.find("NuE_CVN")          != std::string::npos) return cmf::kNuE_CVN;
  // else if(name.find("NuE_NumMichel")    != std::string::npos) return cmf::kNuE_NumMichel;
  // else if(name.find("Had_RecoE")        != std::string::npos) return cmf::kHad_RecoE;
  // else if(name.find("Lep_RecoE")        != std::string::npos) return cmf::kLep_RecoE;
  // else if(name.find("Nu_RecoE")         != std::string::npos) return cmf::kNu_RecoE;
  // else if(name.find("Lep_RecoE_MCFrac") != std::string::npos) return cmf::kLep_RecoE_MCFrac;
  // else if(name.find("Reco_Q2")          != std::string::npos) return cmf::kRecoQ2;
  // else if(name.find("Fake_Weight")      != std::string::npos) return cmf::kFake_Weight;

  // else if(name.find("TrueE")               != std::string::npos) return cmf::kTrueE;
  // else if(name.find("TruePDG")             != std::string::npos) return cmf::kTruePDG;
  // else if(name.find("TrueCCNC")            != std::string::npos) return cmf::kTrueCCNC;
  // else if(name.find("TrueIntType")         != std::string::npos) return cmf::kTrueIntType;
  // else if(name.find("TruePDGOrig")         != std::string::npos) return cmf::kTruePDGOrig;
  // else if(name.find("TrueParentPDG")       != std::string::npos) return cmf::kTrueParentPDG;
  // else if(name.find("TrueParentPT")        != std::string::npos) return cmf::kTrueParentPT;
  // else if(name.find("TrueParentPZ")        != std::string::npos) return cmf::kTrueParentPZ;
  // else if(name.find("TrueParentDecay")     != std::string::npos) return cmf::kTrueParentDecay;
  // else if(name.find("TrueParentTargetPDG") != std::string::npos) return cmf::kTrueParentTargetPDG;
  // else if(name.find("TrueHitNuc")          != std::string::npos) return cmf::kTrueHitNuc;
  // else if(name.find("TrueIntMode")         != std::string::npos) return cmf::kTrueIntMode;

  // // TODO change XSecCVWgt to include PPFX label
  // // else if(name.find("XsecCVWgt")  != std::string::npos) return cmf::kXSecCVPPFX_Weight;
  // else if(name.find("XsecCV2020") != std::string::npos) return cmf::kXSecCV2020Wgt;
  // else if(name.find("PPFXFluxCV") != std::string::npos) return cmf::kPPFXFluxCVWgt;
  // else if(name.find("RPARES")     != std::string::npos) return cmf::kRPARES_Weight;
  
  // // Variables for the size of a shift
  // else if(name.find("-2sigma") != std::string::npos) return cmf::kMinus2Sigma;
  // else if(name.find("-1sigma") != std::string::npos) return cmf::kMinus1Sigma;
  // else if(name.find("+1sigma") != std::string::npos) return cmf::kPlus1Sigma;
  // else if(name.find("+2sigma") != std::string::npos) return cmf::kPlus2Sigma;

  // // Calibration
  // else if(name.find("lightmodel-lightdown") != std::string::npos) return cmf::kLightModelLightDownCalibUp;
  // else if(name.find("lightmodel-lightup")   != std::string::npos) return cmf::kLightModelLightUpCalibDown;
  // else if(name.find("ckv-proton")           != std::string::npos) return cmf::kCkvProtonShiftDown;
  // else if(name.find("RelativeCalibration")  != std::string::npos) return cmf::kRelativeCalibration;
  // else if(name.find("AbsoluteCalibration")  != std::string::npos) return cmf::kAbsoluteCalibration;
  // else if(name.find("CalibrationShape")     != std::string::npos) return cmf::kCalibShape;

  // //GENIE knobs

  // // NC elastic parameters
  // else if(name.find("MaNCEL")  != std::string::npos) return cmf::kMaNCEL;
  // else if(name.find("EtaNCEL") != std::string::npos) return cmf::kEtaNCEL;

  // // DIS tweaking parameters
  // else if(name.find("AhtBY")  != std::string::npos) return cmf::kAhtBY;
  // else if(name.find("BhtBY")  != std::string::npos) return cmf::kBhtBY;
  // else if(name.find("CV1uBY") != std::string::npos) return cmf::kCV1uBY;
  // else if(name.find("CV2uBY") != std::string::npos) return cmf::kCV2uBY;

  // // Hadronization (free nucleon target)
  // else if(name.find("AGKY_xF1pi") != std::string::npos) return cmf::kAGKY_xF1pi;
  // else if(name.find("AGKY_pT1pi") != std::string::npos) return cmf::kAGKY_pT1pi;

  // // Resonance decays
  // else if(name.find("BR1gamma")        != std::string::npos) return cmf::kBR1gamma;
  // else if(name.find("BR1eta")          != std::string::npos) return cmf::kBR1eta;
  // else if(name.find("Theta_Delta2Npi") != std::string::npos) return cmf::kTheta_Delta2Npi;

  // else if(name.find("MvCCRES")          != std::string::npos) return cmf::kMvCCRES;
  // else if(name.find("MaCCRES")          != std::string::npos) return cmf::kMaCCRES;
  // else if(name.find("MaNCRES")          != std::string::npos) return cmf::kMaNCRES;
  // else if(name.find("RPACCQEshapeEnh")  != std::string::npos) return cmf::kRPACCQEshapeEnh;
  // else if(name.find("RPACCQEshapeSupp") != std::string::npos) return cmf::kRPACCQEshapeSupp;

  // // coherent scattering
  // else if(name.find("COHCCScale2018") != std::string::npos) return cmf::kCOHCCScaleSyst2018; 
  // else if(name.find("COHNCScale2018") != std::string::npos) return cmf::kCOHNCScaleSyst2018; 

  // // 2020
  // else if(name.find("ZExpAxialFFSyst2020_eV1")           != std::string::npos) return cmf::kZExpEV1Syst2020;
  // else if(name.find("ZExpAxialFFSyst2020_eV2")           != std::string::npos) return cmf::kZExpEV2Syst2020;
  // else if(name.find("ZExpAxialFFSyst2020_eV3")           != std::string::npos) return cmf::kZExpEV3Syst2020;
  // else if(name.find("ZExpAxialFFSyst2020_eV4")           != std::string::npos) return cmf::kZExpEV4Syst2020;
  // else if(name.find("ZNormCCQE")                         != std::string::npos) return cmf::kZNormCCQE;
  // else if(name.find("RESLowQ2SuppSyst2020")              != std::string::npos) return cmf::kRESLowQ2SuppSyst2020;
  // else if(name.find("hNFSISyst2020_MFP")                 != std::string::npos) return cmf::khNFSISyst2020_MFP;
  // else if(name.find("hNFSISyst2020_EV1")                 != std::string::npos) return cmf::khNFSISyst2020_EV1;
  // else if(name.find("MECEnuShapeSyst2020Nu")             != std::string::npos) return cmf::kMECEnuShapeSyst2020Nu;
  // else if(name.find("MECEnuShapeSyst2020AntiNu")         != std::string::npos) return cmf::kMECEnuShapeSyst2020AntiNu;
  // else if(name.find("MECShapeSyst2020Nu")                != std::string::npos) return cmf::kMECShapeSyst2020Nu;
  // else if(name.find("MECShapeSyst2020AntiNu")            != std::string::npos) return cmf::kMECShapeSyst2020AntiNu;
  // else if(name.find("MECInitStateNPFracSyst2020Nu")      != std::string::npos) return cmf::kMECInitStateNPFracSyst2020Nu;
  // else if(name.find("MECInitStateNPFracSyst2020AntiNu")  != std::string::npos) return cmf::kMECInitStateNPFracSyst2020AntiNu;
  // else if(name.find("RadCorrNue")                        != std::string::npos) return cmf::kRadCorrNue;
  // else if(name.find("RadCorrNuebar")                     != std::string::npos) return cmf::kRadCorrNuebar;
  // else if(name.find("2ndClassCurrs")                     != std::string::npos) return cmf::k2ndClassCurrs;
  // else if(name.find("GENIEPCA00")                        != std::string::npos) return cmf::kGENIEPCA00;
  // else if(name.find("GENIEPCA01")                        != std::string::npos) return cmf::kGENIEPCA01;
  // else if(name.find("GENIEPCA02")                        != std::string::npos) return cmf::kGENIEPCA02;
  // else if(name.find("GENIEPCA03")                        != std::string::npos) return cmf::kGENIEPCA03;
  // else if(name.find("GENIEPCA04")                        != std::string::npos) return cmf::kGENIEPCA04;
  // else if(name.find("GENIEPCA05")                        != std::string::npos) return cmf::kGENIEPCA05;
  // else if(name.find("GENIEPCA06")                        != std::string::npos) return cmf::kGENIEPCA06;
  // else if(name.find("GENIEPCA07")                        != std::string::npos) return cmf::kGENIEPCA07;
  // else if(name.find("GENIEPCA08")                        != std::string::npos) return cmf::kGENIEPCA08;
  // else if(name.find("GENIEPCA09")                        != std::string::npos) return cmf::kGENIEPCA09;
  // else if(name.find("GENIEPCA10")                        != std::string::npos) return cmf::kGENIEPCA10;
  // else if(name.find("GENIEPCA11")                        != std::string::npos) return cmf::kGENIEPCA11;
  // else if(name.find("MvNCRES")                           != std::string::npos) return cmf::kMvNCRES;
  // else if(name.find("UnCorrNDMuEScaleSyst2020")          != std::string::npos) return cmf::kUnCorrNDMuEScaleSyst2020         ;
  // else if(name.find("UnCorrMuCatMuESyst2020")            != std::string::npos) return cmf::kUnCorrMuCatMuESyst2020           ;
  // else if(name.find("PileupMuESyst2020")                 != std::string::npos) return cmf::kPileupMuESyst2020                ;
  // else if(name.find("CorrMuEScaleSyst2020")              != std::string::npos) return cmf::kCorrMuEScaleSyst2020             ;
  // else if(name.find("NeutronVisEScalePrimariesSyst2018") != std::string::npos) return cmf::kNeutronVisEScalePrimariesSyst2018;
  // else if(name.find("MichelTaggingSyst2020")             != std::string::npos) return cmf::kMichelTaggingSyst2020            ;
  // else if(name.find("Ana2020NormFHC")                    != std::string::npos) return cmf::kAna2020NormFHC                   ;
  // else if(name.find("Ana2020NormRHC")                    != std::string::npos) return cmf::kAna2020NormRHC                   ;
  // else if(name.find("Norm_1Nux"   )                      != std::string::npos) return cmf::kNorm_1Nux                        ;
  // else if(name.find("MeanQ0_1Nux" )                      != std::string::npos) return cmf::kMeanQ0_1Nux                      ;
  // else if(name.find("MeanQ3_1Nux" )                      != std::string::npos) return cmf::kMeanQ3_1Nux                      ;
  // else if(name.find("SigmaQ0_1Nux")                      != std::string::npos) return cmf::kSigmaQ0_1Nux                     ;
  // else if(name.find("SigmaQ3_1Nux")                      != std::string::npos) return cmf::kSigmaQ3_1Nux                     ;
  // else if(name.find("Corr_1Nux")                         != std::string::npos) return cmf::kCorr_1Nux                        ;
  // else if(name.find("Norm_2Nux"   )                      != std::string::npos) return cmf::kNorm_2Nux                        ;
  // else if(name.find("MeanQ0_2Nux" )                      != std::string::npos) return cmf::kMeanQ0_2Nux                      ;
  // else if(name.find("MeanQ3_2Nux" )                      != std::string::npos) return cmf::kMeanQ3_2Nux                      ;
  // else if(name.find("SigmaQ0_2Nux")                      != std::string::npos) return cmf::kSigmaQ0_2Nux                     ;
  // else if(name.find("SigmaQ3_2Nux")                      != std::string::npos) return cmf::kSigmaQ3_2Nux                     ;
  // else if(name.find("Corr_2Nux")                         != std::string::npos) return cmf::kCorr_2Nux                        ;
  // else if(name.find("BaselineNux")                       != std::string::npos) return cmf::kBaselineNux                      ;
  // else if(name.find("TauScaleSyst")                      != std::string::npos) return cmf::kTauScaleSyst                     ;
  // else if(name.find("DISvpCC0pi_2020")                   != std::string::npos) return cmf::kDISvpCC0pi_2020                 ;
  // else if(name.find("DISvpCC1pi_2020")                   != std::string::npos) return cmf::kDISvpCC1pi_2020                 ;
  // else if(name.find("DISvpCC2pi_2020")                   != std::string::npos) return cmf::kDISvpCC2pi_2020                 ;
  // else if(name.find("DISvpCC3pi_2020")                   != std::string::npos) return cmf::kDISvpCC3pi_2020                 ;
  // else if(name.find("DISvpNC0pi_2020")                   != std::string::npos) return cmf::kDISvpNC0pi_2020                 ;
  // else if(name.find("DISvpNC1pi_2020")                   != std::string::npos) return cmf::kDISvpNC1pi_2020                 ;
  // else if(name.find("DISvpNC2pi_2020")                   != std::string::npos) return cmf::kDISvpNC2pi_2020                 ;
  // else if(name.find("DISvpNC3pi_2020")                   != std::string::npos) return cmf::kDISvpNC3pi_2020                 ;
  // else if(name.find("DISvnCC0pi_2020")                   != std::string::npos) return cmf::kDISvnCC0pi_2020                 ;
  // else if(name.find("DISvnCC1pi_2020")                   != std::string::npos) return cmf::kDISvnCC1pi_2020                 ;
  // else if(name.find("DISvnCC2pi_2020")                   != std::string::npos) return cmf::kDISvnCC2pi_2020                 ;
  // else if(name.find("DISvnCC3pi_2020")                   != std::string::npos) return cmf::kDISvnCC3pi_2020                 ;
  // else if(name.find("DISvnNC0pi_2020")                   != std::string::npos) return cmf::kDISvnNC0pi_2020                 ;
  // else if(name.find("DISvnNC1pi_2020")                   != std::string::npos) return cmf::kDISvnNC1pi_2020                 ;
  // else if(name.find("DISvnNC2pi_2020")                   != std::string::npos) return cmf::kDISvnNC2pi_2020                 ;
  // else if(name.find("DISvnNC3pi_2020")                   != std::string::npos) return cmf::kDISvnNC3pi_2020                 ;
  // else if(name.find("DISvbarpCC0pi_2020")                != std::string::npos) return cmf::kDISvbarpCC0pi_2020              ;
  // else if(name.find("DISvbarpCC1pi_2020")                != std::string::npos) return cmf::kDISvbarpCC1pi_2020              ;
  // else if(name.find("DISvbarpCC2pi_2020")                != std::string::npos) return cmf::kDISvbarpCC2pi_2020              ;
  // else if(name.find("DISvbarpCC3pi_2020")                != std::string::npos) return cmf::kDISvbarpCC3pi_2020              ;
  // else if(name.find("DISvbarpNC0pi_2020")                != std::string::npos) return cmf::kDISvbarpNC0pi_2020              ;
  // else if(name.find("DISvbarpNC1pi_2020")                != std::string::npos) return cmf::kDISvbarpNC1pi_2020              ;
  // else if(name.find("DISvbarpNC2pi_2020")                != std::string::npos) return cmf::kDISvbarpNC2pi_2020              ;
  // else if(name.find("DISvbarpNC3pi_2020")                != std::string::npos) return cmf::kDISvbarpNC3pi_2020              ;
  // else if(name.find("DISvbarnCC0pi_2020")                != std::string::npos) return cmf::kDISvbarnCC0pi_2020              ;
  // else if(name.find("DISvbarnCC1pi_2020")                != std::string::npos) return cmf::kDISvbarnCC1pi_2020              ;
  // else if(name.find("DISvbarnCC2pi_2020")                != std::string::npos) return cmf::kDISvbarnCC2pi_2020              ;
  // else if(name.find("DISvbarnCC3pi_2020")                != std::string::npos) return cmf::kDISvbarnCC3pi_2020              ;
  // else if(name.find("DISvbarnNC0pi_2020")                != std::string::npos) return cmf::kDISvbarnNC0pi_2020              ;
  // else if(name.find("DISvbarnNC1pi_2020")                != std::string::npos) return cmf::kDISvbarnNC1pi_2020              ;
  // else if(name.find("DISvbarnNC2pi_2020")                != std::string::npos) return cmf::kDISvbarnNC2pi_2020              ;
  // else if(name.find("DISvbarnNC3pi_2020")                != std::string::npos) return cmf::kDISvbarnNC3pi_2020              ;
  // else if(name.find("FormZone_2020")                     != std::string::npos) return cmf::kFormZone_2020                   ;
  // else if(name.find("hNFSISyst2020_EV2")                 != std::string::npos) return cmf::khNFSISyst2020_EV2               ;
  // else if(name.find("hNFSISyst2020_EV3")                 != std::string::npos) return cmf::khNFSISyst2020_EV3               ;
  // else if(name.find("COHCCScaleSyst2018")                != std::string::npos) return cmf::kCOHCCScaleSyst2018              ;
  // else if(name.find("COHNCScaleSyst2018")                != std::string::npos) return cmf::kCOHNCScaleSyst2018              ;

  LOG_VERBATIM("VarNameToKey")
    << "Variable name "
    << name
    << " does not correspond to any key, returning 0";

  return cmf::kUnknownVar;
}

Variable Documentation

const std::string cmf::cBeamType_LatexStrings[4]

Initial value:

= { "FHC",
                                                  "RHC",
                                                  "0HC"
                                                  "Unknown Beam" }

Definition at line 56 of file Constants.h.

Referenced by cmf::CovarianceFitHelper::Make1DSpectra(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), and cmf::MetaData::ToStringLatex().

const std::string cmf::cBeamType_Strings[4]

Initial value:

= {"FHC",
                                            "RHC",
                                            "0HC",
                                            "UnknownBeam"}

Definition at line 51 of file Constants.h.

Referenced by cmf::CovarianceMatrixMaker::beginJob(), cmf::CalibSyst::CalibSystRatio(), cmf::EventListManipulator::FillTextFile(), cmf::CovarianceBinUtility::KeyToOffset(), KeyToString(), cmf::CalibSyst::LoadCalibSystRatios(), cmf::CovarianceFitHelper::Make1DSpectra(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), cmf::ShifterAndWeighter::NueAcceptSignalKin2018Weight(), and cmf::MetaData::ToString().

const std::string cmf::cChiSqrCalcType_Strings[5]

Initial value:

= {"CovMat",
                                                  "Poisson",
                                                  "CNP",
                                                  "Gauss",
                                                  "UnknownChiSqr"}

Definition at line 70 of file Constants.h.

Referenced by cmf::CovarianceFitHelper::MakeIterationGraphs().

const std::string cmf::cContourTypeStrings[5]

Initial value:

= {"Asimov",
                                              "Median",
                                              "Feldman-Cousins",
                                              "Data",
                                              "UnknownContour"}

Definition at line 345 of file Constants.h.

const std::string cmf::cDetType_Strings[5]

Initial value:

= {"UnknownDet",
                                           "Near",
                                           "Far",
                                           "MINOSNear",
                                           "MINOSFar"}

Definition at line 29 of file Constants.h.

Referenced by cmf::CovarianceMatrixMaker::beginJob(), cmf::MetaData::DetectorString(), cmf::ShifterAndWeighter::InitShiftsAndWeightsForDetector(), cmf::CovarianceBinUtility::KeyToOffset(), KeyToString(), cmf::CalibSyst::LoadCalibSystRatios(), cmf::SpectrumPredictionMaker::MakePredictions(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), and cmf::RandomUniverses::writeResults().

const std::string cmf::cFileTypeStrings[10]

Initial value:

= {"Beam",
                                            "FluxSwap",
                                            "TauSwap",
                                            "Data",
                                            "CosmicBackground",
                                            "RockFluxSwap",
                                            "RockNonSwap",
                                            "num_file_types",
                                            "bad_file_type",
                                            "UnknownFileType"}

Definition at line 176 of file Constants.h.

Referenced by cmf::MetaData::DetectorFilePeriodString(), KeyToString(), cmf::CovarianceFitHelper::Make1DSpectra(), and cmf::MetaData::ToString().

const std::string cmf::cFileTypeStrings_Latex[10]

Initial value:

= {"Beam",
                                                  "Flux Swap",
                                                  "#tau Swap",
                                                  "Data",
                                                  "Cosmic #mu Background",
                                                  "Rock Flux Swap #mu Background",
                                                  "Rock Non Swap #mu Background",
                                                  "num_file_types",
                                                  "bad_file_type",
                                                  "none_set"}

Definition at line 187 of file Constants.h.

Referenced by cmf::MetaData::ToStringLatex().

const std::string cmf::cInteractionType_LatexStrings[11]

Initial value:

={"Unknown Interaction",
                                                       "#nu_{#mu} CC",
                                                       "#bar{#nu}_{#mu} CC",
                                                       "#nu_{e} CC",
                                                       "#bar{#nu}_{e} CC",
                                                       "#nu_{#tau} CC",
                                                       "#bar{#nu}_{#tau} CC",
                                                       "NC",
                                                       "Cosmic Muon",
                                                       "Rock Muon",
                                                       "Uncategorised Interaction"}

Definition at line 137 of file Constants.h.

Referenced by cmf::MetaData::ToStringLatex().

const std::string cmf::cInteractionType_Strings[11]

Initial value:

={"UnknownInteraction",
                                                  "NuMuCC",
                                                  "NuMuBarCC",
                                                  "NuECC",
                                                  "NuEBarCC",
                                                  "NuTauCC",
                                                  "NuTauBarCC",
                                                  "NC",
                                                  "CosmicMuon",
                                                  "RockMuon",
                                                  "UncategorisedInteraction"}

Definition at line 149 of file Constants.h.

Referenced by KeyToString(), cmf::CMFSpectraMaker::reconfigure(), and cmf::MetaData::ToString().

const std::string cmf::cOscParams_LatexScales[kNumOscParams]

Initial value:

= {" (m)",
                                                             " (g/cc)",
                                                             " (#times10^{-5} eV^{2})",
                                                             " (#times10^{-3} eV^{2})",
                                                             "",
                                                             "",
                                                             "",
                                                             " (#pi rad)",
                                                             "",
                                                             "",
                                                             "",
                                                             "(eV^{2})",
                                                             " (#pi rad)",
                                                             "",
                                                             "",                                                             "",
                                                             "",
                                                             "",
                                                             "",
                                                             "",
                                                             "",
                                                             ""}

Definition at line 250 of file Constants.h.

Referenced by cmf::FitFeldmanCousinsPoint::beginJob(), and cmf::PlotUtilities::Initialize().

const double cmf::cOscParams_Scales[kNumOscParams]

Initial value:

= {1.,
                                                        1.,
                                                        1.e5,
                                                        1.e3,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1. / 3.14159,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1. / 3.14159,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1.,
                                                        1.}

Definition at line 227 of file Constants.h.

Referenced by cmf::FitFeldmanCousinsPoint::beginJob(), cmf::FitFeldmanCousinsPoint::FillHistograms(), cmf::PlotUtilities::Initialize(), and cmf::ContourFromLibrary::MakeAndStorePlots().

const std::string cmf::cOscParams_Strings[kNumOscParams]

Initial value:

= {"L",
                                                         "Rho",
                                                         "Dmsq21",
                                                         "Dmsq32",
                                                         "Th12",
                                                         "Th13",
                                                         "Th23",
                                                         "dCP",
                                                         "Th14",
                                                         "Th24",
                                                         "Th34",
                                                         "Dmsq41",
                                                         "d24",
                                                         "Eps_ee",
                                                         "Eps_emu",
                                                         "Eps_etau",
                                                         "Eps_mumu",
                                                         "Eps_mutau",
                                                         "Eps_tautau",
                                                         "Delta_emu",
                                                         "Delta_etau",
                                                         "Delta_mutau"}

Definition at line 272 of file Constants.h.

Referenced by cmf::ChiSqrCalculator::ChiSqr(), cmf::ContourFromLibrary::ContourForUniverse(), cmf::ContourFromLibrary::endJob(), cmf::SpectrumPredictionMaker::FindOscillationPoints(), cmf::PlotUtilities::Initialize(), cmf::SpectrumPredictionMaker::Initialize(), cmf::PlotUtilities::Make1DPlot(), cmf::PlotUtilities::Make2DContours(), cmf::PlotUtilities::Make2DHist(), cmf::ContourFromLibrary::MakeAndStorePlots(), cmf::PlotUtilities::MakeCLHeatMaps(), cmf::SpectrumPredictionMaker::MakeHiddenParameterHistograms(), cmf::Parameter::Name(), operator<<(), and StringToDetectorType().

const std::string cmf::cOscParams_Strings_Latex[kNumOscParams]

Initial value:

= {"L",
                                                               "#rho",
                                                               "#Delta m^{2}_{21}",
                                                               "#Delta m^{2}_{32}",
                                                               "#theta_{12}",
                                                               "#theta_{13}",
                                                               "#theta_{23}",
                                                               "#delta_{CP}",
                                                               "#theta_{14}",
                                                               "#theta_{24}",
                                                               "#theta_{34}",
                                                               "#Delta m^{2}_{41}",
                                                               "#delta_{24}",
                                                               "#epsilon_{ee}",
                                                               "#epsilon_{e#mu}",
                                                               "#epsilon_{e#tau}",
                                                               "#epsilon_{#mu#mu}",
                                                               "#epsilon_{#mu#tau}",
                                                               "#epsilon_{#tau#tau}",
                                                               "#delta_{e#mu}",
                                                               "#delta_{e#tau}",
                                                               "#delta_{#mu#tau}"}

Definition at line 295 of file Constants.h.

Referenced by cmf::FitFeldmanCousinsPoint::beginJob(), cmf::PlotUtilities::Make1DPlot(), cmf::PlotUtilities::Make2DContours(), and cmf::PlotUtilities::MakeGeneric2DHist().

const std::string cmf::cSelectionType_LatexStrings[12]

Initial value:

= {"#nu_{e} Selection",
                                                       "#nu_{e} Selection - Low PID",
                                                       "#nu_{e} Selection - Mid PID",
                                                       "#nu_{e} Selection - High PID",
                                                       "#nu_{e} Selection - Peripheral",
                                                       "#nu_{#mu} Selection",
                                                       "#nu_{#mu} Selection - Quantile 1",
                                                       "#nu_{#mu} Selection - Quantile 2",
                                                       "#nu_{#mu} Selection - Quantile 3",
                                                       "#nu_{#mu} Selection - Quantile 4",
                                                       "NC Selection",
                                                       "Unknown Selection"}

Definition at line 106 of file Constants.h.

Referenced by cmf::CovarianceFitHelper::Make1DSpectra(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), and cmf::MetaData::ToStringLatex().

const std::string cmf::cSelectionType_Strings[12]

Initial value:

= {"NuESel_AllPID",
                                                  "NuESel_LowPID",
                                                  "NuESel_MidPID",
                                                  "NuESel_HighPID",
                                                  "NuESel_Peripheral",
                                                  "NuMuSel",
                                                  "NuMuSelQ1",
                                                  "NuMuSelQ2",
                                                  "NuMuSelQ3",