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	CAFToEventList
class	ChiSqrCalculator
struct	ChiSqrInfo
class	CMFCappedEventList
class	CMFDecorrelator
class	CMFSpectraMaker
class	CombineResults
class	ContourFromGrid
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...
struct	DetBeamBins
class	DSTToEventList
class	Event
class	EventId
class	EventList
class	EventListManipulator
class	FakeUniverse
class	FCResultCollection
class	FCUniverseCollection
struct	FileExtracts
class	FitFeldmanCousinsPoint
class	GridPoint
class	GridPointsBestFit
struct	HiddenParameterConfig
class	InputPoint
class	Location
class	MCVarVals
	Base container for the MC related Vars that constitute an event. More...
struct	MetaData
struct	MetaDataLite
class	OscPar
class	OscParamPoint
class	Parameter
class	ParameterSpaceLoc
class	ParameterUtility
struct	PeriodRun
class	PlotUtilities
class	PointBestFit
class	PointResult
class	PointSpectra
struct	POTLiveTime
class	PredictionLibraryMaker
class	RandomUniverses
class	RandomUniverseUtility
class	SelectionUtility
class	ShifterAndWeighter
class	SpectraFromPredictions
class	SpectrumPredictionMaker
struct	SpillSummary
struct	SubMatrixData
class	SystPar
struct	SystVar
struct	TruthVars
class	UniversePointBestFits
struct	WeightVars

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

Enumerations
enum	det_type {   kUnknownDet = 0, kNEARDET, kFARDET, kMINOSNEAR,   kMINOSFAR, kALLDET }
enum	beam_type { kFHC = 0, kRHC, k0HC, kUnknownBeam }
enum	chisqr_type {   kCovMat = 0, kPoisson, kCNP, kGauss,   kUnknownChiSqr }
enum	sel_type {   kNuESelection = 0, kNuESelectionLowPID, kNuESelectionMidPID, kNuESelectionHighPID,   kNuESelectionPeripheral, kNuMuSelection, kNuMuSelectionQ1, kNuMuSelectionQ2,   kNuMuSelectionQ3, kNuMuSelectionQ4, kNCSelection, kUnknownSelection }
enum	interaction_type {   kUnknownInteraction = 0, kNuMuCC, kNuMuBarCC, kNuECC,   kNuEBarCC, kNuTauCC, kNuTauBarCC, kNC,   kCosmicMuon, kRockMuon, kUncategorised }
enum	file_type {   kBeam =0, kSwap, kTauSwap, kDataFile,   kCosmicBackgroundFile, kRockFluxSwap, kRockNonSwap, kNumFileTypes,   kBadFileType, kUnknownFileType }
enum	osc_params {   kL = 0, kRho, kDmsq21, kDmsq32,   kTh12, kTh13, kTh23, kdCP,   kTh14, kTh24, kTh34, kDmsq41,   kd24, kEps_ee, kEps_emu, kEps_etau,   kEps_mumu, kEps_mutau, kEps_tautau, kDelta_emu,   kDelta_etau, kDelta_mutau, kNumOscParams }
enum	calc_type { kPMNS =0, kNSI, kSterile }
enum	covmat_type { kStatMatrix =0, kSystMatrix, kTotalMatrix }
enum	cont_type {   kAsimovContour =0, kMedianContour, kFCContour, kDataContour,   kUnknownContour }
enum	dataMC_type { kData = 0, kMC, kFakeData, kBoth }
enum	varpar_type {   kUnknownVar = 0, kNuE_CVN, kNuE_NumMichel, kNu_RecoE,   kCMF_RecoE, kHad_RecoE, kLep_RecoE, kLep_RecoE_MCFrac,   kRecoQ2, kFake_Weight, kTrueE, kTruePDG,   kTrueCCNC, kTrueIntType, kTruePDGOrig, kTrueParentPDG,   kTrueParentPT, kTrueParentPZ, kTrueParentDecay, kTrueParentTargetPDG,   kTrueHitNuc, kTrueIntMode, kXSecCVPPFX_Weight, kXSecCV2020Wgt,   kPPFXFluxCVWgt, kRPARES_Weight, kMinus2Sigma, kMinus1Sigma,   kPlus1Sigma, kPlus2Sigma, kFirstSigmaVar, kMaCCRES =kFirstSigmaVar,   kMvCCRES, kMaNCRES, kMvNCRES, kRPACCQEshapeEnh,   kRPACCQEshapeSupp, kZNormCCQE, kZExpEV1Syst2020, kZExpEV2Syst2020,   kZExpEV3Syst2020, kZExpEV4Syst2020, kRESLowQ2SuppSyst2020, khNFSISyst2020_MFP,   khNFSISyst2020_EV1, kMECEnuShapeSyst2020Nu, kMECEnuShapeSyst2020AntiNu, kMECShapeSyst2020Nu,   kMECShapeSyst2020AntiNu, kMECInitStateNPFracSyst2020Nu, kMECInitStateNPFracSyst2020AntiNu, kRadCorrNue,   kRadCorrNuebar, k2ndClassCurrs, kTauScaleSyst, kDISvpCC0pi_2020,   kDISvpCC1pi_2020, kDISvpCC2pi_2020, kDISvpCC3pi_2020, kDISvpNC0pi_2020,   kDISvpNC1pi_2020, kDISvpNC2pi_2020, kDISvpNC3pi_2020, kDISvnCC0pi_2020,   kDISvnCC1pi_2020, kDISvnCC2pi_2020, kDISvnCC3pi_2020, kDISvnNC0pi_2020,   kDISvnNC1pi_2020, kDISvnNC2pi_2020, kDISvnNC3pi_2020, kDISvbarpCC0pi_2020,   kDISvbarpCC1pi_2020, kDISvbarpCC2pi_2020, kDISvbarpCC3pi_2020, kDISvbarpNC0pi_2020,   kDISvbarpNC1pi_2020, kDISvbarpNC2pi_2020, kDISvbarpNC3pi_2020, kDISvbarnCC0pi_2020,   kDISvbarnCC1pi_2020, kDISvbarnCC2pi_2020, kDISvbarnCC3pi_2020, kDISvbarnNC0pi_2020,   kDISvbarnNC1pi_2020, kDISvbarnNC2pi_2020, kDISvbarnNC3pi_2020, kFormZone_2020,   khNFSISyst2020_EV2, khNFSISyst2020_EV3, kCOHCCScaleSyst2018, kCOHNCScaleSyst2018,   kMaNCEL, kEtaNCEL, kAhtBY, kBhtBY,   kCV1uBY, kCV2uBY, kAGKY_xF1pi, kAGKY_pT1pi,   kBR1gamma, kBR1eta, kTheta_Delta2Npi, kFluxPCA00,   kFluxPCA01, kFluxPCA02, kFluxPCA03, kFluxPCA04,   kKaonSyst, 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, kLastSigmaVar =kBaselineNux, kFirstNormalizationVar,   kNormalizationPOT =kFirstNormalizationVar, kNormalizationNDMass, kNormalizationFDMass, kNormalizationML,   kNormalizationFHCNuMuContext, kNormalizationRHCNuMuContext, kNormalizationFHCNuEContext, kNormalizationRHCNuEContext,   kNormalizationFHCNCContext, kNormalizationRHCNCContext, kLastNormalizationVar =kNormalizationRHCNCContext, kFirstCalibrationVar,   kLightModelND =kFirstCalibrationVar, kLightModelFD, kCherenkov, kAbsoluteCalibrationND,   kAbsoluteCalibrationFD, kCalibShapeND, kCalibShapeFD, kDetectorAging,   kLastCalibrationVar =kDetectorAging, kFirstEShiftVar, kUnCorrNDMuEScaleSyst2020 =kFirstEShiftVar, kUnCorrMuCatMuESyst2020,   kPileupMuESyst2020, kCorrMuEScaleSyst2020, kNeutronVisEScalePrimariesSyst2018, kMichelTaggingSyst2020,   kLastEShiftVar =kMichelTaggingSyst2020 }
enum	par_type {   kOscPar = 0, kCMFSystPar, kCMFWeightPar, kCMFNormSystPar,   kCalibSystPar, kEShiftSystPar, kOtherSystPar, kUnknownPar }
enum	weight_type {   kSystWgtOnly =0, kOscWgtOnly, kSystAndOscWgt, kAllWgt,   kNoWgt }
enum	minosRP {   kRun1, kRunpHE, kRun2, kRun3,   kRun4, kRun5, kRun6, kRun7,   kRun9, kRun10, kRun11, kRun12,   kRun13, kEnd }

Functions
std::ostream &	operator<< (std::ostream &o, cmf::Event const &event)
cmf::EventListColl::iterator	FindEventList (cmf::MetaData const &md, cmf::EventListColl &eventListColl)
void	SerializeEvents (TTree *eventTree, cmf::MetaData const &md, cmf::EventList const &events)
void	SerializeEventListColl (std::string const &dirName, cmf::EventListColl const &listColl)
void	FillSpectrumFromSingleList (cmf::EventList const &list, cmf::MetaData const &md, cmf::ExposureMap const &exposureMap, cmf::Spectrum &spectrum, cmf::Spectrum &count, bool applyExposureNorm)
void	FillSpectrum (cmf::EventListColl const &eventLists, cmf::ExposureMap const &exposureMap, cmf::Spectrum &spectrum, cmf::Spectrum &count, cmf::InteractionType_t intType, bool applyExposureNorm)
void	FillSpectrum (cmf::EventListColl const &eventLists, cmf::ExposureMap const &exposureMap, cmf::Spectrum &spectrum, cmf::Spectrum &count, bool applyExposureNorm)
std::ostream &	operator<< (std::ostream &o, cmf::MCVarVals const &mcvv)
std::ostream &	operator<< (std::ostream &o, cmf::SystVar const &sv)
std::ostream &	operator<< (std::ostream &o, cmf::EventId const &evid)
std::ostream &	operator<< (std::ostream &o, cmf::DataVarVals const &dvv)
static float	RecoEnergy (float leptonicEnergy, float hadronicEnergy, cmf::MetaData const &md)
static float	NuMuEnergy (float leptonicEnergy, float hadronicEnergy)
static float	NuEEnergy (float leptonicEnergy, float hadronicEnergy, cmf::BeamType_t const &beamType)
static float	NCEnergy (float leptonicEnergy, float hadronicEnergy, cmf::BeamType_t const &beamType, cmf::DetType_t const &detector)
const std::vector< std::string >	cDetType_Strings ({"UnknownDet","NearDet","FarDet","MINOSNear","MINOSFar","AllDetectors"})
static const std::set< cmf::DetType_t >	cDetIds ({cmf::kNEARDET, cmf::kFARDET, cmf::kMINOSNEAR, cmf::kMINOSFAR})
static const std::set< cmf::BeamType_t >	cBeamTypes ({kFHC, kRHC})
const std::vector< std::string >	cBeamType_Strings ({"FHC","RHC","0HC","UnknownBeam"})
const std::vector< std::string >	cBeamType_LatexStrings ({"FHC","RHC","0HC""Unknown Beam"})
const std::vector< std::string >	cChiSqrCalcType_Strings ({"CovMat","Poisson","CNP","Gauss","UnknownChiSqr"})
const std::vector< std::string >	cSelectionType_Strings ({"NuESel_AllPID","NuESel_LowPID","NuESel_MidPID","NuESel_HighPID","NuESel_Peripheral","NuMuSel","NuMuSelQ1","NuMuSelQ2","NuMuSelQ3","NuMuSelQ4","NCSel","UnknownSel"})
const std::vector< std::string >	cSelectionType_LatexStrings ({"#nu_{e} Selection","#nu_{e} Selection - Low PID","#nu_{e} Selection - Mid PID","#nu_{e} Selection - High PID","#nu_{e} Selection - Peripheral","#nu_{#mu} Selection","#nu_{#mu} Selection - Quantile 1","#nu_{#mu} Selection - Quantile 2","#nu_{#mu} Selection - Quantile 3","#nu_{#mu} Selection - Quantile 4","NC Selection","Unknown Selection"})
const std::vector< std::string >	cInteractionType_LatexStrings ({"Unknown Interaction","#nu_{#mu} CC","#bar{#nu}_{#mu} CC","#nu_{e} CC","#bar{#nu}_{e} CC","#nu_{#tau} CC","#bar{#nu}_{#tau} CC","NC","Cosmic Muon","Rock Muon","Uncategorised Interaction"})
const std::vector< std::string >	cInteractionType_Strings ({"UnknownInteraction","NuMuCC","NuMuBarCC","NuECC","NuEBarCC","NuTauCC","NuTauBarCC","NC","CosmicMuon","RockMuon","UncategorisedInteraction"})
const std::vector< std::string >	cFileTypeStrings ({"Beam","FluxSwap","TauSwap","Data","CosmicBackground","RockFluxSwap","RockNonSwap","num_file_types","bad_file_type","UnknownFileType"})
const std::vector< std::string >	cFileTypeStrings_Latex ({"Beam","Flux Swap","#tau Swap","Data","Cosmic #mu Background","Rock Flux Swap #mu Background","Rock Non Swap #mu Background","num_file_types","bad_file_type","none_set"})
const std::vector< double >	cOscParams_Scales ({1., 1., 1.e5, 1.e3, 1., 1., 1., 1./3.14159, 1., 1., 1., 1., 1./3.14159, 1., 1., 1., 1., 1., 1., 1., 1., 1.})
const std::vector< std::string >	cOscParams_LatexScales ({" (m)"," (g/cc)"," (#times10^{-5} eV^{2})"," (#times10^{-3} eV^{2})","","",""," (#pi rad)","","","","(eV^{2})"," (#pi rad)","","","","","","","","",""})
const std::vector< std::string >	cOscParams_Strings ({"L","Rho","Dmsq21","Dmsq32","Th12","Th13","Th23","dCP","Th14","Th24","Th34","Dmsq41","d24","Eps_ee","Eps_emu","Eps_etau","Eps_mumu","Eps_mutau","Eps_tautau","Delta_emu","Delta_etau","Delta_mutau"})
const std::vector< std::string >	cOscParams_Strings_Latex ({"L","#rho","#Delta m^{2}_{21}","#Delta m^{2}_{32}","#theta_{12}","#theta_{13}","#theta_{23}","#delta_{CP}","#theta_{14}","#theta_{24}","#theta_{34}","#Delta m^{2}_{41}","#delta_{24}","#epsilon_{ee}","#epsilon_{e#mu}","#epsilon_{e#tau}","#epsilon_{#mu#mu}","#epsilon_{#mu#tau}","#epsilon_{#tau#tau}","#delta_{e#mu}","#delta_{e#tau}","#delta_{#mu#tau}"})
const std::vector< std::string >	cContourTypeStrings ({"Asimov","Median","Feldman-Cousins","Data","UnknownContour"})
static std::vector< std::string >	cDataTypeStrings ({"Data","MC","FakeData","Data and MC"})
static const std::map< std::string, uint8_t >	kVarNameToKey ({{"NuE_CVN", cmf::kNuE_CVN},{"NuE_NumMichel", cmf::kNuE_NumMichel},{"Had_RecoE", cmf::kHad_RecoE},{"Lep_RecoE", cmf::kLep_RecoE},{"Nu_RecoE", cmf::kNu_RecoE},{"Lep_RecoE_MCFrac", cmf::kLep_RecoE_MCFrac},{"Reco_Q2", cmf::kRecoQ2},{"Fake_Weight", cmf::kFake_Weight},{"TrueE", cmf::kTrueE},{"TruePDG", cmf::kTruePDG},{"TrueCCNC", cmf::kTrueCCNC},{"TrueIntType", cmf::kTrueIntType},{"TruePDGOrig", cmf::kTruePDGOrig},{"TrueParentPDG", cmf::kTrueParentPDG},{"TrueParentPT", cmf::kTrueParentPT},{"TrueParentPZ", cmf::kTrueParentPZ},{"TrueParentDecay", cmf::kTrueParentDecay},{"TrueParentTargetPDG", cmf::kTrueParentTargetPDG},{"TrueHitNuc", cmf::kTrueHitNuc},{"TrueIntMode", cmf::kTrueIntMode},{"XsecCV2020", cmf::kXSecCV2020Wgt},{"PPFXFluxCV", cmf::kPPFXFluxCVWgt},{"RPARES", cmf::kRPARES_Weight},{"UnCorrNDMuEScaleSyst2020", cmf::kUnCorrNDMuEScaleSyst2020},{"UnCorrMuCatMuESyst2020", cmf::kUnCorrMuCatMuESyst2020},{"PileupMuESyst2020", cmf::kPileupMuESyst2020},{"CorrMuEScaleSyst2020", cmf::kCorrMuEScaleSyst2020},{"NeutronEvisPrimariesSyst2018", cmf::kNeutronVisEScalePrimariesSyst2018},{"MichelTaggingSyst2020", cmf::kMichelTaggingSyst2020},{"llND", cmf::kLightModelND},{"llFD", cmf::kLightModelFD},{"cherenkov", cmf::kCherenkov},{"calibND", cmf::kAbsoluteCalibrationND},{"calibFD", cmf::kAbsoluteCalibrationFD},{"calibshapeND", cmf::kCalibShapeND},{"calibshapeFD", cmf::kCalibShapeFD},{"detectoraging", cmf::kDetectorAging},{"NormalizationPOT", cmf::kNormalizationPOT},{"NormalizationNDMass", cmf::kNormalizationNDMass},{"NormalizationFDMass", cmf::kNormalizationFDMass},{"NormalizationML", cmf::kNormalizationML},{"NormalizationFHCNuMuContext", cmf::kNormalizationFHCNuMuContext},{"NormalizationRHCNuMuContext", cmf::kNormalizationRHCNuMuContext},{"NormalizationFHCNuEContext", cmf::kNormalizationFHCNuEContext},{"NormalizationRHCNuEContext", cmf::kNormalizationRHCNuEContext},{"NormalizationFHCNCContext", cmf::kNormalizationFHCNCContext},{"NormalizationRHCNCContext", cmf::kNormalizationRHCNCContext},{"MaNCEL", cmf::kMaNCEL},{"EtaNCEL", cmf::kEtaNCEL},{"AhtBY", cmf::kAhtBY},{"BhtBY", cmf::kBhtBY},{"CV1uBY", cmf::kCV1uBY},{"CV2uBY", cmf::kCV2uBY},{"AGKY_xF1pi", cmf::kAGKY_xF1pi},{"AGKY_pT1pi", cmf::kAGKY_pT1pi},{"BR1gamma", cmf::kBR1gamma},{"BR1eta", cmf::kBR1eta},{"Theta_Delta2Npi", cmf::kTheta_Delta2Npi},{"MvCCRES", cmf::kMvCCRES},{"MaCCRES", cmf::kMaCCRES},{"MvNCRES", cmf::kMvNCRES},{"MaNCRES", cmf::kMaNCRES},{"RPACCQEshapeEnh", cmf::kRPACCQEshapeEnh},{"RPACCQEshapeSupp", cmf::kRPACCQEshapeSupp},{"COHCCScale2018", cmf::kCOHCCScaleSyst2018},{"COHNCScale2018", cmf::kCOHNCScaleSyst2018},{"ZExpAxialFFSyst2020_eV1", cmf::kZExpEV1Syst2020},{"ZExpAxialFFSyst2020_eV2", cmf::kZExpEV2Syst2020},{"ZExpAxialFFSyst2020_eV3", cmf::kZExpEV3Syst2020},{"ZExpAxialFFSyst2020_eV4", cmf::kZExpEV4Syst2020},{"ZNormCCQE", cmf::kZNormCCQE},{"RESLowQ2SuppSyst2020", cmf::kRESLowQ2SuppSyst2020},{"hNFSISyst2020_MFP", cmf::khNFSISyst2020_MFP},{"hNFSISyst2020_EV1", cmf::khNFSISyst2020_EV1},{"MECEnuShapeSyst2020Nu", cmf::kMECEnuShapeSyst2020Nu},{"MECEnuShapeSyst2020AntiNu", cmf::kMECEnuShapeSyst2020AntiNu},{"MECShapeSyst2020Nu", cmf::kMECShapeSyst2020Nu},{"MECShapeSyst2020AntiNu", cmf::kMECShapeSyst2020AntiNu},{"MECInitStateNPFracSyst2020Nu", cmf::kMECInitStateNPFracSyst2020Nu},{"MECInitStateNPFracSyst2020AntiNu", cmf::kMECInitStateNPFracSyst2020AntiNu},{"RadCorrNue", cmf::kRadCorrNue},{"RadCorrNuebar", cmf::kRadCorrNuebar},{"2ndClassCurrs", cmf::k2ndClassCurrs},{"Norm_1Nux", cmf::kNorm_1Nux},{"MeanQ0_1Nux", cmf::kMeanQ0_1Nux},{"MeanQ3_1Nux", cmf::kMeanQ3_1Nux},{"SigmaQ0_1Nux", cmf::kSigmaQ0_1Nux},{"SigmaQ3_1Nux", cmf::kSigmaQ3_1Nux},{"Corr_1Nux", cmf::kCorr_1Nux},{"Norm_2Nux", cmf::kNorm_2Nux},{"MeanQ0_2Nux", cmf::kMeanQ0_2Nux},{"MeanQ3_2Nux", cmf::kMeanQ3_2Nux},{"SigmaQ0_2Nux", cmf::kSigmaQ0_2Nux},{"SigmaQ3_2Nux", cmf::kSigmaQ3_2Nux},{"Corr_2Nux", cmf::kCorr_2Nux},{"BaselineNux", cmf::kBaselineNux},{"TauScaleSyst", cmf::kTauScaleSyst},{"DISvpCC0pi_2020", cmf::kDISvpCC0pi_2020},{"DISvpCC1pi_2020", cmf::kDISvpCC1pi_2020},{"DISvpCC2pi_2020", cmf::kDISvpCC2pi_2020},{"DISvpCC3pi_2020", cmf::kDISvpCC3pi_2020},{"DISvpNC0pi_2020", cmf::kDISvpNC0pi_2020},{"DISvpNC1pi_2020", cmf::kDISvpNC1pi_2020},{"DISvpNC2pi_2020", cmf::kDISvpNC2pi_2020},{"DISvpNC3pi_2020", cmf::kDISvpNC3pi_2020},{"DISvnCC0pi_2020", cmf::kDISvnCC0pi_2020},{"DISvnCC1pi_2020", cmf::kDISvnCC1pi_2020},{"DISvnCC2pi_2020", cmf::kDISvnCC2pi_2020},{"DISvnCC3pi_2020", cmf::kDISvnCC3pi_2020},{"DISvnNC0pi_2020", cmf::kDISvnNC0pi_2020},{"DISvnNC1pi_2020", cmf::kDISvnNC1pi_2020},{"DISvnNC2pi_2020", cmf::kDISvnNC2pi_2020},{"DISvnNC3pi_2020", cmf::kDISvnNC3pi_2020},{"DISvbarpCC0pi_2020", cmf::kDISvbarpCC0pi_2020},{"DISvbarpCC1pi_2020", cmf::kDISvbarpCC1pi_2020},{"DISvbarpCC2pi_2020", cmf::kDISvbarpCC2pi_2020},{"DISvbarpCC3pi_2020", cmf::kDISvbarpCC3pi_2020},{"DISvbarpNC0pi_2020", cmf::kDISvbarpNC0pi_2020},{"DISvbarpNC1pi_2020", cmf::kDISvbarpNC1pi_2020},{"DISvbarpNC2pi_2020", cmf::kDISvbarpNC2pi_2020},{"DISvbarpNC3pi_2020", cmf::kDISvbarpNC3pi_2020},{"DISvbarnCC0pi_2020", cmf::kDISvbarnCC0pi_2020},{"DISvbarnCC1pi_2020", cmf::kDISvbarnCC1pi_2020},{"DISvbarnCC2pi_2020", cmf::kDISvbarnCC2pi_2020},{"DISvbarnCC3pi_2020", cmf::kDISvbarnCC3pi_2020},{"DISvbarnNC0pi_2020", cmf::kDISvbarnNC0pi_2020},{"DISvbarnNC1pi_2020", cmf::kDISvbarnNC1pi_2020},{"DISvbarnNC2pi_2020", cmf::kDISvbarnNC2pi_2020},{"DISvbarnNC3pi_2020", cmf::kDISvbarnNC3pi_2020},{"FormZone_2020", cmf::kFormZone_2020},{"hNFSISyst2020_EV2", cmf::khNFSISyst2020_EV2},{"hNFSISyst2020_EV3", cmf::khNFSISyst2020_EV3},{"COHCCScaleSyst2018", cmf::kCOHCCScaleSyst2018},{"COHNCScaleSyst2018", cmf::kCOHNCScaleSyst2018},{"FluxPCA00", cmf::kFluxPCA00},{"FluxPCA01", cmf::kFluxPCA01},{"FluxPCA02", cmf::kFluxPCA02},{"FluxPCA03", cmf::kFluxPCA03},{"FluxPCA04", cmf::kFluxPCA04},{"KaonSyst", cmf::kKaonSyst},{"-2sigma", cmf::kMinus2Sigma},{"-1sigma", cmf::kMinus1Sigma},{"+1sigma", cmf::kPlus1Sigma},{"+2sigma", cmf::kPlus2Sigma}})
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::OscPar const &op)
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::InteractionType_t	StringToInteractionType (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 bool	IsNCSelected (cmf::SelectionType_t const &sel)
static uint8_t	VarNameToKey (std::string const &name)
static std::string	KeyToVarName (uint8_t const &key)
static std::string	OscParMapToString (cmf::OscillationParameterMap const &opm)
long	StringToKey (std::string const &str)
long	PeriodStringToInt (std::string const &epochStr)
std::ostream &	operator<< (std::ostream &o, SpillSummary const &ss)
double	FitFunction_ForROOT (const double *params)
void	ParameterSetToLocation (fhicl::ParameterSet const &pset, cmf::DetType_t const &det, cmf::Location &loc)
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	gHadE
static int	gBin
static int	gOffset
static const double	kGarbageDouble = std::numeric_limits<double>::max()
static const float	kGarbageFloat = std::numeric_limits<float >::max()
static const uint8_t	kNumSigmaSysts = kLastSigmaVar - kFirstSigmaVar + 1
static const uint8_t	kNumCalibSysts = kLastCalibrationVar - kFirstCalibrationVar + 1
static const uint8_t	kNumEShiftSysts = kLastEShiftVar - kFirstEShiftVar + 1
static const uint8_t	kNumNormSysts = kLastNormalizationVar - kFirstNormalizationVar + 1
static CovarianceFitHelper *	gCovFitHelp = nullptr
std::unique_ptr< cmf::EventListColl >	gMCEventLists
std::unique_ptr< cmf::ExposureMap >	gExposureMap
std::unique_ptr< cmf::Location >	gLoc
std::unique_ptr< std::vector< double > >	gFFVals
std::unique_ptr< std::vector< std::string > >	gFFNames
ROOT::Math::Minimizer *	gFFMin
cmf::ChiSqrCalc_t	gChiSqrCalc
double	gMinChiSqr
int	gMinStatus
static const double	gPI = 3.141592653589793238462643383279502884
static SpectrumPredictionMaker *	gLPU = nullptr
static ChiSqrCalculator *	gChiSqrCalculator = nullptr
static CovarianceBinUtility *	gCovBinUtil = nullptr
static ParameterUtility *	gParUtil = nullptr
static PlotUtilities *	gPlotUtil = nullptr
static RandomUniverseUtility *	gRUU = nullptr
static SelectionUtility *	gSU = nullptr

Detailed Description

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

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

Use covariance matrices in fits.

Author

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

Typedef Documentation

typedef enum cmf::beam_type cmf::BeamType_t

typedef enum cmf::calc_type cmf::CalcType_t

typedef enum cmf::chisqr_type cmf::ChiSqrCalc_t

typedef enum cmf::cont_type cmf::ContourType_t

typedef enum cmf::covmat_type cmf::CovMat_t

typedef enum cmf::dataMC_type cmf::DataMC_t

typedef std::pair<cmf::DetType_t, cmf::BeamType_t> cmf::DetBeamPair

Definition at line 738 of file Constants.h.

typedef enum cmf::det_type cmf::DetType_t

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

Definition at line 92 of file Event.h.

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

Definition at line 150 of file Event.h.

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

Definition at line 91 of file Event.h.

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

Definition at line 215 of file Structs.h.

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

Definition at line 14 of file FakeUniverse.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 745 of file Constants.h.

typedef enum cmf::osc_params cmf::OscParm_t

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

Definition at line 744 of file Constants.h.

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

Definition at line 737 of file Constants.h.

typedef enum cmf::par_type cmf::ParType_t

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

Definition at line 44 of file GridPointResult.h.

typedef enum cmf::sel_type cmf::SelectionType_t

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

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

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

enum cmf::calc_type

Enumerator
kPMNS
kNSI
kSterile

Definition at line 325 of file Constants.h.

                        {
    kPMNS=0,
    kNSI,
    kSterile
  } CalcType_t;

enum cmf::chisqr_type

Enumerator
kCovMat
kPoisson
kCNP
kGauss
kUnknownChiSqr

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

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

enum cmf::covmat_type

Enumerator
kStatMatrix
kSystMatrix
kTotalMatrix

Definition at line 333 of file Constants.h.

                          {
    kStatMatrix=0,
    kSystMatrix,
    kTotalMatrix
  }CovMat_t;

enum cmf::dataMC_type

Enumerator
kData
kMC
kFakeData
kBoth

Definition at line 357 of file Constants.h.

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

enum cmf::det_type

Enumerator
kUnknownDet
kNEARDET
kFARDET
kMINOSNEAR
kMINOSFAR
kALLDET

Definition at line 21 of file Constants.h.

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

enum cmf::file_type

Enumerator
kBeam
kSwap
kTauSwap
kDataFile
kCosmicBackgroundFile
kRockFluxSwap
kRockNonSwap
kNumFileTypes
kBadFileType
kUnknownFileType

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

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

enum cmf::minosRP

Enumerator
kRun1
kRunpHE
kRun2
kRun3
kRun4
kRun5
kRun6
kRun7
kRun9
kRun10
kRun11
kRun12
kRun13
kEnd

Definition at line 51 of file CMFDSTToEventList_module.cc.

                 {
        kRun1,
        kRunpHE,
        kRun2,
        kRun3,
        kRun4,
        kRun5,
        kRun6,
        kRun7,
        kRun9,
        kRun10,
        kRun11,
        kRun12,
        kRun13,
        kEnd
    };

enum cmf::osc_params

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

Definition at line 205 of file Constants.h.

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

enum cmf::par_type

Enumerator
kOscPar
kCMFSystPar
kCMFWeightPar
kCMFNormSystPar
kCalibSystPar
kEShiftSystPar
kOtherSystPar
kUnknownPar

Definition at line 716 of file Constants.h.

                       {
    kOscPar = 0,
    kCMFSystPar,
    kCMFWeightPar,
    kCMFNormSystPar,
    kCalibSystPar,
    kEShiftSystPar,
    kOtherSystPar,
    kUnknownPar
  } ParType_t;

enum cmf::sel_type

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

Definition at line 82 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
kNu_RecoE
kCMF_RecoE
kHad_RecoE
kLep_RecoE
kLep_RecoE_MCFrac
kRecoQ2
kFake_Weight
kTrueE
kTruePDG
kTrueCCNC
kTrueIntType
kTruePDGOrig
kTrueParentPDG
kTrueParentPT
kTrueParentPZ
kTrueParentDecay
kTrueParentTargetPDG
kTrueHitNuc
kTrueIntMode
kXSecCVPPFX_Weight
kXSecCV2020Wgt
kPPFXFluxCVWgt
kRPARES_Weight
kMinus2Sigma
kMinus1Sigma
kPlus1Sigma
kPlus2Sigma
kFirstSigmaVar
kMaCCRES
kMvCCRES
kMaNCRES
kMvNCRES
kRPACCQEshapeEnh
kRPACCQEshapeSupp
kZNormCCQE
kZExpEV1Syst2020
kZExpEV2Syst2020
kZExpEV3Syst2020
kZExpEV4Syst2020
kRESLowQ2SuppSyst2020
khNFSISyst2020_MFP
khNFSISyst2020_EV1
kMECEnuShapeSyst2020Nu
kMECEnuShapeSyst2020AntiNu
kMECShapeSyst2020Nu
kMECShapeSyst2020AntiNu
kMECInitStateNPFracSyst2020Nu
kMECInitStateNPFracSyst2020AntiNu
kRadCorrNue
kRadCorrNuebar
k2ndClassCurrs
kTauScaleSyst
kDISvpCC0pi_2020
kDISvpCC1pi_2020
kDISvpCC2pi_2020
kDISvpCC3pi_2020
kDISvpNC0pi_2020
kDISvpNC1pi_2020
kDISvpNC2pi_2020
kDISvpNC3pi_2020
kDISvnCC0pi_2020
kDISvnCC1pi_2020
kDISvnCC2pi_2020
kDISvnCC3pi_2020
kDISvnNC0pi_2020
kDISvnNC1pi_2020
kDISvnNC2pi_2020
kDISvnNC3pi_2020
kDISvbarpCC0pi_2020
kDISvbarpCC1pi_2020
kDISvbarpCC2pi_2020
kDISvbarpCC3pi_2020
kDISvbarpNC0pi_2020
kDISvbarpNC1pi_2020
kDISvbarpNC2pi_2020
kDISvbarpNC3pi_2020
kDISvbarnCC0pi_2020
kDISvbarnCC1pi_2020
kDISvbarnCC2pi_2020
kDISvbarnCC3pi_2020
kDISvbarnNC0pi_2020
kDISvbarnNC1pi_2020
kDISvbarnNC2pi_2020
kDISvbarnNC3pi_2020
kFormZone_2020
khNFSISyst2020_EV2
khNFSISyst2020_EV3
kCOHCCScaleSyst2018
kCOHNCScaleSyst2018
kMaNCEL
kEtaNCEL
kAhtBY
kBhtBY
kCV1uBY
kCV2uBY
kAGKY_xF1pi
kAGKY_pT1pi
kBR1gamma
kBR1eta
kTheta_Delta2Npi
kFluxPCA00
kFluxPCA01
kFluxPCA02
kFluxPCA03
kFluxPCA04
kKaonSyst
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
kLastSigmaVar
kFirstNormalizationVar
kNormalizationPOT
kNormalizationNDMass
kNormalizationFDMass
kNormalizationML
kNormalizationFHCNuMuContext
kNormalizationRHCNuMuContext
kNormalizationFHCNuEContext
kNormalizationRHCNuEContext
kNormalizationFHCNCContext
kNormalizationRHCNCContext
kLastNormalizationVar
kFirstCalibrationVar
kLightModelND
kLightModelFD
kCherenkov
kAbsoluteCalibrationND
kAbsoluteCalibrationFD
kCalibShapeND
kCalibShapeFD
kDetectorAging
kLastCalibrationVar
kFirstEShiftVar
kUnCorrNDMuEScaleSyst2020
kUnCorrMuCatMuESyst2020
kPileupMuESyst2020
kCorrMuEScaleSyst2020
kNeutronVisEScalePrimariesSyst2018
kMichelTaggingSyst2020
kLastEShiftVar

Definition at line 374 of file Constants.h.

                   {
    kUnknownVar = 0,

    // Data info - kFake_Weight is in this group because it only applies to fake data
    // kNu_RecoE - the reconstructed energy directly from the CAFs
    // kCMF_RecoE - the reconstructed energy using Energy Estimators in CMF
    kNuE_CVN,
    kNuE_NumMichel,
    kNu_RecoE,
    kCMF_RecoE,
    kHad_RecoE,
    kLep_RecoE,
    kLep_RecoE_MCFrac,
    kRecoQ2,
    kFake_Weight,

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

    // MC Reweighting info
    kXSecCVPPFX_Weight,
    kXSecCV2020Wgt,
    kPPFXFluxCVWgt,
    kRPARES_Weight,

    // Systematic uncertainties where we store -2, -1, +1, +2 sigma values
    kMinus2Sigma,
    kMinus1Sigma,
    kPlus1Sigma,
    kPlus2Sigma,

    // other systematics
    kFirstSigmaVar,
    kMaCCRES=kFirstSigmaVar,
    kMvCCRES,
    kMaNCRES,
    kMvNCRES,
    kRPACCQEshapeEnh,
    kRPACCQEshapeSupp,

    // new for 2020
    kZNormCCQE,
    kZExpEV1Syst2020,
    kZExpEV2Syst2020,
    kZExpEV3Syst2020,
    kZExpEV4Syst2020,
    kRESLowQ2SuppSyst2020,
    khNFSISyst2020_MFP,
    khNFSISyst2020_EV1,
    kMECEnuShapeSyst2020Nu,
    kMECEnuShapeSyst2020AntiNu,
    kMECShapeSyst2020Nu,
    kMECShapeSyst2020AntiNu,
    kMECInitStateNPFracSyst2020Nu,
    kMECInitStateNPFracSyst2020AntiNu,
    kRadCorrNue,
    kRadCorrNuebar,
    k2ndClassCurrs,
    kTauScaleSyst,
    kDISvpCC0pi_2020,
    kDISvpCC1pi_2020,
    kDISvpCC2pi_2020,
    kDISvpCC3pi_2020,
    kDISvpNC0pi_2020,
    kDISvpNC1pi_2020,
    kDISvpNC2pi_2020,
    kDISvpNC3pi_2020,
    kDISvnCC0pi_2020,
    kDISvnCC1pi_2020,
    kDISvnCC2pi_2020,
    kDISvnCC3pi_2020,
    kDISvnNC0pi_2020,
    kDISvnNC1pi_2020,
    kDISvnNC2pi_2020,
    kDISvnNC3pi_2020,
    kDISvbarpCC0pi_2020,
    kDISvbarpCC1pi_2020,
    kDISvbarpCC2pi_2020,
    kDISvbarpCC3pi_2020,
    kDISvbarpNC0pi_2020,
    kDISvbarpNC1pi_2020,
    kDISvbarpNC2pi_2020,
    kDISvbarpNC3pi_2020,
    kDISvbarnCC0pi_2020,
    kDISvbarnCC1pi_2020,
    kDISvbarnCC2pi_2020,
    kDISvbarnCC3pi_2020,
    kDISvbarnNC0pi_2020,
    kDISvbarnNC1pi_2020,
    kDISvbarnNC2pi_2020,
    kDISvbarnNC3pi_2020,
    kFormZone_2020,
    khNFSISyst2020_EV2,
    khNFSISyst2020_EV3,
    kCOHCCScaleSyst2018,
    kCOHNCScaleSyst2018,
    kMaNCEL,
    kEtaNCEL,
    kAhtBY,
    kBhtBY,
    kCV1uBY,
    kCV2uBY,
    kAGKY_xF1pi,
    kAGKY_pT1pi,
    kBR1gamma,
    kBR1eta,
    kTheta_Delta2Npi,
    kFluxPCA00,
    kFluxPCA01,
    kFluxPCA02,
    kFluxPCA03,
    kFluxPCA04,
    kKaonSyst,

    // nux MEC systs
    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,
    kLastSigmaVar=kBaselineNux,

    // anything below this point can be safely modified 
    // without disturbing current event lists, since they either
    // -- come from files
    // -- are calculated on the fly

    // norm syst
    kFirstNormalizationVar,
    kNormalizationPOT=kFirstNormalizationVar,
    kNormalizationNDMass,
    kNormalizationFDMass,
    kNormalizationML,
    kNormalizationFHCNuMuContext,
    kNormalizationRHCNuMuContext,
    kNormalizationFHCNuEContext,
    kNormalizationRHCNuEContext,
    kNormalizationFHCNCContext,
    kNormalizationRHCNCContext,
    kLastNormalizationVar=kNormalizationRHCNCContext,

    // calibration related uncertainties
    kFirstCalibrationVar,
    kLightModelND=kFirstCalibrationVar,
    kLightModelFD,
    kCherenkov,
    kAbsoluteCalibrationND,
    kAbsoluteCalibrationFD,
    kCalibShapeND,
    kCalibShapeFD,
    kDetectorAging,
    kLastCalibrationVar=kDetectorAging,

    // other E-shift systematics
    kFirstEShiftVar,
    kUnCorrNDMuEScaleSyst2020=kFirstEShiftVar,
    kUnCorrMuCatMuESyst2020,
    kPileupMuESyst2020,
    kCorrMuEScaleSyst2020,
    kNeutronVisEScalePrimariesSyst2018,
    kMichelTaggingSyst2020,
    kLastEShiftVar=kMichelTaggingSyst2020

  };

enum cmf::weight_type

Enumerator
kSystWgtOnly
kOscWgtOnly
kSystAndOscWgt
kAllWgt
kNoWgt

Definition at line 727 of file Constants.h.

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

Function Documentation

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

inlinestatic

Definition at line 239 of file StaticFuncs.h.

References kFHC, and kRHC.

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

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

  return 0;
}

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

inlinestatic

Definition at line 18 of file StaticFuncs.h.

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

{ return (bt + 1) * 10000;      }

const std::vector<std::string> cmf::cBeamType_LatexStrings

(

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

)

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

const std::vector<std::string> cmf::cBeamType_Strings

(

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

)

Referenced by cmf::CovarianceMatrixMaker::beginJob(), cmf::EventListManipulator::Deserialize(), cmf::ShifterAndWeighter::FileSystWeight(), cmf::EventListManipulator::FillTextFile(), cmf::CovarianceBinUtility::KeyToOffset(), KeyToString(), cmf::ShifterAndWeighter::LoadRatiosFromFile(), cmf::CovarianceFitHelper::Make1DSpectra(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), cmf::SelectionUtility::PrintSelections(), cmf::OscParamPoint::ScaleSpectra(), cmf::EventListManipulator::SetExposures(), and cmf::MetaData::ToString().

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

static

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

const std::vector<std::string> cmf::cChiSqrCalcType_Strings

(

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

)

Referenced by cmf::CovarianceFitHelper::MakeIterationGraphs(), and StringToDetectorType().

const std::vector<std::string> cmf::cContourTypeStrings

(

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

)

Referenced by StringToDetectorType().

static std::vector<std::string> cmf::cDataTypeStrings ( {"Data","MC","FakeData","Data and MC"}  )

static

Referenced by cmf::EventListManipulator::Deserialize().

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

static

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

const std::vector<std::string> cmf::cDetType_Strings

(

{"UnknownDet","NearDet","FarDet","MINOSNear","MINOSFar","AllDetectors"}

)

Referenced by cmf::CovarianceMatrixMaker::beginJob(), cmf::ParameterSpaceLoc::count(), cmf::EventListManipulator::Deserialize(), cmf::Location::DetectorLocation(), cmf::MetaData::DetectorString(), cmf::ShifterAndWeighter::FileSystWeight(), cmf::ShifterAndWeighter::FractionalShift(), cmf::ParameterUtility::Initialize(), cmf::SpectrumPredictionMaker::Initialize(), cmf::CovarianceFitHelper::InitializeGlobalVars(), cmf::ShifterAndWeighter::InitShiftsAndWeightsForDetector(), cmf::CovarianceBinUtility::KeyToOffset(), KeyToString(), cmf::ShifterAndWeighter::LoadRatiosFromFile(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), cmf::SpectrumPredictionMaker::MakePredictions(), operator<<(), cmf::Location::OscillationParameters(), cmf::ParameterUtility::OscParameterInfo(), cmf::ParameterSpaceLoc::Parameter(), cmf::SelectionUtility::PrintSelections(), cmf::CMFCappedEventList::reconfigure(), cmf::RandomUniverses::reconfigure(), cmf::OscParamPoint::ScaleSpectra(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), cmf::EventListManipulator::SetExposures(), cmf::ParameterSpaceLoc::SetParameterValue(), cmf::Location::SetParameterValue(), cmf::CovarianceMatrixMaker::SetSystematicParameter(), StringToDetectorType(), StringToKey(), cmf::MetaDataLite::ToString(), cmf::MetaData::ToStringLatex(), and cmf::RandomUniverses::writeResults().

const std::vector<std::string> cmf::cFileTypeStrings

(

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

)

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

const std::vector<std::string> cmf::cFileTypeStrings_Latex

(

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

)

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

const std::vector<std::string> cmf::cInteractionType_LatexStrings

(

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

)

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

const std::vector<std::string> cmf::cInteractionType_Strings

(

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

)

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

const std::vector<std::string> cmf::cOscParams_LatexScales

(

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

)

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

const std::vector<double> cmf::cOscParams_Scales

(

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

)

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

const std::vector<std::string> cmf::cOscParams_Strings

(

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

)

Referenced by cmf::RandomUniverses::beginJob(), cmf::GridPointsBestFit::BestFitPlots(), cmf::ChiSqrCalculator::ChiSqr(), cmf::ContourFromLibrary::ContourForUniverse(), cmf::ContourFromGrid::CreateChiSqrMaps(), cmf::SpectraFromPredictions::endJob(), cmf::ContourFromGrid::endJob(), cmf::ContourFromLibrary::endJob(), cmf::SpectrumPredictionMaker::FindOscillationPoints(), cmf::PlotUtilities::Initialize(), cmf::SpectrumPredictionMaker::Initialize(), cmf::Location::Location(), cmf::PlotUtilities::Make1DPlot(), cmf::PlotUtilities::Make2DContours(), cmf::PlotUtilities::Make2DHist(), cmf::ContourFromGrid::MakeAndStorePlots(), cmf::ContourFromLibrary::MakeAndStorePlots(), cmf::PlotUtilities::MakeCLHeatMaps(), cmf::SpectrumPredictionMaker::MakeHiddenParameterHistograms(), cmf::Parameter::Name(), operator<<(), cmf::OscParamPoint::OscParamPoint(), OscParMapToString(), cmf::SpectraFromPredictions::reconfigure(), StringToDetectorType(), and cmf::GridPointsBestFit::writeResults().

const std::vector<std::string> cmf::cOscParams_Strings_Latex

(

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

)

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

const std::vector<std::string> cmf::cSelectionType_LatexStrings

(

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

)

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

const std::vector<std::string> cmf::cSelectionType_Strings

(

{"NuESel_AllPID","NuESel_LowPID","NuESel_MidPID","NuESel_HighPID","NuESel_Peripheral","NuMuSel","NuMuSelQ1","NuMuSelQ2","NuMuSelQ3","NuMuSelQ4","NCSel","UnknownSel"}

)

Referenced by cmf::CovarianceMatrixMaker::beginJob(), cmf::EventListManipulator::Deserialize(), cmf::DSTToEventList::endJob(), cmf::CAFToEventList::endJob(), cmf::ShifterAndWeighter::FileSystWeight(), cmf::EventListManipulator::FillTextFile(), cmf::CovarianceBinUtility::KeyToOffset(), KeyToString(), cmf::ShifterAndWeighter::LoadRatiosFromFile(), cmf::CovarianceFitHelper::Make1DSpectra(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), cmf::SelectionUtility::PrintSelections(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), StringToSelectionType(), cmf::MetaDataLite::ToString(), cmf::MetaData::ToString(), and cmf::EventListManipulator::UseEventsFromMetaData().

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

inlinestatic

Definition at line 61 of file StaticFuncs.h.

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

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

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

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

inlinestatic

Definition at line 15 of file StaticFuncs.h.

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

{ return det      * 1000000000; }

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

inlinestatic

Definition at line 17 of file StaticFuncs.h.

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

{ return (ft + 1) * 100000;     }

void cmf::FillSpectrum	(	cmf::EventListColl const &	eventLists,
		cmf::ExposureMap const &	exposureMap,
		cmf::Spectrum &	spectrum,
		cmf::Spectrum &	count,
		cmf::InteractionType_t	intType,
		bool	applyExposureNorm
	)

Definition at line 135 of file SpectrumTools.cxx.

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

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

  {

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

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

      if(md.interactionType != intType) continue;

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

  }

void cmf::FillSpectrum	(	cmf::EventListColl const &	eventLists,
		cmf::ExposureMap const &	exposureMap,
		cmf::Spectrum &	spectrum,
		cmf::Spectrum &	count,
		bool	applyExposureNorm
	)

Definition at line 166 of file SpectrumTools.cxx.

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

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

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

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

void cmf::FillSpectrumFromSingleList	(	cmf::EventList const &	list,
		cmf::MetaData const &	md,
		cmf::ExposureMap const &	exposureMap,
		cmf::Spectrum &	spectrum,
		cmf::Spectrum &	count,
		bool	applyExposureNorm
	)

Definition at line 28 of file SpectrumTools.cxx.

References cmf::MetaData::detector, cmf::MetaData::DetectorBeamSelectionKey(), cmf::CovarianceBinUtility::EnergyToBin(), evt, cmf::MetaData::fileType, gBin, gNormalization, cmf::SpillSummary::goodPOT, gWeight, cmf::CovarianceBinUtility::Instance(), cmf::ShifterAndWeighter::Instance(), cmf::MetaData::isMC, kCMF_RecoE, kCosmicBackgroundFile, kDataFile, cmf::CovarianceBinUtility::KeyToOffset(), kHad_RecoE, kLep_RecoE, kUnknownInteraction, cmf::EventList::ListSpillSummary(), cmf::SpillSummary::liveTime, MF_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;
        }

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

      }
      else gNormalization = 1;

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

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

        gRecoE = evt->DataVals().val_at(cmf::kCMF_RecoE, md);

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

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

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

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

  }

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

Definition at line 44 of file Event.cxx.

References fetch_tb_beamline_files::md.

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

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

    return eventListColl.end();
  }

double cmf::FitFunction_ForROOT

(

const double *

params

)

Definition at line 50 of file CovarianceFitHelper.cxx.

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

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

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

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

      if(cmf::IsAngleParameter(cmf::StringToOscParmType((*gFFNames)[i])) )
        MF_LOG_VERBATIM("CovarianceFit")
        << "\t"
        << (*gFFNames)[i]
        << " : "
        << params[i]
        << "; sin^2("
        << (*gFFNames)[i]
        << "): "
        << std::pow(std::sin(params[i]), 2.);
      else if ((*gFFNames)[i] == "dCP")
        MF_LOG_VERBATIM("CovarianceFit")
        << "\t"
        << (*gFFNames)[i]
        << " : "
        << params[i]
        << " = "
        << params[i] / gPI
        << " (pi)";
      else
        MF_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());

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

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

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


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

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

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

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

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

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

inlinestatic

Definition at line 20 of file StaticFuncs.h.

References POTSpillRate::beam, BeamToPeriod(), fillBadChanDBTables::det, DetectorBeamSelectionTypesToKey(), IsAngleParameter(), IsNCSelected(), IsNuESelected(), IsNuMuQuantiles(), IsNuMuSelected(), IsOscillationParameter(), findDuplicateFiles::key, KeyToBeamType(), KeyToDetectorType(), KeyToEpoch(), KeyToFileType(), KeyToInteractionType(), KeyToSelectionType(), KeyToString(), KeyToVarName(), OscParMapToString(), par, PeriodToBeamType(), submit_syst::str, string, StringToBeamType(), StringToChiSqrType(), StringToContourType(), StringToDetectorType(), StringToInteractionType(), 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 354 of file StaticFuncs.h.

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

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

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

  return false;
}

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

inlinestatic

Definition at line 387 of file StaticFuncs.h.

References kNCSelection.

Referenced by InteractionTypeKey(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), and cmf::MetaData::Period().

{
  return sel == cmf::kNCSelection;
}

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

inlinestatic

Definition at line 380 of file StaticFuncs.h.

References kNuESelection, and kNuESelectionPeripheral.

Referenced by cmf::EventListManipulator::Deserialize(), cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), cmf::MetaData::IsNuESelected(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), cmf::CovarianceBinUtility::NumSelectionBins(), cmf::MetaData::Period(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), cmf::CovarianceBinUtility::SelectionHighEdges(), cmf::CovarianceBinUtility::SelectionLowEdge(), 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 373 of file StaticFuncs.h.

References kNuMuSelectionQ1, and kNuMuSelectionQ4.

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

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

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

inlinestatic

Definition at line 366 of file StaticFuncs.h.

References IsNuMuQuantiles(), and kNuMuSelection.

Referenced by cmf::ChiSqrCalculator::FindReducedMatrixBin(), InteractionTypeKey(), cmf::MetaData::IsNuMuSelected(), cmf::PlotUtilities::MakeEnergySpectraFromBins(), cmf::CovarianceBinUtility::NumSelectionBins(), cmf::MetaData::Period(), cmf::CovarianceBinUtility::SelectionBinToEnergy(), cmf::CovarianceBinUtility::SelectionHighEdges(), cmf::CovarianceBinUtility::SelectionLowEdge(), 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(), cmf::ParameterUtility::ParameterInfo(), and StringToDetectorType().

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

inlinestatic

Definition at line 135 of file StaticFuncs.h.

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

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

{
  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;

  MF_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 69 of file StaticFuncs.h.

References kUnknownDet, and MF_LOG_DEBUG.

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

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

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

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

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

inlinestatic

Definition at line 83 of file StaticFuncs.h.

References DetectorTypeKey(), findDuplicateFiles::key, KeyToDetectorType(), kUnknownDet, and MF_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;

  MF_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 108 of file StaticFuncs.h.

References DetectorTypeKey(), KeyToDetectorType(), KeyToEpoch(), kUnknownDet, kUnknownFileType, MF_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;

  MF_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 207 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 169 of file StaticFuncs.h.

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

Referenced by cmf::CovarianceMatrixMaker::beginJob(), 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;

  MF_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 227 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 410 of file StaticFuncs.h.

References kVarNameToKey().

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

{
  for(auto const& itr : cmf::kVarNameToKey){
    if(itr.second == key) return itr.first;
  }
  return "Unknown";
}

static const std::map<std::string, uint8_t> cmf::kVarNameToKey ( {{"NuE_CVN", cmf::kNuE_CVN},{"NuE_NumMichel", cmf::kNuE_NumMichel},{"Had_RecoE", cmf::kHad_RecoE},{"Lep_RecoE", cmf::kLep_RecoE},{"Nu_RecoE", cmf::kNu_RecoE},{"Lep_RecoE_MCFrac", cmf::kLep_RecoE_MCFrac},{"Reco_Q2", cmf::kRecoQ2},{"Fake_Weight", cmf::kFake_Weight},{"TrueE", cmf::kTrueE},{"TruePDG", cmf::kTruePDG},{"TrueCCNC", cmf::kTrueCCNC},{"TrueIntType", cmf::kTrueIntType},{"TruePDGOrig", cmf::kTruePDGOrig},{"TrueParentPDG", cmf::kTrueParentPDG},{"TrueParentPT", cmf::kTrueParentPT},{"TrueParentPZ", cmf::kTrueParentPZ},{"TrueParentDecay", cmf::kTrueParentDecay},{"TrueParentTargetPDG", cmf::kTrueParentTargetPDG},{"TrueHitNuc", cmf::kTrueHitNuc},{"TrueIntMode", cmf::kTrueIntMode},{"XsecCV2020", cmf::kXSecCV2020Wgt},{"PPFXFluxCV", cmf::kPPFXFluxCVWgt},{"RPARES", cmf::kRPARES_Weight},{"UnCorrNDMuEScaleSyst2020", cmf::kUnCorrNDMuEScaleSyst2020},{"UnCorrMuCatMuESyst2020", cmf::kUnCorrMuCatMuESyst2020},{"PileupMuESyst2020", cmf::kPileupMuESyst2020},{"CorrMuEScaleSyst2020", cmf::kCorrMuEScaleSyst2020},{"NeutronEvisPrimariesSyst2018", cmf::kNeutronVisEScalePrimariesSyst2018},{"MichelTaggingSyst2020", cmf::kMichelTaggingSyst2020},{"llND", cmf::kLightModelND},{"llFD", cmf::kLightModelFD},{"cherenkov", cmf::kCherenkov},{"calibND", cmf::kAbsoluteCalibrationND},{"calibFD", cmf::kAbsoluteCalibrationFD},{"calibshapeND", cmf::kCalibShapeND},{"calibshapeFD", cmf::kCalibShapeFD},{"detectoraging", cmf::kDetectorAging},{"NormalizationPOT", cmf::kNormalizationPOT},{"NormalizationNDMass", cmf::kNormalizationNDMass},{"NormalizationFDMass", cmf::kNormalizationFDMass},{"NormalizationML", cmf::kNormalizationML},{"NormalizationFHCNuMuContext", cmf::kNormalizationFHCNuMuContext},{"NormalizationRHCNuMuContext", cmf::kNormalizationRHCNuMuContext},{"NormalizationFHCNuEContext", cmf::kNormalizationFHCNuEContext},{"NormalizationRHCNuEContext", cmf::kNormalizationRHCNuEContext},{"NormalizationFHCNCContext", cmf::kNormalizationFHCNCContext},{"NormalizationRHCNCContext", cmf::kNormalizationRHCNCContext},{"MaNCEL", cmf::kMaNCEL},{"EtaNCEL", cmf::kEtaNCEL},{"AhtBY", cmf::kAhtBY},{"BhtBY", cmf::kBhtBY},{"CV1uBY", cmf::kCV1uBY},{"CV2uBY", cmf::kCV2uBY},{"AGKY_xF1pi", cmf::kAGKY_xF1pi},{"AGKY_pT1pi", cmf::kAGKY_pT1pi},{"BR1gamma", cmf::kBR1gamma},{"BR1eta", cmf::kBR1eta},{"Theta_Delta2Npi", cmf::kTheta_Delta2Npi},{"MvCCRES", cmf::kMvCCRES},{"MaCCRES", cmf::kMaCCRES},{"MvNCRES", cmf::kMvNCRES},{"MaNCRES", cmf::kMaNCRES},{"RPACCQEshapeEnh", cmf::kRPACCQEshapeEnh},{"RPACCQEshapeSupp", cmf::kRPACCQEshapeSupp},{"COHCCScale2018", cmf::kCOHCCScaleSyst2018},{"COHNCScale2018", cmf::kCOHNCScaleSyst2018},{"ZExpAxialFFSyst2020_eV1", cmf::kZExpEV1Syst2020},{"ZExpAxialFFSyst2020_eV2", cmf::kZExpEV2Syst2020},{"ZExpAxialFFSyst2020_eV3", cmf::kZExpEV3Syst2020},{"ZExpAxialFFSyst2020_eV4", cmf::kZExpEV4Syst2020},{"ZNormCCQE", cmf::kZNormCCQE},{"RESLowQ2SuppSyst2020", cmf::kRESLowQ2SuppSyst2020},{"hNFSISyst2020_MFP", cmf::khNFSISyst2020_MFP},{"hNFSISyst2020_EV1", cmf::khNFSISyst2020_EV1},{"MECEnuShapeSyst2020Nu", cmf::kMECEnuShapeSyst2020Nu},{"MECEnuShapeSyst2020AntiNu", cmf::kMECEnuShapeSyst2020AntiNu},{"MECShapeSyst2020Nu", cmf::kMECShapeSyst2020Nu},{"MECShapeSyst2020AntiNu", cmf::kMECShapeSyst2020AntiNu},{"MECInitStateNPFracSyst2020Nu", cmf::kMECInitStateNPFracSyst2020Nu},{"MECInitStateNPFracSyst2020AntiNu", cmf::kMECInitStateNPFracSyst2020AntiNu},{"RadCorrNue", cmf::kRadCorrNue},{"RadCorrNuebar", cmf::kRadCorrNuebar},{"2ndClassCurrs", cmf::k2ndClassCurrs},{"Norm_1Nux", cmf::kNorm_1Nux},{"MeanQ0_1Nux", cmf::kMeanQ0_1Nux},{"MeanQ3_1Nux", cmf::kMeanQ3_1Nux},{"SigmaQ0_1Nux", cmf::kSigmaQ0_1Nux},{"SigmaQ3_1Nux", cmf::kSigmaQ3_1Nux},{"Corr_1Nux", cmf::kCorr_1Nux},{"Norm_2Nux", cmf::kNorm_2Nux},{"MeanQ0_2Nux", cmf::kMeanQ0_2Nux},{"MeanQ3_2Nux", cmf::kMeanQ3_2Nux},{"SigmaQ0_2Nux", cmf::kSigmaQ0_2Nux},{"SigmaQ3_2Nux", cmf::kSigmaQ3_2Nux},{"Corr_2Nux", cmf::kCorr_2Nux},{"BaselineNux", cmf::kBaselineNux},{"TauScaleSyst", cmf::kTauScaleSyst},{"DISvpCC0pi_2020", cmf::kDISvpCC0pi_2020},{"DISvpCC1pi_2020", cmf::kDISvpCC1pi_2020},{"DISvpCC2pi_2020", cmf::kDISvpCC2pi_2020},{"DISvpCC3pi_2020", cmf::kDISvpCC3pi_2020},{"DISvpNC0pi_2020", cmf::kDISvpNC0pi_2020},{"DISvpNC1pi_2020", cmf::kDISvpNC1pi_2020},{"DISvpNC2pi_2020", cmf::kDISvpNC2pi_2020},{"DISvpNC3pi_2020", cmf::kDISvpNC3pi_2020},{"DISvnCC0pi_2020", cmf::kDISvnCC0pi_2020},{"DISvnCC1pi_2020", cmf::kDISvnCC1pi_2020},{"DISvnCC2pi_2020", cmf::kDISvnCC2pi_2020},{"DISvnCC3pi_2020", cmf::kDISvnCC3pi_2020},{"DISvnNC0pi_2020", cmf::kDISvnNC0pi_2020},{"DISvnNC1pi_2020", cmf::kDISvnNC1pi_2020},{"DISvnNC2pi_2020", cmf::kDISvnNC2pi_2020},{"DISvnNC3pi_2020", cmf::kDISvnNC3pi_2020},{"DISvbarpCC0pi_2020", cmf::kDISvbarpCC0pi_2020},{"DISvbarpCC1pi_2020", cmf::kDISvbarpCC1pi_2020},{"DISvbarpCC2pi_2020", cmf::kDISvbarpCC2pi_2020},{"DISvbarpCC3pi_2020", cmf::kDISvbarpCC3pi_2020},{"DISvbarpNC0pi_2020", cmf::kDISvbarpNC0pi_2020},{"DISvbarpNC1pi_2020", cmf::kDISvbarpNC1pi_2020},{"DISvbarpNC2pi_2020", cmf::kDISvbarpNC2pi_2020},{"DISvbarpNC3pi_2020", cmf::kDISvbarpNC3pi_2020},{"DISvbarnCC0pi_2020", cmf::kDISvbarnCC0pi_2020},{"DISvbarnCC1pi_2020", cmf::kDISvbarnCC1pi_2020},{"DISvbarnCC2pi_2020", cmf::kDISvbarnCC2pi_2020},{"DISvbarnCC3pi_2020", cmf::kDISvbarnCC3pi_2020},{"DISvbarnNC0pi_2020", cmf::kDISvbarnNC0pi_2020},{"DISvbarnNC1pi_2020", cmf::kDISvbarnNC1pi_2020},{"DISvbarnNC2pi_2020", cmf::kDISvbarnNC2pi_2020},{"DISvbarnNC3pi_2020", cmf::kDISvbarnNC3pi_2020},{"FormZone_2020", cmf::kFormZone_2020},{"hNFSISyst2020_EV2", cmf::khNFSISyst2020_EV2},{"hNFSISyst2020_EV3", cmf::khNFSISyst2020_EV3},{"COHCCScaleSyst2018", cmf::kCOHCCScaleSyst2018},{"COHNCScaleSyst2018", cmf::kCOHNCScaleSyst2018},{"FluxPCA00", cmf::kFluxPCA00},{"FluxPCA01", cmf::kFluxPCA01},{"FluxPCA02", cmf::kFluxPCA02},{"FluxPCA03", cmf::kFluxPCA03},{"FluxPCA04", cmf::kFluxPCA04},{"KaonSyst", cmf::kKaonSyst},{"-2sigma", cmf::kMinus2Sigma},{"-1sigma", cmf::kMinus1Sigma},{"+1sigma", cmf::kPlus1Sigma},{"+2sigma", cmf::kPlus2Sigma}}  )

static

Referenced by KeyToVarName(), and VarNameToKey().

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

inlinestatic

Definition at line 365 of file VarVals.h.

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

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

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

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

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

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

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

inlinestatic

Definition at line 342 of file VarVals.h.

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

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

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

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

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

inlinestatic

Definition at line 334 of file VarVals.h.

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

{
  return leptonicEnergy + hadronicEnergy;

}

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

Definition at line 27 of file Event.cxx.

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

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

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

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

    o << std::endl;

    return o;
  }

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

Definition at line 34 of file GridPointResult.cxx.

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

  {

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

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

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

    o << gp.Y();

    return o;
  }

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

Definition at line 34 of file InputPoint.cxx.

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

  {

    double val;
    std::string name;

    for(auto const& itr : ip.DetectorParameters()){
      o << "InputPoint " << itr.Detector() << std::endl;

      for(auto const& parItr : itr.Parameters()){
         name = parItr.Name();
         val  = parItr.Value();
         if     (name == "dCP")
           o << "\t" << std::setw(20) << name << " " << std::setw(10) << val << " = " << val/TMath::Pi() << "(pi)" << " fixed: " << parItr.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: " << parItr.IsFixed() << std::endl;
         else if(cmf::IsOscillationParameter(name))
           o << "\t" << std::setw(20) << name << " " << std::setw(10) << val << " fixed: " << parItr.IsFixed() << std::endl;
         else
           o << "\t"<< std::setw(10) << name << " " << std::setw(10) << val << " fixed: " << parItr.IsFixed() << std::endl;
      }   
    } // end loop over detectors

    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(" << cmf::cOscParams_Strings[itr.first] << ") : " << std::pow(std::sin(itr.second), 2.) << std::endl;
      else o << "\t" << std::setw(20) << cmf::cOscParams_Strings[itr.first] << " " << itr.second << std::endl;
    }

    return o;
  }

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

Definition at line 59 of file FakeUniverse.cxx.

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

  {
    o << "universe location ";

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

    o << std::endl;

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

    return o;
  }

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

Definition at line 71 of file VarVals.cxx.

References allTimeWatchdog::endl, KeyToVarName(), 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::kRPARES_Weight)                 << " " << mcvv.val_at(cmf::kRPARES_Weight      )
    << "\n\t and too many GENIE knobs to list"
    << std::endl;

    return o;
  }

std::ostream& cmf::operator<<	(	std::ostream &	o,
		cmf::OscPar const &	op
	)

Definition at line 88 of file Parameter.cxx.

References cOscParams_Strings(), msf_helper::o, cmf::OscPar::Param(), and cmf::OscPar::Value().

                                                             {
    o << cmf::cOscParams_Strings[op.Param()]
      << " " 
      << op.Value();
      
    return o;
  }

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

Definition at line 95 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::EventId const &	evid
	)

Definition at line 142 of file VarVals.cxx.

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

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

    return o;
  }

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

Definition at line 184 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, 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::Location const &	loc
	)

Definition at line 201 of file Parameter.cxx.

References cDetType_Strings(), cmf::Location::DetectorLocations(), allTimeWatchdog::endl, and msf_helper::o.

  {
    auto const& detLocs = loc.DetectorLocations();

    std::set<std::string> parsDone;

    o << std::endl;
    for(auto const& itr : detLocs){
      for(auto const& parItr : itr.Parameters()){

        if(parsDone.find(parItr.Name()) != parsDone.end()) continue;

        parsDone.insert(parItr.Name());

        o << " -- parameter: "  
          << std::setw(30)
          << parItr.Name()
          << std::setw(15)
          << " val "
          << cmf::cDetType_Strings[itr.Detector()]
          << ": "
          << parItr.Value()
          << " fixed: "
          << std::setw(5)
          << parItr.IsFixed();

        // see if this parameter is set for other detectors too
        for(auto const& itr2 : detLocs){
          if(itr2.Detector() == itr.Detector()) continue;
          if(itr2.count(parItr.Name()) > 0){
            auto const& par2 = itr2.Parameter(parItr.Name());
            o << std::setw(15)
              << " val "
              << cmf::cDetType_Strings[itr2.Detector()]
              << ": "
              << std::setw(15)
              << " "
              << par2.Value()
              << " fixed: "
              << std::setw(5)
              << par2.IsFixed();
          }
        } // end loop over other detectors
              o << std::endl;
      } // end loop over parameters 
      o << std::endl;
    } // end loop over the current detector

    return o;
  }

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

Definition at line 205 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;
  }

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

Definition at line 254 of file GridPointResult.cxx.

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

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

    o << std::endl;

    return o;
  }

static std::string cmf::OscParMapToString ( cmf::OscillationParameterMap const &  opm )

inlinestatic

Definition at line 419 of file StaticFuncs.h.

References cOscParams_Strings(), string, and art::to_string().

Referenced by cmf::GridPointsBestFit::FindChiSqrForPoint(), and InteractionTypeKey().

{
  std::string oscParString;
  for(auto const& itr : opm){
    oscParString += " " + cmf::cOscParams_Strings[itr.first] + ": " + std::to_string(itr.second);
  }

  return oscParString;
}

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

Definition at line 12 of file ParameterUtility.cxx.

References fillBadChanDBTables::det, fhicl::ParameterSet::get(), fhicl::ParameterSet::get_names(), cmf::Location::InsertParameter(), fhicl::ParameterSet::is_empty(), PandAna.Demos.demo0::loc, MF_LOG_DEBUG, ParseFluxesFile::param, sigma(), string, 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;

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

    auto const& parNames = pset.get_names();

    for(auto const& itr : parNames){

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

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

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

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

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

        MF_LOG_DEBUG("ParameterSpaceLoc")
            << "inserting parameter "
            << parstr;
      } // end if using the correct detector
    } // end loop over parameter names

    MF_LOG_DEBUG("ParameterSpaceLoc")
      << " full location is "
      << loc;

  }

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

inlinestatic

Definition at line 16 of file StaticFuncs.h.

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

{ return ep       * 10000000;   }

long cmf::PeriodStringToInt

(

std::string const &

epochStr

)

Definition at line 69 of file Structs.cxx.

References MF_LOG_DEBUG, and MF_LOG_WARNING.

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

                                                   {
    size_t first = epochStr.find_first_of("abcdefghijklmnopqrstuvwxyz");
    if(first != std::string::npos){
      MF_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())));
    }

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

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

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

static

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

template<class T >

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

static

template<class T >

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

static

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

template<class T >

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

static

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

inlinestatic

Definition at line 317 of file VarVals.h.

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

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

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

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

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

inlinestatic

Definition at line 19 of file StaticFuncs.h.

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

{ return (st + 1) * 100;        }

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

Definition at line 117 of file Event.cxx.

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

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

  {

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

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

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

    for(auto const& itr : listColl){

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

      metadataTree->Fill();

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

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

    } // end loop over the lists
  }

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

Definition at line 55 of file Event.cxx.

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

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

  {

    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:fNu_RecoE/F:fHad_RecoE/F:fLep_RecoE/F:fLep_RecoE_MCFrac/F:fRecoQ2/F:fFake_Weight/F");
    std::string weightvst("fXSecCVPPFX_Weight/F:fRPACCQE_Weight/F:fRPARES_Weight/F:fDISvnCC1pi_Weight/F:fEmpiricalMEC_Weight/F:fEmpiricalMECtoGENIEQE_Weight/F:fEmpiricalMECtoGENIERES_Weight/F:fOtherDIS_Weight/F:fXSecCVPPFX2020_Weight/F:fPPFXFluxCV_Weight/F");
    std::string truthvrst("fTrueE/F:fTruePDG/F:fTrueCCNC/F:fTrueIntType/F:fTruePDGOrig/F:fTrueParentPDG/F:fTrueNucHit/F:fTrueParentPT/F:fTrueParentPZ/F:fTrueParentDecay/F:fTrueParentTargetPDG/F:fTrueIntMode/F");

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

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

    for(auto & itr : events){

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

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

      eventTree->Fill();
    }
  }

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

inlinestatic

Definition at line 258 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::ContourFromLibrary::reconfigure(), cmf::GridPointsBestFit::reconfigure(), cmf::FitFeldmanCousinsPoint::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 267 of file StaticFuncs.h.

References cChiSqrCalcType_Strings(), cContourTypeStrings(), cDetType_Strings(), cInteractionType_Strings(), cOscParams_Strings(), MECModelEnuComparisons::i, makeTrainCVSamples::int, IsOscillationParameter(), kFHC, kMINOSFAR, kNumOscParams, kRHC, kUnknownBeam, kUnknownChiSqr, kUnknownContour, kUnknownDet, kUnknownInteraction, MF_LOG_WARNING, PeriodToBeamType(), submit_syst::str, string, StringToChiSqrType(), StringToContourType(), StringToInteractionType(), and StringToOscParmType().

Referenced by cmf::SelectionUtility::Initialize(), InteractionTypeKey(), ParameterSetToLocation(), cmf::EventListManipulator::reconfigure(), cmf::DSTToEventList::reconfigure(), cmf::CAFToEventList::reconfigure(), cmf::EventListManipulator::SetExposures(), and StringToKey().

{
  for(uint8_t itr = 1; itr < (uint8_t)cmf::kMINOSFAR + 1; ++itr){
    if(cmf::cDetType_Strings[itr].find(str) != std::string::npos)
      return (cmf::DetType_t)itr;
  }

  return cmf::kUnknownDet;
}

static cmf::InteractionType_t cmf::StringToInteractionType ( std::string const &  str )

static

Referenced by InteractionTypeKey(), and StringToDetectorType().

long cmf::StringToKey

(

std::string const &

str

)

Definition at line 15 of file Structs.cxx.

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

  {
    long key = 0;
    
    // check for the detector
    for(auto const& detItr : cmf::cDetType_Strings){
      if(str.find(detItr) != std::string::npos)
              key += cmf::DetectorTypeKey(cmf::StringToDetectorType(detItr));
    }
    
    // check the period
    if(str.find("Period") != std::string::npos)
      key += cmf::PeriodKey(std::stol(str.substr(str.find("Period") + 6, std::string::npos)));
    else if(str.find("P") != std::string::npos)
      key += cmf::PeriodKey(std::stol(str.substr(str.find("P") + 1, std::string::npos)));

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

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

    return key;
  }

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

static

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

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

inlinestatic

Definition at line 248 of file StaticFuncs.h.

References cSelectionType_Strings(), MECModelEnuComparisons::i, and kUnknownSelection.

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

{
  for(size_t i = 0; i < cmf::cSelectionType_Strings.size() - 1; ++i){
    if(str == cmf::cSelectionType_Strings[i]) return (cmf::SelectionType_t)i;
  }

  return cmf::kUnknownSelection;
}

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

inlinestatic

Definition at line 395 of file StaticFuncs.h.

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

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

{
  auto const& itr = cmf::kVarNameToKey.find(name);
  if(itr != cmf::kVarNameToKey.end()) return itr->second;
  MF_LOG_VERBATIM("VarNameToKey")
    << "Variable name "
    << name
    << " does not correspond to any key, returning 0";

  return cmf::kUnknownVar;
}

Variable Documentation

int cmf::gBin

static

Definition at line 22 of file SpectrumTools.cxx.

Referenced by FillSpectrumFromSingleList().

cmf::ChiSqrCalc_t cmf::gChiSqrCalc

Definition at line 43 of file CovarianceFitHelper.cxx.

ChiSqrCalculator* cmf::gChiSqrCalculator = nullptr

static

Definition at line 18 of file ChiSqrCalculator.cxx.

Referenced by cmf::ChiSqrCalculator::Instance().

CovarianceBinUtility* cmf::gCovBinUtil = nullptr

static

Definition at line 15 of file CovarianceBinUtility.cxx.

Referenced by cmf::CovarianceBinUtility::Instance().

CovarianceFitHelper* cmf::gCovFitHelp = nullptr

static

Definition at line 34 of file CovarianceFitHelper.cxx.

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

std::unique_ptr<cmf::ExposureMap> cmf::gExposureMap

Definition at line 38 of file CovarianceFitHelper.cxx.

ROOT::Math::Minimizer* cmf::gFFMin

Definition at line 42 of file CovarianceFitHelper.cxx.

std::unique_ptr<std::vector<std::string> > cmf::gFFNames

Definition at line 41 of file CovarianceFitHelper.cxx.

std::unique_ptr<std::vector<double> > cmf::gFFVals

Definition at line 40 of file CovarianceFitHelper.cxx.

float cmf::gHadE

static

Definition at line 21 of file SpectrumTools.cxx.

float cmf::gLepE

static

Definition at line 19 of file SpectrumTools.cxx.

std::unique_ptr<cmf::Location> cmf::gLoc

Definition at line 39 of file CovarianceFitHelper.cxx.

SpectrumPredictionMaker* cmf::gLPU = nullptr

static

Definition at line 20 of file SpectrumPredictionMaker.cxx.

Referenced by cmf::SpectrumPredictionMaker::Instance().

std::unique_ptr<cmf::EventListColl> cmf::gMCEventLists

Definition at line 37 of file CovarianceFitHelper.cxx.

double cmf::gMinChiSqr

Definition at line 44 of file CovarianceFitHelper.cxx.

Referenced by cmf::CovarianceFitHelper::FindInitialGuess(), cmf::CovarianceFitHelper::Minimize(), cmf::CovarianceFitHelper::MinimizeCP(), and cmf::CovarianceFitHelper::Result().

int cmf::gMinStatus

Definition at line 45 of file CovarianceFitHelper.cxx.

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

double cmf::gNormalization

static

Definition at line 18 of file SpectrumTools.cxx.

Referenced by FillSpectrumFromSingleList().

int cmf::gOffset

static

Definition at line 23 of file SpectrumTools.cxx.

ParameterUtility* cmf::gParUtil = nullptr

static

Definition at line 81 of file ParameterUtility.cxx.

Referenced by cmf::ParameterUtility::Instance().

const double cmf::gPI = 3.141592653589793238462643383279502884

static

Definition at line 46 of file CovarianceFitHelper.cxx.

PlotUtilities* cmf::gPlotUtil = nullptr

static

Definition at line 23 of file PlotUtilities.cxx.

Referenced by cmf::PlotUtilities::Instance().

float cmf::gRecoE

static

Definition at line 20 of file SpectrumTools.cxx.

RandomUniverseUtility* cmf::gRUU = nullptr

static

Definition at line 20 of file RandomUniverseUtility.cxx.

Referenced by cmf::RandomUniverseUtility::Instance().

ShifterAndWeighter* cmf::gShifterAndWeighter = nullptr

static

Definition at line 31 of file ShifterAndWeighter.cxx.

Referenced by cmf::ShifterAndWeighter::Instance().

SelectionUtility* cmf::gSU = nullptr

static

Definition at line 9 of file SelectionUtility.cxx.

Referenced by cmf::SelectionUtility::Instance().

double cmf::gWeight

static

Definition at line 17 of file SpectrumTools.cxx.

Referenced by FillSpectrumFromSingleList().

const double cmf::kGarbageDouble = std::numeric_limits<double>::max()

static

Definition at line 18 of file Constants.h.

Referenced by cmf::GridPointsBestFit::BestFitPlots(), cmf::ChiSqrInfo::Clear(), cmf::ChiSqrCalculator::CovarianceMatrixEntry(), cmf::ContourFromLibrary::CreateChiSqrMaps(), cmf::ContourFromGrid::CreateChiSqrMaps(), cmf::GridPointsBestFit::FindChiSqrForPoint(), cmf::CovarianceFitHelper::FindInitialGuess(), cmf::SpectrumPredictionMaker::FindOscillationPoints(), cmf::CovarianceFitHelper::InitializeGlobalVars(), and cmf::CovarianceFitHelper::Minimize().

const float cmf::kGarbageFloat = std::numeric_limits<float >::max()

static

Definition at line 19 of file Constants.h.

Referenced by cmf::FitFeldmanCousinsPoint::reconfigure().

const uint8_t cmf::kNumCalibSysts = kLastCalibrationVar - kFirstCalibrationVar + 1

static

Definition at line 559 of file Constants.h.

const uint8_t cmf::kNumEShiftSysts = kLastEShiftVar - kFirstEShiftVar + 1

static

Definition at line 560 of file Constants.h.

const uint8_t cmf::kNumNormSysts = kLastNormalizationVar - kFirstNormalizationVar + 1

static

Definition at line 561 of file Constants.h.

const uint8_t cmf::kNumSigmaSysts = kLastSigmaVar - kFirstSigmaVar + 1

static

Definition at line 558 of file Constants.h.