This guy talks to the input files and is intended to smooth over the fact that our OA fitters use such a beautiful and diverse range of output file structures. More...

#include <Utils/Plotting/InputManager.h>

Collaboration diagram for M3::Plotting::InputManager:

[legend]

Public Member Functions
	InputManager (const std::string &translationConfigName, const std::vector< std::string > &_fileNames)
	Construct a new InputManager using specified fitter translation config file. More...

void	addFile (const std::string &fileName)
	Add a new InputFile object to this input manager. More...

	~InputManager ()
	Destructor. More...

	InputManager (const InputManager &)=delete

	InputManager (InputManager &&)=default

void	print (const std::string &printLevel="summary") const
	Print out what this Inputmanager instance knows about. More...

std::vector< std::vector< double > >	getLLHScan (const int fileNum, const std::string &paramName, const std::string &LLHType) const
	Get the log likelihood scan data for a particular parameter from a particular input file. More...

void	getMCMCentry (const int fileNum, const int entry) const
	Get the MCMC chain entry in an InputFile. More...

double	getMCMCvalue (int fileNum, const std::string &paramName) const
	Get the parameter value for the current step for a particular parameter from a particular input file. More...

std::vector< std::vector< double > >	get1dPosterior (const int fileNum, const std::string &paramName) const
	Get the 1d posterior particular parameter from a particular input file. More...

int	getnMCMCentries (const int fileNum) const
	Get the number of entries in the MCMC chain in a particular file. More...

TGraph	getLLHScan_TGraph (const int fileNum, const std::string &paramName, const std::string &LLHType) const
	Get the log likelihood scan for a particular parameter from a particular input file. More...

TH1D	getLLHScan_TH1D (const int fileNum, const std::string &paramName, const std::string &LLHType) const

std::vector< std::vector< double > >	getSampleSpecificLLHScan (const int fileNum, const std::string &paramName, const std::string &sample) const
	Get the log likelihood scan for a particular parameter, for a specific sample, from a particular input file. More...

TGraph	getSampleSpecificLLHScan_TGraph (const int fileNum, const std::string &paramName, const std::string &sample) const

TH1D	getSampleSpecificLLHScan_TH1D (const int fileNum, const std::string &paramName, const std::string &sample) const

bool	getEnabledLLH (const int fileNum, const std::string &paramName, const std::string &LLHType="total") const
	Get whether or not a particular parameter has an LLH scan in a particular input file. More...

bool	getEnabledLLHBySample (const int fileNum, const std::string &paramName, const std::string &sample) const
	Get whether or not a particular parameter has an LLH scan in a particular input file for a particular sample. More...

bool	getEnabledMCMCchain (const int fileNum, const std::string &paramName) const
	Get whether or not a particular parameter has MCMC chain entries in a particular input file. More...

bool	getEnabled1dPosteriors (const int fileNum, const std::string &paramName) const
	Get whether or not a particular parameter has 1d posteriors in a particular input file. More...

double	getPostFitError (const int fileNum, const std::string &paramName, std::string errorType="") const
	Get the post fit error for a particular parameter from a particular input file. More...

double	getPostFitValue (const int fileNum, const std::string &paramName, std::string errorType="") const
	Get the post fit value for a particular parameter from a particular input file. More...

General Getters
const std::vector< std::string > &	getKnownParameters () const

const std::vector< std::string > &	getKnownSamples () const

size_t	getNInputFiles () const

std::vector< std::string >	getTaggedParameters (const std::vector< std::string > &tags, std::string checkType="all") const
	Get all parameters which have some set of tags. More...

std::vector< std::string >	getTaggedSamples (const std::vector< std::string > &tags, std::string checkType="all") const
	Get all samples which have some set of tags. More...

File Specific Getters
InputFile const &	getFile (int fileId) const

std::string	translateName (int fileId, fileTypeEnum fileType, std::string paramName) const

const std::vector< std::string > &	getKnownLLHParameters (int fileId) const

const std::vector< std::string > &	getKnownLLHSamples (int fileId) const

const std::vector< std::string > &	getKnownPostFitParameters (int fileId) const

const std::vector< std::string > &	getKnownMCMCParameters (int fileId) const

const std::vector< std::string > &	getKnown1dPosteriorParameters (int fileId) const

Static Public Member Functions
static const std::string	convertFileTypeNames (const fileTypeEnum fileType)
	Convert from fileTypeEnum to the name of the file type. More...

Public Attributes
const std::string	NOT_FOUND_STR
	the default string to return if something can't be found More...

Private Member Functions
std::vector< std::string >	getTaggedValues (const std::vector< std::string > &values, const std::unordered_map< std::string, std::vector< std::string >> &tagMap, const std::vector< std::string > &tags, std::string checkType) const

std::vector< std::string >	parseLocation (const std::string &locationString, std::string &fitter, fileTypeEnum fileType, const std::string &parameter="", const std::string &sample="", const std::string &parameter2="") const

std::shared_ptr< TObject >	findRootObject (const InputFile &fileDef, const std::vector< std::string > &locationVec) const

bool	findPostFitParamError (InputFile &inputFileDef, const std::string &parameter, std::string &fitter, const std::string &errorType, const bool setInputFileError=false)

bool	findBySampleLLH (InputFile &inputFileDef, const std::string &parameter, std::string &fitter, const std::string &sample, bool setInputFileScan=false)

bool	findRawChainSteps (InputFile &inputFileDef, const std::string &parameter, std::string &fitter, bool setInputBranch=false) const

bool	find1dPosterior (InputFile &inputFileDef, const std::string &parameter, std::string &fitter, bool setFileData=false) const

void	fillFileInfo (InputFile &inputFileDef, const bool printThoughts=true)

void	fillFileData (InputFile &inputFileDef, const bool printThoughts=true)

template<typename T >
bool	getFitterSpecificOption (const std::string &fitter, const std::string &option, T &ret, const std::string &parameter, YAML::Node subConfig) const

template<typename T >
bool	getFitterSpecificParamOption (const std::string &fitter, const std::string &option, T &ret, const std::string &parameter) const

template<typename T >
bool	getFitterSpecificSampleOption (const std::string &fitter, std::string option, T &ret, std::string parameter) const

std::string	getFitterSpecificParamName (const std::string &fitter, fileTypeEnum fileType, const std::string &parameter) const

std::string	getFitterSpecificSampleName (const std::string &fitter, fileTypeEnum fileType, const std::string &sample) const

std::vector< std::string >	TryToFindDefaultParamNames (const std::string &fileNames) const

bool	strEndsWith (const std::string &str, const std::string &ending) const

Private Attributes
std::vector< std::string >	_knownParameters

std::vector< std::string >	_knownSamples

std::vector< std::string >	_knownFitters

std::unordered_map< std::string, std::vector< std::string > >	_paramToTagsMap

std::unordered_map< std::string, std::vector< std::string > >	_sampleToTagsMap

YAML::Node	_translatorConfig

YAML::Node	_fitterSpecConfig

YAML::Node	_parametersConfig

YAML::Node	_samplesConfig

std::vector< InputFile >	_fileVec

Detailed Description

This guy talks to the input files and is intended to smooth over the fact that our OA fitters use such a beautiful and diverse range of output file structures.

Intended use for this class is to be called from inside of a PlottingManager object which is what the user is intended to interact with, though in principle it should be strong and independent enough to be used all by itself. The interface to this object is intentionally pretty small as it is intended to deal with the complexities of the different input files pretty automatically. Usage should follow something like this:

 InputManager man(translationConfig.yaml) man.addFile(filename1)
man.addFile(filename2)
...
 
then use various getter functions like getLLHScan() to access the data in the files to make
plots.

Todo:

A lot of string comparisons going on in the code for the post fit errors, would maybe be good to implement some kind of indexing for parameters and just have a map between the parameter names and this index to be used internally by the class.

Add code to read MCMC from input file

Add code to read Sigma variations. There are usually so many of these that we might not want to read them all into memory at once when adding the file but maybe just check to see what ones are in the file, then be able to read them on the fly later.

Add code to read in Violin plots from the postfit error output files.

Author: Ewan Miller

Definition at line 222 of file InputManager.h.

Constructor & Destructor Documentation

◆ InputManager() [1/3]

M3::Plotting::InputManager::InputManager	(	const std::string &	translationConfigName,
		const std::vector< std::string > &	_fileNames
	)

Construct a new InputManager using specified fitter translation config file.

Parameters

translationConfigName The config file defining the fitter file structures, fit parameter, and what the parameters are called in each fitter.

Returns: Constructed InputManager instance.

Definition at line 6 of file InputManager.cpp.

                                                                                                          {
   // read the config file
   _translatorConfig = M3OpenConfig(translationConfigName);
  
   MACH3LOG_DEBUG("InputManager: have loaded translation config file");
   
   // split up the parts of the config for easier access later
   _fitterSpecConfig = _translatorConfig["FitterSpec"];
   _parametersConfig = _translatorConfig["Parameters"];
   _samplesConfig = _translatorConfig["Samples"];
  
   // check the config file and get which parameters, samples, and fitters we've been told about
   _knownFitters = Get<std::vector<std::string>>(_fitterSpecConfig["fitters"], __FILE__, __LINE__);
   _knownParameters = Get<std::vector<std::string>>(_parametersConfig["Parameters"], __FILE__, __LINE__);
   _knownSamples = Get<std::vector<std::string>>(_samplesConfig["Samples"], __FILE__, __LINE__);
  
   if(_knownParameters.size() == 0){
     _knownParameters = TryToFindDefaultParamNames(_fileNames[0]);
   }
   MACH3LOG_DEBUG("Will now check the specified parameters for tags");
  
   // loop through all parameters and get their tags
   for ( const std::string &param: _knownParameters )
   {
     std::vector<std::string> tags;
  
     MACH3LOG_DEBUG("Looking for tags for parameter {}", param);
     if ( _parametersConfig[param] )
     {
       if ( _parametersConfig[param]["tags"] )
       {
         tags = Get<std::vector<std::string>>(_parametersConfig[param]["tags"], __FILE__, __LINE__);
         MACH3LOG_DEBUG("  - Found {}!", tags.size());
       }
     }
     _paramToTagsMap[param] = tags;
   }
  
   MACH3LOG_DEBUG("Will now check the specified samples for tags");
   
   // same again for samples
   for ( const std::string &samp: _knownSamples )
   {
     std::vector<std::string> tags;
  
     MACH3LOG_DEBUG("Looking for tags for sample {}", samp);
     if ( _samplesConfig[samp])
     {
       if ( _samplesConfig[samp]["tags"] )
       {
         tags = Get<std::vector<std::string>>(_samplesConfig[samp]["tags"], __FILE__, __LINE__);
         MACH3LOG_DEBUG("  - Found {}!", tags.size());
       }
     }
     _sampleToTagsMap[samp] = tags;
   }
  
   for (std::string fileName : _fileNames) {
     addFile(fileName);
   }
 }

◆ ~InputManager()

M3::Plotting::InputManager::~InputManager ( )

inline

Destructor.

Close out all the files that the manager is responsible for

Definition at line 239 of file InputManager.h.

   {
     MACH3LOG_DEBUG("##### Deleting InputManager Instance #####");
     for (InputFile &file: _fileVec)
     {
       file.Close();
     }
   }

◆ InputManager() [2/3]

M3::Plotting::InputManager::InputManager ( const InputManager & )

delete

◆ InputManager() [3/3]

M3::Plotting::InputManager::InputManager ( InputManager && )

default

Member Function Documentation

◆ addFile()

void M3::Plotting::InputManager::addFile ( const std::string & fileName )

Add a new InputFile object to this input manager.

Parameters

fileName The name of the file to read.

Open an input file and add to the manager, consists of:

a new InputFile using the specified file
Get info about the file, like what fitter it came from, what it contains e.g. LLH scans, processed post fit parameters etc.
Load up the data from the file (LLH scans etc.) and put them in a common format to be used by plotting scripts
Push back a pointer to the InputFile objcet to the vector of files known to this InputManager.

Definition at line 76 of file InputManager.cpp.

                                                     {
   _fileVec.emplace_back(fileName);
  
   // EM: need to be done in this order since fillFileData needs to know info about the file, e.g.
   // fitter and what things are in it
   InputFile &fileInfo = _fileVec.back();
   fillFileInfo(fileInfo);
   fillFileData(fileInfo);
 }

◆ convertFileTypeNames()

static const std::string M3::Plotting::InputManager::convertFileTypeNames ( const fileTypeEnum fileType )

inlinestatic

Convert from fileTypeEnum to the name of the file type.

Parameters

fileType The file type ID to convert.

Returns: The name of the file type, or "UNKNOWN_FILE_TYPE" if the fileType does not match any known file type.

Definition at line 261 of file InputManager.h.

                                                                            {
     switch (fileType)
     {
     case kLLH:
       return "LLH";
     case kPostFit:
       return "PostFit";
     case kMCMC:
       return "MCMC";
     case kSigmaVar:
       return "SigmaVar";
     case kNFileTypes:
       return "NFileTypes";
     default:
       return "UNKNOWN_FILE_TYPE";
     }
   }

◆ fillFileData()

void M3::Plotting::InputManager::fillFileData	(	InputFile &	inputFileDef,
		const bool	printThoughts = `true`
	)

private

Definition at line 790 of file InputManager.cpp.

                                                                                  {
   // load in the data in the file using the info gotten above
   // EM: a lot of this is copy paste from above, could be better organised
   if (printThoughts)
     MACH3LOG_INFO("....getting data from file {}", inputFileDef.fileName);
  
   YAML::Node thisFitterSpec_config = _fitterSpecConfig[inputFileDef.fitter];
  
   // set the default post fit error type so we can read it as default later
   inputFileDef.defaultErrorType =
       Get<std::string>(thisFitterSpec_config["defaultPostFitErrorType"], __FILE__, __LINE__);
  
   // ########### First fill up the LLH vectors ############
   for (const std::string LLHType : {"sample", "penalty", "total"})
   {
     if (!inputFileDef.hasLLHScans_map.at(LLHType))
       continue;
  
     // vector of all the possible locations that we might find LLH scans for this type of LLH
     YAML::Node testLLHConfig = thisFitterSpec_config[LLHType + "_LLH"];
     const std::vector<std::string> testLLHRawLocations =
         Get<std::vector<std::string>>(testLLHConfig["location"], __FILE__, __LINE__);
  
     // get the expected root object type of the llh scans
     auto LLHObjType = Get<std::string>(thisFitterSpec_config["LLHObjectType"], __FILE__, __LINE__);
     // EM: now get the objects from the file
     for (const std::string &parameter : inputFileDef.availableParams_LLH)
     {
       std::shared_ptr<TObject> LLHObj = nullptr;
  
       // check the locations for the object
       for (const std::string &rawLocation : testLLHRawLocations)
       {
         LLHObj = findRootObject(inputFileDef,
                                 parseLocation(rawLocation, inputFileDef.fitter, kLLH, parameter));
         // if we found it then break out of the loop
         if (LLHObj != nullptr)
           break;
       }
  
       // double check that we actually found it.. just in case
       if (LLHObj == nullptr)
       {
         MACH3LOG_ERROR("Hmmm, something seems to have gone wrong and I couldn't find the {} LLH scan for {} when attempting to read the data for it", LLHType, parameter);
         MACH3LOG_ERROR("This will very likely cause segfaults and sadness");
       }
  
       // now convert it to a TGraph
       std::shared_ptr<TGraph> LLHGraph = std::make_shared<TGraph>();
  
       // EM: maybe have the type of the LLH object specified in the config to know what to downcast
       // it to??
       if (LLHObjType == "TH1D")
       {
         LLHGraph = std::make_shared<TGraph>(static_cast<TH1D*>(LLHObj.get()));
       }
  
       else if (LLHObjType == "TGraph")
       {
         LLHGraph = std::shared_ptr<TGraph>(static_cast<TGraph*>(LLHObj->Clone()));
       }
  
       else
       {
         MACH3LOG_CRITICAL("ERROR: uknown type of LLH object specified: {}", LLHObjType);
         throw MaCh3Exception(__FILE__ , __LINE__ );
       }
  
       inputFileDef.LLHScans_map[LLHType][parameter] = LLHGraph;
     }
   }
  
   // ####### Get the by sample LLH scans #######
   for (const std::string &parameter : inputFileDef.availableParams_LLH)
   {
     for (const std::string &sample : _knownSamples)
     {
       findBySampleLLH(inputFileDef, parameter, inputFileDef.fitter, sample, true);
     }
   }
  
   // ####### Get the processed post fit errors #######
   for (const std::string &parameter : inputFileDef.availableParams_postFitErrors)
   {
     auto availableErrorTypes = Get<std::vector<std::string>>(thisFitterSpec_config["AvailablePostFitErrorTypes"],
                                                              __FILE__, __LINE__);
  
     for (const std::string &errorType : availableErrorTypes)
     {
       findPostFitParamError(inputFileDef, parameter, inputFileDef.fitter, errorType, true);
     }
   }
  
   // ########## Get the MCMC related posteriors ###########
   for (const std::string &parameter : inputFileDef.availableParams_MCMCchain)
   {
     findRawChainSteps(inputFileDef, parameter, inputFileDef.fitter, true);
   }
   for (const std::string &parameter : inputFileDef.availableParams_1dPosteriors)
   {
     find1dPosterior(inputFileDef, parameter, inputFileDef.fitter, true);
   }
 }

◆ fillFileInfo()

void M3::Plotting::InputManager::fillFileInfo	(	InputFile &	inputFileDef,
		const bool	printThoughts = `true`
	)

private

Todo:: Would like to be able to specify what kind of file and what fitter an input is from on the command like: e.g., like plotApp [options] fileName1;fileType;fitterName and only try to auto-detect it if it's not specified. this would save some time and would also be very helpful in situations where we can't auto-detect e.g. if there is some kind of overlap in the file structure between two fitters

Todo:: add a check here to make sure all the scans that are in the file are being picked up by the reader, and warn if any are not being used

Definition at line 515 of file InputManager.cpp.

                                                                                  {
   
   // use the contents of the file to decide which fitter it came from and what type of file it is
   if (printThoughts)
     MACH3LOG_INFO("Checking contents of file {}", inputFileDef.fileName);
  
   for (std::string fitter: _knownFitters)
   {
     // flag for whether or not the current fitter is the correct one
     bool foundFitter = false;
     if (printThoughts)
       MACH3LOG_INFO("Checking if this is a {} file", fitter);
  
     // EM: get the configuration specifying what the output of this fitter looks like
     if (!_fitterSpecConfig[fitter])
     {
       throw MaCh3Exception(__FILE__ , __LINE__, "translation config doesnt contain a definition for fitter " + fitter);
     }
  
     YAML::Node thisFitterSpec_config = _fitterSpecConfig[fitter];
  
     size_t numLLHParams;
  
     // ##### Look for LLH scans in the input #####
     // check for all 3 LLH directory types
     for (std::string LLHType : {"sample", "penalty", "total"})
     {
       if (printThoughts)
         MACH3LOG_INFO(".... searching for {} LLH scans... ", LLHType);
  
       // vector of all the possible locations that we might find LLH scans for this type of LLH
       YAML::Node testLLHConfig = thisFitterSpec_config[LLHType + "_LLH"];
       auto testLLHRawLocations = Get<std::vector<std::string>>(testLLHConfig["location"], __FILE__, __LINE__);
  
       // counter for the total number of parameters we find scans for
       numLLHParams = 0;
  
       std::vector<std::string> enabledLLHParams;
  
       for (const std::string &parameter : _knownParameters)
       {
         MACH3LOG_DEBUG("     - for {}", parameter);
         inputFileDef.availableParams_map_LLH[LLHType][parameter] = false;
  
         // check if we find the parameter at any of the locations we think it should be at
         for (const std::string &rawLocation : testLLHRawLocations)
         {
           if (findRootObject(inputFileDef, parseLocation(rawLocation, fitter, kLLH, parameter)) !=
               nullptr)
           {
             numLLHParams++;
             enabledLLHParams.push_back(parameter);
             inputFileDef.availableParams_map_LLH[LLHType][parameter] = true;
             MACH3LOG_DEBUG("      FOUND!");
             break; // <- we've found it, no point checking the rest of the locations
           }
         }
       }
  
       if (printThoughts)
         MACH3LOG_INFO(".... Found {}", numLLHParams);
  
       if (numLLHParams > 0)
       {
         foundFitter = true;
         inputFileDef.hasLLHScans = true;
         inputFileDef.availableParams_LLH = enabledLLHParams;
         inputFileDef.hasLLHScans_map[LLHType] = true;
       }
  
     }
  
     if (printThoughts)
       MACH3LOG_INFO("");
  
     // ##### now look for processed post fit errors #####
     if (printThoughts)
     {
       MACH3LOG_INFO("....searching for Post Fit Parameters");
  
       if (thisFitterSpec_config["defaultPostFitErrorType"])
       {
         MACH3LOG_DEBUG("  Default type specified with possible locations: ");
         YAML::Node postFitErrorSpec = thisFitterSpec_config["postFitErrorTypes"];
         YAML::Node defaultErrorType =
             postFitErrorSpec[thisFitterSpec_config["defaultPostFitErrorType"].as<std::string>()];
         auto locations = Get<std::vector<std::string>>(defaultErrorType["location"], __FILE__, __LINE__);
         for (std::string loc : locations)
           MACH3LOG_DEBUG(loc);
       } 
       else
       {
         MACH3LOG_DEBUG("  No default location specified");
       }
     }
  
     int numPostFitParams = 0;
     std::vector<std::string> enabledPostFitParams;
  
     auto defaultErrorType =
         Get<std::string>(thisFitterSpec_config["defaultPostFitErrorType"], __FILE__, __LINE__);
     for (std::string parameter : _knownParameters)
     {
       if (findPostFitParamError(inputFileDef, parameter, fitter, defaultErrorType))
       {
         numPostFitParams++;
         enabledPostFitParams.push_back(parameter);
       }
     }
  
     if (printThoughts)
       MACH3LOG_INFO(".... Found {}", numPostFitParams);
  
     if (numPostFitParams > 0)
     {
       foundFitter = true;
       inputFileDef.hasPostFitErrors = true;
       inputFileDef.availableParams_postFitErrors = enabledPostFitParams;
     }
  
     // ######### Now look for LLH scans broken down by sample #########
     // This is really just a check to see if the number of by sample LLH scans is the same as normal
     // LLH scans
     if (printThoughts)
       MACH3LOG_INFO("....Searching for LLH scans broken down by sample");
  
     for (const std::string &sample : _knownSamples)
     {
       size_t numLLHBySampleParams = 0;
       for (const std::string &parameter : _knownParameters)
       {
         inputFileDef.availableParams_map_LLHBySample[sample][parameter] = false;
         if (findBySampleLLH(inputFileDef, parameter, fitter, sample))
         {
           inputFileDef.availableParams_map_LLHBySample[sample][parameter] = true;
           numLLHBySampleParams++;
         }
       }
  
       if (numLLHBySampleParams != 0)
       {
         inputFileDef.availableSamples_LLH.push_back(sample);
  
         if (printThoughts)
           MACH3LOG_INFO("........ Found {} LLH scans for sample {}", numLLHBySampleParams, sample);
  
         if ((numLLHParams != numLLHBySampleParams))
         {
           MACH3LOG_ERROR("hmmmmm something weird is happening here");
           MACH3LOG_ERROR("  I have {} LLH scans for sample {}", numLLHBySampleParams, sample);
           MACH3LOG_ERROR("  But {} parameters with Total_LLH scals", numLLHParams);
         }
       }
     }
  
     // ######### Now for the main event: Look for MCMC chains and processed posteriors ###########
     
     // EM: if "MCMCsteps" was defined for this fitter, we assume that it is a MaCh3 raw MCMC file
     // thus it needs an MCMCProcessor to read from it. This isn't super general and it would probably
     // be good to have some additional "isMaCh3" option that can decide whether or not to use MCMCProcessor
     // but hey ho it's good enough for now
     if ( thisFitterSpec_config["MCMCsteps"] )
     {
       MACH3LOG_DEBUG("Initialising MCMCProcessor for the input file");
       auto posteriorTreeRawLocations =
             Get<std::vector<std::string>>(thisFitterSpec_config["MCMCsteps"]["location"], __FILE__, __LINE__);
  
       TTree *postTree = nullptr;
       for ( const std::string &rawLoc: posteriorTreeRawLocations )
       {
         MACH3LOG_DEBUG("  - Looking for MCMC chain parameter values at: {}", rawLoc);
  
         postTree = inputFileDef.file->Get<TTree>(rawLoc.c_str());
  
         if ( postTree != nullptr && (postTree->GetNbranches() != 0) )
         {
           inputFileDef.mcmcProc = std::make_unique<MCMCProcessor>(inputFileDef.fileName);
           // KS: We need this so plotting doesn't overwrite default...
           inputFileDef.mcmcProc->SetOutputSuffix("_PlottingTemp");
           inputFileDef.mcmcProc->Initialise();
  
           MACH3LOG_DEBUG("  - FOUND!");
           break;
         }
       }
     
       if ( postTree != nullptr && (postTree->GetNbranches() != 0) )
       {
         inputFileDef.posteriorTree = postTree;
         inputFileDef.nMCMCentries = int(postTree->GetEntries());
       }
     }
  
     if (printThoughts)
     {
       MACH3LOG_INFO("....Searching for MCMC related things");
     }
     
     size_t num1dPosteriors = 0;
     std::vector<std::string> enabled1dPosteriorParams;
  
     size_t numMCMCchainParams = 0;
     std::vector<std::string> enabledMCMCchainParams;
  
     for ( const std::string &parameter : _knownParameters )
     {
       MACH3LOG_DEBUG("     - for {}", parameter);
       // check for 1d post processing posterior.q
       inputFileDef.availableParams_map_1dPosteriors[parameter] = false;
       if ( thisFitterSpec_config["1dPosteriors"] && find1dPosterior(inputFileDef, parameter, fitter) )
       {
         MACH3LOG_DEBUG("       Found 1d processed posterior!");
         enabled1dPosteriorParams.push_back(parameter);
         num1dPosteriors++;
         inputFileDef.availableParams_map_1dPosteriors[parameter] = true;
       }
       // now check for parameters in chain 
       inputFileDef.availableParams_map_MCMCchain[parameter] = false;
       if ( thisFitterSpec_config["MCMCsteps"] && findRawChainSteps(inputFileDef, parameter, fitter) )
       {
         MACH3LOG_DEBUG("       Found raw MCMC steps!");
         enabledMCMCchainParams.push_back(parameter);
         numMCMCchainParams++;
         inputFileDef.availableParams_map_MCMCchain[parameter] = true;
       }
     }
  
     if  (num1dPosteriors > 0 )
     {
       foundFitter = true;
       inputFileDef.has1dPosteriors = true;
       inputFileDef.availableParams_1dPosteriors = enabled1dPosteriorParams;
  
       if (printThoughts)
         MACH3LOG_INFO("........ Found {} 1d processed posteriors", num1dPosteriors);
     }
     if ( numMCMCchainParams > 0 )
     {
       foundFitter = true;
       inputFileDef.hasMCMCchain = true;
       inputFileDef.availableParams_MCMCchain = enabledMCMCchainParams;
  
       if (printThoughts)
         MACH3LOG_INFO("........ Found {} parameters in MCMC chain", numMCMCchainParams);
     }
  
     /*
     switch (i) {
         // any other weird fitter specific conditions/ edge cases should go in here
     }
     */
  
     if (foundFitter)
     {
       if (printThoughts)
       {
         MACH3LOG_INFO("This is a {} file!", fitter);
       }
       inputFileDef.fitter = fitter;
       return;
     }
   }
  
   // if we didn't return above then the fitter type wasn't found
   if (printThoughts)
     MACH3LOG_WARN("I don't know what kinda fitter this came from, will proceed with caution");
   inputFileDef.fitter = "UNKNOWN_FITTER";
 }

◆ find1dPosterior()

bool M3::Plotting::InputManager::find1dPosterior	(	InputFile &	inputFileDef,
		const std::string &	parameter,
		std::string &	fitter,
		bool	setFileData = `false`
	)		const

private

Definition at line 438 of file InputManager.cpp.

                                                                                                                                  {
   bool wasFound = false;
   
   YAML::Node thisFitterSpec_config = _fitterSpecConfig[fitter];
  
   if ( thisFitterSpec_config["1dPosteriors"] ) {
     auto rawLocations = Get<std::vector<std::string>>(thisFitterSpec_config["1dPosteriors"]["location"],
                                                       __FILE__, __LINE__);
     for ( const std::string &rawLoc : rawLocations)
     {
       std::shared_ptr<TH1D> posterior1d = std::static_pointer_cast<TH1D>(findRootObject(inputFileDef, parseLocation(rawLoc, fitter, kMCMC, parameter)));
  
       if ( posterior1d != nullptr )
       {
         wasFound = true;
  
         if ( setFileData )
         {
           inputFileDef.posteriors1d_map[parameter] = std::make_shared<TGraph>(posterior1d.get());
         }
         break;
       }
     }
   }
   return wasFound;
 }

◆ findBySampleLLH()

bool M3::Plotting::InputManager::findBySampleLLH	(	InputFile &	inputFileDef,
		const std::string &	parameter,
		std::string &	fitter,
		const std::string &	sample,
		bool	setInputFileScan = `false`
	)

private

Definition at line 350 of file InputManager.cpp.

                                                                                                       {
   YAML::Node thisFitterSpec_config = _fitterSpecConfig[fitter];
  
   // EM: Get where the by sample LLH scan for this parameter *should* live if it exists
   YAML::Node testLLHConfig = thisFitterSpec_config["bySample_LLH"];
   auto testLLHRawLocations = Get<std::vector<std::string>>(testLLHConfig["location"], __FILE__, __LINE__);
  
   auto LLHObjType = Get<std::string>(thisFitterSpec_config["LLHObjectType"], __FILE__, __LINE__);
   // EM: Now look for the parameter in this folder
   std::shared_ptr<TObject> LLHObj = nullptr;
   for (std::string rawLocation : testLLHRawLocations)
   {
     LLHObj =
         findRootObject(inputFileDef, parseLocation(rawLocation, fitter, kLLH, parameter, sample));
     if (LLHObj != nullptr)
     {
       break;
     }
   }
  
   // EM: If it's not in there we can return here
   if (LLHObj == nullptr)
     return false;
  
   // EM: If specified, we set the object in the InputFile object
   if (setInputFileScan)
   {
     std::shared_ptr<TGraph> LLHGraph = std::make_shared<TGraph>();
  
     if (LLHObjType == "TH1D")
     {
       LLHGraph = std::make_shared<TGraph>(static_cast<TH1D*>(LLHObj.get()));
     } else if (LLHObjType == "TGraph")
     {
       LLHGraph = std::shared_ptr<TGraph>(static_cast<TGraph*>(LLHObj->Clone()));
     } else
     {
       throw MaCh3Exception(__FILE__ , __LINE__, "uknown type of LLH object specified: " + LLHObjType);
     }
  
     inputFileDef.LLHScansBySample_map[sample][parameter] = LLHGraph;
   }
   return true;
 }

◆ findPostFitParamError()

bool M3::Plotting::InputManager::findPostFitParamError	(	InputFile &	inputFileDef,
		const std::string &	parameter,
		std::string &	fitter,
		const std::string &	errorType,
		const bool	setInputFileError = `false`
	)

private

Definition at line 465 of file InputManager.cpp.

                                                                        {
   std::string specificName = getFitterSpecificParamName(fitter, kPostFit, parameter);
   YAML::Node thisFitterSpec_config = _fitterSpecConfig[fitter];
  
   // EM: Get which hist this parameter lives in from the config
   YAML::Node postFitErrorTypes = thisFitterSpec_config["postFitErrorTypes"];
   YAML::Node specificErrorType = postFitErrorTypes[errorType];
   auto postFitLocations = Get<std::vector<std::string>>(specificErrorType["location"], __FILE__, __LINE__);
  
   // EM: If the parameter has a specified list of locations then override the default one
   std::vector<std::string> postFitLocations_override;
   if (getFitterSpecificParamOption<std::vector<std::string>>(fitter, "postFitLoc",
                                                              postFitLocations_override, parameter))
   {
     postFitLocations = postFitLocations_override;
   }
  
   for (std::string postFitLoc : postFitLocations)
   {
     std::shared_ptr<TH1D> postFitErrors = std::static_pointer_cast<TH1D>(findRootObject(inputFileDef, parseLocation(postFitLoc, fitter, kPostFit, parameter)));
  
     // EM: the postfit hist for this parameter isn't in this file
     if (postFitErrors == nullptr)
       continue;
  
     // EM: Loop through the hist to see if it contains the parameter we're looking for
     for (int binIdx = 0; binIdx <= postFitErrors->GetNbinsX(); binIdx++)
     {
       std::string binLabel = std::string(postFitErrors->GetXaxis()->GetBinLabel(binIdx));
       if (strEndsWith(binLabel, specificName))
       {
         if (setInputFileError)
         {
           // EM: if specified, we fill the postfit error TH1D in the provided InputFile object
           inputFileDef.postFitErrors[errorType][parameter] = postFitErrors->GetBinError(binIdx);
           inputFileDef.postFitValues[errorType][parameter] = postFitErrors->GetBinContent(binIdx);
         }
  
         return true;
       }
     }
   }
   // EM: Didn't find the parameter in any of the specified locations
   return false;
 }

◆ findRawChainSteps()

bool M3::Plotting::InputManager::findRawChainSteps	(	InputFile &	inputFileDef,
		const std::string &	parameter,
		std::string &	fitter,
		bool	setInputBranch = `false`
	)		const

private

Definition at line 397 of file InputManager.cpp.

                                                                                                                                       {
   // we'll assume for now that the chain is in the form of a TTree and the branch names are parameter names
   bool wasFound = false;
  
   // make sure that the filedef object has all the necessary stuff to read from the posterior tree
   if ( (inputFileDef.mcmcProc != nullptr) && (inputFileDef.posteriorTree != nullptr) )
   {
     const std::vector<TString> branchNames = inputFileDef.mcmcProc->GetBranchNames();
  
     std::string specificName = getFitterSpecificParamName(fitter, kMCMC, parameter);
  
     // loop over possible parameters and compare names
     for ( int paramIdx = 0; paramIdx < inputFileDef.mcmcProc->GetNParams() -1 ; paramIdx ++ )
     {
       TString title;
       double prior, priorError; // <- will be discarded
       inputFileDef.mcmcProc->GetNthParameter(paramIdx, prior, priorError, title);
  
       // KS: Fitter Base output used for LLH only may be ill-configured
       if (!inputFileDef.posteriorTree->GetBranch(branchNames[paramIdx])) {
         MACH3LOG_DEBUG("Branch {} not found in chain, skipping!", branchNames[paramIdx]);
         continue;
       }
  
       if ( strEndsWith(title.Data(), specificName) )
       {
         wasFound = true;
         if ( setInputBranch )
         {
           // EM: should probably use MCMCProcessor for this so we can use caching, gpu etc.
           inputFileDef.MCMCstepParamsMap[parameter] = new double( M3::_BAD_DOUBLE_ ); // <- initialise the parameter step values
           inputFileDef.posteriorTree->SetBranchAddress( branchNames[paramIdx], inputFileDef.MCMCstepParamsMap.at(parameter) );
         }
         break;
       }
     }
   }
   return wasFound;
 }

◆ findRootObject()

std::shared_ptr< TObject > M3::Plotting::InputManager::findRootObject	(	const InputFile &	fileDef,
		const std::vector< std::string > &	locationVec
	)		const

private

Definition at line 294 of file InputManager.cpp.

                                                                                      {
   std::shared_ptr<TObject> object = nullptr;
  
   // if vector only has one element, just interpret it as the absolute path to the object
   if (locationVec.size() == 1)
   {
     object = std::shared_ptr<TObject>(fileDef.file->Get(locationVec[0].c_str()));
   }
  
   // if vector has two elements, interpret the first as the directory and the second as a string to
   // match with the end of the objects in the file
   else if (locationVec.size() == 2)
   {
     TDirectoryFile *directory = fileDef.file->Get<TDirectoryFile>(locationVec[0].c_str());
     size_t nMatchingObjects = 0;
  
     // let's make sure that the directory itself exists
     if (directory == nullptr)
     {
       object = nullptr;
     }
     else
     {
       // loop through the keys in the directory and find objects whose name matches the specified
       // pattern
       TIter next(directory->GetListOfKeys());
       while (TKey *key = static_cast<TKey*>(next()))
       {
         if (strEndsWith(std::string(key->GetName()), locationVec[1]))
         {
           object = std::shared_ptr<TObject>(directory->Get(key->GetName()));
           nMatchingObjects++;
         }
       }
     }
     // check that only one object matched the pattern
     if (nMatchingObjects > 1)
     {
       MACH3LOG_CRITICAL("Too many objects match the pattern specified by {} {}", locationVec[0], locationVec.size()==2 ? locationVec[1] : "");
       MACH3LOG_CRITICAL("Found {} matching objects, should just be one", nMatchingObjects);
  
       throw MaCh3Exception(__FILE__ , __LINE__ );
     }
   }
   else // Vector too big!!
   {
     MACH3LOG_CRITICAL("Invalid object location vector");
     MACH3LOG_CRITICAL("Should have two elements: [ (directory to look in), (end of the name of the object) ]");
     MACH3LOG_CRITICAL("Or one element that is just the absolute path to the object");
     
     throw MaCh3Exception(__FILE__ , __LINE__ );
   }
   return object;
 }

◆ get1dPosterior()

std::vector<std::vector<double> > M3::Plotting::InputManager::get1dPosterior	(	const int	fileNum,
		const std::string &	paramName
	)		const

inline

Get the 1d posterior particular parameter from a particular input file.

Parameters

fileNum	The index of the file you want the data from.
paramName	The parameter you want the information about.

Returns: A vector of vectors containing the posterior data. First entry is x axis (i.e. the parameter values), 2nd is y axis

Definition at line 339 of file InputManager.h.

                                                                                                    {
     if (!getEnabled1dPosteriors(fileNum, paramName))
     {
       MACH3LOG_WARN("file at index {} does not have a 1d posterior for parameter {}", fileNum, paramName);
       MACH3LOG_WARN("am returning an empty vector");
       return std::vector<std::vector<double>>(2);
     }
     return TGraphToVector(*_fileVec[fileNum].posteriors1d_map.at(paramName));
   }

◆ getEnabled1dPosteriors()

bool M3::Plotting::InputManager::getEnabled1dPosteriors	(	const int	fileNum,
		const std::string &	paramName
	)		const

inline

Get whether or not a particular parameter has 1d posteriors in a particular input file.

Parameters

fileNum	The index of the file that you would like to know about.
paramName	The name of the parameter whose 1d posterior you would like to check for.

Returns: true if scan exists, false if not.

Definition at line 451 of file InputManager.h.

                                                                                           {
     return _fileVec[fileNum].availableParams_map_1dPosteriors.at(paramName);
   }

◆ getEnabledLLH()

bool M3::Plotting::InputManager::getEnabledLLH	(	const int	fileNum,
		const std::string &	paramName,
		const std::string &	LLHType = `"total"`
	)		const

inline

Get whether or not a particular parameter has an LLH scan in a particular input file.

Parameters

fileNum	The index of the file that you would like to know about.
paramName	The name of the parameter whose LLH scan you would like to check for.
LLHType	The type of likelihood scan you would like to check for, e.h. total, prior etc.

Returns: true if scan exists, false if not.

Definition at line 424 of file InputManager.h.

                                                                       {
     return _fileVec[fileNum].availableParams_map_LLH.at(LLHType).at(paramName);
   }

◆ getEnabledLLHBySample()

bool M3::Plotting::InputManager::getEnabledLLHBySample	(	const int	fileNum,
		const std::string &	paramName,
		const std::string &	sample
	)		const

inline

Get whether or not a particular parameter has an LLH scan in a particular input file for a particular sample.

Parameters

fileNum	The index of the file that you would like to know about.
paramName	The name of the parameter whose LLH scan you would like to check for.
sample	The sample to check.

Returns: true if scan exists, false if not.

Definition at line 435 of file InputManager.h.

                                                                                                                   {
     return _fileVec[fileNum].availableParams_map_LLHBySample.at(sample).at(paramName);
   }

◆ getEnabledMCMCchain()

bool M3::Plotting::InputManager::getEnabledMCMCchain	(	const int	fileNum,
		const std::string &	paramName
	)		const

inline

Get whether or not a particular parameter has MCMC chain entries in a particular input file.

Parameters

fileNum	The index of the file that you would like to know about.
paramName	The name of the parameter whose LLH scan you would like to check for.

Returns: true if scan exists, false if not.

Definition at line 443 of file InputManager.h.

                                                                                        {
     return _fileVec[fileNum].availableParams_map_MCMCchain.at(paramName);
   }

◆ getFile()

InputFile const& M3::Plotting::InputManager::getFile ( int fileId ) const

inline

Definition at line 504 of file InputManager.h.

504 { return _fileVec[fileId]; }

◆ getFitterSpecificOption()

template<typename T >

bool M3::Plotting::InputManager::getFitterSpecificOption	(	const std::string &	fitter,
		const std::string &	option,
		T &	ret,
		const std::string &	parameter,
		YAML::Node	subConfig
	)		const

inlineprivate

Definition at line 575 of file InputManager.h.

                                                         {
     if (subConfig[parameter])
     {
       // EM: this is config definition of fitter specific names for this parameter
       YAML::Node paramTranslation = subConfig[parameter];
  
       if (paramTranslation[fitter])
       {
         // EM: then this is definition of how to find parameter in the specified fitter
         YAML::Node fitterParamTranslation = paramTranslation[fitter];
  
         if (fitterParamTranslation[option])
         {
           ret = fitterParamTranslation[option].as<T>();
           return true;
         }
       }
     }
     return false;
   }

◆ getFitterSpecificParamName()

std::string M3::Plotting::InputManager::getFitterSpecificParamName	(	const std::string &	fitter,
		fileTypeEnum	fileType,
		const std::string &	parameter
	)		const

inlineprivate

Definition at line 613 of file InputManager.h.

                                                                                   {
     std::string specificName;
     if (getFitterSpecificParamOption<std::string>(fitter, convertFileTypeNames(fileType),
                                                   specificName, parameter))
     {
       return specificName;
     }
     // EM: Default to just return the specified name
     return parameter;
   }

◆ getFitterSpecificParamOption()

template<typename T >

bool M3::Plotting::InputManager::getFitterSpecificParamOption	(	const std::string &	fitter,
		const std::string &	option,
		T &	ret,
		const std::string &	parameter
	)		const

inlineprivate

Definition at line 599 of file InputManager.h.

                                                                              {
     return getFitterSpecificOption<T>(fitter, option, ret, parameter, _parametersConfig);
   }

◆ getFitterSpecificSampleName()

std::string M3::Plotting::InputManager::getFitterSpecificSampleName	(	const std::string &	fitter,
		fileTypeEnum	fileType,
		const std::string &	sample
	)		const

inlineprivate

Definition at line 627 of file InputManager.h.

                                                                                 {
     std::string specificName;
     if (getFitterSpecificSampleOption<std::string>(fitter, convertFileTypeNames(fileType),
                                                    specificName, sample))
     {
       return specificName;
     }
     // EM: Default to just return the specified name
     return sample;
   }

◆ getFitterSpecificSampleOption()

template<typename T >

bool M3::Plotting::InputManager::getFitterSpecificSampleOption	(	const std::string &	fitter,
		std::string	option,
		T &	ret,
		std::string	parameter
	)		const

inlineprivate

Definition at line 606 of file InputManager.h.

                                                                        {
     return getFitterSpecificOption<T>(fitter, option, ret, parameter, _samplesConfig);
   }

◆ getKnown1dPosteriorParameters()

const std::vector<std::string>& M3::Plotting::InputManager::getKnown1dPosteriorParameters ( int fileId ) const

inline

Definition at line 520 of file InputManager.h.

                                                                                      {
     return _fileVec[fileId].availableParams_1dPosteriors;
   }

◆ getKnownLLHParameters()

const std::vector<std::string>& M3::Plotting::InputManager::getKnownLLHParameters ( int fileId ) const

inline

Definition at line 508 of file InputManager.h.

                                                                              {
     return _fileVec[fileId].availableParams_LLH;
   }

◆ getKnownLLHSamples()

const std::vector<std::string>& M3::Plotting::InputManager::getKnownLLHSamples ( int fileId ) const

inline

Definition at line 511 of file InputManager.h.

                                                                           {
     return _fileVec[fileId].availableSamples_LLH;
   }

◆ getKnownMCMCParameters()

const std::vector<std::string>& M3::Plotting::InputManager::getKnownMCMCParameters ( int fileId ) const

inline

Definition at line 517 of file InputManager.h.

                                                                               {
     return _fileVec[fileId].availableParams_MCMCchain;
   }

◆ getKnownParameters()

const std::vector<std::string>& M3::Plotting::InputManager::getKnownParameters ( ) const

inline

Definition at line 475 of file InputManager.h.

475 { return _knownParameters; }

◆ getKnownPostFitParameters()

const std::vector<std::string>& M3::Plotting::InputManager::getKnownPostFitParameters ( int fileId ) const

inline

Definition at line 514 of file InputManager.h.

                                                                                  {
     return _fileVec[fileId].availableParams_postFitErrors;
   }

◆ getKnownSamples()

const std::vector<std::string>& M3::Plotting::InputManager::getKnownSamples ( ) const

inline

Definition at line 476 of file InputManager.h.

476 { return _knownSamples; }

◆ getLLHScan()

std::vector<std::vector<double> > M3::Plotting::InputManager::getLLHScan	(	const int	fileNum,
		const std::string &	paramName,
		const std::string &	LLHType
	)		const

inline

Get the log likelihood scan data for a particular parameter from a particular input file.

Parameters

fileNum	The index of the file you want the data from.
paramName	The parameter you want the information about.
LLHType	The type of log likelihood scan you want (e.g. total, penalty, etc.)

Returns: A vector of vectors containing the LLH scan data. First entry is x axis, 2nd is y axis

Definition at line 291 of file InputManager.h.

                                                                                                                          {
     if (!getEnabledLLH(fileNum, paramName, LLHType))
     {
       MACH3LOG_WARN("file at index {} does not have LLH scan for parameter {}", fileNum, paramName);
       MACH3LOG_WARN("am returning an empty vector");
       return std::vector<std::vector<double>>(2); 
     }
     return TGraphToVector(*_fileVec[fileNum].LLHScans_map.at(LLHType).at(paramName));
   }

◆ getLLHScan_TGraph()

TGraph M3::Plotting::InputManager::getLLHScan_TGraph	(	const int	fileNum,
		const std::string &	paramName,
		const std::string &	LLHType
	)		const

inline

Get the log likelihood scan for a particular parameter from a particular input file.

Parameters

fileNum	The index of the file that you would like to get the scan from.
paramName	The name of the parameter whose LLH scan you would like.
LLHType	The type of likelihood scan you would like, e.h. total, prior etc.

Template Parameters

T	The type you would like your scan returned as, currently only TGraph and TH1D are supported

Returns: The graph of the likelihood scan.

Definition at line 362 of file InputManager.h.

                                                                                                                  {
     if (!getEnabledLLH(fileNum, paramName, LLHType))
     {
       MACH3LOG_WARN("file at index {} does not have LLH scan for parameter {}", fileNum, paramName);
       MACH3LOG_WARN("am returning an empty TGraph");
       return TGraph(); 
     }
     return *_fileVec[fileNum].LLHScans_map.at(LLHType).at(paramName);
   }

◆ getLLHScan_TH1D()

TH1D M3::Plotting::InputManager::getLLHScan_TH1D	(	const int	fileNum,
		const std::string &	paramName,
		const std::string &	LLHType
	)		const

inline

Definition at line 372 of file InputManager.h.

                                                                                                              {
     if (!getEnabledLLH(fileNum, paramName, LLHType))
     {
       MACH3LOG_WARN("file at index {} does not have LLH scan for parameter {}", fileNum, paramName);
       MACH3LOG_WARN("am returning an empty TH1D");
       return TH1D(); 
     }
     return TGraphToTH1D(*_fileVec[fileNum].LLHScans_map.at(LLHType).at(paramName));
   }

◆ getMCMCentry()

void M3::Plotting::InputManager::getMCMCentry	(	const int	fileNum,
		const int	entry
	)		const

inline

Get the MCMC chain entry in an InputFile.

Parameters

fileNum	The index of the file you want the data from.
entry	The entry to get.

Definition at line 304 of file InputManager.h.

                                                               {
     // EM: the const here is a little bit of a lie since GetEntry will in fact modify 
     //     the pointers to the stored data for the MCMC chain values but hopefully this should be ok
     const InputFile &file = _fileVec[fileNum];
  
     if( entry > file.nMCMCentries )
     {
       MACH3LOG_ERROR("Trying to access entries beyond what exist in file {}. No-can-do!", file.fileName);
     }
     else
     {
       MACH3LOG_TRACE("Getting entry {} in MCMC tree for file at index {}", entry, fileNum);
       file.posteriorTree->GetEntry(entry);
       MACH3LOG_TRACE("  Got successfully");
     }
   }

◆ getMCMCvalue()

double M3::Plotting::InputManager::getMCMCvalue	(	int	fileNum,
		const std::string &	paramName
	)		const

inline

Get the parameter value for the current step for a particular parameter from a particular input file.

Parameters

fileNum	The index of the file you want the data from.
paramName	The parameter you want the value of.

Definition at line 324 of file InputManager.h.

                                                                      {
     if (!getEnabledMCMCchain(fileNum, paramName))
     {
       MACH3LOG_WARN("file at index {} does not have an MCMC entry for parameter {}", fileNum, paramName);
       MACH3LOG_WARN("am returning a bad float");
       return M3::_BAD_DOUBLE_;
     }
  
     return *_fileVec[fileNum].MCMCstepParamsMap.at(paramName);
   }

◆ getNInputFiles()

size_t M3::Plotting::InputManager::getNInputFiles ( ) const

inline

Definition at line 477 of file InputManager.h.

477 { return _fileVec.size(); }

◆ getnMCMCentries()

int M3::Plotting::InputManager::getnMCMCentries ( const int fileNum ) const

inline

Get the number of entries in the MCMC chain in a particular file.

Parameters

fileNum The index of the file you want the number of steps from.

Definition at line 351 of file InputManager.h.

                                                {
     return _fileVec[fileNum].nMCMCentries;
   }

◆ getPostFitError()

double M3::Plotting::InputManager::getPostFitError	(	const int	fileNum,
		const std::string &	paramName,
		std::string	errorType = `""`
	)		const

Get the post fit error for a particular parameter from a particular input file.

Parameters

fileNum	The index of the file that you would like to get the value from.
paramName	The name of the parameter whose error you would like.
errorType	The type of error to return, usually "prior" will be defined, but other possible types will be fitter dependent, e.g. "gauss" or "hpd" for MaCh3. If not specified, will use the default one, as specified in the fitter definition config.

Returns: The error on the specified parameter.

Definition at line 116 of file InputManager.cpp.

                                                                 {
   const InputFile &inputFileDef = getFile(fileNum);
  
   // set default type if not specified
   if (errorType == "")
     errorType = inputFileDef.defaultErrorType;
  
   if (inputFileDef.postFitErrors.find(errorType) == inputFileDef.postFitErrors.end())
   {
     MACH3LOG_CRITICAL("Requested error type, {} does not exist in the specified file: ", errorType);
     MACH3LOG_CRITICAL("  {}", inputFileDef.fileName);
     MACH3LOG_CRITICAL("  at index {}", fileNum);
  
     throw MaCh3Exception(__FILE__ , __LINE__ );
   }
  
   if (inputFileDef.postFitErrors.at(errorType).find(paramName) !=
       inputFileDef.postFitErrors.at(errorType).end())
   {
     return inputFileDef.postFitErrors.at(errorType).at(paramName);
   }
  
   MACH3LOG_WARN("Didn't find {} post fit error for {}. Returning {}", errorType, paramName, M3::_BAD_DOUBLE_);
  
   return M3::_BAD_DOUBLE_;
 }

◆ getPostFitValue()

double M3::Plotting::InputManager::getPostFitValue	(	const int	fileNum,
		const std::string &	paramName,
		std::string	errorType = `""`
	)		const

Get the post fit value for a particular parameter from a particular input file.

Parameters

fileNum	The index of the file that you would like to get the value from.
paramName	The name of the parameter whose value you would like.
errorType	The type of error to return, usually "prior" will be defined, but other possible types will be fitter dependent, e.g. "gauss" or "hpd" for MaCh3. If not specified, will use the default one, as specified in the fitter definition config.

Returns: The value of the specified parameter.

Definition at line 144 of file InputManager.cpp.

                                                                 {
   const InputFile &inputFileDef = getFile(fileNum);
  
   // set default type if not specified
   if (errorType == "")
     errorType = inputFileDef.defaultErrorType;
  
   if (inputFileDef.postFitErrors.find(errorType) == inputFileDef.postFitErrors.end())
   {
     MACH3LOG_CRITICAL("Requested error type, {} does not exist in the specified file: ", errorType);
     MACH3LOG_CRITICAL("  {}", inputFileDef.fileName);
     MACH3LOG_CRITICAL("  at index {}", fileNum);
  
     throw MaCh3Exception(__FILE__ , __LINE__ );
   }
  
   if (inputFileDef.postFitValues.at(errorType).find(paramName) !=
       inputFileDef.postFitValues.at(errorType).end())
   {
     return inputFileDef.postFitValues.at(errorType).at(paramName);
   }
   
   MACH3LOG_WARN("Didn't find {} post fit value for {}. Returning {}", errorType, paramName, M3::_BAD_DOUBLE_);
  
   return M3::_BAD_DOUBLE_;
 }

◆ getSampleSpecificLLHScan()

std::vector<std::vector<double> > M3::Plotting::InputManager::getSampleSpecificLLHScan	(	const int	fileNum,
		const std::string &	paramName,
		const std::string &	sample
	)		const

inline

Get the log likelihood scan for a particular parameter, for a specific sample, from a particular input file.

Parameters

fileNum	The index of the file that you would like to get the scan from.
paramName	The name of the parameter whose LLH scan you would like.
sample	The sample that you would like the LLH scan for.

Returns: A vector of vectors containing the LLH scan data. First entry is x axis, 2nd is y axis.

Definition at line 388 of file InputManager.h.

                                                                                                                                       {
     if (!getEnabledLLHBySample(fileNum, paramName, sample))
     {
       MACH3LOG_WARN("file at index {} does not have LLH scan for sample {} for parameter {}", fileNum, sample, paramName);
       MACH3LOG_WARN("am returning an empty vector");
       return std::vector<std::vector<double>>(2); 
     }
     return TGraphToVector(*_fileVec[fileNum].LLHScansBySample_map.at(sample).at(paramName));
   }

◆ getSampleSpecificLLHScan_TGraph()

TGraph M3::Plotting::InputManager::getSampleSpecificLLHScan_TGraph	(	const int	fileNum,
		const std::string &	paramName,
		const std::string &	sample
	)		const

inline

Definition at line 398 of file InputManager.h.

                                                                         {
     if (!getEnabledLLHBySample(fileNum, paramName, sample))
     {
       MACH3LOG_WARN("file at index {} does not have LLH scan for sample {} for parameter {}", fileNum, sample, paramName);
       MACH3LOG_WARN("am returning an empty TGraph");
       return TGraph();
     }
     return *_fileVec[fileNum].LLHScansBySample_map.at(sample).at(paramName);
   }

◆ getSampleSpecificLLHScan_TH1D()

TH1D M3::Plotting::InputManager::getSampleSpecificLLHScan_TH1D	(	const int	fileNum,
		const std::string &	paramName,
		const std::string &	sample
	)		const

inline

Definition at line 409 of file InputManager.h.

                                                                                                                           {
     if (!getEnabledLLHBySample(fileNum, paramName, sample))
     {
       MACH3LOG_WARN("file at index {} does not have LLH scan for sample {} for parameter {}", fileNum, sample, paramName);
       MACH3LOG_WARN("am returning an empty TH1D");
       return TH1D();
     }
     return TGraphToTH1D(*_fileVec[fileNum].LLHScansBySample_map.at(sample).at(paramName));
   }

◆ getTaggedParameters()

std::vector<std::string> M3::Plotting::InputManager::getTaggedParameters	(	const std::vector< std::string > &	tags,
		std::string	checkType = `"all"`
	)		const

inline

Get all parameters which have some set of tags.

Parameters

tags	The tags to check for
checkType	The type of check to perform: checkType can be one of: all: All parameters which have all of the specified tags will be returned any: All parameters which have any of the specified tags will be returned exact: All of the parameters which have exactly the specified tags will be returned

Definition at line 486 of file InputManager.h.

                                                                                                                        {
     return getTaggedValues(_knownParameters, _paramToTagsMap, tags, checkType);
   }

◆ getTaggedSamples()

std::vector<std::string> M3::Plotting::InputManager::getTaggedSamples	(	const std::vector< std::string > &	tags,
		std::string	checkType = `"all"`
	)		const

inline

Get all samples which have some set of tags.

Parameters

tags	The tags to check for
checkType	The type of check to perform: checkType can be one of: all: All samples which have all of the specified tags will be returned any: All samples which have any of the specified tags will be returned exact: All of the samples which have exactly the specified tags will be returned

Definition at line 497 of file InputManager.h.

                                                                                                                     {
     return getTaggedValues(_knownSamples, _sampleToTagsMap, tags, checkType);
   }

◆ getTaggedValues()

std::vector< std::string > M3::Plotting::InputManager::getTaggedValues	(	const std::vector< std::string > &	values,
		const std::unordered_map< std::string, std::vector< std::string >> &	tagMap,
		const std::vector< std::string > &	tags,
		std::string	checkType
	)		const

private

Definition at line 177 of file InputManager.cpp.

                                                                                                                     {
   // check that checkType is valid
   if(
     checkType != "all" &&
     checkType != "any" &&
     checkType != "exact"
   )
   {  
     MACH3LOG_ERROR("Invalid tag check type specified: {}. Will instead use the default type: 'all'", checkType);
     checkType = "all";
   }
  
   // If no tags were specified, take this to mean that anything should be a match
   if (tags.size() == 0) return values;
  
   std::vector<std::string> retVec;
  
   MACH3LOG_DEBUG("Getting tagged values using checkType {}", checkType);
   for ( std::string val: values )
   {
     MACH3LOG_DEBUG("Checking tags of {}", val);
     // get the tags that this value has
     const std::vector<std::string> &valTags = tagMap.at(val);
  
     // we can skip it if it has no tags
     if (valTags.size() == 0) continue;
  
     // count how many of the specified tags match the tags of the current value 
     unsigned int tagCount = 0;
     for ( const std::string &tag: tags )
     {
       if ( std::find( valTags.begin(), valTags.end(), tag ) != valTags.end() ) 
       {    
         MACH3LOG_DEBUG("  - Matched tag {} !", tag);
         tagCount ++;
       }
     }
  
     // now decide if we include the current value based on the check type
     if ( checkType == "all" )
     {
       if ( tagCount == tags.size() ) retVec.push_back(val);
     }
     else if ( checkType == "any" )
     {
       if ( tagCount > 0 ) retVec.push_back(val);
     }
     else if ( checkType == "exact" )
     {
       // EM: note that this will break if duplicate tags are specified in either vector... so please don't do that
       if ( tagCount == valTags.size() ) retVec.push_back(val);
     }
   }
   MACH3LOG_DEBUG("Found {} values matching the specified tags", retVec.size());
   return retVec;
 }

◆ parseLocation()

std::vector< std::string > M3::Plotting::InputManager::parseLocation	(	const std::string &	locationString,
		std::string &	fitter,
		fileTypeEnum	fileType,
		const std::string &	parameter = `""`,
		const std::string &	sample = `""`,
		const std::string &	parameter2 = `""`
	)		const

private

Definition at line 236 of file InputManager.cpp.

                                                                                                                  {
   std::string locationString(rawLocationString);
   std::vector<std::string> tokens;
  
   std::size_t pos = 0;
   std::string toReplace = "";
  
   // loop through the raw location string and replace any instance of {PARAMETER} with the name of
   // the parameter
   toReplace = "{PARAMETER}";
   while ((pos = locationString.find(toReplace)) != std::string::npos)
   {
     locationString.replace(pos, toReplace.length(),
                            getFitterSpecificParamName(fitter, fileType, parameter));
   }
  
   // same again with {SAMPLE}
   toReplace = "{SAMPLE}";
   while ((pos = locationString.find(toReplace)) != std::string::npos)
   {
     locationString.replace(pos, toReplace.length(),
                            getFitterSpecificSampleName(fitter, fileType, sample));
   }
  
   // loop through the raw location string and replace any instance of {PARAMETER2} with the name of
   // the second specified parameter
   toReplace = "{PARAMETER2}";
   while ((pos = locationString.find(toReplace)) != std::string::npos)
   {
     locationString.replace(pos, toReplace.length(),
                            getFitterSpecificParamName(fitter, fileType, parameter2));
   }
  
   // Now we go through and look for ":" and split the location into two parts
   // first part should be the directory to look for the parameter
   // lats part should be the end of the name of the object to look for
   std::string token;
   std::string delimiter = ":";
   while ((pos = locationString.find(delimiter)) != std::string::npos)
   {
     token = locationString.substr(0, pos);
     tokens.push_back(token);
     locationString.erase(0, pos + delimiter.length());
   }
   tokens.push_back(locationString);
  
   // should only have found 2 parts, anything more means there was too many
   // ":" in the location string
   if (tokens.size() > 2)
   {
     throw MaCh3Exception(__FILE__ , __LINE__, "Too many : tokens in location string: " + rawLocationString);
   }
  
   return tokens;
 }

◆ print()

void M3::Plotting::InputManager::print ( const std::string & printLevel = "summary" ) const

Print out what this Inputmanager instance knows about.

Parameters

printLevel The level of detail to go into in the summary printout: options are "summary", and "dump".

If printLevel is "summary", will loop through all the files known to this InputManager and call InputFile::Summarise(). If printLevel is "dump", will print all parameters known to this InputManager and then loop through all input files and call InputFile::Dump().

Definition at line 89 of file InputManager.cpp.

                                                           {
   MACH3LOG_INFO("Printing contents of InputManager instance:");
  
   if (printLevel == "dump")
   {
     MACH3LOG_INFO("parameters known to this manager: ");
     for (std::string param : _knownParameters)
     {
       MACH3LOG_INFO("  ");
     }
   }
  
   int fileCount = 0;
   for (const InputFile &file : _fileVec)
   {
     MACH3LOG_INFO(" For file {}", fileCount);
     if (printLevel == "summary")
     {
       file.Summarise();
     } else if (printLevel == "dump")
     { file.Dump(); }
     fileCount++;
   }
  
   MACH3LOG_INFO("");
 }

◆ strEndsWith()

bool M3::Plotting::InputManager::strEndsWith	(	const std::string &	str,
		const std::string &	ending
	)		const

inlineprivate

Definition at line 643 of file InputManager.h.

                                                                                {
     if (str.size() >= ending.size()) {
       return str.compare(str.size() - ending.size(), ending.size(), ending) == 0;
     }
     return false;
   }

◆ translateName()

std::string M3::Plotting::InputManager::translateName	(	int	fileId,
		fileTypeEnum	fileType,
		std::string	paramName
	)		const

inline

Definition at line 505 of file InputManager.h.

                                                                                                {
     return getFitterSpecificParamName(_fileVec[fileId].fitter, fileType, paramName);
   }

◆ TryToFindDefaultParamNames()

std::vector< std::string > M3::Plotting::InputManager::TryToFindDefaultParamNames ( const std::string & fileNames ) const

private

Definition at line 894 of file InputManager.cpp.

                                                                                              {
   std::vector<std::string> ParamNames;
   auto file = std::unique_ptr<TFile>(TFile::Open(fileName.c_str()));
   // MCMC processor output format
   if (auto* ProcessorDir = dynamic_cast<TDirectory*>(file->Get("Post"));
   ProcessorDir != nullptr)
   {
     TIter next(ProcessorDir->GetListOfKeys());
  
     while (auto* key = dynamic_cast<TKey*>(next())) {
       ParamNames.emplace_back(key->GetName());
       MACH3LOG_DEBUG("Adding name {}, assuming MCMC Processor file", ParamNames.back());
     }
  
     return ParamNames;
   }
  
   // LLH scan format
   if (auto* llhDir = dynamic_cast<TDirectory*>(file->Get("Total_LLH"));
   llhDir != nullptr)
   {
     TIter next(llhDir->GetListOfKeys());
  
     while (auto* key = dynamic_cast<TKey*>(next())) {
       std::string name = key->GetName();
       // Remove _total from hist name
       const char suffix[] = "_full";
       const std::size_t suffix_len = sizeof(suffix) - 1;
       name.erase(name.size() - suffix_len);
       ParamNames.push_back(std::move(name));
       MACH3LOG_DEBUG("Adding name {}, assuming LLH scan file", ParamNames.back());
     }
  
     return ParamNames;
   }
  
    MACH3LOG_ERROR("You didn't specify any parameter in universalTranslator.yaml");
    MACH3LOG_ERROR("Also you specified file I don't know format of so couldn't atomically find params");
    throw MaCh3Exception(__FILE__, __LINE__);
    return ParamNames;
 }

Member Data Documentation

◆ _fileVec

std::vector<InputFile> M3::Plotting::InputManager::_fileVec

private

Definition at line 675 of file InputManager.h.

◆ _fitterSpecConfig

YAML::Node M3::Plotting::InputManager::_fitterSpecConfig

private

Definition at line 670 of file InputManager.h.

◆ _knownFitters

std::vector<std::string> M3::Plotting::InputManager::_knownFitters

private

Definition at line 660 of file InputManager.h.

◆ _knownParameters

std::vector<std::string> M3::Plotting::InputManager::_knownParameters

private

Definition at line 653 of file InputManager.h.

◆ _knownSamples

std::vector<std::string> M3::Plotting::InputManager::_knownSamples

private

Definition at line 657 of file InputManager.h.

◆ _parametersConfig

YAML::Node M3::Plotting::InputManager::_parametersConfig

private

Definition at line 671 of file InputManager.h.

◆ _paramToTagsMap

std::unordered_map<std::string, std::vector<std::string> > M3::Plotting::InputManager::_paramToTagsMap

private

Definition at line 663 of file InputManager.h.

◆ _samplesConfig

YAML::Node M3::Plotting::InputManager::_samplesConfig

private

Definition at line 672 of file InputManager.h.

◆ _sampleToTagsMap

std::unordered_map<std::string, std::vector<std::string> > M3::Plotting::InputManager::_sampleToTagsMap

private

Definition at line 665 of file InputManager.h.

◆ _translatorConfig

YAML::Node M3::Plotting::InputManager::_translatorConfig

private

Definition at line 669 of file InputManager.h.

◆ NOT_FOUND_STR

const std::string M3::Plotting::InputManager::NOT_FOUND_STR

Initial value:

=

"__PARAM_NAME_NOT_FOUND__"

the default string to return if something can't be found

Definition at line 224 of file InputManager.h.

The documentation for this class was generated from the following files:

Utils/Plotting/InputManager.h
Utils/Plotting/InputManager.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ InputManager() [1/3]

◆ ~InputManager()

◆ InputManager() [2/3]

◆ InputManager() [3/3]

Member Function Documentation

◆ addFile()

◆ convertFileTypeNames()

◆ fillFileData()

◆ fillFileInfo()

◆ find1dPosterior()

◆ findBySampleLLH()

◆ findPostFitParamError()

◆ findRawChainSteps()

◆ findRootObject()

◆ get1dPosterior()

◆ getEnabled1dPosteriors()

◆ getEnabledLLH()

◆ getEnabledLLHBySample()

◆ getEnabledMCMCchain()

◆ getFile()

◆ getFitterSpecificOption()

◆ getFitterSpecificParamName()

◆ getFitterSpecificParamOption()

◆ getFitterSpecificSampleName()

◆ getFitterSpecificSampleOption()

◆ getKnown1dPosteriorParameters()

◆ getKnownLLHParameters()

◆ getKnownLLHSamples()

◆ getKnownMCMCParameters()

◆ getKnownParameters()

◆ getKnownPostFitParameters()

◆ getKnownSamples()

◆ getLLHScan()

◆ getLLHScan_TGraph()

◆ getLLHScan_TH1D()

◆ getMCMCentry()

◆ getMCMCvalue()

◆ getNInputFiles()

◆ getnMCMCentries()

◆ getPostFitError()

◆ getPostFitValue()

◆ getSampleSpecificLLHScan()

◆ getSampleSpecificLLHScan_TGraph()

◆ getSampleSpecificLLHScan_TH1D()

◆ getTaggedParameters()

◆ getTaggedSamples()

◆ getTaggedValues()

◆ parseLocation()

◆ print()

◆ strEndsWith()

◆ translateName()

◆ TryToFindDefaultParamNames()

Member Data Documentation

◆ _fileVec

◆ _fitterSpecConfig

◆ _knownFitters

◆ _knownParameters

◆ _knownSamples

◆ _parametersConfig

◆ _paramToTagsMap

◆ _samplesConfig

◆ _sampleToTagsMap

◆ _translatorConfig

◆ NOT_FOUND_STR