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	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
struct	FileExtracts
class	FitFeldmanCousinsPoint
class	GeniePCASyst
struct	GENIEVar
struct	GENIEVars
class	GridPoint
struct	HiddenParameterConfig
class	InputPoint
struct	Location
class	MCVarVals
	Base container for the MC related Vars that constitute an event. More...
struct	MetaData
struct	MetaDataLite
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
struct	SystVar
struct	TruthVars
struct	WeightVars

Typedefs
typedef std::unique_ptr< Event >	EventPtr
typedef std::vector< EventPtr >	EventContainer
typedef std::map< cmf::MetaData, cmf::EventList >	EventListColl
typedef std::vector< cmf::SystVar >	SystVarColl
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::weight_type	WeightType_t
typedef enum cmf::det_type	DetType_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

Enumerations
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,   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, kXSecCVWgt2020, kPPFXFluxCVWgt,   kRPACCQE_Weight, kRPARES_Weight, kDISvnCC1pi_Weight, kEmpiricalMEC_Weight,   kEmpiricalMECtoGENIEQE_Weight, kEmpiricalMECtoGENIERES_Weight, kOtherDIS_Weight, kMinus2Sigma,   kMinus1Sigma, kPlus1Sigma, kPlus2Sigma, kFirstSigmaVar,   kMaCCRES =kFirstSigmaVar, kMvCCRES, kMaNCRES, kRPACCQEshapeEnh,   kRPACCQEshapeSupp, kGENIEPCA0, kGENIEPCA1, kGENIEPCA2,   kGENIEPCA3, kGENIEPCA4, kGENIEPCA5, kGENIEPCA6,   kGENIEPCA7, kGENIEPCA8, kGENIEPCA9, kGENIEPCA10,   kGENIEPCA11, kMvNCRES, kZNormCCQE, kZExpEV1Syst2020,   kZExpEV2Syst2020, kZExpEV3Syst2020, kZExpEV4Syst2020, kRESLowQ2SuppSyst2020,   kDISvnCC1piWgt_2020, khNFSISyst2020_MFP, khNFSISyst2020_EV1, kMECEnuShapeSyst2020Nu,   kMECEnuShapeSyst2020AntiNu, kMECShapeSyst2020Nu, kMECShapeSyst2020AntiNu, kMECInitStateNPFracSyst2020Nu,   kMECInitStateNPFracSyst2020AntiNu, kRadCorrNue, kRadCorrNuebar, k2ndClassCurrs,   kUnCorrNDMuEScaleSyst2020, kUnCorrMuCatMuESyst2020, kPileupMuESyst2020, kCorrMuEScaleSyst2020,   kNeutronVisEScalePrimariesSyst2018, kMichelTaggingSyst2020, kAna2020NormFHC, kAna2020NormRHC,   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, kTauScaleSyst, kLastSigmaVar =kTauScaleSyst, kLightModelLightDownCalibUp,   kLightModelLightUpCalibDown, kCkvProtonShiftDown, kRelativeCalibration, kAbsoluteCalibration,   kCalibShape, kMaNCEL, kEtaNCEL, kVecCCQE_shape,   kMaCOHpi, kR0COHpi, kAhtBY, kBhtBY,   kCV1uBY, kCV2uBY, kNormDISCC, kRnubarnuCC,   kDISNuclMod, kAGKY_xF1pi, kAGKY_pT1pi, kMFP_pi,   kMFP_N, kFrCEx_pi, kFrElas_pi, kFrAbs_pi,   kFrPiProd_pi, kFrInel_N, kFrPiProd_N, kCCQEMomDistroFGtoSF,   kBR1gamma, kBR1eta, kTheta_Delta2Npi }
enum	weight_type { kSystWgtOnly =0, kOscWgtOnly, kSystAndOscWgt, kAllWgt }
enum	det_type {   kUnknownDet = 0, kNEARDET, kFARDET, kMINOSNEAR,   kMINOSFAR }

Functions
std::ostream &	operator<< (std::ostream &o, cmf::Event const &event)
cmf::EventList &	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 hadronicEnergy)
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})
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::ParameterSpaceLoc &loc, bool clearLoc)
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
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
const std::string	cDetType_Strings [5]
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::map<cmf::MetaData, 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 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 572 of file Constants.h.

typedef enum cmf::osc_params cmf::OscParm_t

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

Definition at line 571 of file Constants.h.

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

Definition at line 558 of file Constants.h.

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

Definition at line 15 of file Parameter.h.

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

Definition at line 42 of file GridPointResult.h.

typedef enum cmf::sel_type cmf::SelectionType_t

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

Definition at line 570 of file Constants.h.

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

Definition at line 223 of file VarVals.h.

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

Definition at line 43 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 26 of file Constants.h.

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

enum cmf::calc_type

Enumerator
kPMNS
kNSI
kSterile

Definition at line 300 of file Constants.h.

                        {
    kPMNS=0,
    kNSI,
    kSterile
  } CalcType_t;

enum cmf::chisqr_type

Enumerator
kCovMat
kPoisson
kCNP
kGauss
kUnknownChiSqr

Definition at line 45 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 318 of file Constants.h.

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

enum cmf::covmat_type

Enumerator
kStatMatrix
kSystMatrix
kTotalMatrix

Definition at line 309 of file Constants.h.

                          {
    kStatMatrix=0,
    kSystMatrix,
    kTotalMatrix
  }CovMat_t;

enum cmf::dataMC_type

Enumerator
kData
kMC
kFakeData
kBoth

Definition at line 332 of file Constants.h.

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

enum cmf::det_type

Enumerator
kUnknownDet
kNEARDET
kFARDET
kMINOSNEAR
kMINOSFAR

Definition at line 544 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 148 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 108 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
kEps_ee
kEps_emu
kEps_etau
kEps_mumu
kEps_mutau
kEps_tautau
kDelta_emu
kDelta_etau
kDelta_mutau
kNumOscParams

Definition at line 187 of file Constants.h.

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

enum cmf::sel_type

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

Definition at line 62 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
kXSecCVWgt2020
kPPFXFluxCVWgt
kRPACCQE_Weight
kRPARES_Weight
kDISvnCC1pi_Weight
kEmpiricalMEC_Weight
kEmpiricalMECtoGENIEQE_Weight
kEmpiricalMECtoGENIERES_Weight
kOtherDIS_Weight
kMinus2Sigma
kMinus1Sigma
kPlus1Sigma
kPlus2Sigma
kFirstSigmaVar
kMaCCRES
kMvCCRES
kMaNCRES
kRPACCQEshapeEnh
kRPACCQEshapeSupp
kGENIEPCA0
kGENIEPCA1
kGENIEPCA2
kGENIEPCA3
kGENIEPCA4
kGENIEPCA5
kGENIEPCA6
kGENIEPCA7
kGENIEPCA8
kGENIEPCA9
kGENIEPCA10
kGENIEPCA11
kMvNCRES
kZNormCCQE
kZExpEV1Syst2020
kZExpEV2Syst2020
kZExpEV3Syst2020
kZExpEV4Syst2020
kRESLowQ2SuppSyst2020
kDISvnCC1piWgt_2020
khNFSISyst2020_MFP
khNFSISyst2020_EV1
kMECEnuShapeSyst2020Nu
kMECEnuShapeSyst2020AntiNu
kMECShapeSyst2020Nu
kMECShapeSyst2020AntiNu
kMECInitStateNPFracSyst2020Nu
kMECInitStateNPFracSyst2020AntiNu
kRadCorrNue
kRadCorrNuebar
k2ndClassCurrs
kUnCorrNDMuEScaleSyst2020
kUnCorrMuCatMuESyst2020
kPileupMuESyst2020
kCorrMuEScaleSyst2020
kNeutronVisEScalePrimariesSyst2018
kMichelTaggingSyst2020
kAna2020NormFHC
kAna2020NormRHC
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
kTauScaleSyst
kLastSigmaVar
kLightModelLightDownCalibUp
kLightModelLightUpCalibDown
kCkvProtonShiftDown
kRelativeCalibration
kAbsoluteCalibration
kCalibShape
kMaNCEL
kEtaNCEL
kVecCCQE_shape
kMaCOHpi
kR0COHpi
kAhtBY
kBhtBY
kCV1uBY
kCV2uBY
kNormDISCC
kRnubarnuCC
kDISNuclMod
kAGKY_xF1pi
kAGKY_pT1pi
kMFP_pi
kMFP_N
kFrCEx_pi
kFrElas_pi
kFrAbs_pi
kFrPiProd_pi
kFrInel_N
kFrPiProd_N
kCCQEMomDistroFGtoSF
kBR1gamma
kBR1eta
kTheta_Delta2Npi

Definition at line 342 of file Constants.h.

                   {
    kUnknownVar = 0,

    // Data info - kFake_Weight is in this group because it only applies to fake data
//  kNuE_LID             = 9;
//  kNuE_LEM             = 10;
    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,
    kXSecCVWgt2020,
    kPPFXFluxCVWgt,
    kRPACCQE_Weight,
    kRPARES_Weight,
    kDISvnCC1pi_Weight,
    kEmpiricalMEC_Weight,
    kEmpiricalMECtoGENIEQE_Weight,
    kEmpiricalMECtoGENIERES_Weight,
    kOtherDIS_Weight,


    kMinus2Sigma,
    kMinus1Sigma,
    kPlus1Sigma,
    kPlus2Sigma,

    // Systematic uncertainties where we store -2, -1, +1, +2 sigma values
    kFirstSigmaVar,
#ifdef PRODUCTION4
    kMaCCQE=kFirstSigmaVar,
    kMaCCRES,
#endif
#ifdef PRODUCTION5
    kMaCCRES=kFirstSigmaVar,
#endif
    kMvCCRES,
    kMaNCRES,
    kRPACCQEshapeEnh,
    kRPACCQEshapeSupp,
#ifdef PRODUCTION4
    kFormZone,
    kFrInel_pi,
    kFrCEx_N,
    kFrElas_N,
    kFrAbs_N,
    kCCQEPauliSupViaKF,
    kLastSigmaVar=kCCQEPauliSupViaKF,
#endif

    // new for 2020
    kGENIEPCA0,
    kGENIEPCA1,
    kGENIEPCA2,
    kGENIEPCA3,
    kGENIEPCA4,
    kGENIEPCA5,
    kGENIEPCA6,
    kGENIEPCA7,
    kGENIEPCA8,
    kGENIEPCA9,
    kGENIEPCA10,
    kGENIEPCA11,
    kMvNCRES,
    kZNormCCQE,
    kZExpEV1Syst2020,
    kZExpEV2Syst2020,
    kZExpEV3Syst2020,
    kZExpEV4Syst2020,
    kRESLowQ2SuppSyst2020,
    kDISvnCC1piWgt_2020,
    khNFSISyst2020_MFP,
    khNFSISyst2020_EV1,
    kMECEnuShapeSyst2020Nu,
    kMECEnuShapeSyst2020AntiNu,
    kMECShapeSyst2020Nu,
    kMECShapeSyst2020AntiNu,
    kMECInitStateNPFracSyst2020Nu,
    kMECInitStateNPFracSyst2020AntiNu,
    kRadCorrNue,
    kRadCorrNuebar,
    k2ndClassCurrs,
    kUnCorrNDMuEScaleSyst2020,
    kUnCorrMuCatMuESyst2020,
    kPileupMuESyst2020,
    kCorrMuEScaleSyst2020,
    kNeutronVisEScalePrimariesSyst2018,
    kMichelTaggingSyst2020,
    kAna2020NormFHC,
    kAna2020NormRHC,
    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,
    kTauScaleSyst,
#ifdef PRODUCTION5
    kLastSigmaVar=kTauScaleSyst,
#endif

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

    // The following variables are not currently used
    //----------------
    kMaNCEL,
    kEtaNCEL,
    kVecCCQE_shape,
    kMaCOHpi,
    kR0COHpi,
    kAhtBY,
    kBhtBY,
    kCV1uBY,
    kCV2uBY,
    kNormDISCC,
    kRnubarnuCC,
    kDISNuclMod,
    kAGKY_xF1pi,
    kAGKY_pT1pi,
    kMFP_pi,
    kMFP_N,
    kFrCEx_pi,
    kFrElas_pi,
    kFrAbs_pi,
    kFrPiProd_pi,
    kFrInel_N,
    kFrPiProd_N,
    kCCQEMomDistroFGtoSF,
    kBR1gamma,
    kBR1eta,
    kTheta_Delta2Npi

    /* 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 537 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 240 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 22 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::CovarianceMatrixMaker::beginJob(), cmf::SelectionUtility::DetermineUnusedSelections(), and cmf::SelectionUtility::Initialize().

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

static

Referenced by cmf::CovarianceMatrixMaker::beginJob(), 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 62 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 19 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 21 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(), fnex::CovarianceFitHelper::Iterations(), 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.second.ListMetaData();

      if(md.interactionType != intType) continue;

      cmf::FillSpectrumFromSingleList(itr.second,
                                      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.second.ListMetaData();

      cmf::FillSpectrumFromSingleList(itr.second,
                                      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::EventList & cmf::FindEventList	(	cmf::MetaData const &	md,
		cmf::EventListColl &	eventListColl
	)

Definition at line 44 of file Event.cxx.

References cmf::MetaData::ToString().

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

  {
    if(eventListColl.count(md))
      return eventListColl.find(md)->second;

    throw cet::exception("FindEventList")
    << "could not find an event list for "
    << md.ToString()
    << " in the event list collection";

    return eventListColl.begin()->second;
  }

double cmf::FitFunction_ForROOT

(

const double *

params

)

Definition at line 52 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(), LOG_DEBUG, LOG_VERBATIM, cet::pow(), cmf::ShifterAndWeighter::SetCurrentVals(), and std::sin().

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((*gFFNames)[i] == "Th23")
        LOG_VERBATIM("CovarianceFit")
            << "\t"
            << (*gFFNames)[i]
            << " : "
            << params[i]
            << "; sin^2(Th23) : "
            << 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 24 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, 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 363 of file StaticFuncs.h.

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

Referenced by cmf::FitFeldmanCousinsPoint::beginJob(), cmf::FitFeldmanCousinsPoint::FillHistograms(), InteractionTypeKey(), 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 389 of file StaticFuncs.h.

References kNuESelection, and kNuESelectionPeripheral.

Referenced by cmf::EventListManipulator::Deserialize(), cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), cmf::MetaData::IsNuESelected(), cmf::CovarianceBinUtility::NumSelectionBins(), fnex::MetaData::Period(), 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 382 of file StaticFuncs.h.

References kNuMuSelectionQ1, and kNuMuSelectionQ4.

Referenced by cmf::EventListManipulator::Deserialize(), InteractionTypeKey(), cmf::MetaData::IsNuMuQuantiles(), IsNuMuSelected(), fnex::MetaData::Period(), 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 375 of file StaticFuncs.h.

References IsNuMuQuantiles(), and kNuMuSelection.

Referenced by cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), cmf::MetaData::IsNuMuSelected(), cmf::CovarianceBinUtility::NumSelectionBins(), fnex::MetaData::Period(), 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 136 of file StaticFuncs.h.

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

Referenced by cmf::CovarianceBinUtility::BinToBeamType(), 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 70 of file StaticFuncs.h.

References kUnknownDet, and LOG_DEBUG.

Referenced by cmf::CovarianceBinUtility::BinToDetector(), 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 84 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 109 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 208 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 170 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 228 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 628 of file StaticFuncs.h.

References k2ndClassCurrs, kAbsoluteCalibration, kAGKY_pT1pi, kAGKY_xF1pi, kAhtBY, kAna2020NormFHC, kAna2020NormRHC, kBaselineNux, kBhtBY, kBR1eta, kBR1gamma, kCalibShape, kCCQEMomDistroFGtoSF, fnex::kCCQEPauliSupViaKF, kCkvProtonShiftDown, kCorr_1Nux, kCorr_2Nux, kCorrMuEScaleSyst2020, kCV1uBY, kCV2uBY, kDISNuclMod, kDISvnCC1pi_Weight, kDISvnCC1piWgt_2020, kEmpiricalMEC_Weight, kEmpiricalMECtoGENIEQE_Weight, kEmpiricalMECtoGENIERES_Weight, kEtaNCEL, kFake_Weight, fnex::kFormZone, fnex::kFrAbs_N, kFrAbs_pi, fnex::kFrCEx_N, kFrCEx_pi, fnex::kFrElas_N, kFrElas_pi, kFrInel_N, fnex::kFrInel_pi, kFrPiProd_N, kFrPiProd_pi, kGENIEPCA0, kGENIEPCA1, kGENIEPCA10, kGENIEPCA11, kGENIEPCA2, kGENIEPCA3, kGENIEPCA4, kGENIEPCA5, kGENIEPCA6, kGENIEPCA7, kGENIEPCA8, kGENIEPCA9, kHad_RecoE, khNFSISyst2020_EV1, khNFSISyst2020_MFP, kLep_RecoE, kLep_RecoE_MCFrac, kLightModelLightDownCalibUp, kLightModelLightUpCalibDown, fnex::kMaCCQE, kMaCCRES, kMaCOHpi, kMaNCEL, kMaNCRES, kMeanQ0_1Nux, kMeanQ0_2Nux, kMeanQ3_1Nux, kMeanQ3_2Nux, kMECEnuShapeSyst2020AntiNu, kMECEnuShapeSyst2020Nu, kMECInitStateNPFracSyst2020AntiNu, kMECInitStateNPFracSyst2020Nu, kMECShapeSyst2020AntiNu, kMECShapeSyst2020Nu, kMFP_N, kMFP_pi, kMichelTaggingSyst2020, kMinus1Sigma, kMinus2Sigma, kMvCCRES, kMvNCRES, kNeutronVisEScalePrimariesSyst2018, kNorm_1Nux, kNorm_2Nux, kNormDISCC, kNu_RecoE, kNuE_CVN, kNuE_NumMichel, kOtherDIS_Weight, kPileupMuESyst2020, kPlus1Sigma, kPlus2Sigma, kPPFXFluxCVWgt, kR0COHpi, kRadCorrNue, kRadCorrNuebar, kRecoQ2, kRelativeCalibration, kRESLowQ2SuppSyst2020, kRnubarnuCC, kRPACCQE_Weight, kRPACCQEshapeEnh, kRPACCQEshapeSupp, kRPARES_Weight, kSigmaQ0_1Nux, kSigmaQ0_2Nux, kSigmaQ3_1Nux, kSigmaQ3_2Nux, kTauScaleSyst, kTheta_Delta2Npi, kTrueCCNC, kTrueE, kTrueHitNuc, kTrueIntMode, kTrueIntType, kTrueParentDecay, kTrueParentPDG, kTrueParentPT, kTrueParentPZ, kTrueParentTargetPDG, kTruePDG, kTruePDGOrig, kUnCorrMuCatMuESyst2020, kUnCorrNDMuEScaleSyst2020, kVecCCQE_shape, kXSecCVPPFX_Weight, kXSecCVWgt2020, kZExpEV1Syst2020, kZExpEV2Syst2020, kZExpEV3Syst2020, kZExpEV4Syst2020, and kZNormCCQE.

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

{
  //    else if(key == cmf::kNuE_LID            ) return "NuE_LID";
  //    else if(key == cmf::kNuE_LEM            ) return "NuE_LEM";
  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::kXSecCVWgt2020                ) return "XsecCVWgt2020";
  else if(key == cmf::kPPFXFluxCVWgt                ) return "PPFXFluxCVWgt";
  else if(key == cmf::kRPACCQE_Weight               ) return "RPACCQEWgt";
  else if(key == cmf::kRPARES_Weight                ) return "RPARESWgt";
  else if(key == cmf::kDISvnCC1pi_Weight            ) return "DISvnCC1piWgt";
  else if(key == cmf::kEmpiricalMEC_Weight          ) return "EmpiricalMECWgt";
  else if(key == cmf::kEmpiricalMECtoGENIEQE_Weight ) return "EmpiricalMECtoGENIEQEWgt";
  else if(key == cmf::kEmpiricalMECtoGENIERES_Weight) return "EmpiricalMECtoGENIERESWgt";
  else if(key == cmf::kOtherDIS_Weight              ) return "OtherDISWgt";

  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
  //else if( isSumSmallXSecJoint2017Key(key) ) return "SumSmallXSecJoint2017";

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

  // 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";
#ifdef PRODUCTION4
  else if(key == cmf::kMaCCQE             ) return "MaCCQE";
#endif
  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";
  else if(key == cmf::kMvCCRES            ) return "MvCCRES";

  // 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";
  else if(key == cmf::kMaNCRES            ) return "MaNCRES";
  else if(key == cmf::kMvNCRES            ) return "MvNCRES";

  // 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";

  // 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";
  //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";

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

  // Medium-effects to hadronization
#ifdef PRODUCTION4
  else if(key == cmf::kFormZone           ) return "FormZone";
#endif

  // Intranuclear rescattering parameters.
  else if(key == cmf::kMFP_pi             ) return "MFP_pi";
  else if(key == cmf::kMFP_N              ) return "MFP_N";
#ifdef PRODUCTION4
  else if(key == cmf::kFrCEx_pi           ) return "FrCEx_pi";
  else if(key == cmf::kFrElas_pi          ) return "FrElas_pi";
  else if(key == cmf::kFrInel_pi          ) return "FrInel_pi";
  else if(key == cmf::kFrAbs_pi           ) return "FrAbs_pi";
  else if(key == cmf::kFrCEx_N            ) return "FrCEx_N";
  else if(key == cmf::kFrElas_N           ) return "FrElas_N";
  else if(key == cmf::kFrInel_N           ) return "FrInel_N";
  else if(key == cmf::kFrAbs_N            ) return "FrAbs_N";
#endif
  else if(key == cmf::kFrPiProd_pi        ) return "FrPiProd_pi";
  else if(key == cmf::kFrPiProd_N         ) return "FrPiProd_N";

  // Nuclear model
#ifdef PRODUCTION4
  else if(key == cmf::kCCQEPauliSupViaKF  ) return "CCQEPauliSupViaKF";
#endif
  else if(key == cmf::kCCQEMomDistroFGtoSF) return "CCQEMomDistroFGtoSF";

  // 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";

  // 2017 RPA shape systematics
  else if(key == cmf::kRPACCQEshapeEnh    ) return "RPACCQEshapeEnh";
  else if(key == cmf::kRPACCQEshapeSupp   ) return "RPACCQEshapeSupp";

  // 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::kDISvnCC1piWgt_2020               ) return "DISvnCC1piWgt_2020";
  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::kGENIEPCA0                        ) return "GENIEPCA0";
  else if(key == cmf::kGENIEPCA1                        ) return "GENIEPCA1";
  else if(key == cmf::kGENIEPCA2                        ) return "GENIEPCA2";
  else if(key == cmf::kGENIEPCA3                        ) return "GENIEPCA3";
  else if(key == cmf::kGENIEPCA4                        ) return "GENIEPCA4";
  else if(key == cmf::kGENIEPCA5                        ) return "GENIEPCA5";
  else if(key == cmf::kGENIEPCA6                        ) return "GENIEPCA6";
  else if(key == cmf::kGENIEPCA7                        ) return "GENIEPCA7";
  else if(key == cmf::kGENIEPCA8                        ) return "GENIEPCA8";
  else if(key == cmf::kGENIEPCA9                        ) return "GENIEPCA9";
  else if(key == cmf::kGENIEPCA10                       ) return "GENIEPCA10";
  else if(key == cmf::kGENIEPCA11                       ) return "GENIEPCA11";
  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";

  return "Unknown";
}

float cmf::NCEnergy ( float  hadronicEnergy )

inlinestatic

Definition at line 517 of file VarVals.h.

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

{
  return hadronicEnergy;
}

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

inlinestatic

Definition at line 523 of file VarVals.h.

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

{
  // 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 482 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
  #ifdef PRODUCTION5
  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;
  #else
  // 2018
  float p0 = 0.0;
  float p1 = (beamType == kFHC) ? 1.00756 : 0.980479;
  float p2 = (beamType == kFHC) ? 1.07093 : 1.45170;
  float p3 = 0.0;
  float p4 = (beamType == kFHC) ? 1.28608e-2 : -5.82609e-3;
  float p5 = (beamType == kFHC) ? 2.27129e-1 : -2.27599e-1;
  float fr = (beamType == kFHC) ? 1. / 1.0501206 : 1. / 1.001766;
  #endif

  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 474 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(), and cmf::SystVar::operator<().

  {
    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::FakeUniverse const &	fu
	)

Definition at line 33 of file FakeUniverse.cxx.

References cmf::FakeUniverse::AsimovSpectrum(), b, allTimeWatchdog::endl, cmf::FakeUniverse::EventCounts(), cmf::FakeUniverse::InputLocation(), msf_helper::o, and cmf::FakeUniverse::PoissonSpectrum().

  {
    o << "input location "
      << fu.InputLocation()
      << 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]
        << " counts: "
        << fu.EventCounts()[b]
        << "\n";
    }

    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(), 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::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(Th23) : " << 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 77 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 84 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::Location const &	loc
	)

Definition at line 101 of file Parameter.cxx.

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

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

      o << std::endl;
    }
    for(auto const& itr : loc.FDLoc){
      if(loc.NDLoc.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::SystVar const &	sv
	)

Definition at line 107 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::OscParamPoint const &	hpp
	)

Definition at line 136 of file GridPointResult.cxx.

References cOscParams_Strings, allTimeWatchdog::endl, and cmf::OscParamPoint::OscPoint().

  {
    for(auto const& p : hpp.OscPoint())
      o << cmf::cOscParams_Strings[p.first]
        << " "
        << p.second
        << " ";

    o << std::endl;

    return o;
  }

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

Definition at line 154 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, 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 215 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::ParameterSpaceLoc &	loc,
		bool	clearLoc
	)

Definition at line 10 of file ParameterUtility.cxx.

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

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;

    if(clearLoc) loc.clear();

    fhicl::ParameterSet param;
    bool        fixed;
    bool        nuisance;
    bool        constraint;
    float       centralVal;
    //float       variance;
    float       sigma;
    double      val;
    float       lowerBound;
    float       upperBound;
    uint8_t     pos;
    uint8_t     numSigWgt;
    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",   false );
      constraint = param.get<bool       >("Constraint",   false );
      lowerBound = param.get<float      >("LoVal",        0.    );
      upperBound = param.get<float      >("HiVal",        1.e6  );

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

        LOG_DEBUG("ParameterSpaceLoc")
            << "inserting parameter "
            << loc.find(parstr)->second;

      } // end if using the correct detector

    } // end loop over parameter names

  }

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

inlinestatic

Definition at line 20 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::ReadDataProducts(), cmf::CovarianceMatrixFitter::readResults(), cmf::FitFeldmanCousinsPoint::readResults(), and cmf::ContourFromLibrary::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 453 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               );
  #ifdef PRODUCTION5
  else if(md.IsNCSelected()  ) return cmf::NCEnergy  (leptonicEnergy, hadronicEnergy, md.BeamType(), md.detector);
  #else
  else if(md.IsNCSelected()  ) return cmf::NCEnergy  (hadronicEnergy);
  #endif
  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 23 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 121 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.second.ListMetaData();
      ss = itr.second.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.second);

    } // end loop over the lists
  }

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

Definition at line 59 of file Event.cxx.

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

Referenced by cmf::EventList::AddEvent(), 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");
    //    truthvrst.     append("fTrueParentPT/F:fTrueParentPZ/F:fTrueParentDecay/F:fTrueParentTargetPDG/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 266 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 275 of file StaticFuncs.h.

References cOscParams_Strings, MECModelEnuComparisons::i, IsOscillationParameter(), kAsimovContour, kCNP, kCovMat, kDataContour, kdCP, kDelta_emu, kDelta_etau, kDelta_mutau, kDmsq21, kDmsq32, kDmsq41, kEps_ee, kEps_emu, kEps_etau, kEps_mumu, kEps_mutau, kEps_tautau, kFARDET, kFCContour, fc::kFHC, kGauss, kL, kMedianContour, kNEARDET, kNumOscParams, kPoisson, fc::kRHC, kRho, kTh12, kTh13, kTh23, kTh24, kTh34, kUnknownBeam, kUnknownChiSqr, kUnknownContour, kUnknownDet, PeriodToBeamType(), submit_syst::str, 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::CovarianceFitHelper::FindInitialGuess(), cmf::SpectrumPredictionMaker::FindOscillationPoints(), cmf::SpectrumPredictionMaker::Initialize(), InteractionTypeKey(), cmf::FakeUniverse::OscParMap(), cmf::Parameter::Parameter(), cmf::ContourFromLibrary::reconfigure(), cmf::CovarianceFitHelper::Result(), and StringToDetectorType().

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

inlinestatic

Definition at line 249 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 398 of file StaticFuncs.h.

References k2ndClassCurrs, kAbsoluteCalibration, kAGKY_pT1pi, kAGKY_xF1pi, kAhtBY, kAna2020NormFHC, kAna2020NormRHC, kBaselineNux, kBhtBY, kBR1eta, kBR1gamma, kCalibShape, kCCQEMomDistroFGtoSF, fnex::kCCQEPauliSupViaKF, kCkvProtonShiftDown, kCorr_1Nux, kCorr_2Nux, kCorrMuEScaleSyst2020, kCV1uBY, kCV2uBY, kDISNuclMod, kDISvnCC1pi_Weight, kDISvnCC1piWgt_2020, kEmpiricalMEC_Weight, kEmpiricalMECtoGENIEQE_Weight, kEmpiricalMECtoGENIERES_Weight, kEtaNCEL, kFake_Weight, fnex::kFormZone, fnex::kFrAbs_N, kFrAbs_pi, fnex::kFrCEx_N, kFrCEx_pi, fnex::kFrElas_N, kFrElas_pi, kFrInel_N, fnex::kFrInel_pi, kFrPiProd_N, kFrPiProd_pi, kGENIEPCA0, kGENIEPCA1, kGENIEPCA10, kGENIEPCA11, kGENIEPCA2, kGENIEPCA3, kGENIEPCA4, kGENIEPCA5, kGENIEPCA6, kGENIEPCA7, kGENIEPCA8, kGENIEPCA9, kHad_RecoE, khNFSISyst2020_EV1, khNFSISyst2020_MFP, kLep_RecoE, kLep_RecoE_MCFrac, kLightModelLightDownCalibUp, kLightModelLightUpCalibDown, fnex::kMaCCQE, kMaCCRES, kMaCOHpi, kMaNCEL, kMaNCRES, kMeanQ0_1Nux, kMeanQ0_2Nux, kMeanQ3_1Nux, kMeanQ3_2Nux, kMECEnuShapeSyst2020AntiNu, kMECEnuShapeSyst2020Nu, kMECInitStateNPFracSyst2020AntiNu, kMECInitStateNPFracSyst2020Nu, kMECShapeSyst2020AntiNu, kMECShapeSyst2020Nu, kMFP_N, kMFP_pi, kMichelTaggingSyst2020, kMinus1Sigma, kMinus2Sigma, kMvCCRES, kMvNCRES, kNeutronVisEScalePrimariesSyst2018, kNorm_1Nux, kNorm_2Nux, kNormDISCC, kNu_RecoE, kNuE_CVN, kNuE_NumMichel, kOtherDIS_Weight, kPileupMuESyst2020, kPlus1Sigma, kPlus2Sigma, kPPFXFluxCVWgt, kR0COHpi, kRadCorrNue, kRadCorrNuebar, kRecoQ2, kRelativeCalibration, kRESLowQ2SuppSyst2020, kRnubarnuCC, kRPACCQE_Weight, kRPACCQEshapeEnh, kRPACCQEshapeSupp, kRPARES_Weight, kSigmaQ0_1Nux, kSigmaQ0_2Nux, kSigmaQ3_1Nux, kSigmaQ3_2Nux, kTauScaleSyst, kTheta_Delta2Npi, kTrueCCNC, kTrueE, kTrueHitNuc, kTrueIntMode, kTrueIntType, kTrueParentDecay, kTrueParentPDG, kTrueParentPT, kTrueParentPZ, kTrueParentTargetPDG, kTruePDG, kTruePDGOrig, kUnCorrMuCatMuESyst2020, kUnCorrNDMuEScaleSyst2020, kUnknownVar, kVecCCQE_shape, kXSecCVPPFX_Weight, kXSecCVWgt2020, kZExpEV1Syst2020, kZExpEV2Syst2020, kZExpEV3Syst2020, kZExpEV4Syst2020, kZNormCCQE, LOG_DEBUG, and LOG_VERBATIM.

Referenced by fnex::Spectrum::BaseVals(), fnex::VarBinning::BinInfo(), cmf::CAFToEventList::FillMCVals(), cmf::ShifterAndWeighter::GENIESystWeight(), fnex::MCVarVals::GENIEWgts(), fnex::Spectrum::Histogram(), InteractionTypeKey(), fnex::IsDataVar(), fnex::IsMCVar(), cmf::ShifterAndWeighter::MaCCQEReducedWeight(), fnex::CorrSpec_NoExtrapNuMu::MakeCorrectedHistograms(), fnex::CorrSpec_SimpleExtrap::MakeCorrectedHistograms(), fnex::CorrSpec_SimpleNuMuExtrap::MakeCorrectedHistograms(), fnex::CorrSpec_NoExtrapNuMu::MakeUncorrectedHistograms(), fnex::CorrSpec_SimpleExtrap::MakeUncorrectedHistograms(), fnex::CorrSpec_SimpleNuMuExtrap::MakeUncorrectedHistograms(), cmf::Parameter::Parameter(), cmf::ShifterAndWeighter::RPACCQEshapeEnhWeight(), cmf::ShifterAndWeighter::RPACCQEshapeSuppWeight(), fnex::MCVarVals::set_GENIEWgt(), fnex::MCVarVals::set_val_at(), fnex::DataVarVals::set_val_at(), fnex::MCVarVals::SetGENIEVarVal(), cmf::ParameterUtility::SysParKeys(), fnex::MCVarVals::val_at(), fnex::DataVarVals::val_at(), and fnex::VarBinning::VarBinning().

{

  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