Rivet_i Class Reference

Interface to the Rivet analysis package. More...

#include <Rivet_i.h>

Inheritance diagram for Rivet_i:

Collaboration diagram for Rivet_i:

Public Member Functions
	Rivet_i (const std::string &name, ISvcLocator *pSvcLocator)
	Standard algorithm constructor. More...
virtual StatusCode initialize	ATLAS_NOT_THREAD_SAFE () override
	Initialise the Rivet interface and Athena services. More...
virtual StatusCode	execute () override
	Run the Rivet analyses on one event, which is retrieved from StoreGate. More...
virtual StatusCode	finalize () override
	Finalise each analysis and commit the plots to an AIDA tree and the THistSvc ROOT tree. More...
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::unique_ptr< HepMC::GenEvent >	checkEvent (const HepMC::GenEvent &event, const EventContext &ctx)
	Book an AIDA::IDataPointSet into the THistSvc as a TH1D at path. More...
void	MeV2GeV (HepMC::GenEvent &event)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::string	m_stream
	A pointer to the THistSvc. More...
std::string	m_file
	The base file name to write results to. More...
std::string	m_preload
std::string	m_anapath
	The analysis plugin search path. More...
bool	m_ignorebeams
	Whether to avoid the beam consistency checks. More...
bool	m_needsConversion
	Do we need to convert xAOD::Truth back to HepMC::GenEvemt? More...
bool	m_patchBeams
	Flag to insert beam protons when they are unavailable in the event. More...
ToolHandle< IxAODtoHepMCTool >	m_xAODtoHepMCTool {this, "HepMCTool", "xAODtoHepMCTool"}
	A tool to convert xAOD::Truth to HepMC::GenEvent. More...
bool	m_doRootHistos
	Will we convert Rivet's internal histo format into a ROOT histo for streaming with THistSvc? More...
std::string	m_runname
	The name of the run (prepended to plot paths). More...
std::string	m_genEventKey
	The GenEvent StoreGate key (default "GEN_EVENT") More...
Rivet::AnalysisHandler *	m_analysisHandler
	A Rivet analysis handler. More...
std::vector< std::string >	m_analysisNames
	A list of names of the analyses to run (set from the job properties) More...
double	m_crossSection
	The cross section for this run of events, set from the job properties. More...
double	m_crossSection_uncert
	The uncertainity of the cross section for this run of events, set from the job properties. More...
bool	m_init
	Flag to determine whether Rivet init has already happened (in execute()) More...
bool	m_skipweights
	Skip variation weights and only run nominal. More...
std::string	m_matchWeights
	String of weight names (or regex) to select multiweights. More...
std::string	m_unmatchWeights
	String of weight names (or regex) to veto multiweights. More...
std::string	m_nominalWeightName
	String to specify non-standard nominal weight. More...
double	m_weightcap
	Weight cap to set allowed maximum for weights. More...
SG::ReadHandleKey< xAOD::EventInfo >	m_evtInfoKey
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Interface to the Rivet analysis package.

Author

James Monk jmonk.nosp@m.@cer.nosp@m.n.ch

Andy Buckley andy..nosp@m.buck.nosp@m.ley@c.nosp@m.ern..nosp@m.ch

Christian Gutschow chris.nosp@m..g@c.nosp@m.ern.c.nosp@m.h

Definition at line 31 of file Rivet_i.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

Rivet_i()

Rivet_i::Rivet_i	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Standard algorithm constructor.

Convert to inherit from GenBase, now we're developing Rivet 2 interfacing for R19+ only.

Definition at line 35 of file Rivet_i.cxx.

                                                                :
  AthAlgorithm(name, pSvcLocator),
  m_needsConversion(false),
  m_analysisHandler(0),
  m_init(false)
{
  // Options
  declareProperty("McEventKey", m_genEventKey="GEN_EVENT");
  declareProperty("Analyses", m_analysisNames);
  declareProperty("CrossSection", m_crossSection=0.0);
  declareProperty("CrossSectionUncertainty", m_crossSection_uncert=0.0);
  declareProperty("Stream", m_stream="/Rivet");
  declareProperty("RunName", m_runname="");
  declareProperty("HistoFile", m_file="Rivet.yoda.gz");
  declareProperty("HistoPreload", m_preload="");
  declareProperty("AnalysisPath", m_anapath="");
  declareProperty("IgnoreBeamCheck", m_ignorebeams=false);
  declareProperty("DoRootHistos", m_doRootHistos=false);
  declareProperty("SkipWeights", m_skipweights=false);
  declareProperty("MatchWeights", m_matchWeights="");
  declareProperty("UnmatchWeights", m_unmatchWeights="");
  declareProperty("NominalWeightName", m_nominalWeightName="");
  declareProperty("WeightCap", m_weightcap=-1.0);
  declareProperty("AddMissingBeamParticles",m_patchBeams=false);
}

Member Function Documentation

ATLAS_NOT_THREAD_SAFE()

virtual StatusCode initialize Rivet_i::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

Initialise the Rivet interface and Athena services.

Pass a list of analyses to the Rivet AnalysisHandler, which dynamically loads the necessary libraries (including user-written analyses).

checkEvent()

std::unique_ptr< HepMC::GenEvent > Rivet_i::checkEvent ( const HepMC::GenEvent &  event, const EventContext &  ctx  )

private

Book an AIDA::IDataPointSet into the THistSvc as a TH1D at path.

Parameters

path	Book an AIDA::IDataPointSet into the THistSvc as a TGraph at path
path

Definition at line 262 of file Rivet_i.cxx.

                                                                                                    {
  auto modEvent = std::make_unique<HepMC::GenEvent>(event);
 
  if (!m_needsConversion) {
    // overwrite the HEPMC dummy event number with the proper ATLAS event number
    SG::ReadHandle<xAOD::EventInfo> evtInfo(m_evtInfoKey, ctx);
    modEvent->set_event_number(static_cast<int>(evtInfo->eventNumber()));
  }
 
  // weight-name cleaning
#ifdef HEPMC3
  std::shared_ptr<HepMC3::GenRunInfo> modRunInfo;
  if (event.run_info()) {
    modRunInfo = std::make_shared<HepMC3::GenRunInfo>(*(event.run_info().get()));
    if (event.run_info()->weight_names().empty() && event.weights().size() == 1) {
       modRunInfo->set_weight_names({"Default"});
    }
  }
  else {
    ATH_MSG_DEBUG("No run info, event weights size is " << event.weights().size() );
    modRunInfo = std::make_shared<HepMC3::GenRunInfo>();
    std::vector<std::string> w_names;
    for (size_t i = 0; i < event.weights().size(); i++) { w_names.push_back(std::string("badweight") + std::to_string(i)); }
    modRunInfo->set_weight_names(w_names);
  }
  modEvent->set_run_info(modRunInfo);
  std::vector<std::string>  w_names = modEvent->weight_names();
  if (w_names.size()) {
    std::vector<std::pair<std::string,std::string> > w_subs = {
      {" nominal ",""},
      {" set = ","_"},
      {" = ","_"},
      {"=",""},
      {",",""},
      {".",""},
      {":",""},
      {" ","_"},
      {"#","num"},
      {"\n","_"},
      {"/","over"}
    };
    for (std::string& wname : w_names) {
      for (const auto& sub : w_subs) {
        size_t start_pos = wname.find(sub.first);
        while (start_pos != std::string::npos) {
          wname.replace(start_pos, sub.first.length(), sub.second);
          start_pos = wname.find(sub.first);
        }
      }
    }
    modEvent->run_info()->set_weight_names(w_names);
  }
#else
  const HepMC::WeightContainer& old_wc = event.weights();
  std::vector<std::string> old_wnames = old_wc.weight_names();
  if (old_wnames.size()) {
    HepMC::WeightContainer& new_wc = modEvent->weights();
    new_wc.clear();
    std::vector<std::pair<std::string,std::string> > w_subs = {
      {" nominal ",""},
      {" set = ","_"},
      {" = ","_"},
      {"=",""},
      {",",""},
      {".",""},
      {":",""},
      {" ","_"},
      {"#","num"},
      {"\n","_"},
      {"/","over"}
    };
    std::map<std::string, double> new_name_to_value;
    std::map<std::string, std::string> old_name_to_new_name;
    for (const std::string& old_name : old_wnames) {
      std::string wname = std::string(old_name);
      double value = old_wc[old_name];
      for (const auto& sub : w_subs) {
        size_t start_pos = wname.find(sub.first);
        while (start_pos != std::string::npos) {
          wname.replace(start_pos, sub.first.length(), sub.second);
          start_pos = wname.find(sub.first);
        }
      }
      new_name_to_value[wname] = value;
      old_name_to_new_name[old_name] = wname;
    }
    auto itEnd = old_name_to_new_name.end();
    for (const std::string& old_name : old_wnames) {
      if (old_name_to_new_name.find(old_name) == itEnd)  continue;
      const std::string& new_name = old_name_to_new_name[old_name];
      new_wc[ new_name ] = new_name_to_value[new_name];
    }
    // end of weight-name cleaning
  }
#endif
 
#ifdef HEPMC3
  modEvent->set_units(HepMC3::Units::GEV, HepMC3::Units::MM);
  if (modEvent->particles().size() == 1) modEvent->set_beam_particles(modEvent->particles().front(), modEvent->particles().front());
  if (m_patchBeams) {
    // workaround in case beam particles were missing in xAOD::Truth
    // first work out centre-of-mass energy
    double etotal = 0;
    for (const auto& p : modEvent->particles()) {
      if (!MC::isStable(p)) continue;
      etotal += p->momentum().e();
    }
    const double ebeam = 0.5*etotal;
    // create dummy beam particles
    HepMC::GenParticlePtr b1 = std::make_shared<HepMC::GenParticle>(HepMC::FourVector(0,0,ebeam,ebeam),2212,4);
    HepMC::GenParticlePtr b2 = std::make_shared<HepMC::GenParticle>(HepMC::FourVector(0,0,-1*ebeam,ebeam),2212,4);
    // remove particles incorrectly labelled as beam particles
    std::vector<HepMC::GenParticlePtr> notBeams;
    for (const HepMC::GenParticlePtr& p : modEvent->beams()) {
      if (!MC::isBeam(p))  notBeams.push_back(p);
    }
    //AV: the loop is over shared pointers! Should be const auto&
    for (const auto& bp : notBeams)  bp->production_vertex()->remove_particle_out(bp);
    // add dummy beam particles
    modEvent->set_beam_particles(b1, b2);
  }
  if (modEvent->beams().front()->momentum().e() > 50000.0) {
    MeV2GeV(*modEvent);
  }
#else
  modEvent->use_units(HepMC::Units::GEV, HepMC::Units::MM);
  if (modEvent->particles_size() == 1)  modEvent->set_beam_particles(*modEvent->particles_begin(), *modEvent->particles_begin());
  if (modEvent->beam_particles().first->momentum().e() > 50000.0) {
    MeV2GeV(*modEvent);
  }
#endif
 
  return modEvent;
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode Rivet_i::execute ( )

overridevirtual

Run the Rivet analyses on one event, which is retrieved from StoreGate.

Todo:

Replace with new GenBase functionality

Todo:

Actually use back(), for the most recent event, or throw an exception if more than one event found?

Todo:

Replace with new GenBase const_event() functionality

Definition at line 141 of file Rivet_i.cxx.

                            {
  ATH_MSG_DEBUG("Rivet_i execute");
 
  const EventContext& ctx = getContext();
 
  m_needsConversion = !evtStore()->contains<McEventCollection>(m_genEventKey);
  ATH_MSG_DEBUG("Rivet_i needs xAOD::Truth to HepMC::GenEvent conversion? " << m_needsConversion);
 
  std::unique_ptr<HepMC::GenEvent> checkedEvent;
  if (m_needsConversion) {
    const xAOD::TruthEventContainer* truthCollection = nullptr;
    if (evtStore()->retrieve(truthCollection, "TruthEvents").isFailure()) {
      ATH_MSG_ERROR("Could not retrieve TruthEvents collection, aborting.");
      return StatusCode::FAILURE;
    }
 
    SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtInfoKey, ctx);
    ATH_MSG_DEBUG("Attempt xAOD::Truth to HepMC::GenEvent conversion.");
    std::vector<HepMC::GenEvent>&& hepmc_evts = m_xAODtoHepMCTool->getHepMCEvents(truthCollection, eventInfo.cptr());
 
    if (hepmc_evts.empty()) {
      ATH_MSG_ERROR("Conversion didn't yield HepMC::GenEvent, aborting.");
      return StatusCode::FAILURE;
    }
    checkedEvent = checkEvent(std::move(hepmc_evts[0]), ctx);
  }
  else {
    // Get the event collection
    const McEventCollection* eventCollection = nullptr;
    StatusCode sc = evtStore()->retrieve(eventCollection, m_genEventKey);
    if (sc.isFailure() || eventCollection == 0) {
      ATH_MSG_ERROR("Unable to retrieve event collection from StoreGate with key " << m_genEventKey);
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG("Retrieved event collection from StoreGate with key " << m_genEventKey);
    }
 
    // Get the first event in the event collection
    const HepMC::GenEvent* event = eventCollection->front();
    if (event == nullptr) {
      ATH_MSG_ERROR("Rivet_i received a null HepMC event");
      return StatusCode::FAILURE;
    }
 
    // Modify the event units etc. if necessary
    checkedEvent = checkEvent(*event, ctx);
  }
 
  if(!checkedEvent) {
    ATH_MSG_ERROR("Check on HepMC event failed!");
    return StatusCode::FAILURE;
  }
 
  // Initialize Rivet (on the first event only)
  if (!m_init) {
    m_analysisHandler->init(*checkedEvent);
    m_init = true;
  }
 
  // Analyse the event
  m_analysisHandler->analyze(*checkedEvent);
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode Rivet_i::finalize ( )

overridevirtual

Finalise each analysis and commit the plots to an AIDA tree and the THistSvc ROOT tree.

Definition at line 210 of file Rivet_i.cxx.

                             {
  ATH_MSG_INFO("Rivet_i finalizing");
 
  // Setting cross-section in Rivet
  // If no user-specified cross-section available,
  // take whatever is in the GenEvent
  if (m_crossSection != 0)   m_analysisHandler->setCrossSection({m_crossSection, m_crossSection_uncert});
 
  // Call Rivet finalize
  m_analysisHandler->finalize();
 
 
 
  // Write out YODA file (add .yoda suffix if missing)
  if (m_file.find(".yoda") == std::string::npos) m_file += ".yoda.gz";
  auto pos = m_file.find(".gz.");
  if (pos == std::string::npos) {
    m_analysisHandler->writeData(m_file);
  }
  else {//filename is e.g. something.yoda.gz.1
      //write to output file name without the ".1"
      m_analysisHandler->writeData(m_file.substr(0, pos)+".gz");
      // then rename it as the requested output filename
      if (std::rename((m_file.substr(0, pos)+".gz").c_str(), m_file.c_str()) !=0) {
        std::string error_msg = "Impossible to rename ";
        error_msg += m_file.substr(0, pos)+".gz";
        error_msg += " as ";
        error_msg += m_file;
        ATH_MSG_ERROR(error_msg.c_str());
        return StatusCode::FAILURE;
    }
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

MeV2GeV()

void Rivet_i::MeV2GeV ( HepMC::GenEvent &  event )

private

Definition at line 397 of file Rivet_i.cxx.

                                        {
#ifdef HEPMC3
  for (auto& p: evt.particles()) {
    p->set_momentum(p->momentum()*0.001);
#else
  for (HepMC::GenParticlePtr p: evt) {
    const HepMC::FourVector& mom = p->momentum();
    p->set_momentum(HepMC::FourVector (mom.px()*0.001,
                                       mom.py()*0.001,
                                       mom.pz()*0.001,
                                       mom.e()*0.001));
#endif
    p->set_generated_mass(p->generated_mass()*0.001);
  }
}

msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_analysisHandler

Rivet::AnalysisHandler* Rivet_i::m_analysisHandler

private

A Rivet analysis handler.

Definition at line 113 of file Rivet_i.h.

m_analysisNames

std::vector<std::string> Rivet_i::m_analysisNames

private

A list of names of the analyses to run (set from the job properties)

Definition at line 116 of file Rivet_i.h.

m_anapath

std::string Rivet_i::m_anapath

private

The analysis plugin search path.

This will be used to internally set RIVET_ANALYSIS_PATH, if not already set in the environment.

Definition at line 80 of file Rivet_i.h.

m_crossSection

double Rivet_i::m_crossSection

private

The cross section for this run of events, set from the job properties.

Definition at line 119 of file Rivet_i.h.

m_crossSection_uncert

double Rivet_i::m_crossSection_uncert

private

The uncertainity of the cross section for this run of events, set from the job properties.

Definition at line 122 of file Rivet_i.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doRootHistos

bool Rivet_i::m_doRootHistos

private

Will we convert Rivet's internal histo format into a ROOT histo for streaming with THistSvc?

The default is yes Currently (03.01.12) there is no conversion for 2D distributions, in which case you want to set this to False

Definition at line 104 of file Rivet_i.h.

m_evtInfoKey

SG::ReadHandleKey<xAOD::EventInfo> Rivet_i::m_evtInfoKey

private

Initial value:

{this
      , "EventInfo"
      , "EventInfo"
      , "ReadHandleKey for xAOD::EventInfo" }

Definition at line 142 of file Rivet_i.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_file

std::string Rivet_i::m_file

private

The base file name to write results to.

Definition at line 72 of file Rivet_i.h.

m_genEventKey

std::string Rivet_i::m_genEventKey

private

The GenEvent StoreGate key (default "GEN_EVENT")

Definition at line 110 of file Rivet_i.h.

m_ignorebeams

bool Rivet_i::m_ignorebeams

private

Whether to avoid the beam consistency checks.

Default is false: checks will be made to ensure that the supplied events have beams of the sort that the analysis was written to expect.

Definition at line 86 of file Rivet_i.h.

m_init

bool Rivet_i::m_init

private

Flag to determine whether Rivet init has already happened (in execute())

Definition at line 125 of file Rivet_i.h.

m_matchWeights

std::string Rivet_i::m_matchWeights

private

String of weight names (or regex) to select multiweights.

Definition at line 131 of file Rivet_i.h.

m_needsConversion

bool Rivet_i::m_needsConversion

private

Do we need to convert xAOD::Truth back to HepMC::GenEvemt?

Default is false: assume user runs on EVNT files

Definition at line 91 of file Rivet_i.h.

m_nominalWeightName

std::string Rivet_i::m_nominalWeightName

private

String to specify non-standard nominal weight.

Definition at line 137 of file Rivet_i.h.

m_patchBeams

bool Rivet_i::m_patchBeams

private

Flag to insert beam protons when they are unavailable in the event.

Definition at line 94 of file Rivet_i.h.

m_preload

std::string Rivet_i::m_preload

private

Definition at line 75 of file Rivet_i.h.

m_runname

std::string Rivet_i::m_runname

private

The name of the run (prepended to plot paths).

Definition at line 107 of file Rivet_i.h.

m_skipweights

bool Rivet_i::m_skipweights

private

Skip variation weights and only run nominal.

Definition at line 128 of file Rivet_i.h.

m_stream

std::string Rivet_i::m_stream

private

A pointer to the THistSvc.

The stream name for storing the output plots under (default "/Rivet")

Definition at line 69 of file Rivet_i.h.

m_unmatchWeights

std::string Rivet_i::m_unmatchWeights

private

String of weight names (or regex) to veto multiweights.

Definition at line 134 of file Rivet_i.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_weightcap

double Rivet_i::m_weightcap

private

Weight cap to set allowed maximum for weights.

Definition at line 140 of file Rivet_i.h.

m_xAODtoHepMCTool

ToolHandle<IxAODtoHepMCTool> Rivet_i::m_xAODtoHepMCTool {this, "HepMCTool", "xAODtoHepMCTool"}

private

A tool to convert xAOD::Truth to HepMC::GenEvent.

Definition at line 97 of file Rivet_i.h.

---

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

• Rivet_i.h
• Rivet_i.cxx