HepMCWeightSvc Class Reference

Service to read/write HepMC's WeightContainer key names from/to IOVMetaDataContainers author: will buttinger , NLAA. More...

#include <HepMCWeightSvc.h>

Inheritance diagram for HepMCWeightSvc:

Collaboration diagram for HepMCWeightSvc:

Classes
struct	WeightInfo
	Cached sets of weights. More...

Public Member Functions
virtual StatusCode	initialize () override
	Standard Gaudi initialize.
virtual StatusCode	setWeightNames (const WeightMap &weightNames, const EventContext &ctx=Gaudi::Hive::currentContext()) override
	Record weight names to metadata if none have yet been set.
virtual WeightMap	weightNames (const EventContext &ctx=Gaudi::Hive::currentContext()) override
	Return the current weight names.
virtual std::vector< std::string >	weightNameVec (const EventContext &ctx=Gaudi::Hive::currentContext()) override
	Return the current weight names.

Private Member Functions
unsigned long	getChanNum (const EventContext &ctx) const
	Return the ‘channel number’ for the current event.
unsigned int	loadWeights (unsigned long chanNum)
	Try to load weight names from metadata.
unsigned int	getWeightIndex (const EventContext &ctx)
	Return the index in m_weights for the current event.

Private Attributes
PublicToolHandle< IIOVDbMetaDataTool >	m_metaDataTool { this, "IOVDbMetaDataTool", "IOVDbMetaDataTool" }
	Handle to metadata tool.
Gaudi::Property< bool >	m_enabled { this, "Enable", true, "If false, will return failure on loadWeights" }
WeightInfo	m_weights [NWEIGHTS]
size_t	m_nextWeight = 0
	Index of next set of weights to overwrite.
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey { this, "EventInfoKey", "EventInfo", "SG key for EventInfo object." }
	Used to get MC channel for the current event.
std::mutex	m_mutex
	Serialize access to this service.

Static Private Attributes
static const unsigned int	NWEIGHTS = 8
	Array of weights.

Detailed Description

Service to read/write HepMC's WeightContainer key names from/to IOVMetaDataContainers author: will buttinger , NLAA.

Definition at line 24 of file HepMCWeightSvc.h.

Member Function Documentation

getChanNum()

unsigned long HepMCWeightSvc::getChanNum ( const EventContext & ctx ) const

private

Return the ‘channel number’ for the current event.

Parameters

ctx	Current event context.

Either the MC channel number or the run number if that hasn't been set.

Definition at line 134 of file HepMCWeightSvc.cxx.

{
  // Try first to get the MC channel number from EventInfo.
  SG::ReadHandle ei (m_eventInfoKey, ctx);
  if (ei.isValid()) {
    unsigned long chanNum = ei->mcChannelNumber();
    if (chanNum > 0) return chanNum;
  }
  // Fall back to run number.
  return ctx.eventID().run_number();
}

getWeightIndex()

unsigned int HepMCWeightSvc::getWeightIndex ( const EventContext & ctx )

private

Return the index in m_weights for the current event.

Parameters

ctx	The current event context.

Returns NWEIGHTS on failure.

Definition at line 225 of file HepMCWeightSvc.cxx.

{
  unsigned long chanNum = getChanNum (ctx);
  if (chanNum != 0) {
    for (size_t i = 0; i < NWEIGHTS; i++) {
      if (m_weights[i].m_chanNum == chanNum) {
        return i;
      }
    }
    return loadWeights (chanNum);
  }
  return NWEIGHTS;
}

initialize()

StatusCode HepMCWeightSvc::initialize ( )

overridevirtual

Standard Gaudi initialize.

Definition at line 18 of file HepMCWeightSvc.cxx.

{
  ATH_CHECK( m_eventInfoKey.initialize() );
  return StatusCode::SUCCESS;
}

loadWeights()

unsigned int HepMCWeightSvc::loadWeights ( unsigned long chanNum )

private

Try to load weight names from metadata.

Parameters

chanNum

Channel number for which to load weights.

Returns the index in m_weights of the loaded weights.

Definition at line 153 of file HepMCWeightSvc.cxx.

{
  // Must be called holding the service mutex.
 
  if (!m_enabled) return NWEIGHTS;
 
  std::map<std::string, int> in; 
 
  Athena::ToolLock toolLock (*m_metaDataTool);
  const IOVMetaDataContainer* cont = m_metaDataTool->findMetaDataContainer ("/Generation/Parameters");
 
  // Return quietly if container isn't there.
  if (cont) {
    if (cont->payloadContainer()->size() == 0) return NWEIGHTS;
 
    unsigned long chanNumRead = chanNum;
    // If there is only one collection of weights, then we just load that one.
    if (cont->payloadContainer()->at(0)->size()==1) {
      chanNumRead = cont->payloadContainer()->at(0)->chanNum(0);
    }
 
    const coral::Attribute& attr = cont->payloadContainer()->at(0)->attributeList(chanNumRead)["HepMCWeightNames"];
 
    int version = 1;
    try {
      version = cont->payloadContainer()->at(0)->attributeList(chanNumRead)["HepMCWeightSvcVersion"].data<int>();
    } catch(const coral::AttributeListException&) {
      version = 1; //no version available so assume version 1
    }
 
    std::string weightNames = attr.data<std::string>();
 
    //protect against malformed weightnames - see ATLMCPROD-3103
    //this actually only came about because the Gaudi::Utils::toString method was not used
    //in setWeightNames below. I've now corrected that, but now the fear is that these
    //replacements will interfere with those too!
    //so use a versioning system now
    if(version==1) {
      weightNames = std::regex_replace(weightNames, std::regex(R"(\{')"), "{\"");
      weightNames = std::regex_replace(weightNames, std::regex(R"(':)"), "\":");
      weightNames = std::regex_replace(weightNames, std::regex(R"(, ')"), ", \"");
    }
   
    ATH_MSG_DEBUG("Loading weightnames: " << weightNames);
 
    if( Gaudi::Parsers::parse(in,weightNames).isFailure() ) return NWEIGHTS;
  }
 
  size_t iweight = m_nextWeight;
  if (++m_nextWeight >= NWEIGHTS) {
    m_nextWeight = 0;
  }
 
  WeightInfo& w = m_weights[iweight];
  w.m_chanNum = chanNum;
  w.m_weightNames.clear();
 
  for(const auto& i : in) {
    w.m_weightNames[i.first] = i.second;
  }
  w.fillVec();
 
  return iweight;
}

setWeightNames()

StatusCode HepMCWeightSvc::setWeightNames ( const WeightMap & weightNames, const EventContext & ctx = Gaudi::Hive::currentContext() )

overridevirtual

Record weight names to metadata if none have yet been set.

Parameters

weightNames	Map of names to record.
ctx	Current event context.

Does nothing if weight names have already been set or read.

Definition at line 33 of file HepMCWeightSvc.cxx.

{
  std::scoped_lock lock (m_mutex);
 
  // Ignore any attempt to set 'nothing' for the weight names.
  if (weightNames.size()==0 ||
      (weightNames.size()==1 && weightNames.begin()->first=="0") )
  {
    return StatusCode::SUCCESS;
  }
 
  if (m_weights[0].m_chanNum != 0 || m_nextWeight != 0) {
    // We only allow setting of weightNames ONCE! ...
    // if the weights have ever been loaded, we will not allow
    // them to be set again!
    // Effectively means the weights are only set in evgen jobs.
    return StatusCode::SUCCESS;
  }
 
  unsigned int chanNum = ctx.eventID().run_number();
 
  WeightInfo& w = m_weights[m_nextWeight++];
  w.m_chanNum = chanNum;
  w.m_weightNames = weightNames;
  w.fillVec();
 
  // Create and register the metadata containter with these weight names 
  // Use the MetaDataTool to do this 
  ATH_CHECK( m_metaDataTool->registerFolder("/Generation/Parameters","Metadata created during Event Generation") );
 
  // Create a new attributelist collection for it ...
  auto cont = std::make_unique<CondAttrListCollection> (true /* use regular timestamps, not run-lumiblock timestamps */) ;
 
  // Create a single attribute list.
  CondAttrListCollection::AttributeList  myAttributes;
 
  // Store as strings ... when read back in we use a gaudi parser to parse the list
  myAttributes.extend("HepMCWeightNames","string");
  myAttributes.extend("HepMCWeightSvcVersion","int");
  myAttributes["HepMCWeightSvcVersion"].data<int>() = 2;
      
  std::string stringToStore = Gaudi::Utils::toString( weightNames );
 
  myAttributes["HepMCWeightNames"].data<std::string>() = stringToStore;
 
  // Use the run-number as the 'channel' ... all weightnames should be the same for the same channel 
  bool add_status = cont->add(chanNum, myAttributes);
  if (!add_status) {
    ATH_MSG_INFO("Failed to add AttributeList for weight " << stringToStore);
  }
 
  ATH_MSG_INFO("Storing /Generation/Parameters :: WeightNames = " << stringToStore);
 
  // And assign it to 'channel 0' .. consistent with other metadata
  ATH_CHECK( m_metaDataTool->addPayload("/Generation/Parameters", cont.release()) );
 
  return StatusCode::SUCCESS;
}

weightNames()

HepMCWeightSvc::WeightMap HepMCWeightSvc::weightNames ( const EventContext & ctx = Gaudi::Hive::currentContext() )

overridevirtual

Return the current weight names.

Definition at line 98 of file HepMCWeightSvc.cxx.

{
  std::scoped_lock lock (m_mutex);
  size_t i = getWeightIndex (ctx);
  if (i < NWEIGHTS) {
    return m_weights[i].m_weightNames;
  }
 
  ATH_MSG_WARNING("Unable to load weightnames from metadata ... do not trust the weightnames!");
  return WeightMap();
}

weightNameVec()

std::vector< std::string > HepMCWeightSvc::weightNameVec ( const EventContext & ctx = Gaudi::Hive::currentContext() )

overridevirtual

Return the current weight names.

Definition at line 115 of file HepMCWeightSvc.cxx.

{
  std::scoped_lock lock (m_mutex);
  size_t i = getWeightIndex (ctx);
  if (i < NWEIGHTS) {
    return m_weights[i].m_weightNameVec;
  }
 
  ATH_MSG_WARNING("Unable to load weightnames from metadata ... do not trust the weightnames!");
  return std::vector<std::string>();
}

Member Data Documentation

m_enabled

Gaudi::Property<bool> HepMCWeightSvc::m_enabled { this, "Enable", true, "If false, will return failure on loadWeights" }

private

Definition at line 96 of file HepMCWeightSvc.h.

{ this, "Enable", true, "If false, will return failure on loadWeights" };

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> HepMCWeightSvc::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "SG key for EventInfo object." }

private

Used to get MC channel for the current event.

Definition at line 126 of file HepMCWeightSvc.h.

{ this, "EventInfoKey", "EventInfo", "SG key for EventInfo object." };

m_metaDataTool

PublicToolHandle<IIOVDbMetaDataTool> HepMCWeightSvc::m_metaDataTool { this, "IOVDbMetaDataTool", "IOVDbMetaDataTool" }

private

Handle to metadata tool.

Definition at line 91 of file HepMCWeightSvc.h.

{ this, "IOVDbMetaDataTool", "IOVDbMetaDataTool" };

m_mutex

std::mutex HepMCWeightSvc::m_mutex

private

Serialize access to this service.

Definition at line 130 of file HepMCWeightSvc.h.

m_nextWeight

size_t HepMCWeightSvc::m_nextWeight = 0

private

Index of next set of weights to overwrite.

Definition at line 123 of file HepMCWeightSvc.h.

m_weights

WeightInfo HepMCWeightSvc::m_weights[NWEIGHTS]

private

Definition at line 120 of file HepMCWeightSvc.h.

NWEIGHTS

const unsigned int HepMCWeightSvc::NWEIGHTS = 8

staticprivate

Array of weights.

Definition at line 119 of file HepMCWeightSvc.h.

---

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

• HepMCWeightSvc.h
• HepMCWeightSvc.cxx