Rivet_i.cxx File Reference

#include "Rivet_i.h"
#include "LogLevels.h"
#include "AtlasHepMC/GenEvent.h"
#include "TruthUtils/HepMCHelpers.h"
#include "GeneratorObjects/McEventCollection.h"
#include "AthenaKernel/errorcheck.h"
#include "PathResolver/PathResolver.h"
#include "GaudiKernel/IAppMgrUI.h"
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/ITHistSvc.h"
#include "Rivet/Rivet.hh"
#include "Rivet/Analysis.hh"
#include "Rivet/Config/RivetConfig.hh"
#include "Rivet/Tools/RivetYODA.hh"
#include <cstdlib>
#include <cstdio>
#include <memory>
#include <regex>

Go to the source code of this file.

Functions
std::string	getenv_str (const std::string &key)
StatusCode Rivet_i::initialize	ATLAS_NOT_THREAD_SAFE ()
	Install fatal handler with default options. More...
bool	cmpGenParticleByEDesc (HepMC::ConstGenParticlePtr a, HepMC::ConstGenParticlePtr b)
	Helper function to sort GenParticles by descending energy. More...
std::vector< std::string >	split (const std::string &input, const std::string &regex)

Function Documentation

ATLAS_NOT_THREAD_SAFE()

StatusCode Rivet_i::initialize ATLAS_NOT_THREAD_SAFE ( )

inline

Install fatal handler with default options.

This is meant to be easy to call from python via ctypes.

Definition at line 66 of file Rivet_i.cxx.

                                                      {
  //                           ^ use of setenv
  ATH_MSG_INFO("Using Rivet version " << Rivet::version());
 
  ATH_CHECK(m_evtInfoKey.initialize());
 
  // Get tool for xAOD::Truth to HepMC::GenEvent conversion
  ATH_CHECK(m_xAODtoHepMCTool.retrieve());
 
 
  // Set RIVET_ANALYSIS_PATH based on alg setup
 
  // First set (overwrite, if necessary) the RIVET_ANALYSIS_PATH variable
  std::string env_rap(getenv_str("RIVET_ANALYSIS_PATH"));
  if (m_anapath.size() > 0) {
    ATH_MSG_INFO("Setting Rivet plugin analyses loader env path: " << m_anapath);
    if (!env_rap.empty()) ATH_MSG_INFO("Overwriting environment's RIVET_ANALYSIS_PATH = " << env_rap << "!");
    setenv("RIVET_ANALYSIS_PATH", m_anapath.c_str(), 1);
  }
 
  // Now horrid runtime ATLAS env variable and CMT path mangling to work out the std analysis plugin search paths
  std::vector<std::string> anapaths;
  const std::string cmtpath = getenv_str("CMTPATH");
  if (cmtpath.empty()) {
    ATH_MSG_WARNING("$CMTPATH variable not set: finding the main analysis plugin directory will be difficult...");
  } else {
    std::vector<std::string> cmtpaths;
    std::stringstream ss(cmtpath);
    std::string item;
    while (std::getline(ss, item, ':')) {
      cmtpaths.push_back(std::move(item));
    }
    const std::string cmtconfig = getenv_str("CMTCONFIG");
    if (cmtconfig.empty()) {
      ATH_MSG_WARNING("$CMTCONFIG variable not set: finding the main analysis plugin directory will be difficult...");
    }
    else {
      const std::string libpath = "/InstallArea/" + cmtconfig + "/lib";
      for (const std::string& p : cmtpaths) {
        const std::string cmtlibpath = p + libpath;
        if (PathResolver::find_file_from_list("RivetMCAnalyses.so", cmtlibpath).empty()) continue;
        ATH_MSG_INFO("Appending " + cmtlibpath + " to default Rivet analysis search path");
        anapaths.push_back(cmtlibpath);
        break;
      }
    }
  }
 
  // Then re-grab RIVET_ANALYSIS_PATH and append all the discovered std plugin paths to it
  std::string anapathstr = getenv_str("RIVET_ANALYSIS_PATH");
  for (const std::string& ap : anapaths) {
    if (anapathstr.size() > 0) anapathstr += ":";
    anapathstr += ap;
  }
  setenv("RIVET_ANALYSIS_PATH", anapathstr.c_str(), 1);
 
  // Get the final form of RIVET_ANALYSIS_PATH and talk about it. Phew.
  env_rap = getenv_str("RIVET_ANALYSIS_PATH");
  if (!env_rap.empty()) ATH_MSG_DEBUG("Loading Rivet plugin analyses from env path: " << env_rap);
 
  // Set up analysis handler
  m_analysisHandler = new Rivet::AnalysisHandler(m_runname);
  assert(m_analysisHandler);
 
  #if RIVET_VERSION_CODE >= 40000
  m_analysisHandler->setCheckBeams(!m_ignorebeams); //< Whether to do beam ID/energy consistency checks
  m_analysisHandler->matchWeightNames(m_matchWeights); //< Only run on a subset of the multi-weights
  m_analysisHandler->unmatchWeightNames(m_unmatchWeights); //< Veto a subset of the multi-weights
  #else
  m_analysisHandler->setIgnoreBeams(m_ignorebeams); //< Whether to do beam ID/energy consistency checks
  m_analysisHandler->selectMultiWeights(m_matchWeights); //< Only run on a subset of the multi-weights
  m_analysisHandler->deselectMultiWeights(m_unmatchWeights); //< Veto a subset of the multi-weights
  #endif
  m_analysisHandler->skipMultiWeights(m_skipweights); //< Only run on the nominal weight
  m_analysisHandler->setNominalWeightName(m_nominalWeightName);
  if (m_weightcap>0) m_analysisHandler->setWeightCap(m_weightcap);
 
  // Set Rivet native log level to match Athena
  Rivet::Log::setLevel("Rivet", rivetLevel(msg().level()));
 
  // Get all available analysis names
  if (msgLvl(MSG::VERBOSE)) {
    std::vector<std::string> analysisNames = Rivet::AnalysisLoader::analysisNames();
    ATH_MSG_VERBOSE("List of available Rivet analyses:");
    for (const std::string& a : analysisNames)  ATH_MSG_VERBOSE(" " + a);
  }
 
  // Add analyses
  for (const std::string& a : m_analysisNames) {
    ATH_MSG_INFO("Loading Rivet analysis " << a);
    m_analysisHandler->addAnalysis(a);
    Rivet::Log::setLevel("Rivet.Analysis."+a, rivetLevel(msg().level()));
  }
 
  // Initialise Rivet
  // m_analysisHandler->init();
 
  //load a pre-existing yoda file to initialize histograms
  if (m_preload!= "") {
    m_analysisHandler->readData(m_preload);
  }
 
  return StatusCode::SUCCESS;
}

cmpGenParticleByEDesc()

bool cmpGenParticleByEDesc	(	HepMC::ConstGenParticlePtr	a,
		HepMC::ConstGenParticlePtr	b
	)

Helper function to sort GenParticles by descending energy.

Todo:

Move into GeneratorUtils (with many friends)

Definition at line 280 of file Rivet_i.cxx.

                                                                                   {
  return a->momentum().e() > b->momentum().e();
}

getenv_str()

std::string getenv_str

(

const std::string &

key

)

Definition at line 60 of file Rivet_i.cxx.

                                           {
  char const* val = getenv(key.c_str());
  return val == NULL ? std::string() : std::string(val);
}

split()

std::vector<std::string> split ( const std::string &  input, const std::string &  regex  )

inline

Definition at line 284 of file Rivet_i.cxx.

                                                                                  {
  // passing -1 as the submatch index parameter performs splitting
  std::regex re(regex);
  std::sregex_token_iterator
  first{input.begin(), input.end(), re, -1},
    last;
    return {first, last};
}