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 <Plotting/plottingUtils/inputManager.h>

Collaboration diagram for MaCh3Plotting::InputManager:

[legend]

Public Member Functions
	InputManager (const std::string &translationConfigName)
	Construct a new InputManager using specified fitter translation config file.

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

	~InputManager ()
	Destructor.

	InputManager (const InputManager &)=delete

	InputManager (InputManager &&)=default

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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.

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 (fileTypeEnum fileType)
	Convert from fileTypeEnum to the name of the file type.

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

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, 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, bool printThoughts=true)

void	fillFileData (InputFile &inputFileDef, 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

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.

Definition at line 214 of file inputManager.h.

Constructor & Destructor Documentation

◆ InputManager() [1/3]

MaCh3Plotting::InputManager::InputManager ( const std::string & translationConfigName )

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 = _fitterSpecConfig["fitters"].as<std::vector<std::string>>();
  _knownParameters = _parametersConfig["Parameters"].as<std::vector<std::string>>();
  _knownSamples = _samplesConfig["Samples"].as<std::vector<std::string>>();
 
  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 = _parametersConfig[param]["tags"].as<std::vector<std::string>>();
        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 = _samplesConfig[samp]["tags"].as<std::vector<std::string>>();
        MACH3LOG_DEBUG("  - Found {}!", tags.size());
      }
    }
    _sampleToTagsMap[samp] = tags;
  }
}

◆ ~InputManager()

MaCh3Plotting::InputManager::~InputManager ( )

inline

Destructor.

Close out all the files that the manager is responsible for

Definition at line 231 of file inputManager.h.

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

◆ InputManager() [2/3]

MaCh3Plotting::InputManager::InputManager ( const InputManager & )

delete

◆ InputManager() [3/3]

MaCh3Plotting::InputManager::InputManager ( InputManager && )

default

Member Function Documentation

◆ addFile()

void MaCh3Plotting::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 69 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 MaCh3Plotting::InputManager::convertFileTypeNames ( 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 255 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 MaCh3Plotting::InputManager::fillFileData	(	InputFile &	inputFileDef,
		bool	printThoughts = `true`
	)

private

Definition at line 778 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 =
      thisFitterSpec_config["defaultPostFitErrorType"].as<std::string>();
 
  // ########### 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 =
        testLLHConfig["location"].as<std::vector<std::string>>();
 
    // get the expected root object type of the llh scans
    std::string LLHObjType = thisFitterSpec_config["LLHObjectType"].as<std::string>();
 
    // 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 couldnt 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)
  {
    std::vector<std::string> availableErrorTypes =
        thisFitterSpec_config["AvailablePostFitErrorTypes"].as<std::vector<std::string>>();
    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 MaCh3Plotting::InputManager::fillFileInfo	(	InputFile &	inputFileDef,
		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 its 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 505 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"];
      std::vector<std::string> testLLHRawLocations =
          testLLHConfig["location"].as<std::vector<std::string>>();
 
      // 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 {}\n", 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>()];
        std::vector<std::string> locations = defaultErrorType["location"].as<std::vector<std::string>>();
        for (std::string loc : locations)
          MACH3LOG_DEBUG(loc);
      } 
      else
      {
        MACH3LOG_DEBUG("  No default location specified");
      }
    }
 
    int numPostFitParams = 0;
    std::vector<std::string> enabledPostFitParams;
 
    std::string defaultErrorType =
        thisFitterSpec_config["defaultPostFitErrorType"].as<std::string>();
    for (std::string parameter : _knownParameters)
    {
      if (findPostFitParamError(inputFileDef, parameter, fitter, defaultErrorType))
      {
        numPostFitParams++;
        enabledPostFitParams.push_back(parameter);
      }
    }
 
    if (printThoughts)
      MACH3LOG_INFO(".... Found {}\n", 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");
      std::vector<std::string> posteriorTreeRawLocations = thisFitterSpec_config["MCMCsteps"]["location"].as<std::vector<std::string>>();
      
      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 )
        {
          inputFileDef.mcmcProc = new MCMCProcessor(inputFileDef.fileName);
          inputFileDef.mcmcProc->Initialise();
 
          MACH3LOG_DEBUG("  - FOUND!");
          break;
        }
      }
    
      if ( postTree != nullptr )
      {
        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!\n", 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 MaCh3Plotting::InputManager::find1dPosterior	(	InputFile &	inputFileDef,
		const std::string &	parameter,
		std::string &	fitter,
		bool	setFileData = `false`
	)		const

private

Definition at line 427 of file inputManager.cpp.

                                                                                                                                 {
  bool wasFound = false;
  
  YAML::Node thisFitterSpec_config = _fitterSpecConfig[fitter];
 
  if ( thisFitterSpec_config["1dPosteriors"] ) {
    std::vector<std::string> rawLocations = thisFitterSpec_config["1dPosteriors"]["location"].as<std::vector<std::string>>();
 
    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 MaCh3Plotting::InputManager::findBySampleLLH	(	InputFile &	inputFileDef,
		const std::string &	parameter,
		std::string &	fitter,
		const std::string &	sample,
		bool	setInputFileScan = `false`
	)

private

Definition at line 343 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"];
  std::vector<std::string> testLLHRawLocations =
      testLLHConfig["location"].as<std::vector<std::string>>();
 
  std::string LLHObjType = thisFitterSpec_config["LLHObjectType"].as<std::string>();
 
  // 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 MaCh3Plotting::InputManager::findPostFitParamError	(	InputFile &	inputFileDef,
		const std::string &	parameter,
		std::string &	fitter,
		const std::string &	errorType,
		bool	setInputFileError = `false`
	)

private

Definition at line 454 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];
  std::vector<std::string> postFitLocations =
      specificErrorType["location"].as<std::vector<std::string>>();
 
  // 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 MaCh3Plotting::InputManager::findRawChainSteps	(	InputFile &	inputFileDef,
		const std::string &	parameter,
		std::string &	fitter,
		bool	setInputBranch = `false`
	)		const

private

Definition at line 392 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);
 
      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 > MaCh3Plotting::InputManager::findRootObject	(	const InputFile &	fileDef,
		const std::vector< std::string > &	locationVec
	)		const

private

Definition at line 287 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 > > MaCh3Plotting::InputManager::get1dPosterior	(	int	fileNum,
		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 333 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 MaCh3Plotting::InputManager::getEnabled1dPosteriors	(	int	fileNum,
		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 445 of file inputManager.h.

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

◆ getEnabledLLH()

bool MaCh3Plotting::InputManager::getEnabledLLH	(	int	fileNum,
		std::string	paramName,
		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 418 of file inputManager.h.

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

◆ getEnabledLLHBySample()

bool MaCh3Plotting::InputManager::getEnabledLLHBySample	(	int	fileNum,
		std::string	paramName,
		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 429 of file inputManager.h.

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

◆ getEnabledMCMCchain()

bool MaCh3Plotting::InputManager::getEnabledMCMCchain	(	int	fileNum,
		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 437 of file inputManager.h.

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

◆ getFile()

InputFile const & MaCh3Plotting::InputManager::getFile ( int fileId ) const

inline

Definition at line 498 of file inputManager.h.

498{ return _fileVec[fileId]; }

◆ getFitterSpecificOption()

template<typename T >

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

inlineprivate

Definition at line 569 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 MaCh3Plotting::InputManager::getFitterSpecificParamName	(	const std::string &	fitter,
		fileTypeEnum	fileType,
		const std::string &	parameter
	)		const

inlineprivate

Definition at line 607 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 MaCh3Plotting::InputManager::getFitterSpecificParamOption	(	const std::string &	fitter,
		const std::string &	option,
		T &	ret,
		const std::string &	parameter
	)		const

inlineprivate

Definition at line 593 of file inputManager.h.

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

◆ getFitterSpecificSampleName()

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

inlineprivate

Definition at line 621 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 MaCh3Plotting::InputManager::getFitterSpecificSampleOption	(	const std::string &	fitter,
		std::string	option,
		T &	ret,
		std::string	parameter
	)		const

inlineprivate

Definition at line 600 of file inputManager.h.

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

◆ getKnown1dPosteriorParameters()

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

inline

Definition at line 514 of file inputManager.h.

                                                                                     {
    return _fileVec[fileId].availableParams_1dPosteriors;
  }

◆ getKnownLLHParameters()

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

inline

Definition at line 502 of file inputManager.h.

                                                                             {
    return _fileVec[fileId].availableParams_LLH;
  }

◆ getKnownLLHSamples()

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

inline

Definition at line 505 of file inputManager.h.

                                                                          {
    return _fileVec[fileId].availableSamples_LLH;
  }

◆ getKnownMCMCParameters()

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

inline

Definition at line 511 of file inputManager.h.

                                                                              {
    return _fileVec[fileId].availableParams_MCMCchain;
  }

◆ getKnownParameters()

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

inline

Definition at line 469 of file inputManager.h.

469{ return _knownParameters; }

◆ getKnownPostFitParameters()

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

inline

Definition at line 508 of file inputManager.h.

                                                                                 {
    return _fileVec[fileId].availableParams_postFitErrors;
  }

◆ getKnownSamples()

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

inline

Definition at line 470 of file inputManager.h.

470{ return _knownSamples; }

◆ getLLHScan()

std::vector< std::vector< double > > MaCh3Plotting::InputManager::getLLHScan	(	int	fileNum,
		std::string	paramName,
		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 285 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 MaCh3Plotting::InputManager::getLLHScan_TGraph	(	int	fileNum,
		std::string	paramName,
		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 356 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 MaCh3Plotting::InputManager::getLLHScan_TH1D	(	int	fileNum,
		std::string	paramName,
		std::string	LLHType
	)		const

inline

Definition at line 366 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 MaCh3Plotting::InputManager::getMCMCentry	(	int	fileNum,
		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 298 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 successfuly");
    }
  }

◆ getMCMCvalue()

double MaCh3Plotting::InputManager::getMCMCvalue	(	int	fileNum,
		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 318 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 MaCh3Plotting::InputManager::getNInputFiles ( ) const

inline

Definition at line 471 of file inputManager.h.

471{ return _fileVec.size(); }

◆ getnMCMCentries()

int MaCh3Plotting::InputManager::getnMCMCentries ( 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 345 of file inputManager.h.

                                         {
    return _fileVec[fileNum].nMCMCentries;
  }

◆ getPostFitError()

double MaCh3Plotting::InputManager::getPostFitError	(	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 109 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 fnd {} post fit error for {}. Returning {}", errorType, paramName, M3::_BAD_DOUBLE_);
 
  return M3::_BAD_DOUBLE_;
}

◆ getPostFitValue()

double MaCh3Plotting::InputManager::getPostFitValue	(	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 137 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 fnd {} post fit value for {}. Returning {}", errorType, paramName, M3::_BAD_DOUBLE_);
 
  return M3::_BAD_DOUBLE_;
}

◆ getSampleSpecificLLHScan()

std::vector< std::vector< double > > MaCh3Plotting::InputManager::getSampleSpecificLLHScan	(	int	fileNum,
		std::string	paramName,
		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 382 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 MaCh3Plotting::InputManager::getSampleSpecificLLHScan_TGraph	(	int	fileNum,
		std::string	paramName,
		std::string	sample
	)		const

inline

Definition at line 392 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 MaCh3Plotting::InputManager::getSampleSpecificLLHScan_TH1D	(	int	fileNum,
		std::string	paramName,
		std::string	sample
	)		const

inline

Definition at line 403 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 > MaCh3Plotting::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 480 of file inputManager.h.

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

◆ getTaggedSamples()

std::vector< std::string > MaCh3Plotting::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 491 of file inputManager.h.

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

◆ getTaggedValues()

std::vector< std::string > MaCh3Plotting::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 170 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 == "exect" )
    {
      // 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 > MaCh3Plotting::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 229 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 MaCh3Plotting::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 82 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 MaCh3Plotting::InputManager::strEndsWith	(	const std::string &	str,
		const std::string &	ending
	)		const

inlineprivate

Definition at line 634 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 MaCh3Plotting::InputManager::translateName	(	int	fileId,
		fileTypeEnum	fileType,
		std::string	paramName
	)		const

inline

Definition at line 499 of file inputManager.h.

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

Member Data Documentation

◆ _fileVec

std::vector<InputFile> MaCh3Plotting::InputManager::_fileVec

private

Definition at line 666 of file inputManager.h.

◆ _fitterSpecConfig

YAML::Node MaCh3Plotting::InputManager::_fitterSpecConfig

private

Definition at line 661 of file inputManager.h.

◆ _knownFitters

std::vector<std::string> MaCh3Plotting::InputManager::_knownFitters

private

Definition at line 651 of file inputManager.h.

◆ _knownParameters

std::vector<std::string> MaCh3Plotting::InputManager::_knownParameters

private

Definition at line 644 of file inputManager.h.

◆ _knownSamples

std::vector<std::string> MaCh3Plotting::InputManager::_knownSamples

private

Definition at line 648 of file inputManager.h.

◆ _parametersConfig

YAML::Node MaCh3Plotting::InputManager::_parametersConfig

private

Definition at line 662 of file inputManager.h.

◆ _paramToTagsMap

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

private

Definition at line 654 of file inputManager.h.

◆ _samplesConfig

YAML::Node MaCh3Plotting::InputManager::_samplesConfig

private

Definition at line 663 of file inputManager.h.

◆ _sampleToTagsMap

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

private

Definition at line 656 of file inputManager.h.

◆ _translatorConfig

YAML::Node MaCh3Plotting::InputManager::_translatorConfig

private

Definition at line 660 of file inputManager.h.

◆ NOT_FOUND_STR

const std::string MaCh3Plotting::InputManager::NOT_FOUND_STR

Initial value:

=

"__PARAM_NAME_NOT_FOUND__"

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

Definition at line 216 of file inputManager.h.

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

Plotting/plottingUtils/inputManager.h
Plotting/plottingUtils/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()

Member Data Documentation

◆ _fileVec

◆ _fitterSpecConfig

◆ _knownFitters

◆ _knownParameters

◆ _knownSamples

◆ _parametersConfig

◆ _paramToTagsMap

◆ _samplesConfig

◆ _sampleToTagsMap

◆ _translatorConfig

◆ NOT_FOUND_STR